A bit of cleanup (#17394)

RobinMalfait · web-flow · commit eecb6f7476e8 · 2025-03-26T12:08:53.000-04:00
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.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/oxide/Cargo.toml b/crates/oxide/Cargo.toml
@@ -22,3 +22,4 @@ regex = "1.11.1"
 
 [dev-dependencies]
 tempfile = "3.13.0"
+pretty_assertions = "1.4.1"
diff --git a/crates/oxide/src/cursor.rs b/crates/oxide/src/cursor.rs
@@ -119,6 +119,7 @@ impl Display for Cursor<'_> {
 #[cfg(test)]
 mod test {
     use super::*;
+    use pretty_assertions::assert_eq;
 
     #[test]
     fn test_cursor() {
diff --git a/crates/oxide/src/extractor/arbitrary_property_machine.rs b/crates/oxide/src/extractor/arbitrary_property_machine.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);
             }
diff --git a/crates/oxide/src/extractor/arbitrary_value_machine.rs b/crates/oxide/src/extractor/arbitrary_value_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]
diff --git a/crates/oxide/src/extractor/arbitrary_variable_machine.rs b/crates/oxide/src/extractor/arbitrary_variable_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]
diff --git a/crates/oxide/src/extractor/candidate_machine.rs b/crates/oxide/src/extractor/candidate_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);
diff --git a/crates/oxide/src/extractor/css_variable_machine.rs b/crates/oxide/src/extractor/css_variable_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);
diff --git a/crates/oxide/src/extractor/mod.rs b/crates/oxide/src/extractor/mod.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);
     }
diff --git a/crates/oxide/src/extractor/modifier_machine.rs b/crates/oxide/src/extractor/modifier_machine.rs
@@ -121,6 +121,7 @@ enum Class {
 mod tests {
     use super::ModifierMachine;
     use crate::extractor::machine::Machine;
+    use pretty_assertions::assert_eq;
 
     #[test]
     #[ignore]
diff --git a/crates/oxide/src/extractor/named_utility_machine.rs b/crates/oxide/src/extractor/named_utility_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);
             }
diff --git a/crates/oxide/src/extractor/named_variant_machine.rs b/crates/oxide/src/extractor/named_variant_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);
         }
diff --git a/crates/oxide/src/extractor/pre_processors/haml.rs b/crates/oxide/src/extractor/pre_processors/haml.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() {
diff --git a/crates/oxide/src/extractor/pre_processors/pre_processor.rs b/crates/oxide/src/extractor/pre_processors/pre_processor.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());
diff --git a/crates/oxide/src/extractor/pre_processors/ruby.rs b/crates/oxide/src/extractor/pre_processors/ruby.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
diff --git a/crates/oxide/src/extractor/string_machine.rs b/crates/oxide/src/extractor/string_machine.rs
@@ -87,6 +87,7 @@ enum Class {
 mod tests {
     use super::StringMachine;
     use crate::extractor::machine::Machine;
+    use pretty_assertions::assert_eq;
 
     #[test]
     #[ignore]
diff --git a/crates/oxide/src/extractor/utility_machine.rs b/crates/oxide/src/extractor/utility_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);
             }
diff --git a/crates/oxide/src/extractor/variant_machine.rs b/crates/oxide/src/extractor/variant_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]
diff --git a/crates/oxide/src/glob.rs b/crates/oxide/src/glob.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;
diff --git a/crates/oxide/src/scanner/mod.rs b/crates/oxide/src/scanner/mod.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() {
diff --git a/crates/oxide/src/scanner/sources.rs b/crates/oxide/src/scanner/sources.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());
                 }
                 _ => {}
             }
diff --git a/crates/oxide/tests/scanner.rs b/crates/oxide/tests/scanner.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;

Original file line number	Diff line number	Diff line change
`@@ -22,3 +22,4 @@ regex = "1.11.1"`
`22`	`22`
`23`	`23`	`[dev-dependencies]`
`24`	`24`	`tempfile = "3.13.0"`
	`25`	`+pretty_assertions = "1.4.1"`
Original file line number	Diff line number	Diff line change
`@@ -307,6 +307,7 @@ enum Class {`
`307`	`307`	`mod tests {`
`308`	`308`	`use super::{ArbitraryPropertyMachine, IdleState};`
`309`	`309`	`use crate::extractor::machine::Machine;`
	`310`	`+ use pretty_assertions::assert_eq;`
`310`	`311`
`311`	`312`	`#[test]`
`312`	`313`	`#[ignore]`
`@@ -413,7 +414,7 @@ mod tests {`
`413`	`414`	`let actual = ArbitraryPropertyMachine::<IdleState>::test_extract_all(&input);`
`414`	`415`
`415`	`416`	`if actual != expected {`
`416`		`- dbg!(&input, &actual, &expected);`
	`417`	`+ dbg!(&input);`
`417`	`418`	`}`
`418`	`419`	`assert_eq!(actual, expected);`
`419`	`420`	`}`
Original file line number	Diff line number	Diff line change
`@@ -199,6 +199,7 @@ fn drop_covered_spans(mut spans: Vec<Span>) -> Vec<Span> {`
`199`	`199`	`mod tests {`
`200`	`200`	`use super::{Extracted, Extractor};`
`201`	`201`	`use crate::throughput::Throughput;`
	`202`	`+ use pretty_assertions::assert_eq;`
`202`	`203`	`use std::hint::black_box;`
`203`	`204`
`204`	`205`	`fn pre_process_input(input: &str, extension: &str) -> String {`
`@@ -244,7 +245,7 @@ mod tests {`
`244`	`245`	`expected.dedup();`
`245`	`246`
`246`	`247`	`if actual != expected {`
`247`		`- dbg!(&input, &actual, &expected);`
	`248`	`+ dbg!(&input);`
`248`	`249`	`}`
`249`	`250`	`assert_eq!(actual, expected);`
`250`	`251`	`}`
`@@ -272,7 +273,7 @@ mod tests {`
`272`	`273`	`expected.sort();`
`273`	`274`
`274`	`275`	`if actual != expected {`
`275`		`- dbg!(&input, &actual, &expected);`
	`276`	`+ dbg!(&input);`
`276`	`277`	`}`
`277`	`278`	`assert_eq!(actual, expected);`
`278`	`279`	`}`