panoptes 0.0.2

Keep an eye on your repositories.
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

use colored::Colorize;

pub trait RepositoryExt {
    fn last_commit(&self) -> git2::Commit;
    fn file_statuses(&self) -> git2::Statuses;
}

impl RepositoryExt for git2::Repository {
    fn last_commit(&self) -> git2::Commit {
        // TODO: properly handle all errors
        self.head().unwrap().peel_to_commit().unwrap()
    }

    fn file_statuses(&self) -> git2::Statuses {
        let mut status_opts = git2::StatusOptions::new();
        status_opts
            .include_untracked(true)
            .show(git2::StatusShow::IndexAndWorkdir);

        // TODO: properly handle the Result
        self.statuses(Some(&mut status_opts)).unwrap()
    }
}

pub trait Summarize: RepositoryExt {
    fn summarize(&self, commit_opts: &CommitOptions);
}

impl Summarize for git2::Repository {
    fn summarize(&self, commit_opts: &CommitOptions) {
        println!(
            "{} [{}]",
            self.path().parent().unwrap().display().to_string().green(),
            self.head().unwrap().shorthand().unwrap().blue().bold()
        );

        let statuses = self.file_statuses();
        if !statuses.is_empty() {
            if !commit_opts.is_empty() {
                println!("File status:");
            }
            for s in statuses.iter() {
                if let Some(path) = s.path() {
                    println!("  {:#?} {}", s.status(), path.yellow());
                }
            }
        }

        if !commit_opts.is_empty() {
            let commit = self.last_commit();
            println!("Last commit:");
            if commit_opts.contains(CommitOptions::MESSAGE) {
                println!("  Message:");
                println!(
                    "    {}",
                    commit
                        .message()
                        .unwrap()
                        .split("\n")
                        .take(1)
                        .collect::<String>()
                );
            }
            if commit_opts.contains(CommitOptions::DATE) {
                println!("  Date:");
                let time = commit.time().seconds();
                println!("    {}", chrono::NaiveDateTime::from_timestamp(time, 0));
            }
            if commit_opts.contains(CommitOptions::HASH) {
                println!("  Hash:");
                println!("    {}", commit.id());
            }
        }
    }
}

bitflags::bitflags! {
    pub struct CommitOptions: usize {
        const DATE = 0b00000001;
        const HASH = 0b00000010;
        const MESSAGE = 0b00000100;
    }
}

impl CommitOptions {
    /// Return the bitflag length.
    pub const fn length() -> usize {
        let mut all = Self::all().bits();
        let mut idx = 0;
        while all != 0 {
            all >>= 1;
            idx += 1;
        }
        idx
    }
}

impl std::str::FromStr for CommitOptions {
    /// During parsing, unknown strings are ignored.
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let mut opts = Self::empty();

        for elem in s.to_ascii_lowercase().split(",").map(&str::trim) {
            match elem {
                "date" => opts |= CommitOptions::DATE,
                "hash" => opts |= CommitOptions::HASH,
                "message" => opts |= CommitOptions::MESSAGE,
                "all" => opts |= CommitOptions::all(),
                _ => continue,
            }
        }

        Ok(opts)
    }
}