cargo-rail: added metadata cache via FNV-1a instead of adding sha2/hex deps. extensive testing updates and fixes across the codebase for those end-to-end test bugs.

Author: loadingalias

src/cargo/metadata.rs

@@ -1,6 +1,7 @@
 use crate::error::RailResult;
 use cargo_metadata::{Dependency, DependencyKind, MetadataCommand, Package, Resolve, Target, TargetKind};
 use semver::Version;
+use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, HashSet};
 use std::path::Path;
 
@@ -11,7 +12,7 @@ use std::path::Path;
 /// - Resolved dependency graph with actual enabled features
 /// - MSRV and edition information
 /// - Platform-specific and optional dependencies
-#[derive(Clone)]
+#[derive(Clone, Serialize, Deserialize)]
 pub struct WorkspaceMetadata {
   metadata: cargo_metadata::Metadata,
 }

src/commands/affected.rs

@@ -73,10 +73,10 @@ fn get_changed_files(
   // Determine git range
   let changes = if let (Some(from_ref), Some(to_ref)) = (from, to) {
     // SHA pair mode: from..to
-    ctx.git.git().get_changed_files_between(from_ref, to_ref)?
+    ctx.git.git().get_changed_files_between(from_ref, Some(to_ref))?
   } else {
-    // Single ref mode: since..HEAD
-    ctx.git.git().get_changed_files_between(since, "HEAD")?
+    // Single ref mode: since..working tree
+    ctx.git.git().get_changed_files_between(since, None)?
   };
 
   // Extract just the file paths (ignore status char)

src/commands/config_sync.rs

@@ -139,6 +139,19 @@ impl ConfigSyncer for ToolchainSyncer {
   fn check(&self, workspace_root: &Path, config: &crate::config::RailConfig) -> RailResult<SyncStatus> {
     let toolchain_path = workspace_root.join("rust-toolchain.toml");
 
+    // If not managed by rail, skip sync
+    if !config.toolchain.managed_by_rail {
+      if toolchain_path.exists() {
+        return Ok(SyncStatus::InSync(
+          "rust-toolchain.toml exists but not managed by rail (managed_by_rail = false)".to_string(),
+        ));
+      } else {
+        return Ok(SyncStatus::OutOfSync(
+          "rust-toolchain.toml missing (set managed_by_rail = true to enable sync)".to_string(),
+        ));
+      }
+    }
+
     // If rust-toolchain.toml doesn't exist, it's out of sync
     if !toolchain_path.exists() {
       return Ok(SyncStatus::OutOfSync(
@@ -166,6 +179,19 @@ impl ConfigSyncer for ToolchainSyncer {
   fn sync(&self, workspace_root: &Path, config: &crate::config::RailConfig) -> RailResult<SyncStatus> {
     let toolchain_path = workspace_root.join("rust-toolchain.toml");
 
+    // If not managed by rail, skip sync
+    if !config.toolchain.managed_by_rail {
+      if toolchain_path.exists() {
+        return Ok(SyncStatus::InSync(
+          "rust-toolchain.toml not managed by rail (skipping sync)".to_string(),
+        ));
+      } else {
+        return Ok(SyncStatus::InSync(
+          "rust-toolchain.toml sync disabled (set managed_by_rail = true to enable)".to_string(),
+        ));
+      }
+    }
+
     // Check if already in sync
     let check_status = self.check(workspace_root, config)?;
     if matches!(check_status, SyncStatus::InSync(_)) {
@@ -183,6 +209,62 @@ impl ConfigSyncer for ToolchainSyncer {
   }
 }
 
+/// Parse existing rust-toolchain.toml and import into ToolchainConfig
+///
+/// Returns None if file doesn't exist or can't be parsed
+pub fn import_rust_toolchain_toml(workspace_root: &Path) -> Option<crate::config::ToolchainConfig> {
+  let toolchain_path = workspace_root.join("rust-toolchain.toml");
+
+  if !toolchain_path.exists() {
+    return None;
+  }
+
+  let content = std::fs::read_to_string(&toolchain_path).ok()?;
+
+  // Parse TOML using toml_edit which is already a dependency
+  let parsed: toml_edit::DocumentMut = content.parse().ok()?;
+  let toolchain_table = parsed.get("toolchain")?.as_table()?;
+
+  // Extract fields
+  let channel = toolchain_table
+    .get("channel")
+    .and_then(|v| v.as_str())
+    .unwrap_or("stable")
+    .to_string();
+
+  let path = toolchain_table
+    .get("path")
+    .and_then(|v| v.as_str())
+    .map(|s| s.to_string());
+
+  let profile = toolchain_table
+    .get("profile")
+    .and_then(|v| v.as_str())
+    .unwrap_or("default")
+    .to_string();
+
+  let components = toolchain_table
+    .get("components")
+    .and_then(|v| v.as_array())
+    .map(|arr| arr.iter().filter_map(|v| v.as_str()).map(|s| s.to_string()).collect())
+    .unwrap_or_default();
+
+  let targets = toolchain_table
+    .get("targets")
+    .and_then(|v| v.as_array())
+    .map(|arr| arr.iter().filter_map(|v| v.as_str()).map(|s| s.to_string()).collect())
+    .unwrap_or_default();
+
+  Some(crate::config::ToolchainConfig {
+    channel,
+    path,
+    profile,
+    components,
+    targets,
+    managed_by_rail: true, // Set to true when importing
+  })
+}
+
 /// Generate rust-toolchain.toml content from ToolchainConfig
 ///
 /// Supports all rust-toolchain.toml fields:
@@ -245,6 +327,7 @@ mod tests {
       profile: "default".to_string(),
       components: vec![],
       targets: vec![],
+      managed_by_rail: false,
     };
 
     let content = generate_rust_toolchain_toml(&config);
@@ -266,6 +349,7 @@ mod tests {
         "x86_64-unknown-linux-gnu".to_string(),
         "aarch64-apple-darwin".to_string(),
       ],
+      managed_by_rail: false,
     };
 
     let content = generate_rust_toolchain_toml(&config);
@@ -285,6 +369,7 @@ mod tests {
       profile: "default".to_string(),                        // Ignored in path mode
       components: vec!["clippy".to_string()],                // Ignored in path mode
       targets: vec!["x86_64-unknown-linux-gnu".to_string()], // Ignored in path mode
+      managed_by_rail: false,
     };
 
     let content = generate_rust_toolchain_toml(&config);

src/commands/init.rs

@@ -199,13 +199,19 @@ fn detect_workspace_patterns(ctx: &WorkspaceContext) -> WorkspacePatternInfo {
 }
 
 /// Detect toolchain configuration from existing rust-toolchain.toml
+///
+/// If rust-toolchain.toml exists, imports it and sets managed_by_rail = true.
+/// This enables bidirectional sync: rail.toml becomes the source of truth,
+/// and future syncs will update rust-toolchain.toml from rail.toml.
 fn detect_toolchain_config(workspace_root: &Path) -> RailResult<ToolchainConfig> {
   let toolchain_path = workspace_root.join("rust-toolchain.toml");
 
   if !toolchain_path.exists() {
     // Try rust-toolchain without .toml extension
     let alt_path = workspace_root.join("rust-toolchain");
     if !alt_path.exists() {
+      // No existing toolchain file - use default and don't enable management yet
+      // User can enable managed_by_rail = true manually if they want rail to create it
       return Ok(ToolchainConfig::default());
     }
 
@@ -216,6 +222,7 @@ fn detect_toolchain_config(workspace_root: &Path) -> RailResult<ToolchainConfig>
 
     return Ok(ToolchainConfig {
       channel,
+      managed_by_rail: true, // Imported from existing file
       ..ToolchainConfig::default()
     });
   }
@@ -251,6 +258,7 @@ fn detect_toolchain_config(workspace_root: &Path) -> RailResult<ToolchainConfig>
     profile: parsed.toolchain.profile.unwrap_or_else(|| "default".to_string()),
     components: parsed.toolchain.components.unwrap_or_default(),
     targets: parsed.toolchain.targets.unwrap_or_default(),
+    managed_by_rail: true, // Imported from existing file - rail now manages it
   })
 }
 
@@ -397,11 +405,12 @@ fn serialize_config_with_comments(config: &RailConfig) -> RailResult<String> {
   output.push_str("# rust-toolchain.toml automatically.\n");
   output.push_str("#\n");
   output.push_str("# Fields:\n");
-  output.push_str("#   channel    - Rust release channel (stable, beta, nightly, or version)\n");
-  output.push_str("#   path       - Path to custom toolchain (mutually exclusive with channel)\n");
-  output.push_str("#   profile    - Toolchain profile (minimal, default, complete)\n");
-  output.push_str("#   components - Additional components (clippy, rustfmt, rust-src, etc.)\n");
-  output.push_str("#   targets    - Cross-compilation targets\n\n");
+  output.push_str("#   channel         - Rust release channel (stable, beta, nightly, or version)\n");
+  output.push_str("#   path            - Path to custom toolchain (mutually exclusive with channel)\n");
+  output.push_str("#   profile         - Toolchain profile (minimal, default, complete)\n");
+  output.push_str("#   components      - Additional components (clippy, rustfmt, rust-src, etc.)\n");
+  output.push_str("#   targets         - Cross-compilation targets\n");
+  output.push_str("#   managed_by_rail - Enable rust-toolchain.toml sync (true if imported)\n\n");
 
   output.push_str("[toolchain]\n");
   if let Some(ref path) = config.toolchain.path {
@@ -443,6 +452,13 @@ fn serialize_config_with_comments(config: &RailConfig) -> RailResult<String> {
     output.push_str("targets = []  # e.g., [\"x86_64-unknown-linux-gnu\", \"aarch64-apple-darwin\"]\n");
   }
 
+  // Add managed_by_rail field
+  if config.toolchain.managed_by_rail {
+    output.push_str("managed_by_rail = true  # rust-toolchain.toml imported - rail now manages it\n");
+  } else {
+    output.push_str("managed_by_rail = false  # Set to true to enable rust-toolchain.toml sync\n");
+  }
+
   output.push('\n');
 
   // Dependency Unification

src/commands/unify.rs

@@ -501,17 +501,18 @@ pub fn run_unify_check(
 
   // Run optional per-target validation if CLI flag is set
   if validate_targets_flag {
-    // Get targets from config
+    // Get targets from config - use [unify].validate_targets which is the source of truth
     let targets = if let Some(cfg) = ctx.config.as_ref() {
-      if cfg.toolchain.targets.is_empty() {
-        println!("\n⚠️  --validate-targets flag set but no targets configured in rail.toml [toolchain.targets]");
-        println!("Add targets to .config/rail.toml to enable validation.");
+      if cfg.unify.validate_targets.is_empty() {
+        println!("\n⚠️  --validate-targets flag set but no targets configured in rail.toml [unify.validate_targets]");
+        println!("Add targets to .config/rail.toml under [unify] section to enable validation.");
+        println!("Example: validate_targets = [\"x86_64-unknown-linux-gnu\", \"wasm32-unknown-unknown\"]");
         return Ok(());
       }
-      cfg.toolchain.targets.clone()
+      cfg.unify.validate_targets.clone()
     } else {
       println!("\n⚠️  --validate-targets flag set but no rail.toml found");
-      println!("Run 'cargo rail init' to create a configuration file with [toolchain.targets].");
+      println!("Run 'cargo rail init' to create a configuration file with [unify.validate_targets].");
       return Ok(());
     };
 

src/config.rs

@@ -188,10 +188,21 @@ pub struct ToolchainConfig {
   pub components: Vec<String>,
 
   /// Target triples for cross-compilation
-  /// Used by unify for optional validation and by config sync for rust-toolchain.toml
+  /// Used by config sync for rust-toolchain.toml
   /// The host platform is automatically included. No effect if `path` is set.
   #[serde(default)]
   pub targets: Vec<String>,
+
+  /// Whether rust-toolchain.toml is managed by rail
+  ///
+  /// When true, cargo-rail will sync rail.toml `[toolchain]` → rust-toolchain.toml
+  /// When false, rust-toolchain.toml is assumed to be managed externally
+  ///
+  /// Set automatically during `cargo rail init` based on whether rust-toolchain.toml exists:
+  /// - If exists: imports values and sets to true
+  /// - If doesn't exist: creates it and sets to true
+  #[serde(default)]
+  pub managed_by_rail: bool,
 }
 
 fn default_channel() -> String {
@@ -210,6 +221,7 @@ impl Default for ToolchainConfig {
       profile: default_profile(),
       components: vec![],
       targets: vec![],
+      managed_by_rail: false, // Default to false for safety
     }
   }
 }
@@ -702,6 +714,7 @@ mod tests {
       profile: "minimal".to_string(),
       components: vec!["clippy".to_string(), "rustfmt".to_string()],
       targets: vec!["x86_64-unknown-linux-gnu".to_string()],
+      managed_by_rail: false,
     };
     assert!(toolchain.validate().is_ok());
   }
@@ -714,6 +727,7 @@ mod tests {
       profile: "default".to_string(),
       components: vec![],
       targets: vec![],
+      managed_by_rail: false,
     };
     assert!(toolchain.validate().is_ok());
   }
@@ -726,6 +740,7 @@ mod tests {
       profile: "default".to_string(),
       components: vec![],
       targets: vec![],
+      managed_by_rail: false,
     };
     assert!(toolchain.validate().is_err());
   }
@@ -738,6 +753,7 @@ mod tests {
       profile: "invalid".to_string(),
       components: vec![],
       targets: vec![],
+      managed_by_rail: false,
     };
     assert!(toolchain.validate().is_err());
   }
@@ -750,6 +766,7 @@ mod tests {
       profile: "default".to_string(),
       components: vec![],
       targets: vec![],
+      managed_by_rail: false,
     };
     assert!(toolchain.validate().is_err());
   }

src/git/ops.rs

@@ -114,17 +114,24 @@ impl SystemGit {
   /// # Performance
   /// Uses `git diff --name-status` which is optimized for listing changes.
   /// Typically <100ms even for large diffs with 1000s of files.
-  pub fn get_changed_files_between(&self, base_ref: &str, head_ref: &str) -> RailResult<Vec<(PathBuf, char)>> {
-    let output = self
-      .git_cmd()
-      .args(["diff", "--name-status", base_ref, head_ref])
-      .output()
-      .context("Failed to get changed files between refs")?;
+  pub fn get_changed_files_between(&self, base_ref: &str, head_ref: Option<&str>) -> RailResult<Vec<(PathBuf, char)>> {
+    let mut cmd = self.git_cmd();
+    cmd.args(["diff", "--name-status", base_ref]);
+
+    if let Some(head) = head_ref {
+      cmd.arg(head);
+    }
+
+    let output = cmd.output().context("Failed to get changed files between refs")?;
 
     if !output.status.success() {
       let stderr = String::from_utf8_lossy(&output.stderr);
       return Err(RailError::Git(GitError::CommandFailed {
-        command: format!("git diff --name-status {} {}", base_ref, head_ref),
+        command: format!(
+          "git diff --name-status {} {}",
+          base_ref,
+          head_ref.unwrap_or("working tree")
+        ),
         stderr: stderr.to_string(),
       }));
     }
@@ -346,8 +353,9 @@ impl SystemGit {
     // Read all files in one batch (100x+ faster than loop)
     let contents = self.read_files_bulk(&items)?;
 
-    // Combine paths with contents
-    let results: Vec<(PathBuf, Vec<u8>)> = files.into_iter().zip(contents).collect();
+    // Combine full paths (with crate prefix) with contents
+    // Use paths from items (which include the crate prefix) not files (which are relative)
+    let results: Vec<(PathBuf, Vec<u8>)> = items.into_iter().map(|(_, path)| path).zip(contents).collect();
 
     Ok(results)
   }