slip_git 0.1.2

Simple `slip` command (git clone runner to better categorize personal repos and work repos).
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

use serde_derive::Deserialize;


#[derive(Deserialize, Debug)]
pub struct Config {
    pub default: Option<WorkOrPersonal>,
    work: Option<RepoRoot>,
    personal: Option<RepoRoot>,
}

#[derive(Deserialize, Debug)]
pub enum WorkOrPersonal {
    Work,
    Personal,
}

#[derive(Deserialize, Debug, Clone)]
pub struct RepoRoot {
    pub root: Option<String>,
    pub pattern: Option<RepoNamePattern>,
}

#[derive(Deserialize, Debug, Clone, Copy)]
pub enum RepoNamePattern {
    Hyphen,
    Recursive,
    Plain,
}

impl RepoNamePattern {
    pub fn get_directory(&self, path: String) -> String {
        match &self {
            RepoNamePattern::Recursive => path,
            RepoNamePattern::Hyphen => path.replace('/', "-"),
            RepoNamePattern::Plain => {
                let at = path.rfind('/').unwrap() + 1;
                path[at..path.len()].to_string()
            }
        }
    }
}

#[test]
fn teste2() {
    assert_eq!(
        "asdfadf".to_string(),
        RepoNamePattern::Plain.get_directory("asdf/asdfadf".to_string())
    );

    assert_eq!(
        "asdf/asdfadf".to_string(),
        RepoNamePattern::Recursive.get_directory("asdf/asdfadf".to_string())
    );

    assert_eq!(
        "asdf-asdfadf".to_string(),
        RepoNamePattern::Hyphen.get_directory("asdf/asdfadf".to_string())
    );
}

impl RepoRoot {
    fn get_pattern(&self) -> RepoNamePattern {
        *self.pattern.as_ref().unwrap_or(&RepoNamePattern::Recursive)
    }
}

impl Config {
    pub fn work(&self) -> (String, RepoNamePattern) {
        if self.work.is_some() && self.work.as_ref().unwrap().root.is_some() {
            (
                String::from(shellexpand::tilde(
                    self.work.as_ref().unwrap().root.as_ref().unwrap(),
                )),
                self.work.as_ref().unwrap().get_pattern(),
            )
        } else {
            (
                String::from(shellexpand::tilde("~/projects/work")),
                RepoNamePattern::Recursive,
            )
        }
    }

    pub fn personal(&self) -> (String, RepoNamePattern) {
        if self.personal.is_some() && self.personal.as_ref().unwrap().root.is_some() {
            (
                String::from(shellexpand::tilde(
                    self.personal.as_ref().unwrap().root.as_ref().unwrap(),
                )),
                self.personal.as_ref().unwrap().get_pattern(),
            )
        } else {
            (
                String::from(shellexpand::tilde("~/projects/personal")),
                RepoNamePattern::Recursive,
            )
        }
    }
    pub fn default(&self) -> (String, RepoNamePattern) {
        match self.default.as_ref().unwrap() {
            WorkOrPersonal::Personal => self.personal(),
            WorkOrPersonal::Work => self.work(),
        }
    }
    pub fn new() -> Config {
        Config {
            work: None,
            personal: None,
            default: Some(WorkOrPersonal::Work),
        }
    }
}