gobbledygit 0.1.0

A tool to print the git repository status
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

use core::fmt;
use git2::{ErrorCode, Repository, RepositoryOpenFlags, Status, Statuses};
use std::fmt::{Error, Formatter};
use std::path::Path;

struct GitStatus {
    new: i32,
    modified: i32,
    deleted: i32,
    renamed: i32,
    type_changed: i32,
    conflicted: i32,
}

impl fmt::Display for GitStatus {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
        let mut fmt_string = String::new();
        // TODO: Too much duplication, refactor this into a impl fn?
        if self.new != 0 {
            fmt_string.push_str(format!("{}A", self.new).as_str())
        }

        if self.modified != 0 {
            fmt_string.push_str(format!("{}M", self.modified).as_str())
        }

        if self.deleted != 0 {
            fmt_string.push_str(format!("{}D", self.deleted).as_str())
        }

        if self.renamed != 0 {
            fmt_string.push_str(format!("{}R", self.renamed).as_str())
        }

        if self.type_changed != 0 {
            fmt_string.push_str(format!("{}T", self.type_changed).as_str())
        }
        if self.conflicted != 0 {
            fmt_string.push_str(format!("{}C", self.conflicted).as_str())
        }
        write!(f, "{}", fmt_string)
    }
}

pub fn repo() -> Option<Repository> {
    let open_flags = RepositoryOpenFlags::all();
    let paths: [&Path; 0] = []; //Empty path that doesn't need to be
    match Repository::open_ext(".", open_flags, paths.iter()) {
        Ok(repo) => Some(repo),
        Err(_e) => None,
    }
}

pub fn head_status(repo: &Repository) -> String {
    let head = match repo.head() {
        Ok(head) => Some(head),
        Err(ref e) if e.code() == ErrorCode::UnbornBranch || e.code() == ErrorCode::NotFound => {
            None
        }
        Err(_e) => None,
    };

    head.as_ref()
        .and_then(|r| r.shorthand())
        .unwrap_or("HEAD")
        .to_string()
}

pub fn status(repo: &Repository) -> String {
    let result = repo.statuses(None);

    match result.as_ref() {
        Ok(statuses) => format!("{}", git_status(statuses)),
        Err(_e) => format!(""),
    }
}

fn git_status(statuses: &Statuses) -> GitStatus {
    //TODO: Currently combines both index and working tree status. Separate them
    let mut new = 0;
    let mut modified = 0;
    let mut renamed = 0;
    let mut deleted = 0;
    let mut type_changed = 0;
    let mut conflicted = 0;

    for entry in statuses.iter().filter(|e| e.status() != Status::CURRENT) {
        match entry.status() {
            s if s.contains(Status::INDEX_NEW) => new += 1,
            s if s.contains(Status::INDEX_MODIFIED) => modified += 1,
            s if s.contains(Status::INDEX_DELETED) => deleted += 1,
            s if s.contains(Status::INDEX_RENAMED) => renamed += 1,
            s if s.contains(Status::INDEX_TYPECHANGE) => type_changed += 1,
            s if s.contains(Status::CONFLICTED) => conflicted += 1,
            _ => (),
        };

        match entry.status() {
            s if s.contains(git2::Status::WT_MODIFIED) => modified += 1,
            s if s.contains(git2::Status::WT_DELETED) => deleted += 1,
            s if s.contains(git2::Status::WT_RENAMED) => renamed += 1,
            s if s.contains(git2::Status::WT_TYPECHANGE) => type_changed += 1,
            _ => (),
        };
    }

    GitStatus {
        new,
        modified,
        renamed,
        deleted,
        type_changed,
        conflicted,
    }
}