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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! State snapshot for debugging and time-travel debugging.
//!
//! Captures state snapshots that can be serialized for debugging
//! and potentially replayed.

use std::time::{Duration, Instant};

/// A snapshot of application state at a point in time.
#[derive(Debug, Clone)]
pub struct Snapshot {
    /// Unique ID for this snapshot
    pub id: u64,
    /// When the snapshot was taken (relative to app start)
    pub timestamp: Duration,
    /// Action that caused this snapshot (if any)
    pub action: Option<String>,
    /// Key state values for debugging
    pub state_summary: StateSummary,
}

/// Summary of key state values (without full serialization).
#[derive(Debug, Clone, Default)]
pub struct StateSummary {
    pub focus: String,
    pub status_count: usize,
    pub commit_count: usize,
    pub branch_count: usize,
    pub feedback: Option<String>,
    pub error: Option<String>,
    pub running: bool,
}

/// Manages state snapshots for debugging.
pub struct SnapshotManager {
    snapshots: Vec<Snapshot>,
    max_snapshots: usize,
    start_time: Instant,
    next_id: u64,
}

impl SnapshotManager {
    /// Create a new snapshot manager.
    pub fn new(max_snapshots: usize) -> Self {
        Self {
            snapshots: Vec::with_capacity(max_snapshots),
            max_snapshots,
            start_time: Instant::now(),
            next_id: 0,
        }
    }
    
    /// Take a snapshot.
    pub fn take_snapshot(&mut self, action: Option<String>, summary: StateSummary) -> u64 {
        let id = self.next_id;
        self.next_id += 1;
        
        let snapshot = Snapshot {
            id,
            timestamp: self.start_time.elapsed(),
            action,
            state_summary: summary,
        };
        
        // Evict oldest if at capacity
        if self.snapshots.len() >= self.max_snapshots {
            self.snapshots.remove(0);
        }
        
        self.snapshots.push(snapshot);
        id
    }
    
    /// Get recent snapshots.
    pub fn recent(&self, count: usize) -> Vec<&Snapshot> {
        self.snapshots.iter().rev().take(count).collect()
    }
    
    /// Get snapshot by ID.
    pub fn get(&self, id: u64) -> Option<&Snapshot> {
        self.snapshots.iter().find(|s| s.id == id)
    }
    
    /// Get snapshot count.
    pub fn count(&self) -> usize {
        self.snapshots.len()
    }
    
    /// Clear all snapshots.
    pub fn clear(&mut self) {
        self.snapshots.clear();
    }
    
    /// Create a summary from AppState.
    pub fn summarize(state: &crate::app::AppState) -> StateSummary {
        StateSummary {
            focus: format!("{:?}", state.focus),
            status_count: state.status_entries.len(),
            commit_count: state.commits.len(),
            branch_count: state.branches.len(),
            feedback: state.feedback_message.clone(),
            error: state.last_status_error.clone(),
            running: state.running,
        }
    }
}

impl Default for SnapshotManager {
    fn default() -> Self {
        Self::new(100) // Keep last 100 snapshots
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_snapshot_creation() {
        let mut manager = SnapshotManager::new(10);
        
        let summary = StateSummary {
            focus: "Status".to_string(),
            status_count: 5,
            ..Default::default()
        };
        
        let id = manager.take_snapshot(Some("Tick".to_string()), summary);
        assert_eq!(id, 0);
        assert_eq!(manager.count(), 1);
    }
    
    #[test]
    fn test_snapshot_eviction() {
        let mut manager = SnapshotManager::new(3);
        
        for i in 0..5 {
            manager.take_snapshot(
                Some(format!("Action {}", i)),
                StateSummary::default(),
            );
        }
        
        // Should only keep last 3
        assert_eq!(manager.count(), 3);
        
        // First snapshot should be action 2 (0 and 1 evicted)
        let recent = manager.recent(10);
        assert_eq!(recent.len(), 3);
    }
}