sgit 0.1.2

stupid git in a tool 
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

use std::path::PathBuf;
use std::process::Command;

use url::Url;

#[derive(Debug)]
pub struct GitWrapper<'a> {
    repo: &'a str,
}

impl<'a> GitWrapper<'a> {
    pub(crate) fn new(repo: &'a str) -> GitWrapper<'a> {
        GitWrapper {
            repo
        }
    }

    #[must_use]
    #[inline]
    fn git(&self) -> Command {
        let cmd = Command::new("git");
        cmd
    }

    pub fn get_repo_name(&self) -> Option<String> {
        let url = Url::parse(self.repo);
        if url.is_err() {
            return None;
        }

        let url = url.unwrap();
        let maybe_paths = url.path_segments()
            .map(|c| {
                c.collect::<Vec<_>>()
            });

        match &maybe_paths {
            None => { None }
            Some(paths) => {
                let mut last = paths.last().unwrap_or(&"").to_string();
                let maybe_suffix = last.strip_suffix(".git");
                if maybe_suffix.is_some() {
                    last = maybe_suffix.unwrap().to_string();
                }

                Some(last)
            }
        }
    }

    pub fn try_clone(&self) {
        let maybe_repo_name = self.get_repo_name();
        if maybe_repo_name.is_none() {
            error!("cannot get repo name, try to fetch");
        }

        let repo_name = maybe_repo_name.unwrap();

        let is_already_exists = PathBuf::from(repo_name).exists();
        if is_already_exists {
            error!("target repo is exists, try to pull it");
            self.try_pull();
        } else {
            self.done_clone()
        }
    }

    pub fn done_clone(&self) {
        let mut cmd = self.git();
        cmd.arg("clone")
            .arg(self.repo);

        let output = cmd.output().expect("git command failed to start");

        info!("{}", String::from_utf8_lossy(&*output.stderr));
        info!("{:?}", String::from_utf8_lossy(&*output.stdout).to_string());
    }

    pub fn try_clean(&self) {
        let mut cmd = self.with_path();
        cmd.arg("stash");

        let output = cmd.output().expect("stash code");
        info!("{}", String::from_utf8_lossy(&*output.stderr));
        info!("{}", String::from_utf8_lossy(&*output.stdout).to_string());
    }

    pub fn try_pull(&self) {
        self.try_clean();

        let mut cmd = self.with_path();
        cmd.arg("pull");

        info!("pull from path: {}", self.repo);

        let output = cmd.output().expect("pull code");

        info!("{}", String::from_utf8_lossy(&*output.stderr));
        info!("{}", String::from_utf8_lossy(&*output.stdout).to_string());
    }

    fn with_path(&self) -> Command {
        let mut cmd = self.git();
        cmd.arg("-C").arg(self.get_repo_name().unwrap());
        cmd
    }
}


#[cfg(test)]
mod tests {
    use std::fs;
    use std::path::Path;

    use crate::git_wrapper::GitWrapper;

    #[test]
    fn pull_code() {
        let wrapper = GitWrapper::new("https://github.com/phodal/batch-git");

        wrapper.done_clone();
        wrapper.try_pull();

        let path = Path::new("batch-git");
        assert!(path.exists());

        fs::remove_dir_all(Path::new("batch-git")).unwrap();
    }

    #[test]
    fn repo_name_success() {
        let name = GitWrapper::new("https://github.com/phodal/batch-git").get_repo_name();
        assert_eq!("batch-git", name.unwrap());
    }

    #[test]
    fn suffix_name_success() {
        let name = GitWrapper::new("https://github.com/phodal/batch-git.git").get_repo_name();
        assert_eq!("batch-git", name.unwrap());
    }

    #[test]
    fn repo_name_return_empty() {
        let name = GitWrapper::new("batch-git").get_repo_name();

        assert!(name.is_none());
    }
}