eazygit/commands/git_commands/

stage.rs

//! Stage and unstage file commands.
//!
//! These commands handle staging and unstaging files with optimistic UI updates
//! for immediate visual feedback.

use crate::commands::{Command, CommandResult};
use crate::services::GitService;
use crate::app::{AppState, Action, reducer};
use crate::errors::CommandError;
use tracing::instrument;

/// Command to stage one or more files
pub struct StageFilesCommand {
    pub paths: Vec<String>,
}

impl Command for StageFilesCommand {
    #[instrument(skip(self, git, state), fields(paths = ?self.paths))]
    fn execute(
        &self,
        git: &GitService,
        state: &AppState,
    ) -> Result<CommandResult, CommandError> {
        let mut staged_count = 0;
        let mut errors = Vec::new();
        
        for path in &self.paths {
            match git.stage_file(&state.repo_path, path) {
                Ok(_) => staged_count += 1,
                Err(e) => errors.push(format!("stage error: {e}")),
            }
        }
        
        let mut new_state = state.clone();
        
        if !errors.is_empty() {
            new_state = reducer(new_state, Action::SetStatusError(Some(errors.join(", "))));
        }
        
        if staged_count > 0 {
            // Apply optimistic update: mark staged files as staged in status_entries
            // This provides immediate visual feedback before the async refresh completes
            for entry in new_state.status_entries.iter_mut() {
                if self.paths.contains(&entry.path) {
                    entry.staged = true;
                    // Preserve unstaged state - file might have both staged and unstaged changes
                }
            }
            
            new_state = reducer(new_state, Action::SetFeedback(Some(
                format!("Staged {} file(s)", staged_count)
            )));
            new_state = reducer(new_state, Action::ClearFileSelects);
            new_state = reducer(new_state, Action::SetRefreshing(true));
        }
        
        Ok(CommandResult::StateUpdate(new_state))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::commands::Command as CommandTrait;
    use tempfile::tempdir;
    use std::fs;
    use std::process::Command;

    fn setup_test_repo() -> (std::path::PathBuf, GitService) {
        let temp_dir = tempdir().expect("Failed to create temp directory");
        let repo_path = temp_dir.path().to_path_buf();
        
        Command::new("git")
            .arg("init")
            .arg(&repo_path)
            .output()
            .expect("Failed to init repo");
        
        Command::new("git")
            .args(["-C", repo_path.to_str().unwrap(), "config", "user.name", "Test"])
            .output()
            .expect("Failed to set user.name");
        
        Command::new("git")
            .args(["-C", repo_path.to_str().unwrap(), "config", "user.email", "test@test.com"])
            .output()
            .expect("Failed to set user.email");
        
        // Create initial commit
        let test_file = repo_path.join("existing.txt");
        fs::write(&test_file, "content").expect("Failed to write");
        Command::new("git")
            .args(["-C", repo_path.to_str().unwrap(), "add", "existing.txt"])
            .output()
            .expect("Failed to stage");
        Command::new("git")
            .args(["-C", repo_path.to_str().unwrap(), "commit", "-m", "Initial"])
            .output()
            .expect("Failed to commit");
        
        std::mem::forget(temp_dir);
        let git_service = GitService::new();
        (repo_path, git_service)
    }

    #[test]
    fn test_stage_files_command_structure() {
        let command = StageFilesCommand {
            paths: vec!["test.txt".to_string()],
        };
        assert_eq!(command.paths.len(), 1);
    }

    #[test]
    fn test_stage_files_execution() {
        let (repo_path, git_service) = setup_test_repo();
        let mut state = AppState::new();
        state.repo_path = repo_path.to_str().unwrap().to_string();
        
        // Create test file
        let test_file = repo_path.join("test.txt");
        fs::write(&test_file, "content").expect("Failed to write");
        
        let command = StageFilesCommand {
            paths: vec!["test.txt".to_string()],
        };
        
        let result = CommandTrait::execute(&command, &git_service, &state);
        assert!(result.is_ok());
        
        // Verify file is staged
        let status = git_service.status_porcelain(repo_path.to_str().unwrap())
            .expect("Failed to get status");
        assert!(status.contains("A ") || status.contains("test.txt"));
        
        let _ = fs::remove_dir_all(&repo_path);
    }

    #[test]
    fn test_unstage_files_execution() {
        let (repo_path, git_service) = setup_test_repo();
        let mut state = AppState::new();
        state.repo_path = repo_path.to_str().unwrap().to_string();
        
        // Create and stage file
        let test_file = repo_path.join("test.txt");
        fs::write(&test_file, "content").expect("Failed to write");
        git_service.stage_file(repo_path.to_str().unwrap(), "test.txt")
            .expect("Failed to stage");
        
        let command = UnstageFilesCommand {
            paths: vec!["test.txt".to_string()],
        };
        
        let result = CommandTrait::execute(&command, &git_service, &state);
        assert!(result.is_ok());
        
        // Verify file is unstaged
        let status = git_service.status_porcelain(repo_path.to_str().unwrap())
            .expect("Failed to get status");
        assert!(!status.contains("A "));
        
        let _ = fs::remove_dir_all(&repo_path);
    }

    #[test]
    fn test_command_error_handling() {
        let (repo_path, git_service) = setup_test_repo();
        let mut state = AppState::new();
        state.repo_path = repo_path.to_str().unwrap().to_string();
        
        // Try to stage non-existent file
        let command = StageFilesCommand {
            paths: vec!["nonexistent.txt".to_string()],
        };
        
        // This might succeed (git add creates empty file) or fail
        let result = CommandTrait::execute(&command, &git_service, &state);
        // Both outcomes are acceptable
        assert!(result.is_ok() || result.is_err());
        
        let _ = fs::remove_dir_all(&repo_path);
    }
}

/// Command to unstage one or more files
pub struct UnstageFilesCommand {
    pub paths: Vec<String>,
}

impl Command for UnstageFilesCommand {
    #[instrument(skip(self, git, state), fields(paths = ?self.paths))]
    fn execute(
        &self,
        git: &GitService,
        state: &AppState,
    ) -> Result<CommandResult, CommandError> {
        let mut unstaged_count = 0;
        let mut errors = Vec::new();
        
        for path in &self.paths {
            match git.unstage_file(&state.repo_path, path) {
                Ok(_) => unstaged_count += 1,
                Err(e) => errors.push(format!("unstage error: {e}")),
            }
        }
        
        let mut new_state = state.clone();
        
        if !errors.is_empty() {
            new_state = reducer(new_state, Action::SetStatusError(Some(errors.join(", "))));
        }
        
        if unstaged_count > 0 {
            // Apply optimistic update: mark unstaged files as unstaged in status_entries
            // This provides immediate visual feedback before the async refresh completes
            for entry in new_state.status_entries.iter_mut() {
                if self.paths.contains(&entry.path) {
                    entry.staged = false;
                    // Preserve unstaged state - status refresh will set correct state
                }
            }
            
            new_state = reducer(new_state, Action::SetFeedback(Some(
                format!("Unstaged {} file(s)", unstaged_count)
            )));
            new_state = reducer(new_state, Action::ClearFileSelects);
            new_state = reducer(new_state, Action::SetRefreshing(true));
        }
        
        Ok(CommandResult::StateUpdate(new_state))
    }
}