mure 0.2.1

A command line tool for creating and managing multiple repositories.
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

use once_cell::sync::Lazy;
use regex::Regex;

#[derive(PartialEq, Eq, Debug, Clone)]
pub struct RepoInfo {
    pub domain: String,
    pub owner: String,
    pub repo: String,
}

impl RepoInfo {
    fn new(domain: &str, owner: &str, repo: &str) -> Self {
        RepoInfo {
            domain: domain.to_string(),
            owner: owner.to_string(),
            repo: repo.to_string(),
        }
    }

    #[allow(dead_code)]
    pub fn fully_qualified_name(&self) -> String {
        format!("{}/{}/{}", self.domain, self.owner, self.repo)
    }

    pub fn name_with_owner(&self) -> String {
        format!("{}/{}", self.owner, self.repo)
    }

    pub fn parse_url(url: &str) -> Option<Self> {
        let patterns = [
            GITHUB_HTTPS_URL.clone(),
            GITHUB_GIT_URL.clone(),
            GITHUB_SSH_URL.clone(),
        ];
        for pattern in patterns.iter() {
            if let Some(repo_info) = RepoInfo::parse_with_regex(pattern, url) {
                return Some(repo_info);
            }
        }
        None
    }
    fn parse_with_regex(pattern: &Regex, url: &str) -> Option<Self> {
        if let Some(caps) = pattern.captures(url) {
            let domain = caps.name("domain")?.as_str();
            let owner = caps.name("owner")?.as_str();
            let repo = caps.name("repo")?.as_str();
            return Some(RepoInfo::new(domain, owner, repo));
        }
        None
    }
}

static GITHUB_HTTPS_URL: Lazy<Regex> = Lazy::new(|| {
    #[allow(clippy::unwrap_used)]
    Regex::new("^https?://(?P<domain>github\\.com)/(?P<owner>.*?)/(?P<repo>.*?)(/?|(?:\\.git))$")
        .unwrap()
});

static GITHUB_GIT_URL: Lazy<Regex> = Lazy::new(|| {
    #[allow(clippy::unwrap_used)]
    Regex::new("^git@(?P<domain>github\\.com):(?P<owner>.*?)/(?P<repo>.*?)(?:\\.git)?$").unwrap()
});

static GITHUB_SSH_URL: Lazy<Regex> = Lazy::new(|| {
    #[allow(clippy::unwrap_used)]
    Regex::new(
        "^ssh://git@(?P<domain>github\\.com)(?::22)?/(?P<owner>.*?)/(?P<repo>.*?)(?:\\.git)$",
    )
    .unwrap()
});

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_parse_github_url() {
        let tobe = RepoInfo::new("github.com", "kitsuyui", "mure");
        fn parse(url: &str) -> Option<RepoInfo> {
            RepoInfo::parse_url(url)
        }

        // match
        assert_eq!(parse("https://github.com/kitsuyui/mure").unwrap(), tobe);
        assert_eq!(parse("https://github.com/kitsuyui/mure.git").unwrap(), tobe);
        assert_eq!(parse("[email protected]:kitsuyui/mure.git").unwrap(), tobe);
        assert_eq!(
            parse("ssh://[email protected]:22/kitsuyui/mure.git").unwrap(),
            tobe
        );
        assert_eq!(
            parse("ssh://[email protected]/kitsuyui/mure.git").unwrap(),
            tobe
        );

        // not match
        assert!(parse("https://github.com/").is_none());
        assert!(parse("https://example.com/something/else").is_none());
        assert!(parse("[email protected]:kitsuyui/mure.git").is_none());
        assert!(parse("ssh://[email protected]/kitsuyui/mure.git").is_none());
    }

    #[test]
    fn test_names() {
        let repo_info = RepoInfo::new("github.com", "kitsuyui", "mure");
        assert_eq!(repo_info.fully_qualified_name(), "github.com/kitsuyui/mure");
        assert_eq!(repo_info.name_with_owner(), "kitsuyui/mure");
    }
}