gitx 0.0.4

git subcommands 
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

use std::io;
use std::collections::HashMap;
use std::process::{Command, Output};
use std::ffi::*;
use git::branch::*;
use git::log::*;

pub struct Git {
    path: String,
}

impl Git {
    pub fn new() -> Git {
        Git{path: "git".to_string()}
    }

    fn command(&self) -> Command {
        Command::new(OsString::from(&self.path))
    }

    pub fn status(&self) -> io::Result<Output> {
        self.command()
            .arg("status")
            .output()
    }

    pub fn branches(&self) -> Branches {
        let output = self.command().arg("branch").arg("-vv").output().unwrap();

        let mut current = String::new();

        let map = String::from_utf8_lossy(&output.stdout)
            .lines()
            .map(|l| l.trim_matches(' '))
            .map(|l| {
                let branch = Branch::new(l.replace("* ", "").as_ref());
                if l.starts_with('*') {
                    current = branch.name.clone();
                }
                branch
            })
            .fold(HashMap::new(), |mut branches, branch| {
                branches.insert(branch.name.clone(), branch);
                branches
            });
        Branches{branches: map, current: current}
    }

    pub fn logs(&self) -> Vec<Log> {
        let output = self.command()
            .arg("log")
            .arg("--oneline")
            .output()
            .unwrap();
        String::from_utf8_lossy(&output.stdout)
            .lines()
            .map(|l| {
                let (commit, msg) = l.split_at(8);
                Log::new(commit, msg)
            })
            .collect()
    }

    pub fn checkout(&self, branch : &Branch) -> io::Result<Output> {
        self.command().arg("checkout").arg(&branch.name).output()
    }

    pub fn checkout_prev(&self) -> io::Result<Output> {
        self.checkout(&Branch::new_by_name("-"))
    }

    pub fn create_branch(&self, branch : &Branch) -> io::Result<Output> {
        self.command().arg("checkout").arg("-b").arg(&branch.name).output()
    }

    pub fn delete_local_branch(&self, branch: &Branch) ->  io::Result<Output> {
        self.command().arg("branch").arg("-D").arg(&branch.name).output()
    }
}