post-push-party 0.1.7

Push code, earn points, throw a party!
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

//! Git operations for detecting pushes and tracking seen commits.

mod commands;
pub mod detection;

pub use detection::{get_pushed_commits, snapshot_refs};

/// data about a single commit in a push
#[derive(Debug, Clone, Default)]
pub struct Commit {
    lines_changed: u64,
    #[expect(dead_code)]
    sha: String,
    #[expect(dead_code)]
    timestamp: u64,
}

impl Commit {
    pub fn new(sha: impl Into<String>, lines_changed: u64, timestamp: u64) -> Self {
        Self {
            sha: sha.into(),
            lines_changed,
            timestamp,
        }
    }

    #[cfg(test)]
    pub fn with_lines(lines_changed: u64) -> Self {
        Self {
            lines_changed,
            ..Default::default()
        }
    }

    pub fn lines_changed(&self) -> u64 {
        self.lines_changed
    }
}

/// data about a single push
#[derive(Debug)]
pub struct Push {
    commits: Vec<Commit>,
    remote_url: String,
    branch: String,
}

impl Default for Push {
    fn default() -> Self {
        Self {
            commits: Vec::new(),
            remote_url: "git@github.com:user/repo.git".to_string(),
            branch: "main".to_string(),
        }
    }
}

impl Push {
    #[cfg(test)]
    pub fn new(commits: Vec<Commit>) -> Self {
        Self {
            commits,
            ..Default::default()
        }
    }

    #[cfg(any(test, feature = "dev"))]
    pub fn with_repo(commits: Vec<Commit>, remote_url: impl Into<String>) -> Self {
        Self {
            commits,
            remote_url: remote_url.into(),
            ..Default::default()
        }
    }

    pub fn from_parts(
        commits: Vec<Commit>,
        remote_url: impl Into<String>,
        branch: impl Into<String>,
    ) -> Self {
        Self {
            commits,
            remote_url: remote_url.into(),
            branch: branch.into(),
        }
    }

    pub fn commits(&self) -> &[Commit] {
        &self.commits
    }

    pub fn remote_url(&self) -> &str {
        &self.remote_url
    }

    pub fn branch(&self) -> &str {
        &self.branch
    }
}