gmap 0.3.0

Git repository analysis tool for churn and heatmap visualization
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
151
152
153

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use std::collections::HashSet;

pub const SCHEMA_VERSION: u32 = 1;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CommitInfo {
    pub id: String,
    pub author_name: String,
    pub author_email: String,
    pub message: String,
    pub timestamp: DateTime<Utc>,
    pub parent_ids: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FileStats {
    pub path: String,
    pub added_lines: u32,
    pub deleted_lines: u32,
    pub is_binary: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CommitStats {
    pub commit_id: String,
    pub files: Vec<FileStats>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChurnEntry {
    pub path: String,
    pub added_lines: u64,
    pub deleted_lines: u64,
    pub total_lines: u64,
    pub commit_count: u32,
    pub authors: HashSet<String>,
}

impl ChurnEntry {
    pub fn new(path: String) -> Self {
        Self {
            path,
            added_lines: 0,
            deleted_lines: 0,
            total_lines: 0,
            commit_count: 0,
            authors: HashSet::new(),
        }
    }

    pub fn add_stats(&mut self, stats: &FileStats, author: &str) {
        self.added_lines += stats.added_lines as u64;
        self.deleted_lines += stats.deleted_lines as u64;
        self.total_lines += (stats.added_lines + stats.deleted_lines) as u64;
        self.commit_count += 1;
        if self.authors.len() < 100 {
            self.authors.insert(author.to_string());
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChurnOutput {
    pub version: u32,
    pub generated_at: DateTime<Utc>,
    pub repository_path: String,
    pub since: Option<String>,
    pub until: Option<String>,
    pub depth: Option<u32>,
    pub entries: Vec<ChurnEntry>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HeatBucket {
    pub week: String,
    pub commit_count: u32,
    pub lines_changed: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HeatOutput {
    pub version: u32,
    pub generated_at: DateTime<Utc>,
    pub repository_path: String,
    pub path_prefix: String,
    pub since: Option<String>,
    pub until: Option<String>,
    pub buckets: Vec<HeatBucket>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ExportEntry {
    pub commit_id: String,
    pub author_name: String,
    pub author_email: String,
    pub timestamp: DateTime<Utc>,
    pub message: String,
    pub files: Vec<FileStats>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ExportOutput {
    pub version: u32,
    pub generated_at: DateTime<Utc>,
    pub repository_path: String,
    pub since: Option<String>,
    pub until: Option<String>,
    pub entries: Vec<ExportEntry>,
}

#[derive(Debug, Clone)]
pub struct DateRange {
    pub since: Option<DateTime<Utc>>,
    pub until: Option<DateTime<Utc>>,
}

impl DateRange {
    pub fn new() -> Self {
        Self { since: None, until: None }
    }

    pub fn with_since(mut self, since: DateTime<Utc>) -> Self {
        self.since = Some(since);
        self
    }

    pub fn with_until(mut self, until: DateTime<Utc>) -> Self {
        self.until = Some(until);
        self
    }

    pub fn contains(&self, timestamp: &DateTime<Utc>) -> bool {
        if let Some(since) = self.since {
            if timestamp < &since {
                return false;
            }
        }
        if let Some(until) = self.until {
            if timestamp > &until {
                return false;
            }
        }
        true
    }
}

impl Default for DateRange {
    fn default() -> Self {
        Self::new()
    }
}