Move Match into its own module

Author: oli-obk

src/config.rs

@@ -2,8 +2,8 @@ use regex::bytes::Regex;
 use spanned::{Span, Spanned};
 
 use crate::{
-    dependencies::build_dependencies, per_test_config::Comments, CommandBuilder, Match, Mode,
-    RustfixMode,
+    dependencies::build_dependencies, filter::Match, per_test_config::Comments, CommandBuilder,
+    Mode, RustfixMode,
 };
 pub use color_eyre;
 use color_eyre::eyre::Result;

src/filter.rs

@@ -0,0 +1,71 @@
+//! Datastructures and operations used for normalizing test output.
+
+use bstr::ByteSlice;
+use lazy_static::lazy_static;
+use regex::bytes::{Captures, Regex};
+use std::borrow::Cow;
+use std::path::Path;
+
+/// A filter's match rule.
+#[derive(Clone, Debug)]
+pub enum Match {
+    /// If the regex matches, the filter applies
+    Regex(Regex),
+    /// If the exact byte sequence is found, the filter applies
+    Exact(Vec<u8>),
+    /// Uses a heuristic to find backslashes in windows style paths
+    PathBackslash,
+}
+
+impl Match {
+    pub(crate) fn replace_all<'a>(&self, text: &'a [u8], replacement: &[u8]) -> Cow<'a, [u8]> {
+        match self {
+            Match::Regex(regex) => regex.replace_all(text, replacement),
+            Match::Exact(needle) => text.replace(needle, replacement).into(),
+            Match::PathBackslash => {
+                lazy_static! {
+                    static ref PATH_RE: Regex = Regex::new(
+                        r"(?x)
+                        (?:
+                            # Match paths to files with extensions that don't include spaces
+                            \\(?:[\pL\pN.\-_']+[/\\])*[\pL\pN.\-_']+\.\pL+
+                        |
+                            # Allow spaces in absolute paths
+                            [A-Z]:\\(?:[\pL\pN.\-_'\ ]+[/\\])+
+                        )",
+                    )
+                    .unwrap();
+                }
+
+                PATH_RE.replace_all(text, |caps: &Captures<'_>| {
+                    caps[0].replace(r"\", replacement)
+                })
+            }
+        }
+    }
+}
+
+impl From<&'_ Path> for Match {
+    fn from(v: &Path) -> Self {
+        let mut v = v.display().to_string();
+        // Normalize away windows canonicalized paths.
+        if v.starts_with(r"\\?\") {
+            v.drain(0..4);
+        }
+        let mut v = v.into_bytes();
+        // Normalize paths on windows to use slashes instead of backslashes,
+        // So that paths are rendered the same on all systems.
+        for c in &mut v {
+            if *c == b'\\' {
+                *c = b'/';
+            }
+        }
+        Self::Exact(v)
+    }
+}
+
+impl From<Regex> for Match {
+    fn from(v: Regex) -> Self {
+        Self::Regex(v)
+    }
+}

src/lib.rs

@@ -13,13 +13,10 @@ pub use color_eyre;
 use color_eyre::eyre::{eyre, Result};
 use crossbeam_channel::{unbounded, Receiver, Sender};
 use dependencies::{Build, BuildManager};
-use lazy_static::lazy_static;
 use parser::{ErrorMatch, ErrorMatchKind, OptWithLine, Revisioned, Spanned};
-use regex::bytes::{Captures, Regex};
 use rustc_stderr::{Level, Message};
 use spanned::Span;
 use status_emitter::{StatusEmitter, TestStatus};
-use std::borrow::Cow;
 use std::collections::{HashSet, VecDeque};
 use std::ffi::OsString;
 use std::num::NonZeroUsize;
@@ -34,12 +31,14 @@ mod config;
 mod dependencies;
 mod diff;
 mod error;
+pub mod filter;
 pub mod github_actions;
 mod mode;
 mod parser;
 pub mod per_test_config;
 mod rustc_stderr;
 pub mod status_emitter;
+
 #[cfg(test)]
 mod tests;
 
@@ -50,69 +49,6 @@ pub use mode::*;
 
 pub use spanned;
 
-/// A filter's match rule.
-#[derive(Clone, Debug)]
-pub enum Match {
-    /// If the regex matches, the filter applies
-    Regex(Regex),
-    /// If the exact byte sequence is found, the filter applies
-    Exact(Vec<u8>),
-    /// Uses a heuristic to find backslashes in windows style paths
-    PathBackslash,
-}
-impl Match {
-    fn replace_all<'a>(&self, text: &'a [u8], replacement: &[u8]) -> Cow<'a, [u8]> {
-        match self {
-            Match::Regex(regex) => regex.replace_all(text, replacement),
-            Match::Exact(needle) => text.replace(needle, replacement).into(),
-            Match::PathBackslash => {
-                lazy_static! {
-                    static ref PATH_RE: Regex = Regex::new(
-                        r"(?x)
-                        (?:
-                            # Match paths to files with extensions that don't include spaces
-                            \\(?:[\pL\pN.\-_']+[/\\])*[\pL\pN.\-_']+\.\pL+
-                        |
-                            # Allow spaces in absolute paths
-                            [A-Z]:\\(?:[\pL\pN.\-_'\ ]+[/\\])+
-                        )",
-                    )
-                    .unwrap();
-                }
-
-                PATH_RE.replace_all(text, |caps: &Captures<'_>| {
-                    caps[0].replace(r"\", replacement)
-                })
-            }
-        }
-    }
-}
-
-impl From<&'_ Path> for Match {
-    fn from(v: &Path) -> Self {
-        let mut v = v.display().to_string();
-        // Normalize away windows canonicalized paths.
-        if v.starts_with(r"\\?\") {
-            v.drain(0..4);
-        }
-        let mut v = v.into_bytes();
-        // Normalize paths on windows to use slashes instead of backslashes,
-        // So that paths are rendered the same on all systems.
-        for c in &mut v {
-            if *c == b'\\' {
-                *c = b'/';
-            }
-        }
-        Self::Exact(v)
-    }
-}
-
-impl From<Regex> for Match {
-    fn from(v: Regex) -> Self {
-        Self::Regex(v)
-    }
-}
-
 /// Run all tests as described in the config argument.
 /// Will additionally process command line arguments.
 pub fn run_tests(mut config: Config) -> Result<()> {

src/parser.rs

@@ -8,7 +8,7 @@ use std::{
 use bstr::{ByteSlice, Utf8Error};
 use regex::bytes::Regex;
 
-use crate::{rustc_stderr::Level, Error, Errored, Match, Mode};
+use crate::{filter::Match, rustc_stderr::Level, Error, Errored, Mode};
 
 use color_eyre::eyre::{Context, Result};
 

tests/integration.rs

@@ -1,7 +1,7 @@
 use std::path::Path;
 
 use ui_test::color_eyre::Result;
-use ui_test::{spanned::Spanned, *};
+use ui_test::{filter::Match, spanned::Spanned, *};
 
 fn main() -> Result<()> {
     let path = Path::new(file!()).parent().unwrap();