A bit of cleanup (#17394)

Was working on another issue and noticed that I wanted these but they
aren't related to any of the issues. So opening a separate PR to do some
internal cleanup.

Author: RobinMalfait

Cargo.lock

@@ -22,3 +22,4 @@ regex = "1.11.1"
 
 [dev-dependencies]
 tempfile = "3.13.0"
+pretty_assertions = "1.4.1"

crates/oxide/Cargo.toml

@@ -119,6 +119,7 @@ impl Display for Cursor<'_> {
 #[cfg(test)]
 mod test {
     use super::*;
+    use pretty_assertions::assert_eq;
 
     #[test]
     fn test_cursor() {

crates/oxide/src/cursor.rs

@@ -307,6 +307,7 @@ enum Class {
 mod tests {
     use super::{ArbitraryPropertyMachine, IdleState};
     use crate::extractor::machine::Machine;
+    use pretty_assertions::assert_eq;
 
     #[test]
     #[ignore]
@@ -413,7 +414,7 @@ mod tests {
                 let actual = ArbitraryPropertyMachine::<IdleState>::test_extract_all(&input);
 
                 if actual != expected {
-                    dbg!(&input, &actual, &expected);
+                    dbg!(&input);
                 }
                 assert_eq!(actual, expected);
             }

crates/oxide/src/extractor/arbitrary_property_machine.rs

@@ -149,6 +149,7 @@ enum Class {
 mod tests {
     use super::ArbitraryValueMachine;
     use crate::extractor::machine::Machine;
+    use pretty_assertions::assert_eq;
 
     #[test]
     #[ignore]

crates/oxide/src/extractor/arbitrary_value_machine.rs

@@ -336,6 +336,7 @@ enum Class {
 mod tests {
     use super::ArbitraryVariableMachine;
     use crate::extractor::{arbitrary_variable_machine::IdleState, machine::Machine};
+    use pretty_assertions::assert_eq;
 
     #[test]
     #[ignore]

crates/oxide/src/extractor/arbitrary_variable_machine.rs

@@ -181,6 +181,7 @@ impl CandidateMachine {
 mod tests {
     use super::CandidateMachine;
     use crate::extractor::machine::Machine;
+    use pretty_assertions::assert_eq;
 
     #[test]
     #[ignore]
@@ -307,7 +308,7 @@ mod tests {
                 actual.sort();
 
                 if actual != expected {
-                    dbg!(&input, &expected, &actual);
+                    dbg!(&input);
                 }
 
                 assert_eq!(actual, expected);

crates/oxide/src/extractor/candidate_machine.rs

@@ -116,6 +116,7 @@ enum Class {
 mod tests {
     use super::CssVariableMachine;
     use crate::extractor::machine::Machine;
+    use pretty_assertions::assert_eq;
 
     #[test]
     #[ignore]
@@ -203,7 +204,7 @@ mod tests {
                 let actual = CssVariableMachine::test_extract_all(&input);
 
                 if actual != expected {
-                    dbg!(&input, &actual, &expected);
+                    dbg!(&input);
                 }
 
                 assert_eq!(actual, expected);

crates/oxide/src/extractor/css_variable_machine.rs

@@ -199,6 +199,7 @@ fn drop_covered_spans(mut spans: Vec<Span>) -> Vec<Span> {
 mod tests {
     use super::{Extracted, Extractor};
     use crate::throughput::Throughput;
+    use pretty_assertions::assert_eq;
     use std::hint::black_box;
 
     fn pre_process_input(input: &str, extension: &str) -> String {
@@ -244,7 +245,7 @@ mod tests {
         expected.dedup();
 
         if actual != expected {
-            dbg!(&input, &actual, &expected);
+            dbg!(&input);
         }
         assert_eq!(actual, expected);
     }
@@ -272,7 +273,7 @@ mod tests {
         expected.sort();
 
         if actual != expected {
-            dbg!(&input, &actual, &expected);
+            dbg!(&input);
         }
         assert_eq!(actual, expected);
     }

crates/oxide/src/extractor/mod.rs

@@ -121,6 +121,7 @@ enum Class {
 mod tests {
     use super::ModifierMachine;
     use crate::extractor::machine::Machine;
+    use pretty_assertions::assert_eq;
 
     #[test]
     #[ignore]

crates/oxide/src/extractor/modifier_machine.rs

@@ -386,6 +386,7 @@ enum Class {
 mod tests {
     use super::{IdleState, NamedUtilityMachine};
     use crate::extractor::machine::Machine;
+    use pretty_assertions::assert_eq;
 
     #[test]
     #[ignore]
@@ -515,7 +516,7 @@ mod tests {
                 actual.sort();
 
                 if actual != expected {
-                    dbg!(&input, &expected, &actual);
+                    dbg!(&input);
                 }
                 assert_eq!(actual, expected);
             }

crates/oxide/src/extractor/named_utility_machine.rs

@@ -367,6 +367,7 @@ enum Class {
 mod tests {
     use super::{IdleState, NamedVariantMachine};
     use crate::extractor::machine::Machine;
+    use pretty_assertions::assert_eq;
 
     #[test]
     #[ignore]
@@ -413,7 +414,7 @@ mod tests {
         ] {
             let actual = NamedVariantMachine::<IdleState>::test_extract_all(input);
             if actual != expected {
-                dbg!(&input, &actual, &expected);
+                dbg!(&input);
             }
             assert_eq!(actual, expected);
         }

crates/oxide/src/extractor/named_variant_machine.rs

@@ -93,6 +93,7 @@ impl PreProcessor for Haml {
 mod tests {
     use super::Haml;
     use crate::extractor::pre_processors::pre_processor::PreProcessor;
+    use pretty_assertions::assert_eq;
 
     #[test]
     fn test_haml_pre_processor() {

crates/oxide/src/extractor/pre_processors/haml.rs

@@ -3,6 +3,8 @@ pub trait PreProcessor: Sized + Default {
 
     #[cfg(test)]
     fn test(input: &str, expected: &str) {
+        use pretty_assertions::assert_eq;
+
         let input = input.as_bytes();
         let expected = expected.as_bytes();
 
@@ -15,10 +17,6 @@ pub trait PreProcessor: Sized + Default {
         let actual = String::from_utf8_lossy(&actual);
         let expected = String::from_utf8_lossy(expected);
 
-        if actual != expected {
-            dbg!((&input, &actual, &expected));
-        }
-
         // The input and output should have the exact same length.
         assert_eq!(input.len(), actual.len());
         assert_eq!(actual.len(), expected.len());

crates/oxide/src/extractor/pre_processors/pre_processor.rs

@@ -10,16 +10,16 @@ use std::sync;
 
 static TEMPLATE_START_REGEX: sync::LazyLock<Regex> = sync::LazyLock::new(|| {
     RegexBuilder::new(r#"\s*([a-z0-9_-]+)_template\s*<<[-~]?([A-Z]+)$"#)
-      .multi_line(true)
-      .build()
-      .unwrap()
+        .multi_line(true)
+        .build()
+        .unwrap()
 });
 
 static TEMPLATE_END_REGEX: sync::LazyLock<Regex> = sync::LazyLock::new(|| {
-  RegexBuilder::new(r#"^\s*([A-Z]+)"#)
-    .multi_line(true)
-    .build()
-    .unwrap()
+    RegexBuilder::new(r#"^\s*([A-Z]+)"#)
+        .multi_line(true)
+        .build()
+        .unwrap()
 });
 
 #[derive(Debug, Default)]
@@ -36,39 +36,43 @@ impl PreProcessor for Ruby {
         // https://viewcomponent.org/guide/templates.html#interpolations
         let content_as_str = std::str::from_utf8(content).unwrap();
 
-        let starts = TEMPLATE_START_REGEX.captures_iter(content_as_str).collect::<Vec<_>>();
-        let ends = TEMPLATE_END_REGEX.captures_iter(content_as_str).collect::<Vec<_>>();
+        let starts = TEMPLATE_START_REGEX
+            .captures_iter(content_as_str)
+            .collect::<Vec<_>>();
+        let ends = TEMPLATE_END_REGEX
+            .captures_iter(content_as_str)
+            .collect::<Vec<_>>();
 
         for start in starts.iter() {
-          // The language for this block
-          let lang = start.get(1).unwrap().as_str();
+            // The language for this block
+            let lang = start.get(1).unwrap().as_str();
 
-          // The HEREDOC delimiter
-          let delimiter_start = start.get(2).unwrap().as_str();
+            // The HEREDOC delimiter
+            let delimiter_start = start.get(2).unwrap().as_str();
 
-          // Where the "body" starts for the HEREDOC block
-          let body_start = start.get(0).unwrap().end();
+            // Where the "body" starts for the HEREDOC block
+            let body_start = start.get(0).unwrap().end();
 
-          // Look through all of the ends to find a matching language
-          for end in ends.iter() {
-            // 1. This must appear after the start
-            let body_end = end.get(0).unwrap().start();
-            if body_end < body_start {
-              continue;
-            }
+            // Look through all of the ends to find a matching language
+            for end in ends.iter() {
+                // 1. This must appear after the start
+                let body_end = end.get(0).unwrap().start();
+                if body_end < body_start {
+                    continue;
+                }
 
-            // The languages must match otherwise we haven't found the end
-            let delimiter_end = end.get(1).unwrap().as_str();
-            if delimiter_end != delimiter_start {
-              continue;
-            }
+                // The languages must match otherwise we haven't found the end
+                let delimiter_end = end.get(1).unwrap().as_str();
+                if delimiter_end != delimiter_start {
+                    continue;
+                }
 
-            let body = &content_as_str[body_start..body_end];
-            let replaced = pre_process_input(body.as_bytes(), &lang.to_ascii_lowercase());
+                let body = &content_as_str[body_start..body_end];
+                let replaced = pre_process_input(body.as_bytes(), &lang.to_ascii_lowercase());
 
-            result.replace_range(body_start..body_end, replaced);
-            break;
-          }
+                result.replace_range(body_start..body_end, replaced);
+                break;
+            }
         }
 
         // Ruby extraction

crates/oxide/src/extractor/pre_processors/ruby.rs

@@ -87,6 +87,7 @@ enum Class {
 mod tests {
     use super::StringMachine;
     use crate::extractor::machine::Machine;
+    use pretty_assertions::assert_eq;
 
     #[test]
     #[ignore]

crates/oxide/src/extractor/string_machine.rs

@@ -192,6 +192,7 @@ enum Class {
 mod tests {
     use super::UtilityMachine;
     use crate::extractor::machine::Machine;
+    use pretty_assertions::assert_eq;
 
     #[test]
     #[ignore]
@@ -336,7 +337,7 @@ mod tests {
                 actual.sort();
 
                 if actual != expected {
-                    dbg!(&input, &expected, &actual);
+                    dbg!(&input);
                 }
                 assert_eq!(actual, expected);
             }

crates/oxide/src/extractor/utility_machine.rs

@@ -80,6 +80,7 @@ enum Class {
 mod tests {
     use super::VariantMachine;
     use crate::extractor::machine::Machine;
+    use pretty_assertions::assert_eq;
 
     #[test]
     #[ignore]

crates/oxide/src/extractor/variant_machine.rs

@@ -191,6 +191,7 @@ mod tests {
     use super::optimize_patterns;
     use crate::GlobEntry;
     use bexpand::Expression;
+    use pretty_assertions::assert_eq;
     use std::process::Command;
     use std::{fs, path};
     use tempfile::tempdir;

crates/oxide/src/glob.rs

@@ -664,6 +664,7 @@ fn create_walker(sources: Sources) -> Option<WalkBuilder> {
 #[cfg(test)]
 mod tests {
     use super::{ChangedContent, Scanner};
+    use pretty_assertions::assert_eq;
 
     #[test]
     fn test_positions() {

crates/oxide/src/scanner/mod.rs

@@ -128,14 +128,8 @@ impl PublicSourceEntry {
                         .to_string_lossy()
                         .to_string();
                     // Ensure leading slash, otherwise it will match against all files in all folders/
-                    self.pattern = format!(
-                        "/{}",
-                        resolved_path
-                            .file_name()
-                            .unwrap()
-                            .to_string_lossy()
-                            .to_string()
-                    );
+                    self.pattern =
+                        format!("/{}", resolved_path.file_name().unwrap().to_string_lossy());
                 }
                 _ => {}
             }

crates/oxide/src/scanner/sources.rs

@@ -1,5 +1,6 @@
 #[cfg(test)]
 mod scanner {
+    use pretty_assertions::assert_eq;
     use std::path::{Path, PathBuf};
     use std::process::Command;
     use std::thread::sleep;