cargo-rail: major dx, perf, and reliability updated.

Author: loadingalias

Cargo.lock

@@ -29,6 +29,7 @@ exclude = [
 
 [dependencies]
 clap = { version = "4.5.53", features = ["derive", "cargo"] }
+clap_complete = "4.5"
 cargo_metadata = "0.23.1"
 petgraph = { version = "0.8.3", default-features = false }
 toml_edit = { version = "0.23.9", features = ["serde"] }

Cargo.toml

@@ -40,18 +40,20 @@ pub use metadata::{BackupMetadata, BackupRecord};
 /// Backup identifier (timestamp-based)
 pub type BackupId = String;
 
-/// Creates a backup ID from current timestamp
+/// Creates a backup ID from current timestamp.
+#[doc(hidden)]
 pub fn create_backup_id() -> BackupId {
   chrono::Local::now().format("%Y-%m-%d-%H%M%S-%3f").to_string()
 }
 
-/// Get the backup root directory for a workspace
-///
+/// Get the backup root directory for a workspace.
+#[doc(hidden)]
 pub fn get_backup_root(workspace_root: &Path) -> PathBuf {
   workspace_root.join("target").join("cargo-rail").join("backups")
 }
 
-/// Get the path to a specific backup directory
+/// Get the path to a specific backup directory.
+#[doc(hidden)]
 pub fn get_backup_dir(workspace_root: &Path, backup_id: &str) -> PathBuf {
   get_backup_root(workspace_root).join(backup_id)
 }

src/backup/mod.rs

@@ -36,16 +36,6 @@ impl DepKey {
     }
   }
 
-  /// Get the canonical key (package name only, ignoring rename)
-  ///
-  /// Used when `include_renamed = true` to group renamed and non-renamed deps together
-  pub fn canonical(&self) -> Self {
-    Self {
-      name: Arc::clone(&self.name),
-      renamed_from: None,
-    }
-  }
-
   /// Check if this is a renamed dependency
   pub fn is_renamed(&self) -> bool {
     self.renamed_from.is_some()

src/cargo/manifest_analyzer.rs

@@ -165,8 +165,7 @@ mod tests {
   use crate::cargo::unify_types::UnifiedDep;
   use std::path::PathBuf;
 
-  use super::super::fields::{extract_features, extract_path, has_default_features, has_path};
-  use super::super::transform::{extract_version, is_inline_table_dep, is_optional, is_simple_string_dep};
+  use super::super::fields::extract_features;
   use super::super::workspace_ref::is_workspace_dep;
 
   fn create_test_dep(name: &str, version: &str) -> UnifiedDep {
@@ -185,9 +184,9 @@ mod tests {
   fn test_build_dep_entry_simple() {
     let dep = create_test_dep("serde", "1.0");
     let entry = build_dep_entry(&dep);
-    assert!(is_simple_string_dep(&entry));
-    // Version requirement parsing adds the caret operator
-    assert_eq!(extract_version(&entry).unwrap(), "^1.0");
+    // Simple case returns a string value
+    assert!(entry.as_str().is_some());
+    assert_eq!(entry.as_str().unwrap(), "^1.0");
   }
 
   #[test]
@@ -196,7 +195,7 @@ mod tests {
     dep.features = vec!["derive".to_string()];
 
     let entry = build_dep_entry(&dep);
-    assert!(is_inline_table_dep(&entry));
+    assert!(entry.as_inline_table().is_some());
     let features = extract_features(&entry).unwrap();
     assert_eq!(features, vec!["derive"]);
   }
@@ -207,9 +206,9 @@ mod tests {
     dep.path = Some(PathBuf::from("../local-crate"));
 
     let entry = build_dep_entry(&dep);
-    assert!(is_inline_table_dep(&entry));
-    assert!(has_path(&entry));
-    assert_eq!(extract_path(&entry).unwrap(), "../local-crate");
+    let table = entry.as_inline_table().unwrap();
+    assert!(table.contains_key("path"));
+    assert_eq!(table.get("path").unwrap().as_str().unwrap(), "../local-crate");
   }
 
   #[test]
@@ -218,15 +217,15 @@ mod tests {
     dep.default_features = false;
 
     let entry = build_dep_entry(&dep);
-    assert!(is_inline_table_dep(&entry));
-    assert!(!has_default_features(&entry));
+    let table = entry.as_inline_table().unwrap();
+    assert!(!table.get("default-features").unwrap().as_bool().unwrap());
   }
 
   #[test]
   fn test_build_workspace_dep_entry_simple() {
     let entry = build_workspace_dep_entry(None, false);
     assert!(is_workspace_dep(&entry));
-    assert!(is_inline_table_dep(&entry));
+    assert!(entry.as_inline_table().is_some());
   }
 
   #[test]
@@ -241,7 +240,8 @@ mod tests {
   fn test_build_workspace_dep_entry_optional() {
     let entry = build_workspace_dep_entry(None, true);
     assert!(is_workspace_dep(&entry));
-    assert!(is_optional(&entry));
+    let table = entry.as_inline_table().unwrap();
+    assert!(table.get("optional").unwrap().as_bool().unwrap());
   }
 
   #[test]

src/cargo/manifest_ops/entry_builder.rs

@@ -8,14 +8,6 @@ use toml_edit::{Array, InlineTable, Item, Table, Value};
 // ============================================================================
 
 /// Build feature array from strings
-///
-/// # Arguments
-///
-/// * `features` - List of feature names
-///
-/// # Returns
-///
-/// `Value::Array` containing the features
 pub fn build_feature_array(features: &[String]) -> Value {
   let mut array = Array::new();
   for feature in features {
@@ -25,10 +17,6 @@ pub fn build_feature_array(features: &[String]) -> Value {
 }
 
 /// Extract features from dependency entry
-///
-/// # Returns
-///
-/// `Some(features)` if present, `None` otherwise
 pub fn extract_features(item: &Item) -> Option<Vec<String>> {
   if let Some(table) = item.as_inline_table() {
     extract_features_from_inline_table(table)
@@ -67,56 +55,11 @@ pub fn set_features(item: &mut Item, features: Vec<String>) -> RailResult<()> {
   }
 }
 
-/// Remove features field from dependency entry
-///
-/// # Returns
-///
-/// `true` if features were present and removed, `false` otherwise
-pub fn remove_features(item: &mut Item) -> bool {
-  if let Some(table) = item.as_inline_table_mut() {
-    table.remove("features").is_some()
-  } else if let Some(table) = item.as_table_mut() {
-    table.remove("features").is_some()
-  } else {
-    false
-  }
-}
-
 // ============================================================================
 // Path Dependency Operations
 // ============================================================================
 
-/// Check if dependency has path field
-pub fn has_path(item: &Item) -> bool {
-  if let Some(table) = item.as_inline_table() {
-    table.contains_key("path")
-  } else if let Some(table) = item.as_table() {
-    table.contains_key("path")
-  } else {
-    false
-  }
-}
-
-/// Extract path value from dependency
-pub fn extract_path(item: &Item) -> Option<String> {
-  if let Some(table) = item.as_inline_table() {
-    table.get("path").and_then(|v| v.as_str()).map(String::from)
-  } else if let Some(table) = item.as_table() {
-    table
-      .get("path")
-      .and_then(|item| item.as_value())
-      .and_then(|v| v.as_str())
-      .map(String::from)
-  } else {
-    None
-  }
-}
-
 /// Remove path field from dependency
-///
-/// # Returns
-///
-/// `true` if path was present and removed, `false` otherwise
 pub fn remove_path(item: &mut Item) -> bool {
   if let Some(table) = item.as_inline_table_mut() {
     table.remove("path").is_some()
@@ -127,64 +70,6 @@ pub fn remove_path(item: &mut Item) -> bool {
   }
 }
 
-/// Set path field on dependency
-pub fn set_path(item: &mut Item, path: &str) -> RailResult<()> {
-  if let Some(table) = item.as_inline_table_mut() {
-    table.insert("path", Value::from(path));
-    Ok(())
-  } else if let Some(table) = item.as_table_mut() {
-    table.insert("path", Item::Value(Value::from(path)));
-    Ok(())
-  } else {
-    Err(RailError::message("cannot set path: item is not a table"))
-  }
-}
-
-// ============================================================================
-// Default Features Operations
-// ============================================================================
-
-/// Check default-features setting
-///
-/// Returns `true` if not specified (default) or explicitly set to true
-pub fn has_default_features(item: &Item) -> bool {
-  if let Some(table) = item.as_inline_table() {
-    table.get("default-features").and_then(|v| v.as_bool()).unwrap_or(true)
-  } else if let Some(table) = item.as_table() {
-    table
-      .get("default-features")
-      .and_then(|item| item.as_value())
-      .and_then(|v| v.as_bool())
-      .unwrap_or(true)
-  } else {
-    true
-  }
-}
-
-/// Set default-features flag
-pub fn set_default_features(item: &mut Item, enabled: bool) -> RailResult<()> {
-  if let Some(table) = item.as_inline_table_mut() {
-    table.insert("default-features", Value::from(enabled));
-    Ok(())
-  } else if let Some(table) = item.as_table_mut() {
-    table.insert("default-features", Item::Value(Value::from(enabled)));
-    Ok(())
-  } else {
-    Err(RailError::message("cannot set default-features: item is not a table"))
-  }
-}
-
-/// Remove default-features field
-pub fn remove_default_features(item: &mut Item) -> bool {
-  if let Some(table) = item.as_inline_table_mut() {
-    table.remove("default-features").is_some()
-  } else if let Some(table) = item.as_table_mut() {
-    table.remove("default-features").is_some()
-  } else {
-    false
-  }
-}
-
 #[cfg(test)]
 mod tests {
   use super::*;
@@ -223,93 +108,14 @@ mod tests {
     assert_eq!(features, vec!["new"]);
   }
 
-  #[test]
-  fn test_remove_features() {
-    let mut table = InlineTable::new();
-    table.insert("version", Value::from("1.0"));
-    table.insert("features", build_feature_array(&["old".to_string()]));
-    let mut item = Item::Value(Value::InlineTable(table));
-
-    assert!(extract_features(&item).is_some());
-    let removed = remove_features(&mut item);
-    assert!(removed);
-    assert!(extract_features(&item).is_none());
-  }
-
-  #[test]
-  fn test_has_path() {
-    let mut table = InlineTable::new();
-    table.insert("path", Value::from("../other"));
-    let item = Item::Value(Value::InlineTable(table));
-
-    assert!(has_path(&item));
-  }
-
-  #[test]
-  fn test_extract_path() {
-    let mut table = InlineTable::new();
-    table.insert("path", Value::from("../local"));
-    let item = Item::Value(Value::InlineTable(table));
-
-    assert_eq!(extract_path(&item).unwrap(), "../local");
-  }
-
   #[test]
   fn test_remove_path() {
     let mut table = InlineTable::new();
     table.insert("path", Value::from("../other"));
     let mut item = Item::Value(Value::InlineTable(table));
 
     assert!(remove_path(&mut item));
-    assert!(!has_path(&item));
-  }
-
-  #[test]
-  fn test_set_path() {
-    let mut table = InlineTable::new();
-    table.insert("version", Value::from("1.0"));
-    let mut item = Item::Value(Value::InlineTable(table));
-
-    set_path(&mut item, "../new-path").unwrap();
-    assert_eq!(extract_path(&item).unwrap(), "../new-path");
-  }
-
-  #[test]
-  fn test_has_default_features_default_true() {
-    let item = Item::Value(Value::from("1.0"));
-    assert!(has_default_features(&item));
-  }
-
-  #[test]
-  fn test_has_default_features_explicit_false() {
-    let mut table = InlineTable::new();
-    table.insert("version", Value::from("1.0"));
-    table.insert("default-features", Value::from(false));
-    let item = Item::Value(Value::InlineTable(table));
-
-    assert!(!has_default_features(&item));
-  }
-
-  #[test]
-  fn test_set_default_features() {
-    let mut table = InlineTable::new();
-    table.insert("version", Value::from("1.0"));
-    let mut item = Item::Value(Value::InlineTable(table));
-
-    set_default_features(&mut item, false).unwrap();
-    assert!(!has_default_features(&item));
-  }
-
-  #[test]
-  fn test_remove_default_features() {
-    let mut table = InlineTable::new();
-    table.insert("version", Value::from("1.0"));
-    table.insert("default-features", Value::from(false));
-    let mut item = Item::Value(Value::InlineTable(table));
-
-    let removed = remove_default_features(&mut item);
-    assert!(removed);
-    // Should now be true (default)
-    assert!(has_default_features(&item));
+    // Path should be gone
+    assert!(item.as_inline_table().unwrap().get("path").is_none());
   }
 }