Add parse_to_url, TryFrom and GitProvider for Url

Author: tjtelan

src/types/mod.rs

@@ -196,6 +196,24 @@ impl TryFrom<GitUrl> for Url {
     }
 }
 
+#[cfg(feature = "url")]
+impl TryFrom<&Url> for GitUrl {
+    type Error = GitUrlParseError;
+    fn try_from(value: &Url) -> Result<Self, Self::Error> {
+        // Since we don't fully implement any spec, we'll rely on the url crate
+        GitUrl::parse(value.as_str())
+    }
+}
+
+#[cfg(feature = "url")]
+impl TryFrom<Url> for GitUrl {
+    type Error = GitUrlParseError;
+    fn try_from(value: Url) -> Result<Self, Self::Error> {
+        // Since we don't fully implement any spec, we'll rely on the url crate
+        GitUrl::parse(value.as_str())
+    }
+}
+
 impl GitUrl {
     /// Returns `GitUrl` after removing all user info values
     pub fn trim_auth(&self) -> GitUrl {
@@ -219,8 +237,16 @@ impl GitUrl {
     /// #  }
     /// ```
     pub fn parse(input: &str) -> Result<Self, GitUrlParseError> {
-        let mut git_url_result = GitUrl::default();
+        let git_url = Self::parse_to_git_url(input)?;
+
+        git_url.is_valid()?;
 
+        Ok(git_url)
+    }
+
+    /// Internal parse to `GitUrl` without further validation
+    fn parse_to_git_url(input: &str) -> Result<Self, GitUrlParseError> {
+        let mut git_url_result = GitUrl::default();
         // Error if there are null bytes within the url
         // https://github.com/tjtelan/git-url-parse-rs/issues/16
         if input.contains('\0') {
@@ -294,6 +320,14 @@ impl GitUrl {
         Ok(git_url_result)
     }
 
+    /// Normalize input into form that can be used by [`Url::parse`](https://docs.rs/url/latest/url/struct.Url.html#method.parse)
+    #[cfg(feature = "url")]
+    pub fn parse_to_url(input: &str) -> Result<Url, GitUrlParseError> {
+        let git_url = Self::parse_to_git_url(input)?;
+
+        Ok(Url::try_from(git_url)?)
+    }
+
     /// ```
     /// use git_url_parse::GitUrl;
     /// use git_url_parse::types::provider::GenericProvider;

src/types/provider/azure_devops.rs

@@ -0,0 +1,139 @@
+use super::GitProvider;
+use crate::types::GitUrlParseHint;
+use crate::{GitUrl, GitUrlParseError};
+
+use getset::Getters;
+use nom::Parser;
+use nom::bytes::complete::{is_not, tag, take_until};
+use nom::combinator::opt;
+use nom::sequence::{preceded, separated_pair, terminated};
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+#[cfg(feature = "url")]
+use url::Url;
+
+/// Azure DevOps repository provider
+/// ## Supported URL Formats
+///
+/// - `https://dev.azure.com/org/project/_git/repo`
+/// - `[email protected]:v3/org/project/repo`
+///
+/// Example:
+///
+/// ```
+/// use git_url_parse::{GitUrl, GitUrlParseError};
+/// use git_url_parse::types::provider::AzureDevOpsProvider;
+///
+/// let test_url = "https://[email protected]/CompanyName/ProjectName/_git/RepoName";
+/// let parsed = GitUrl::parse(test_url).expect("URL parse failed");
+///
+/// let provider_info: AzureDevOpsProvider = parsed.provider_info().unwrap();
+///
+/// assert_eq!(provider_info.org(), "CompanyName");
+/// assert_eq!(provider_info.project(), "ProjectName");
+/// assert_eq!(provider_info.repo(), "RepoName");
+/// assert_eq!(provider_info.fullname(), "CompanyName/ProjectName/RepoName");
+/// ```
+///
+#[derive(Debug, PartialEq, Eq, Clone, Getters)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[getset(get = "pub")]
+pub struct AzureDevOpsProvider {
+    /// Azure Devops organization name
+    org: String,
+    /// Azure Devops project name
+    project: String,
+    /// Azure Devops repo name
+    repo: String,
+}
+
+impl AzureDevOpsProvider {
+    /// Helper method to get the full name of a repo: `{org}/{project}/{repo}`
+    pub fn fullname(&self) -> String {
+        format!("{}/{}/{}", self.org, self.project, self.repo)
+    }
+
+    /// Parse the path of a http url for Azure Devops patterns
+    fn parse_http_path(input: &str) -> Result<(&str, AzureDevOpsProvider), GitUrlParseError> {
+        // Handle optional leading /
+        let (input, _) = opt(tag("/")).parse(input)?;
+
+        // Parse org/project/repo
+        let (input, (org, (project, repo))) = separated_pair(
+            is_not("/"),
+            tag("/"),
+            separated_pair(
+                is_not("/"),
+                tag("/"),
+                preceded(opt(tag("_git/")), is_not("")),
+            ),
+        )
+        .parse(input)?;
+
+        Ok((
+            input,
+            AzureDevOpsProvider {
+                org: org.to_string(),
+                project: project.to_string(),
+                repo: repo.to_string(),
+            },
+        ))
+    }
+
+    /// Parse the path of an ssh url for Azure Devops patterns
+    fn parse_ssh_path(input: &str) -> Result<(&str, AzureDevOpsProvider), GitUrlParseError> {
+        // Handle optional leading v3/ or other prefix
+        let (input, _) = opt(take_until("/")).parse(input)?;
+        let (input, _) = opt(tag("/")).parse(input)?;
+
+        // Parse org/project/repo
+        let (input, (org, (project, repo))) = separated_pair(
+            is_not("/"),
+            tag("/"),
+            separated_pair(
+                is_not("/"),
+                tag("/"),
+                terminated(is_not("."), opt(tag(".git"))),
+            ),
+        )
+        .parse(input)?;
+
+        Ok((
+            input,
+            AzureDevOpsProvider {
+                org: org.to_string(),
+                project: project.to_string(),
+                repo: repo.to_string(),
+            },
+        ))
+    }
+}
+
+impl GitProvider<GitUrl, GitUrlParseError> for AzureDevOpsProvider {
+    fn from_git_url(url: &GitUrl) -> Result<Self, GitUrlParseError> {
+        let path = url.path();
+
+        let parsed = if url.hint() == GitUrlParseHint::Httplike {
+            Self::parse_http_path(path)
+        } else {
+            Self::parse_ssh_path(path)
+        };
+
+        parsed.map(|(_, provider)| provider)
+    }
+}
+
+#[cfg(feature = "url")]
+impl GitProvider<Url, GitUrlParseError> for AzureDevOpsProvider {
+    fn from_git_url(url: &Url) -> Result<Self, GitUrlParseError> {
+        let path = url.path();
+
+        let parsed = if url.scheme().contains("http") {
+            Self::parse_http_path(path)
+        } else {
+            Self::parse_ssh_path(path)
+        };
+
+        parsed.map(|(_, provider)| provider)
+    }
+}

src/types/provider/generic.rs

@@ -0,0 +1,93 @@
+use super::GitProvider;
+use crate::types::GitUrlParseHint;
+use crate::{GitUrl, GitUrlParseError};
+
+use getset::Getters;
+use nom::Parser;
+use nom::bytes::complete::{is_not, tag, take_until};
+use nom::combinator::opt;
+use nom::sequence::separated_pair;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+#[cfg(feature = "url")]
+use url::Url;
+
+/// Represents a generic Git repository provider
+///
+/// ## Typical Use Cases
+///
+/// - Common service hosting with `owner/repo` patterns (e.g. GitHub, Bitbucket)
+/// - Self-hosted repositories (e.g. Codeberg, Gitea)
+///
+/// Example:
+///
+/// ```
+/// use git_url_parse::{GitUrl, GitUrlParseError};
+/// use git_url_parse::types::provider::GenericProvider;
+///
+/// let test_url = "[email protected]:tjtelan/git-url-parse-rs.git";
+/// let parsed = GitUrl::parse(test_url).expect("URL parse failed");
+///
+/// let provider_info: GenericProvider = parsed.provider_info().unwrap();
+///
+/// assert_eq!(provider_info.owner(), "tjtelan");
+/// assert_eq!(provider_info.repo(), "git-url-parse-rs");
+/// assert_eq!(provider_info.fullname(), "tjtelan/git-url-parse-rs");
+/// ```
+///
+#[derive(Debug, PartialEq, Eq, Clone, Getters)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[getset(get = "pub")]
+pub struct GenericProvider {
+    /// Repo owner
+    owner: String,
+    /// Repo name
+    repo: String,
+}
+
+impl GenericProvider {
+    /// Parse the most common form of git url by offered by git providers
+    fn parse_path(input: &str) -> Result<(&str, GenericProvider), GitUrlParseError> {
+        let (input, _) = opt(tag("/")).parse(input)?;
+        let (input, (user, repo)) = if input.ends_with(".git") {
+            separated_pair(is_not("/"), tag("/"), take_until(".git")).parse(input)?
+        } else {
+            separated_pair(is_not("/"), tag("/"), is_not("/")).parse(input)?
+        };
+        Ok((
+            input,
+            GenericProvider {
+                owner: user.to_string(),
+                repo: repo.to_string(),
+            },
+        ))
+    }
+
+    /// Helper method to get the full name of a repo: `{owner}/{repo}`
+    pub fn fullname(&self) -> String {
+        format!("{}/{}", self.owner, self.repo)
+    }
+}
+
+impl GitProvider<GitUrl, GitUrlParseError> for GenericProvider {
+    fn from_git_url(url: &GitUrl) -> Result<Self, GitUrlParseError> {
+        if url.hint() == GitUrlParseHint::Filelike {
+            return Err(GitUrlParseError::ProviderUnsupported);
+        }
+
+        let path = url.path();
+        Self::parse_path(path).map(|(_, provider)| provider)
+    }
+}
+
+#[cfg(feature = "url")]
+impl GitProvider<Url, GitUrlParseError> for GenericProvider {
+    fn from_git_url(url: &Url) -> Result<Self, GitUrlParseError> {
+        if url.scheme() == "file" {
+            return Err(GitUrlParseError::ProviderUnsupported);
+        }
+
+        let path = url.path();
+        Self::parse_path(path).map(|(_, provider)| provider)
+    }
+}