void_core/workspace/

remove.rs

//! Remove operations for workspace.

use std::collections::HashMap;
use std::fs;

use crate::VoidContext;
use crate::index::{entry_matches_file, write_workspace_index, IndexEntry};
use crate::{Result, VoidError};

use super::stage::{load_head_entries, load_index_or_empty};

/// Options for removing paths.
#[derive(Clone)]
pub struct RemoveOptions {
    pub ctx: VoidContext,
    pub paths: Vec<String>,
    /// If true, only remove from index (keep files on disk).
    pub cached_only: bool,
    /// If true, remove even if file has uncommitted changes.
    pub force: bool,
    /// If true, recursively remove directories.
    pub recursive: bool,
}

/// Result of removing paths.
#[derive(Debug, Clone)]
pub struct RemoveResult {
    pub removed: Vec<String>,
}

/// Remove paths from the index and optionally from the working tree.
///
/// # Arguments
/// * `opts` - Remove options including paths, cached_only, force, and recursive flags.
///
/// # Behavior
/// - Without `cached_only`: deletes file from disk, removes from index
/// - With `cached_only`: only removes from index (file stays on disk, becomes untracked)
/// - Fails if file has uncommitted changes (unless `force` is set)
/// - With `recursive`: removes entire directories
pub fn remove_paths(opts: RemoveOptions) -> Result<RemoveResult> {
    let root = &opts.ctx.paths.root;

    let mut index = load_index_or_empty(&opts.ctx)?;
    let head_entries = load_head_entries(&opts.ctx)?;

    let head_map: HashMap<String, IndexEntry> = head_entries
        .into_iter()
        .map(|e| (e.path.clone(), e))
        .collect();

    let mut to_remove: Vec<String> = Vec::new();

    // Collect paths to remove (expand directories if recursive)
    for path in &opts.paths {
        let path = path.replace('\\', "/").trim_start_matches('/').to_string();

        // Check if path is in index
        if let Some(_entry) = index.get(&path) {
            to_remove.push(path);
        } else if opts.recursive {
            // Check if path is a directory prefix - collect all matching entries
            let prefix = if path.ends_with('/') {
                path.clone()
            } else {
                format!("{}/", path)
            };

            let matching: Vec<String> = index
                .entries
                .iter()
                .filter(|e| e.path.starts_with(&prefix) || e.path == path)
                .map(|e| e.path.clone())
                .collect();

            if matching.is_empty() {
                return Err(VoidError::NotFound(format!(
                    "pathspec '{}' did not match any files",
                    path
                )));
            }

            to_remove.extend(matching);
        } else {
            // Check if it's a directory and suggest -r
            let prefix = format!("{}/", path);
            let has_children = index.entries.iter().any(|e| e.path.starts_with(&prefix));
            if has_children {
                return Err(VoidError::InvalidPattern(format!(
                    "'{}' is a directory. Use -r to remove recursively.",
                    path
                )));
            }

            return Err(VoidError::NotFound(format!(
                "pathspec '{}' did not match any files",
                path
            )));
        }
    }

    // Deduplicate
    to_remove.sort();
    to_remove.dedup();

    // Check for uncommitted changes (unless force)
    if !opts.force && !opts.cached_only {
        for path in &to_remove {
            if let Some(index_entry) = index.get(path) {
                // Validate path to prevent traversal attacks
                let file_path = crate::util::safe_join(opts.ctx.paths.root.as_std_path(), path)?;

                // Check if file exists and has different content than index
                if file_path.exists() {
                    let matches = match entry_matches_file(index_entry, root) {
                        Ok(m) => m,
                        Err(VoidError::NotFound(_)) => true, // File doesn't exist, ok to remove
                        Err(e) => return Err(e),
                    };

                    if !matches {
                        // File has local modifications
                        return Err(VoidError::InvalidPattern(format!(
                            "file '{}' has local modifications (use --force to remove anyway)",
                            path
                        )));
                    }
                }

                // Check if staged changes differ from HEAD
                if let Some(head_entry) = head_map.get(path) {
                    if index_entry.content_hash != head_entry.content_hash {
                        return Err(VoidError::InvalidPattern(format!(
                            "file '{}' has staged changes (use --force to remove anyway)",
                            path
                        )));
                    }
                } else {
                    // File is new (not in HEAD), so it has staged changes
                    return Err(VoidError::InvalidPattern(format!(
                        "file '{}' has staged changes (use --force to remove anyway)",
                        path
                    )));
                }
            }
        }
    }

    // Actually remove
    let mut removed = Vec::new();
    for path in to_remove {
        // Remove from index
        index.entries.retain(|e| e.path != path);
        removed.push(path.clone());

        // Delete from disk if not cached_only
        if !opts.cached_only {
            // Use safe_join to prevent path traversal
            let file_path = crate::util::safe_join(opts.ctx.paths.root.as_std_path(), &path)?;
            if file_path.exists() {
                fs::remove_file(&file_path)?;
            }
        }
    }

    write_workspace_index(opts.ctx.paths.workspace_dir.as_std_path(), opts.ctx.crypto.vault.index_key()?, &index)?;

    removed.sort();
    Ok(RemoveResult { removed })
}