Merge branch 'main' into main

Author: genedna

aria/contents/docs/libra/command/rm/index.mdx

@@ -26,3 +26,6 @@ that.)
 
 -   `-r`, `--recursive`<br/>
     Allow recursive removal when a leading directory name is given.
+
+-   `-f`, `--force`<br/>
+    Force removal even if the specified paths are not tracked. This skips validation checks and deletes files or directories regardless of their index status.

libra/Cargo.toml

@@ -52,6 +52,8 @@ tracing-subscriber = { workspace = true }
 wax = { workspace = true }
 url = { workspace = true }
 ignore = { workspace = true }
+tempfile = { workspace = true }
+serial_test = { workspace = true }
 
 [target.'cfg(unix)'.dependencies] # only on Unix
 pager = { workspace = true }

libra/src/command/remove.rs

@@ -13,13 +13,16 @@ use mercury::internal::index::Index;
 #[derive(Parser, Debug)]
 pub struct RemoveArgs {
     /// file or dir to remove
-    pathspec: Vec<String>,
+    pub pathspec: Vec<String>,
     /// whether to remove from index
     #[clap(long)]
-    cached: bool,
+    pub cached: bool,
     /// indicate recursive remove dir
     #[clap(short, long)]
-    recursive: bool,
+    pub recursive: bool,
+    /// force removal, skip validation
+    #[clap(short, long)]
+    pub force: bool,
 }
 
 pub fn execute(args: RemoveArgs) -> Result<(), GitError> {
@@ -28,11 +31,13 @@ pub fn execute(args: RemoveArgs) -> Result<(), GitError> {
     }
     let idx_file = path::index();
     let mut index = Index::load(&idx_file)?;
-    // check if pathspec is all in index
-    if !validate_pathspec(&args.pathspec, &index) {
+    
+    // check if pathspec is all in index (skip if force is enabled)
+    if !args.force && !validate_pathspec(&args.pathspec, &index) {
         return Ok(());
     }
-    let dirs = get_dirs(&args.pathspec, &index);
+    
+    let dirs = get_dirs(&args.pathspec, &index, args.force);
     if !dirs.is_empty() && !args.recursive {
         println!(
             "fatal: not removing '{}' recursively without -r",
@@ -44,6 +49,7 @@ pub fn execute(args: RemoveArgs) -> Result<(), GitError> {
     for path_str in args.pathspec.iter() {
         let path = PathBuf::from(path_str);
         let path_wd = path.to_workdir().to_string_or_panic();
+        
         if dirs.contains(path_str) {
             // dir
             let removed = index.remove_dir_files(&path_wd);
@@ -56,8 +62,20 @@ pub fn execute(args: RemoveArgs) -> Result<(), GitError> {
             }
         } else {
             // file
-            index.remove(&path_wd, 0);
-            println!("rm '{}'", path_wd.bright_green());
+            if args.force {
+                // In force mode, remove from index if tracked, otherwise just delete from filesystem
+                if index.tracked(&path_wd, 0) {
+                    index.remove(&path_wd, 0);
+                    println!("rm '{}'", path_wd.bright_green());
+                } else {
+                    println!("rm '{}'", path_wd.bright_yellow());
+                }
+            } else {
+                // Normal mode - only remove if tracked
+                index.remove(&path_wd, 0);
+                println!("rm '{}'", path_wd.bright_green());
+            }
+            
             if !args.cached {
                 fs::remove_file(&path)?;
             }
@@ -90,14 +108,22 @@ fn validate_pathspec(pathspec: &[String], index: &Index) -> bool {
 }
 
 /// run after `validate_pathspec`
-fn get_dirs(pathspec: &[String], index: &Index) -> Vec<String> {
+fn get_dirs(pathspec: &[String], index: &Index, force: bool) -> Vec<String> {
     let mut dirs = Vec::new();
     for path_str in pathspec.iter() {
         let path = PathBuf::from(path_str);
         let path_wd = path.to_workdir().to_string_or_panic();
-        // valid but not tracked, means a dir
-        if !index.tracked(&path_wd, 0) {
-            dirs.push(path_str.clone());
+        
+        if force {
+            // In force mode, check if the path exists and is a directory
+            if path.exists() && path.is_dir() {
+                dirs.push(path_str.clone());
+            }
+        } else {
+            // valid but not tracked, means a dir
+            if !index.tracked(&path_wd, 0) {
+                dirs.push(path_str.clone());
+            }
         }
     }
     dirs

libra/tests/command/fetch_test.rs

@@ -1 +1,110 @@
+use std::process::Command;
+use std::time::Duration;
+use tempfile::TempDir;
+use tokio::process::Command as TokioCommand;
+use tokio::time::timeout;
 
+/// Helper function: Initialize a temporary Libra repository
+fn init_temp_repo() -> TempDir {
+    let temp_dir = tempfile::tempdir().expect("Failed to create temporary directory");
+    let temp_path = temp_dir.path();
+
+    eprintln!("Temporary directory created at: {temp_path:?}");
+    assert!(temp_path.is_dir(), "Temporary path is not a valid directory");
+
+    let output = Command::new(env!("CARGO_BIN_EXE_libra"))
+        .current_dir(temp_path)
+        .arg("init")
+        .output()
+        .expect("Failed to execute libra binary");
+
+    if !output.status.success() {
+        panic!(
+            "Failed to initialize libra repository: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+
+    eprintln!("Initialized libra repo at: {temp_path:?}");
+    temp_dir
+}
+
+#[tokio::test]
+/// Test fetching from an invalid remote repository with timeout
+async fn test_fetch_invalid_remote() {
+    let temp_repo = init_temp_repo();
+    let temp_path = temp_repo.path();
+
+    eprintln!("Starting test: fetch from invalid remote");
+
+    // Configure an invalid remote repository
+    eprintln!("Adding invalid remote: https://invalid-url.example/repo.git");
+    let remote_output = TokioCommand::new(env!("CARGO_BIN_EXE_libra"))
+        .current_dir(temp_path)
+        .args(["remote", "add", "origin", "https://invalid-url.example/repo.git"])
+        .output()
+        .await
+        .expect("Failed to add remote");
+
+    assert!(
+        remote_output.status.success(),
+        "Failed to add remote: {}",
+        String::from_utf8_lossy(&remote_output.stderr)
+    );
+
+    // Set upstream branch
+    eprintln!("Setting upstream to origin/main");
+    let branch_output = TokioCommand::new(env!("CARGO_BIN_EXE_libra"))
+        .current_dir(temp_path)
+        .args(["branch", "--set-upstream-to", "origin/main"])
+        .output()
+        .await
+        .expect("Failed to set upstream branch");
+
+    assert!(
+        branch_output.status.success(),
+        "Failed to set upstream: {}",
+        String::from_utf8_lossy(&branch_output.stderr)
+    );
+
+    // Attempt to fetch with 15-second timeout to avoid hanging CI
+    eprintln!("Attempting 'libra fetch' with 15s timeout...");
+    let fetch_result = timeout(Duration::from_secs(15), async {
+        TokioCommand::new(env!("CARGO_BIN_EXE_libra"))
+            .current_dir(temp_path)
+            .arg("fetch")
+            .output()
+            .await
+    })
+    .await;
+
+    match fetch_result {
+        // Timeout occurred — this is expected for unreachable remotes
+        Err(_) => {
+            eprintln!("Fetch timed out after 15 seconds — expected for invalid remote");
+        }
+        // Command completed within timeout
+        Ok(Ok(output)) => {
+
+            eprintln!("Fetch completed (status: {:?})", output.status);
+            assert!(
+                !output.status.success(),
+                "Fetch should fail when remote is unreachable"
+            );
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            assert!(
+                !stderr.trim().is_empty(),
+                "Expected error message in stderr, but was empty"
+            );
+
+            eprintln!("Fetch failed as expected: {stderr}");
+        }
+        // Failed to start the command
+        Ok(Err(e)) => {
+
+            panic!("Failed to run 'libra fetch' command: {e}");
+        }
+    }
+
+    eprintln!("test_fetch_invalid_remote passed");
+}

libra/tests/command/lfs_test.rs

@@ -1 +1,107 @@
+use std::process::Command;
+use tempfile::TempDir;
 
+/// Helper function: Initialize a temporary Libra repository
+fn init_temp_repo() -> TempDir {
+    let temp_dir = tempfile::tempdir().expect("Failed to create temporary directory");
+    let temp_path = temp_dir.path();
+
+    // Variables can be used directly in the `format!` string
+    // FIX: Removed {:?} and added variable directly with formatting
+    println!("Temporary directory created at: {temp_path:?}");
+    assert!(temp_path.is_dir(), "Temporary path is not a valid directory");
+
+    // Using env!("CARGO_BIN_EXE_libra") to get the path to the libra executable
+    let output = Command::new(env!("CARGO_BIN_EXE_libra"))
+        .current_dir(temp_path)
+        .arg("init")
+        .output()
+        .expect("Failed to execute libra binary");
+
+    if !output.status.success() {
+        panic!(
+            "Failed to initialize libra repository: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+
+    temp_dir
+}
+
+#[tokio::test]
+/// Test track/untrack path rule management
+async fn test_lfs_track_untrack() {
+    let temp_repo = init_temp_repo();
+    let temp_path = temp_repo.path();
+
+    // Add a path rule
+    // FIX: Removed & from args
+    let track_output = Command::new(env!("CARGO_BIN_EXE_libra"))
+        .current_dir(temp_path)
+        .args(["lfs", "track", "*.txt"]) // Changed &[...] to [...]
+        .output()
+        .expect("Failed to track path");
+    assert!(
+        track_output.status.success(),
+        "Failed to track path: {}",
+        String::from_utf8_lossy(&track_output.stderr)
+    );
+
+    // Remove a path rule
+    // FIX: Removed & from args
+    let untrack_output = Command::new(env!("CARGO_BIN_EXE_libra"))
+        .current_dir(temp_path)
+        .args(["lfs", "untrack", "*.txt"]) // Changed &[...] to [...]
+        .output()
+        .expect("Failed to untrack path");
+    assert!(
+        untrack_output.status.success(),
+        "Failed to untrack path: {}",
+        String::from_utf8_lossy(&untrack_output.stderr)
+    );
+}
+
+#[tokio::test]
+/// Test file status viewing
+async fn test_lfs_ls_files() {
+    let temp_repo = init_temp_repo();
+    let temp_path = temp_repo.path();
+
+    // Create a test file and add it to LFS
+    let file_path = temp_path.join("tracked_file.txt");
+    std::fs::write(&file_path, "Tracked content").expect("Failed to create tracked file");
+
+    // FIX: Removed & from args
+    Command::new(env!("CARGO_BIN_EXE_libra"))
+        .current_dir(temp_path)
+        .args(["lfs", "track", "*.txt"]) // Changed &[...] to [...]
+        .output()
+        .expect("Failed to track file");
+
+    // FIX: Removed & from args
+    Command::new(env!("CARGO_BIN_EXE_libra"))
+        .current_dir(temp_path)
+        .args(["add", "tracked_file.txt"]) // Changed &[...] to [...]
+        .output()
+        .expect("Failed to add file to LFS");
+
+    // View file status
+    // FIX: Removed & from args
+    let ls_files_output = Command::new(env!("CARGO_BIN_EXE_libra"))
+        .current_dir(temp_path)
+        .args(["lfs", "ls-files"]) // Changed &[...] to [...]
+        .output()
+        .expect("Failed to list LFS files");
+    assert!(
+        ls_files_output.status.success(),
+        "Failed to list LFS files: {}",
+        String::from_utf8_lossy(&ls_files_output.stderr)
+    );
+
+    let stdout = String::from_utf8_lossy(&ls_files_output.stdout);
+    // FIX: Variables can be used directly in the `format!` string
+    assert!(
+        stdout.contains("tracked_file.txt"),
+        "LFS file list does not contain expected file: {stdout}", // Changed {} to direct variable embed
+    );
+}