fix: handle Cargo.lock and Cargo.toml changes in ripples command (#28)

When Cargo.lock or Cargo.toml files at a workspace root are changed, all
workspace members are now correctly marked as directly affected. This ensures
that dependency version changes (via Cargo.lock) and workspace configuration
changes (via Cargo.toml) properly propagate to all affected crates.

Added comprehensive test coverage for various scenarios including nested
workspaces and standalone crates.

Author: brndnmtthws

src/commands/affected.rs

@@ -1,7 +1,7 @@
 //! Ripples command implementation
 
 use std::collections::{HashMap, HashSet};
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use miette::{Result, WrapErr};
 use petgraph::graph::{DiGraph, NodeIndex};
@@ -177,6 +177,42 @@ impl AffectedAnalysis {
         })
     }
 
+    /// Handle workspace-level Cargo files (Cargo.toml or Cargo.lock)
+    fn handle_workspace_cargo_file(
+        &self,
+        abs_file: &Path,
+        cwd: &Path,
+        directly_affected_crates: &mut HashSet<String>,
+        directly_affected_crate_paths: &mut HashSet<(String, PathBuf)>,
+    ) -> bool {
+        // Check if this file is at a workspace root
+        for ws_path in self.workspaces.keys() {
+            let abs_ws_path = if ws_path.is_absolute() {
+                ws_path.clone()
+            } else {
+                cwd.join(ws_path)
+            };
+            let abs_ws_path = abs_ws_path.canonicalize().unwrap_or(abs_ws_path);
+
+            // Check if the Cargo file is directly in the workspace root
+            if let Some(parent) = abs_file.parent()
+                && parent == abs_ws_path
+            {
+                // This is a workspace-level Cargo file
+                // Mark all crates in this workspace as directly affected
+                for ((crate_name, crate_path), crate_ws_path) in &self.crate_path_to_workspace {
+                    if crate_ws_path == ws_path {
+                        directly_affected_crates.insert(crate_name.clone());
+                        directly_affected_crate_paths
+                            .insert((crate_name.clone(), crate_path.clone()));
+                    }
+                }
+                return true;
+            }
+        }
+        false
+    }
+
     /// Analyze which crates and workspaces are affected by the given files
     pub fn analyze_affected_files(&self, files: &[String]) -> AffectedResult {
         let mut directly_affected_crates = HashSet::new();
@@ -199,6 +235,22 @@ impl AffectedAnalysis {
             // Try to canonicalize to resolve symlinks (e.g., /private/var -> /var on macOS)
             let abs_file = abs_file.canonicalize().unwrap_or(abs_file);
 
+            // Check if this is a Cargo.lock or Cargo.toml file
+            let filename = abs_file.file_name().and_then(|f| f.to_str());
+            let is_cargo_file = matches!(filename, Some("Cargo.lock") | Some("Cargo.toml"));
+
+            // Handle workspace-level Cargo files
+            if is_cargo_file
+                && self.handle_workspace_cargo_file(
+                    &abs_file,
+                    &cwd,
+                    &mut directly_affected_crates,
+                    &mut directly_affected_crate_paths,
+                )
+            {
+                continue;
+            }
+
             // Try to find by checking if file is under any crate directory
             // When multiple crates match, prefer the one with the longest matching path
             let mut best_match: Option<(String, PathBuf, usize)> = None;
@@ -570,6 +622,24 @@ name = "crate-b"
         )
         .unwrap();
 
+        // Add Cargo.lock file to the workspace root
+        fs::write(
+            root.join("my-workspace/Cargo.lock"),
+            r#"# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "crate-a"
+version = "0.1.0"
+
+[[package]]
+name = "crate-b"
+version = "0.1.0"
+"#,
+        )
+        .unwrap();
+
         temp
     }
 
@@ -1096,12 +1166,12 @@ version = "0.1.0"
         let files = vec![format!("{}/my-workspace/Cargo.toml", temp.path().display())];
         let result = analysis.analyze_affected_files(&files);
 
-        // Workspace Cargo.toml should not map to any specific crate
-        assert_eq!(result.unmatched_files.len(), 1);
-        assert_eq!(
-            result.unmatched_files[0],
-            format!("{}/my-workspace/Cargo.toml", temp.path().display())
-        );
+        // Workspace Cargo.toml should affect all workspace members
+        assert_eq!(result.directly_affected_crates.len(), 2);
+        assert!(result.directly_affected_crates.contains("crate-a"));
+        assert!(result.directly_affected_crates.contains("crate-b"));
+        assert!(result.directly_affected_workspaces.contains("my-workspace"));
+        assert!(result.unmatched_files.is_empty());
     }
 
     #[test]
@@ -1123,10 +1193,226 @@ version = "0.1.0"
                 .contains("standalone-test-crate")
         );
 
-        // Workspace Cargo.lock should not map to any specific crate
-        assert!(result.unmatched_files.contains(&format!(
-            "{}/real-workspace/Cargo.lock",
+        // Workspace Cargo.lock should affect all workspace members
+        assert!(result.directly_affected_crates.contains("crate-a"));
+        assert!(result.directly_affected_crates.contains("crate-b"));
+
+        // No unmatched files
+        assert!(result.unmatched_files.is_empty());
+    }
+
+    #[test]
+    fn test_workspace_cargo_lock_affects_all_members() {
+        let temp = create_simple_test_workspace();
+        let analysis = build_test_analysis(temp.path());
+
+        // Test that changing Cargo.lock at workspace root affects all members
+        let files = vec![format!("{}/my-workspace/Cargo.lock", temp.path().display())];
+        let result = analysis.analyze_affected_files(&files);
+
+        // All workspace members should be directly affected
+        assert!(result.directly_affected_crates.contains("crate-a"));
+        assert!(result.directly_affected_crates.contains("crate-b"));
+        assert_eq!(result.directly_affected_crates.len(), 2);
+
+        // The workspace should be affected
+        assert!(result.directly_affected_workspaces.contains("my-workspace"));
+
+        // No unmatched files
+        assert!(result.unmatched_files.is_empty());
+    }
+
+    #[test]
+    fn test_workspace_cargo_toml_affects_all_members() {
+        let temp = create_simple_test_workspace();
+        let analysis = build_test_analysis(temp.path());
+
+        // Test that changing workspace Cargo.toml affects all members
+        let files = vec![format!("{}/my-workspace/Cargo.toml", temp.path().display())];
+        let result = analysis.analyze_affected_files(&files);
+
+        // All workspace members should be directly affected
+        assert!(result.directly_affected_crates.contains("crate-a"));
+        assert!(result.directly_affected_crates.contains("crate-b"));
+        assert_eq!(result.directly_affected_crates.len(), 2);
+
+        // The workspace should be affected
+        assert!(result.directly_affected_workspaces.contains("my-workspace"));
+
+        // No unmatched files
+        assert!(result.unmatched_files.is_empty());
+    }
+
+    #[test]
+    fn test_standalone_cargo_lock_affects_only_that_crate() {
+        let temp = create_mixed_workspace_and_standalone();
+        let analysis = build_test_analysis(temp.path());
+
+        // Test that changing a standalone crate's Cargo.lock only affects that crate
+        let files = vec![format!(
+            "{}/standalone-test-crate/Cargo.lock",
+            temp.path().display()
+        )];
+        let result = analysis.analyze_affected_files(&files);
+
+        // Only the standalone crate should be affected
+        assert!(
+            result
+                .directly_affected_crates
+                .contains("standalone-test-crate")
+        );
+        assert_eq!(result.directly_affected_crates.len(), 1);
+
+        // No workspace members should be affected
+        assert!(!result.directly_affected_crates.contains("crate-a"));
+        assert!(!result.directly_affected_crates.contains("crate-b"));
+
+        // No unmatched files
+        assert!(result.unmatched_files.is_empty());
+    }
+
+    #[test]
+    fn test_crate_cargo_toml_affects_dependents() {
+        let temp = create_simple_test_workspace();
+        let analysis = build_test_analysis(temp.path());
+
+        // Test that changing a crate's Cargo.toml affects its dependents
+        let files = vec![format!(
+            "{}/my-workspace/crate-b/Cargo.toml",
             temp.path().display()
-        )));
+        )];
+        let result = analysis.analyze_affected_files(&files);
+
+        // crate-b should be directly affected
+        assert!(result.directly_affected_crates.contains("crate-b"));
+        assert_eq!(result.directly_affected_crates.len(), 1);
+
+        // crate-a depends on crate-b, so it should be affected through reverse
+        // dependencies
+        assert!(result.all_affected_crates.contains("crate-a"));
+        assert!(result.all_affected_crates.contains("crate-b"));
+        assert_eq!(result.all_affected_crates.len(), 2);
+    }
+
+    #[test]
+    fn test_multiple_cargo_files_affected() {
+        let temp = create_simple_test_workspace();
+        let analysis = build_test_analysis(temp.path());
+
+        // Test multiple Cargo files changed at once
+        let files = vec![
+            format!("{}/my-workspace/Cargo.toml", temp.path().display()),
+            format!("{}/my-workspace/Cargo.lock", temp.path().display()),
+            format!("{}/my-workspace/crate-a/Cargo.toml", temp.path().display()),
+        ];
+        let result = analysis.analyze_affected_files(&files);
+
+        // All crates should be directly affected
+        assert!(result.directly_affected_crates.contains("crate-a"));
+        assert!(result.directly_affected_crates.contains("crate-b"));
+        assert_eq!(result.directly_affected_crates.len(), 2);
+
+        // No unmatched files
+        assert!(result.unmatched_files.is_empty());
+    }
+
+    #[test]
+    fn test_nested_workspace_cargo_lock() {
+        let temp = TempDir::new().unwrap();
+        let root = temp.path();
+
+        // Create a nested workspace structure
+        fs::create_dir_all(root.join("outer-workspace")).unwrap();
+        fs::write(
+            root.join("outer-workspace/Cargo.toml"),
+            r#"
+[workspace]
+members = ["inner-workspace", "outer-crate"]
+"#,
+        )
+        .unwrap();
+
+        // Create inner workspace
+        fs::create_dir_all(root.join("outer-workspace/inner-workspace")).unwrap();
+        fs::write(
+            root.join("outer-workspace/inner-workspace/Cargo.toml"),
+            r#"
+[workspace]
+members = ["inner-crate-a", "inner-crate-b"]
+"#,
+        )
+        .unwrap();
+
+        // Create crates
+        fs::create_dir_all(root.join("outer-workspace/inner-workspace/inner-crate-a/src")).unwrap();
+        fs::write(
+            root.join("outer-workspace/inner-workspace/inner-crate-a/Cargo.toml"),
+            r#"
+[package]
+name = "inner-crate-a"
+"#,
+        )
+        .unwrap();
+        fs::write(
+            root.join("outer-workspace/inner-workspace/inner-crate-a/src/lib.rs"),
+            "pub fn func() {}",
+        )
+        .unwrap();
+
+        fs::create_dir_all(root.join("outer-workspace/inner-workspace/inner-crate-b/src")).unwrap();
+        fs::write(
+            root.join("outer-workspace/inner-workspace/inner-crate-b/Cargo.toml"),
+            r#"
+[package]
+name = "inner-crate-b"
+"#,
+        )
+        .unwrap();
+        fs::write(
+            root.join("outer-workspace/inner-workspace/inner-crate-b/src/lib.rs"),
+            "pub fn func() {}",
+        )
+        .unwrap();
+
+        fs::create_dir_all(root.join("outer-workspace/outer-crate/src")).unwrap();
+        fs::write(
+            root.join("outer-workspace/outer-crate/Cargo.toml"),
+            r#"
+[package]
+name = "outer-crate"
+"#,
+        )
+        .unwrap();
+        fs::write(
+            root.join("outer-workspace/outer-crate/src/lib.rs"),
+            "pub fn func() {}",
+        )
+        .unwrap();
+
+        // Add Cargo.lock files
+        fs::write(
+            root.join("outer-workspace/Cargo.lock"),
+            "# Outer workspace lock file",
+        )
+        .unwrap();
+        fs::write(
+            root.join("outer-workspace/inner-workspace/Cargo.lock"),
+            "# Inner workspace lock file",
+        )
+        .unwrap();
+
+        let analysis = build_test_analysis(root);
+
+        // Test that inner workspace Cargo.lock only affects inner crates
+        let files = vec![format!(
+            "{}/outer-workspace/inner-workspace/Cargo.lock",
+            root.display()
+        )];
+        let result = analysis.analyze_affected_files(&files);
+
+        assert!(result.directly_affected_crates.contains("inner-crate-a"));
+        assert!(result.directly_affected_crates.contains("inner-crate-b"));
+        assert!(!result.directly_affected_crates.contains("outer-crate"));
+        assert_eq!(result.directly_affected_crates.len(), 2);
     }
 }