git-url-parse 0.6.0

A parser for urls used by git
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
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

use super::GitProvider;
use crate::{GitUrl, GitUrlParseError};

use getset::{CloneGetters, Getters};
use nom::Parser;
use nom::bytes::complete::tag;
use nom::combinator::opt;
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};
#[cfg(feature = "url")]
use url::Url;

/// ## GitLab repository provider
///
/// ## Supported URL Formats
///
/// - `https://gitlab.com/owner/repo.git`
/// - `https://gitlab.com/owner/subgroup1/subgroup2/repo.git`
/// - `git@gitlab.com:owner/repo.git`
/// - `git@gitlab.com:owner/subgroup1/subgroup2/repo.git`
///
/// ## Examples
///
/// ```
/// use git_url_parse::GitUrl;
/// use git_url_parse::types::provider::GitLabProvider;
///
/// fn main() -> Result<(), git_url_parse::GitUrlParseError> {
///     // Top-level repository
///     let url1 = GitUrl::parse("https://gitlab.com/gitlab-org/gitlab.git")?;
///     let provider1 : GitLabProvider = url1.provider_info()?;
///     assert_eq!(provider1.owner(), "gitlab-org");
///     assert_eq!(provider1.repo(), "gitlab");
///     assert_eq!(provider1.subgroup(), None);
///     assert_eq!(provider1.fullname(), "gitlab-org/gitlab");
///
///     // Repository with subgroups
///     let url2 = GitUrl::parse("https://gitlab.com/owner/group1/group2/project.git")?;
///     let provider2 : GitLabProvider = url2.provider_info()?;
///     assert_eq!(provider2.owner(), "owner");
///     assert_eq!(provider2.repo(), "project");
///     assert_eq!(provider2.subgroup(), Some(vec!["group1", "group2"]));
///     assert_eq!(provider2.fullname(), "owner/group1/group2/project");
///
///     Ok(())
/// }
/// ```
///
#[derive(Clone, Debug, PartialEq, Eq, Default, Getters, CloneGetters)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct GitLabProvider {
    /// Repo owner
    #[getset(get = "pub")]
    owner: String,
    /// Gitlab subgroups
    //#[getset(get_clone = "pub")]
    subgroup: Option<Vec<String>>,
    /// Repo name
    #[getset(get = "pub")]
    repo: String,
}

impl GitLabProvider {
    /// Repo owner
    /// Gitlab subgroups
    pub fn subgroup(&self) -> Option<Vec<&str>> {
        if let Some(s) = &self.subgroup {
            let subgroup_vec: Vec<&str> = s.iter().map(|s| s.as_str()).collect();
            Some(subgroup_vec)
        } else {
            None
        }
    }

    /// Helper method to get the full name of a repo: `{owner}/{repo}` or `{owner}/{subgroups}/{repo}`
    pub fn fullname(&self) -> String {
        if let Some(subgroup) = self.subgroup() {
            let subgroup_str = subgroup.join("/");

            format!("{}/{subgroup_str}/{}", self.owner, self.repo)
        } else {
            format!("{}/{}", self.owner, self.repo)
        }
    }

    /// Parse the path of url for GitLab patterns
    fn parse_path(input: &str) -> Result<(&str, GitLabProvider), GitUrlParseError> {
        // Optional leading slash
        let (input, _) = opt(tag("/")).parse(input)?;

        // Remove .git extension if present
        let input = input.trim_end_matches(".git");

        // Split the path
        let parts: Vec<&str> = input.split('/').filter(|s| !s.is_empty()).collect();

        // Ensure we have at least 2 parts (owner and repo)
        if parts.len() < 2 {
            return Err(GitUrlParseError::ProviderParseFail(
                "Path needs at least 2 parts: ex. \'/owner/repo\'".into(),
            ));
        }

        // Last part is the repo
        let repo = parts[parts.len() - 1].to_string();

        // Everything before the last part is the owner/subgroups
        let (owner, subgroup) = if parts.len() > 2 {
            let subgroup: Vec<String> = parts[1..(parts.len() - 1)]
                .iter()
                .copied()
                .map(|s| s.to_string())
                .collect();

            (parts[0].to_string(), Some(subgroup))
        } else {
            (parts[0].to_string(), None)
        };

        Ok((
            input,
            GitLabProvider {
                owner,
                subgroup,
                repo,
            },
        ))
    }
}

impl GitProvider<GitUrl, GitUrlParseError> for GitLabProvider {
    fn from_git_url(url: &GitUrl) -> Result<Self, GitUrlParseError> {
        let path = url.path();
        Self::parse_path(path).map(|(_, provider)| provider)
    }
}

#[cfg(feature = "url")]
impl GitProvider<Url, GitUrlParseError> for GitLabProvider {
    fn from_git_url(url: &Url) -> Result<Self, GitUrlParseError> {
        let path = url.path();
        Self::parse_path(path).map(|(_, provider)| provider)
    }
}