Merge pull request #4 from oli-obk/fmt

Rustfmt everything

Author: oli-obk

.github/workflows/rust.yml

@@ -10,8 +10,19 @@ env:
   CARGO_TERM_COLOR: always
 
 jobs:
-  build:
+  style:
+    name: style checks
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Format
+      run: cargo fmt --check
+    - name: Clippy
+      run: cargo clippy -- -D warnings
 
+  build:
+  
     runs-on: ubuntu-latest
 
     steps:

src/dependencies.rs

@@ -40,7 +40,10 @@ pub fn build_dependencies(config: &Config) -> Result<Dependencies> {
     let setup_command = |cmd: &mut Command| {
         cmd.envs(envs.iter().map(|(k, v)| (k, v)));
         cmd.arg("--manifest-path").arg(manifest_path);
-        if matches!(config.output_conflict_handling, OutputConflictHandling::Error) {
+        if matches!(
+            config.output_conflict_handling,
+            OutputConflictHandling::Error
+        ) {
             cmd.arg("--locked");
         }
     };
@@ -124,13 +127,19 @@ pub fn build_dependencies(config: &Config) -> Result<Dependencies> {
                     .id;
                 // Return the name chosen in `Cargo.toml` and the path to the corresponding artifact
                 (
-                    package.rename.clone().unwrap_or_else(|| package.name.clone()),
+                    package
+                        .rename
+                        .clone()
+                        .unwrap_or_else(|| package.name.clone()),
                     artifacts.remove(id).expect("package without artifact"),
                 )
             })
             .collect();
         let import_paths = import_paths.into_iter().collect();
-        return Ok(Dependencies { dependencies, import_paths });
+        return Ok(Dependencies {
+            dependencies,
+            import_paths,
+        });
     }
 
     bail!("no json found in cargo-metadata output")

src/lib.rs

@@ -115,8 +115,10 @@ pub fn run_tests(mut config: Config) -> Result<()> {
                 if path.is_dir() {
                     // Enqueue everything inside this directory.
                     // We want it sorted, to have some control over scheduling of slow tests.
-                    let mut entries =
-                        std::fs::read_dir(path).unwrap().collect::<Result<Vec<_>, _>>().unwrap();
+                    let mut entries = std::fs::read_dir(path)
+                        .unwrap()
+                        .collect::<Result<Vec<_>, _>>()
+                        .unwrap();
                     entries.sort_by_key(|e| e.file_name());
                     for entry in entries {
                         todo.push_back(entry.path());
@@ -178,7 +180,11 @@ pub fn run_tests(mut config: Config) -> Result<()> {
                 for path in &receive {
                     if !config.path_filter.is_empty() {
                         let path_display = path.display().to_string();
-                        if !config.path_filter.iter().any(|filter| path_display.contains(filter)) {
+                        if !config
+                            .path_filter
+                            .iter()
+                            .any(|filter| path_display.contains(filter))
+                        {
                             filtered.fetch_add(1, Ordering::Relaxed);
                             continue;
                         }
@@ -192,8 +198,10 @@ pub fn run_tests(mut config: Config) -> Result<()> {
                         continue;
                     }
                     // Run the test for all revisions
-                    for revision in
-                        comments.revisions.clone().unwrap_or_else(|| vec![String::new()])
+                    for revision in comments
+                        .revisions
+                        .clone()
+                        .unwrap_or_else(|| vec![String::new()])
                     {
                         let (m, errors, stderr) =
                             run_test(&path, &config, &target, &revision, &comments);
@@ -248,12 +256,17 @@ pub fn run_tests(mut config: Config) -> Result<()> {
             for error in errors {
                 match error {
                     Error::ExitStatus(mode, exit_status) => eprintln!("{mode:?} got {exit_status}"),
-                    Error::PatternNotFound { pattern, definition_line } => {
+                    Error::PatternNotFound {
+                        pattern,
+                        definition_line,
+                    } => {
                         match pattern {
-                            Pattern::SubString(s) =>
-                                eprintln!("substring `{s}` {} in stderr output", "not found".red()),
-                            Pattern::Regex(r) =>
-                                eprintln!("`/{r}/` does {} stderr output", "not match".red()),
+                            Pattern::SubString(s) => {
+                                eprintln!("substring `{s}` {} in stderr output", "not found".red())
+                            }
+                            Pattern::Regex(r) => {
+                                eprintln!("`/{r}/` does {} stderr output", "not match".red())
+                            }
                         }
                         eprintln!(
                             "expected because of pattern here: {}:{definition_line}",
@@ -263,11 +276,19 @@ pub fn run_tests(mut config: Config) -> Result<()> {
                     Error::NoPatternsFound => {
                         eprintln!("{}", "no error patterns found in failure test".red());
                     }
-                    Error::PatternFoundInPassTest =>
-                        eprintln!("{}", "error pattern found in success test".red()),
-                    Error::OutputDiffers { path, actual, expected } => {
+                    Error::PatternFoundInPassTest => {
+                        eprintln!("{}", "error pattern found in success test".red())
+                    }
+                    Error::OutputDiffers {
+                        path,
+                        actual,
+                        expected,
+                    } => {
                         eprintln!("actual output differed from expected {}", path.display());
-                        eprintln!("{}", pretty_assertions::StrComparison::new(expected, actual));
+                        eprintln!(
+                            "{}",
+                            pretty_assertions::StrComparison::new(expected, actual)
+                        );
                         eprintln!()
                     }
                     Error::ErrorsWithoutPattern { path: None, msgs } => {
@@ -279,7 +300,10 @@ pub fn run_tests(mut config: Config) -> Result<()> {
                             eprintln!("    {level:?}: {message}")
                         }
                     }
-                    Error::ErrorsWithoutPattern { path: Some((path, line)), msgs } => {
+                    Error::ErrorsWithoutPattern {
+                        path: Some((path, line)),
+                        msgs,
+                    } => {
                         eprintln!(
                             "There were {} unmatched diagnostics at {}:{line}",
                             msgs.len(),
@@ -457,16 +481,24 @@ fn check_annotations(
         {
             messages_from_unknown_file_or_line.remove(i);
         } else {
-            errors.push(Error::PatternNotFound { pattern: error_pattern.clone(), definition_line });
+            errors.push(Error::PatternNotFound {
+                pattern: error_pattern.clone(),
+                definition_line,
+            });
         }
     }
 
     // The order on `Level` is such that `Error` is the highest level.
     // We will ensure that *all* diagnostics of level at least `lowest_annotation_level`
     // are matched.
     let mut lowest_annotation_level = Level::Error;
-    for &ErrorMatch { ref pattern, revision: ref rev, definition_line, line, level } in
-        &comments.error_matches
+    for &ErrorMatch {
+        ref pattern,
+        revision: ref rev,
+        definition_line,
+        line,
+        level,
+    } in &comments.error_matches
     {
         if let Some(rev) = rev {
             if rev != revision {
@@ -480,22 +512,28 @@ fn check_annotations(
         lowest_annotation_level = std::cmp::min(lowest_annotation_level, level);
 
         if let Some(msgs) = messages.get_mut(line) {
-            let found =
-                msgs.iter().position(|msg| pattern.matches(&msg.message) && msg.level == level);
+            let found = msgs
+                .iter()
+                .position(|msg| pattern.matches(&msg.message) && msg.level == level);
             if let Some(found) = found {
                 msgs.remove(found);
                 continue;
             }
         }
 
-        errors.push(Error::PatternNotFound { pattern: pattern.clone(), definition_line });
+        errors.push(Error::PatternNotFound {
+            pattern: pattern.clone(),
+            definition_line,
+        });
     }
 
     let filter = |msgs: Vec<Message>| -> Vec<_> {
         msgs.into_iter()
             .filter(|msg| {
                 msg.level
-                    >= comments.require_annotations_for_level.unwrap_or(lowest_annotation_level)
+                    >= comments
+                        .require_annotations_for_level
+                        .unwrap_or(lowest_annotation_level)
             })
             .collect()
     };
@@ -511,12 +549,17 @@ fn check_annotations(
     for (line, msgs) in messages.into_iter().enumerate() {
         let msgs = filter(msgs);
         if !msgs.is_empty() {
-            errors
-                .push(Error::ErrorsWithoutPattern { path: Some((path.to_path_buf(), line)), msgs });
+            errors.push(Error::ErrorsWithoutPattern {
+                path: Some((path.to_path_buf(), line)),
+                msgs,
+            });
         }
     }
 
-    match (config.mode, comments.error_pattern.is_some() || !comments.error_matches.is_empty()) {
+    match (
+        config.mode,
+        comments.error_pattern.is_some() || !comments.error_matches.is_empty(),
+    ) {
         (Mode::Pass, true) | (Mode::Panic, true) => errors.push(Error::PatternFoundInPassTest),
         (Mode::Fail, false) => errors.push(Error::NoPatternsFound),
         _ => {}
@@ -536,12 +579,13 @@ fn check_output(
     let output = normalize(path, output, filters, comments);
     let path = output_path(path, comments, kind, target);
     match config.output_conflict_handling {
-        OutputConflictHandling::Bless =>
+        OutputConflictHandling::Bless => {
             if output.is_empty() {
                 let _ = std::fs::remove_file(path);
             } else {
                 std::fs::write(path, &output).unwrap();
-            },
+            }
+        }
         OutputConflictHandling::Error => {
             let expected_output = std::fs::read_to_string(&path).unwrap_or_default();
             if output != expected_output {
@@ -573,10 +617,17 @@ fn test_condition(condition: &Condition, target: &str, config: &Config) -> bool
 
 /// Returns whether according to the in-file conditions, this file should be run.
 fn test_file_conditions(comments: &Comments, target: &str, config: &Config) -> bool {
-    if comments.ignore.iter().any(|c| test_condition(c, target, config)) {
+    if comments
+        .ignore
+        .iter()
+        .any(|c| test_condition(c, target, config))
+    {
         return false;
     }
-    comments.only.iter().all(|c| test_condition(c, target, config))
+    comments
+        .only
+        .iter()
+        .all(|c| test_condition(c, target, config))
 }
 
 // Taken 1:1 from compiletest-rs