gitstack 5.3.0

Git history viewer with insights - Author stats, file heatmap, code ownership
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

//! Graph layout definitions

use super::cell::GraphCell;
use crate::event::GitEvent;

/// Data for a single row of the graph
#[derive(Debug, Clone)]
pub struct GraphRow {
    /// Event information for this commit (None for connector rows)
    pub event: Option<GitEvent>,
    /// Column position of this commit
    pub column: usize,
    /// Color index
    pub color_idx: usize,
    /// Graph cell array (rendering content for each column from left to right)
    pub cells: Vec<GraphCell>,
    /// Whether this is HEAD
    pub is_head: bool,
    /// List of branch names
    pub branch_names: Vec<String>,
}

impl GraphRow {
    /// Create a new GraphRow
    pub fn new(
        event: Option<GitEvent>,
        column: usize,
        color_idx: usize,
        cells: Vec<GraphCell>,
    ) -> Self {
        Self {
            event,
            column,
            color_idx,
            cells,
            is_head: false,
            branch_names: Vec::new(),
        }
    }

    /// Set the HEAD flag
    pub fn with_head(mut self, is_head: bool) -> Self {
        self.is_head = is_head;
        self
    }

    /// Set branch names
    pub fn with_branches(mut self, names: Vec<String>) -> Self {
        self.branch_names = names;
        self
    }
}

/// Layout of the entire graph
#[derive(Debug, Clone)]
pub struct GraphLayout {
    /// Row data
    pub rows: Vec<GraphRow>,
    /// Maximum column count
    pub max_column: usize,
}

impl GraphLayout {
    /// Create an empty layout
    pub fn empty() -> Self {
        Self {
            rows: Vec::new(),
            max_column: 0,
        }
    }

    /// Get the number of rows
    pub fn len(&self) -> usize {
        self.rows.len()
    }

    /// Check if empty
    pub fn is_empty(&self) -> bool {
        self.rows.is_empty()
    }

    /// Get the row at the specified index
    pub fn get(&self, idx: usize) -> Option<&GraphRow> {
        self.rows.get(idx)
    }

    /// Get an iterator
    pub fn iter(&self) -> impl Iterator<Item = &GraphRow> {
        self.rows.iter()
    }
}

impl Default for GraphLayout {
    fn default() -> Self {
        Self::empty()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_graph_row_new() {
        let row = GraphRow::new(None, 0, 1, vec![GraphCell::Empty]);
        assert!(row.event.is_none());
        assert_eq!(row.column, 0);
        assert_eq!(row.color_idx, 1);
        assert!(!row.is_head);
    }

    #[test]
    fn test_graph_row_with_head() {
        let row = GraphRow::new(None, 0, 0, vec![]).with_head(true);
        assert!(row.is_head);
    }

    #[test]
    fn test_graph_row_with_branches() {
        let row = GraphRow::new(None, 0, 0, vec![]).with_branches(vec!["main".to_string()]);
        assert_eq!(row.branch_names, vec!["main"]);
    }

    #[test]
    fn test_graph_layout_empty() {
        let layout = GraphLayout::empty();
        assert!(layout.is_empty());
        assert_eq!(layout.len(), 0);
        assert_eq!(layout.max_column, 0);
    }

    #[test]
    fn test_graph_layout_get() {
        let mut layout = GraphLayout::empty();
        layout.rows.push(GraphRow::new(None, 0, 0, vec![]));
        assert!(layout.get(0).is_some());
        assert!(layout.get(1).is_none());
    }
}