refactor: merge duplicate fix arms, extract helpers, single-pass counting

Author: RomarQ

src/diagnostic.rs

@@ -95,14 +95,13 @@ pub struct Summary {
 
 impl DiagnosticReport {
     pub fn new(diagnostics: Vec<Diagnostic>) -> Self {
-        let errors = diagnostics
-            .iter()
-            .filter(|d| d.severity == Severity::Error)
-            .count();
-        let warnings = diagnostics
-            .iter()
-            .filter(|d| d.severity == Severity::Warning)
-            .count();
+        let (mut errors, mut warnings) = (0, 0);
+        for d in &diagnostics {
+            match d.severity {
+                Severity::Error => errors += 1,
+                Severity::Warning => warnings += 1,
+            }
+        }
         Self {
             diagnostics,
             summary: Summary { errors, warnings },

src/fix.rs

@@ -22,30 +22,27 @@ pub fn apply_fixes(
 
     for diag in diagnostics {
         match &diag.check {
-            CheckKind::NotInherited => {
+            CheckKind::NotInherited | CheckKind::VersionMismatch => {
                 let member = diag.member.as_deref().unwrap_or("?");
                 let full_path = workspace_root.join(member);
                 if fix_member_dep(&full_path, &diag.dependency)? {
                     modified_files.insert(full_path);
                     fixes_applied += 1;
-                    actions.push(format!(
-                        "fixed: `{}` in {} now uses workspace inheritance",
-                        diag.dependency, member,
-                    ));
-                }
-            }
-            CheckKind::VersionMismatch => {
-                let member = diag.member.as_deref().unwrap_or("?");
-                let dep_ver = diag.version.as_deref().unwrap_or("?");
-                let ws_ver = diag.workspace_version.as_deref().unwrap_or("?");
-                let full_path = workspace_root.join(member);
-                if fix_member_dep(&full_path, &diag.dependency)? {
-                    modified_files.insert(full_path);
-                    fixes_applied += 1;
-                    actions.push(format!(
-                        "fixed: `{}` in {} changed from {} to {} (workspace version)",
-                        diag.dependency, member, dep_ver, ws_ver,
-                    ));
+                    let msg = match &diag.check {
+                        CheckKind::NotInherited => format!(
+                            "fixed: `{}` in {} now uses workspace inheritance",
+                            diag.dependency, member,
+                        ),
+                        CheckKind::VersionMismatch => format!(
+                            "fixed: `{}` in {} changed from {} to {} (workspace version)",
+                            diag.dependency,
+                            member,
+                            diag.version.as_deref().unwrap_or("?"),
+                            diag.workspace_version.as_deref().unwrap_or("?"),
+                        ),
+                        _ => unreachable!(),
+                    };
+                    actions.push(msg);
                 }
             }
             CheckKind::PromotionCandidate => {
@@ -283,14 +280,10 @@ mod tests {
     use super::*;
     use crate::check;
     use crate::workspace::parse_workspace;
-    use std::path::PathBuf;
 
     fn copy_fixture(name: &str) -> tempfile::TempDir {
-        let fixture_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-            .join("tests/fixtures")
-            .join(name);
         let tmp = tempfile::tempdir().unwrap();
-        copy_dir_recursive(&fixture_dir, tmp.path());
+        copy_dir_recursive(&crate::fixture(name), tmp.path());
         tmp
     }
 

src/workspace.rs

@@ -76,25 +76,8 @@ pub fn parse_workspace(path: &Path) -> Result<WorkspaceInfo, String> {
 
     let workspace_deps = parse_workspace_deps(workspace_table);
 
-    let member_patterns: Vec<String> = workspace_table
-        .get("members")
-        .and_then(|v| v.as_array())
-        .map(|arr| {
-            arr.iter()
-                .filter_map(|v| v.as_str().map(String::from))
-                .collect()
-        })
-        .unwrap_or_default();
-
-    let exclude_patterns: Vec<String> = workspace_table
-        .get("exclude")
-        .and_then(|v| v.as_array())
-        .map(|arr| {
-            arr.iter()
-                .filter_map(|v| v.as_str().map(String::from))
-                .collect()
-        })
-        .unwrap_or_default();
+    let member_patterns = get_string_array(workspace_table, "members");
+    let exclude_patterns = get_string_array(workspace_table, "exclude");
 
     let member_paths = expand_members(path, &member_patterns, &exclude_patterns)?;
 
@@ -114,6 +97,18 @@ pub fn parse_workspace(path: &Path) -> Result<WorkspaceInfo, String> {
     })
 }
 
+fn get_string_array(table: &toml_edit::Table, key: &str) -> Vec<String> {
+    table
+        .get(key)
+        .and_then(|v| v.as_array())
+        .map(|arr| {
+            arr.iter()
+                .filter_map(|v| v.as_str().map(String::from))
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
 fn parse_workspace_deps(workspace_table: &toml_edit::Table) -> BTreeMap<String, WorkspaceDep> {
     let mut deps = BTreeMap::new();
     let Some(dep_table) = workspace_table