eazygit 0.5.1

A fast TUI for Git with staging, conflicts, rebase, and palette-first UX
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! Validation functions for rebase operations.
//!
//! Ensures repository state is valid before performing rebase operations.

use crate::services::GitService;
use crate::app::rebase::{RebaseSession, RebasePhase};
use std::path::Path;

/// Errors that can occur during rebase validation
#[derive(Debug, thiserror::Error)]
pub enum RebaseValidationError {
    #[error("Repository has uncommitted changes")]
    UncommittedChanges,

    #[error("Repository is already in a rebase state")]
    RebaseInProgress,

    #[error("Invalid repository state: {0}")]
    InvalidRepositoryState(String),

    #[error("No commits to rebase")]
    NoCommitsToRebase,

    #[error("Invalid base commit: {0}")]
    InvalidBaseCommit(String),

    #[error("Session is in invalid state: {0}")]
    InvalidSessionState(String),
}

/// Validator for rebase operations
pub struct RebaseValidator;

impl RebaseValidator {
    /// Validate that the repository is in a clean state for rebase
    pub fn validate_repository_state(
        git_service: &GitService,
        repo_path: &str,
    ) -> Result<(), RebaseValidationError> {
        // Check for uncommitted changes
        let status = git_service
            .status_porcelain(repo_path)
            .map_err(|_| RebaseValidationError::InvalidRepositoryState("Cannot read status".to_string()))?;

        if !status.trim().is_empty() {
            return Err(RebaseValidationError::UncommittedChanges);
        }

        // Check if rebase is already in progress
        let git_dir = Path::new(repo_path).join(".git");
        if git_dir.join("rebase-merge").exists() || git_dir.join("rebase-apply").exists() {
            return Err(RebaseValidationError::RebaseInProgress);
        }

        Ok(())
    }

    /// Validate that a rebase session is in a valid state for the given operation
    pub fn validate_session_state(
        session: &RebaseSession,
        operation: &str,
    ) -> Result<(), RebaseValidationError> {
        match operation {
            "start_planning" => {
                // Can always start planning (even from empty state)
                Ok(())
            }
            "execute_rebase" => {
                if session.entries.is_empty() {
                    return Err(RebaseValidationError::NoCommitsToRebase);
                }
                if session.base_commit.is_none() && !session.use_root {
                    return Err(RebaseValidationError::InvalidBaseCommit("No base commit specified".to_string()));
                }
                if session.phase != RebasePhase::Planning {
                    return Err(RebaseValidationError::InvalidSessionState(
                        format!("Cannot execute from phase {:?}", session.phase)
                    ));
                }
                Ok(())
            }
            "continue_rebase" => {
                if session.phase != RebasePhase::Active && session.phase != RebasePhase::Conflict {
                    return Err(RebaseValidationError::InvalidSessionState(
                        format!("Cannot continue from phase {:?}", session.phase)
                    ));
                }
                Ok(())
            }
            "abort_rebase" => {
                if session.phase == RebasePhase::Planning {
                    return Err(RebaseValidationError::InvalidSessionState(
                        "Cannot abort planning phase".to_string()
                    ));
                }
                Ok(())
            }
            _ => Ok(()),
        }
    }

    /// Validate that all entries in the session are valid
    pub fn validate_session_entries(session: &RebaseSession) -> Result<(), RebaseValidationError> {
        for entry in &session.entries {
            if entry.hash.is_empty() {
                return Err(RebaseValidationError::InvalidSessionState("Entry has empty hash".to_string()));
            }
            if entry.hash.len() < 4 {
                return Err(RebaseValidationError::InvalidSessionState("Entry hash too short".to_string()));
            }
        }
        Ok(())
    }

    /// Comprehensive validation before starting a rebase
    pub fn validate_before_execution(
        git_service: &GitService,
        repo_path: &str,
        session: &RebaseSession,
    ) -> Result<(), RebaseValidationError> {
        // Validate repository state
        Self::validate_repository_state(git_service, repo_path)?;

        // Validate session state
        Self::validate_session_state(session, "execute_rebase")?;

        // Validate session entries
        Self::validate_session_entries(session)?;

        Ok(())
    }
}