cargo-rail: cleaning up dead_code blocks; fixing CI for Windows ARM64 runner (wrong label) and Windows escaping in TOML parsing.

Author: loadingalias

.github/workflows/commit.yaml

@@ -47,16 +47,16 @@ jobs:
             runner: windows-latest
             cache-key: commit-windows-x64
 
-          # Windows ARM64 (GitHub Teams/Enterprise)
+          # Windows ARM64 (GitHub Free in public repos)
           - name: aarch64-pc-windows-msvc
-            runner: windows-11-arm64
+            runner: windows-11-arm
             cache-key: commit-windows-arm64
 
           # macOS tested locally (not in CI)
 
     steps:
       - name: Checkout
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8  # v5.0.0
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
       - name: Setup
         uses: ./.github/actions/setup
@@ -74,7 +74,7 @@ jobs:
 
       - name: Upload Test Results (on failure)
         if: failure()
-        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4  # v5.0.0
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
         with:
           name: test-results-${{ matrix.target.name }}
           path: target/nextest/

src/cargo/files.rs

@@ -1,5 +1,3 @@
-#![allow(dead_code)]
-
 use crate::core::error::{RailResult, ResultExt};
 use crate::ui::progress::FileProgress;
 use std::fs;

src/cargo/metadata.rs

@@ -1,5 +1,3 @@
-#![allow(dead_code)]
-
 use crate::core::error::RailResult;
 use cargo_metadata::{MetadataCommand, Package};
 use std::path::Path;
@@ -22,6 +20,8 @@ impl WorkspaceMetadata {
     self.metadata.workspace_packages()
   }
 
+  /// Get package by name - public API for external use
+  #[allow(dead_code)]
   pub fn get_package(&self, name: &str) -> Option<&Package> {
     self
       .metadata
@@ -34,7 +34,8 @@ impl WorkspaceMetadata {
     self.metadata.workspace_root.as_std_path()
   }
 
-  /// Get raw JSON string for external tools
+  /// Get raw JSON string for external tools - public API for debugging/logging
+  #[allow(dead_code)]
   pub fn to_json_string(&self) -> RailResult<String> {
     serde_json::to_string(&self.metadata)
       .map_err(|e| crate::core::error::RailError::message(format!("Failed to serialize metadata: {}", e)))

src/cargo/transform.rs

@@ -1,14 +1,16 @@
-#![allow(dead_code)]
-
 use crate::cargo::metadata::WorkspaceMetadata;
 use crate::core::error::{RailError, RailResult, ResultExt};
 use std::collections::HashMap;
 use std::path::PathBuf;
 use toml_edit::{DocumentMut, Item, Value};
 
-/// Context for transforming Cargo.toml
+/// Context for transformation operations
 pub struct TransformContext {
+  /// Crate name being transformed - public API field for future use
+  #[allow(dead_code)]
   pub crate_name: String,
+  /// Workspace root path - public API field for future use
+  #[allow(dead_code)]
   pub workspace_root: PathBuf,
 }
 

src/commands/release.rs

@@ -63,7 +63,8 @@ pub fn run_release_plan(name: Option<String>, all: bool, json: bool) -> RailResu
 pub fn run_release_apply(
   name: String,
   dry_run: bool,
-  _skip_sync: bool, // TODO: Implement split sync
+  // Skip syncing to split repos - deferred to post-v1 (see TODO.md Post-v1: Auto-sync to split repos)
+  #[allow(unused_variables)] skip_sync: bool,
 ) -> RailResult<()> {
   let workspace_root = env::current_dir()?;
 

src/commands/split.rs

@@ -22,7 +22,13 @@ fn prompt_for_confirmation(message: &str) -> RailResult<bool> {
 }
 
 /// Run the split command
-pub fn run_split(crate_name: Option<String>, all: bool, apply: bool, json: bool) -> RailResult<()> {
+pub fn run_split(
+  crate_name: Option<String>,
+  all: bool,
+  remote: Option<String>,
+  apply: bool,
+  json: bool,
+) -> RailResult<()> {
   let current_dir = env::current_dir()?;
 
   // Load configuration
@@ -35,8 +41,8 @@ pub fn run_split(crate_name: Option<String>, all: bool, apply: bool, json: bool)
   let config = RailConfig::load(&current_dir)?;
   println!("📦 Loaded configuration from .rail/config.toml");
 
-  // Determine which crates to split (need this to check if they're all local)
-  let crates_to_split_check: Vec<_> = if all {
+  // Determine which crates to split
+  let mut crates_to_split_check: Vec<_> = if all {
     config.splits.clone()
   } else if let Some(ref name) = crate_name {
     let split_config = config
@@ -52,6 +58,13 @@ pub fn run_split(crate_name: Option<String>, all: bool, apply: bool, json: bool)
     ));
   };
 
+  // Apply remote override if provided (before all_local check)
+  if let Some(ref remote_override) = remote {
+    for split_config in &mut crates_to_split_check {
+      split_config.remote = remote_override.clone();
+    }
+  }
+
   // Check if all remotes are local paths (skip SSH checks for local testing)
   let all_local = crates_to_split_check
     .iter()

src/commands/sync.rs

@@ -9,16 +9,60 @@ use crate::core::sync::{SyncConfig, SyncDirection, SyncEngine, SyncResult};
 use crate::ui::progress::{FileProgress, MultiProgress};
 use rayon::prelude::*;
 
+/// Sync command parameters
+pub struct SyncParams {
+  pub crate_name: Option<String>,
+  pub all: bool,
+  pub remote: Option<String>,
+  pub from_remote: bool,
+  pub to_remote: bool,
+  pub strategy_str: String,
+  pub no_protected_branches: bool,
+  pub apply: bool,
+  pub json: bool,
+}
+
 /// Run the sync command
+#[allow(clippy::too_many_arguments)]
 pub fn run_sync(
   crate_name: Option<String>,
   all: bool,
+  remote: Option<String>,
   from_remote: bool,
   to_remote: bool,
   strategy_str: String,
+  no_protected_branches: bool,
   apply: bool,
   json: bool,
 ) -> RailResult<()> {
+  // Convert to struct for internal use
+  let params = SyncParams {
+    crate_name,
+    all,
+    remote,
+    from_remote,
+    to_remote,
+    strategy_str,
+    no_protected_branches,
+    apply,
+    json,
+  };
+  run_sync_impl(params)
+}
+
+/// Internal implementation of sync command
+fn run_sync_impl(params: SyncParams) -> RailResult<()> {
+  let SyncParams {
+    crate_name,
+    all,
+    remote,
+    from_remote,
+    to_remote,
+    strategy_str,
+    no_protected_branches,
+    apply,
+    json,
+  } = params;
   // Parse conflict strategy
   let strategy = ConflictStrategy::from_str(&strategy_str)?;
   let current_dir = env::current_dir()?;
@@ -30,11 +74,17 @@ pub fn run_sync(
     }));
   }
 
-  let config = RailConfig::load(&current_dir)?;
+  let mut config = RailConfig::load(&current_dir)?;
+
+  // Apply CLI overrides to security config if provided
+  if no_protected_branches {
+    config.security.protected_branches.clear();
+  }
+
   println!("📦 Loaded configuration from .rail/config.toml");
 
-  // Determine which crates to sync (need this to check if they're all local)
-  let crates_to_sync_check: Vec<_> = if all {
+  // Determine which crates to sync
+  let mut crates_to_sync_check: Vec<_> = if all {
     config.splits.clone()
   } else if let Some(ref name) = crate_name {
     let split_config = config
@@ -50,6 +100,13 @@ pub fn run_sync(
     ));
   };
 
+  // Apply remote override if provided (before all_local check)
+  if let Some(ref remote_override) = remote {
+    for split_config in &mut crates_to_sync_check {
+      split_config.remote = remote_override.clone();
+    }
+  }
+
   // Check if all remotes are local paths (skip SSH checks for local testing)
   let all_local = crates_to_sync_check
     .iter()

src/core/config.rs

@@ -1,5 +1,3 @@
-#![allow(dead_code)]
-
 use crate::core::error::{ConfigError, RailError, RailResult, ResultExt};
 use serde::{Deserialize, Serialize};
 use std::fs;
@@ -147,7 +145,8 @@ impl PolicyConfig {
     Ok(())
   }
 
-  /// Check if policy is enabled (any field is set)
+  /// Check if policy is enabled (any field is set) - public API for conditional logic
+  #[allow(dead_code)]
   pub fn is_enabled(&self) -> bool {
     self.resolver.is_some()
       || self.msrv.is_some()

src/core/split.rs

@@ -26,7 +26,6 @@ struct RecreateCommitParams<'a> {
   commit: &'a CommitInfo,
   crate_paths: &'a [PathBuf],
   target_repo_path: &'a Path,
-  transform: &'a CargoTransform,
   workspace_root: &'a Path,
   crate_name: &'a str,
   mode: &'a SplitMode,
@@ -76,22 +75,8 @@ impl Splitter {
   fn walk_filtered_history(&self, paths: &[PathBuf]) -> RailResult<Vec<CommitInfo>> {
     println!("   Walking commit history to find commits touching crate...");
 
-    // Collect commits that touch any of the paths
-    // Use HashSet + Vec to deduplicate while preserving insertion order from git log
-    let mut seen_shas = std::collections::HashSet::new();
-    let mut filtered_commits = Vec::new();
-
-    for path in paths {
-      // Get all commits that touch this path (already in chronological order from git log --reverse)
-      let path_commits = self.git.get_commits_touching_path(path, None, "HEAD")?;
-
-      // Add to our deduplication list (skip if already seen)
-      for commit in path_commits {
-        if seen_shas.insert(commit.sha.clone()) {
-          filtered_commits.push(commit);
-        }
-      }
-    }
+    // Use batched git command for all paths at once (much faster than N separate calls)
+    let filtered_commits = self.git.get_commits_touching_paths(paths, None, "HEAD")?;
 
     println!(
       "   Found {} total commits that touch the crate paths",
@@ -101,6 +86,23 @@ impl Splitter {
     Ok(filtered_commits)
   }
 
+  /// Apply Cargo.toml transformation to a manifest file
+  /// Returns Ok(()) if transform succeeded or file doesn't exist
+  fn apply_manifest_transform(&self, manifest_path: &Path, crate_name: &str) -> RailResult<()> {
+    if !manifest_path.exists() {
+      return Ok(());
+    }
+
+    let content = std::fs::read_to_string(manifest_path)?;
+    let context = TransformContext {
+      crate_name: crate_name.to_string(),
+      workspace_root: self.workspace_root.clone(),
+    };
+    let transformed = self.transform.transform_to_split(&content, &context)?;
+    std::fs::write(manifest_path, transformed)?;
+    Ok(())
+  }
+
   /// Recreate a commit in the target repository with transforms applied
   /// Returns the new commit SHA
   fn recreate_commit_in_target(&self, params: &RecreateCommitParams) -> RailResult<String> {
@@ -143,19 +145,12 @@ impl Splitter {
         std::fs::create_dir_all(parent)?;
       }
 
+      // Write file content
+      std::fs::write(&target_path, content_bytes)?;
+
       // Apply Cargo.toml transformation if applicable
       if file_path.file_name() == Some(std::ffi::OsStr::new("Cargo.toml")) {
-        // Transform the manifest
-        let content = String::from_utf8(content_bytes.clone())
-          .map_err(|_| RailError::message(format!("File '{}' is not valid UTF-8", file_path.display())))?;
-        let context = TransformContext {
-          crate_name: params.crate_name.to_string(),
-          workspace_root: params.workspace_root.to_path_buf(),
-        };
-        let transformed = params.transform.transform_to_split(&content, &context)?;
-        std::fs::write(&target_path, transformed)?;
-      } else {
-        std::fs::write(&target_path, content_bytes)?;
+        self.apply_manifest_transform(&target_path, params.crate_name)?;
       }
     }
 
@@ -391,7 +386,6 @@ impl Splitter {
           commit,
           crate_paths: &config.crate_paths,
           target_repo_path: &config.target_repo_path,
-          transform: &self.transform,
           workspace_root: &self.workspace_root,
           crate_name: &config.crate_name,
           mode: &config.mode,
@@ -417,17 +411,21 @@ impl Splitter {
         project_files.copy_to_split(&self.workspace_root, &config.target_repo_path)?;
 
         // Create a final commit if any files were added
-        let status = std::process::Command::new("git")
+        // git add -A is safe to run unconditionally (no-op if no changes)
+        std::process::Command::new("git")
           .current_dir(&config.target_repo_path)
-          .args(["status", "--porcelain"])
-          .output()?;
+          .args(["add", "-A"])
+          .status()?;
 
-        if !status.stdout.is_empty() {
+        // Check if there are staged changes before committing
+        let diff_cached = std::process::Command::new("git")
+          .current_dir(&config.target_repo_path)
+          .args(["diff", "--cached", "--quiet"])
+          .status()?;
+
+        if !diff_cached.success() {
+          // Exit code 1 means there are differences (i.e., staged changes)
           println!("   Creating commit for auxiliary files");
-          std::process::Command::new("git")
-            .current_dir(&config.target_repo_path)
-            .args(["add", "-A"])
-            .status()?;
           std::process::Command::new("git")
             .current_dir(&config.target_repo_path)
             .args(["commit", "-m", "Add workspace configs and project files"])
@@ -609,17 +607,9 @@ impl Splitter {
     self.copy_directory_recursive(&source_path, target_repo_path)?;
 
     // Transform Cargo.toml manifest
+    println!("   Transforming Cargo.toml");
     let manifest_path = target_repo_path.join("Cargo.toml");
-    if manifest_path.exists() {
-      println!("   Transforming Cargo.toml");
-      let content = std::fs::read_to_string(&manifest_path)?;
-      let context = TransformContext {
-        crate_name: crate_name.to_string(),
-        workspace_root: self.workspace_root.clone(),
-      };
-      let transformed = self.transform.transform_to_split(&content, &context)?;
-      std::fs::write(&manifest_path, transformed)?;
-    }
+    self.apply_manifest_transform(&manifest_path, crate_name)?;
 
     // Copy auxiliary files
     if !aux_files.is_empty() {
@@ -653,15 +643,7 @@ impl Splitter {
 
       // Transform Cargo.toml manifest
       let manifest_path = target_path.join("Cargo.toml");
-      if manifest_path.exists() {
-        let content = std::fs::read_to_string(&manifest_path)?;
-        let context = TransformContext {
-          crate_name: crate_name.to_string(),
-          workspace_root: self.workspace_root.clone(),
-        };
-        let transformed = self.transform.transform_to_split(&content, &context)?;
-        std::fs::write(&manifest_path, transformed)?;
-      }
+      self.apply_manifest_transform(&manifest_path, crate_name)?;
     }
 
     // Copy auxiliary files