chore!: restructure gix-url parsing error variants

Author: niklaswimmer

Cargo.lock

@@ -33,6 +33,7 @@ home = "0.5.3"
 document-features = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
+assert_matches = "1.5.0"
 gix-testtools = { path = "../tests/tools" }
 libtest-mimic = "0.6.1"
 

gix-url/Cargo.toml

@@ -5,13 +5,21 @@ use bstr::{BStr, BString, ByteSlice};
 #[derive(Debug, thiserror::Error)]
 #[allow(missing_docs)]
 pub enum Error {
-    #[error("Could not decode URL as UTF8")]
-    Utf8(#[from] std::str::Utf8Error),
-    #[error(transparent)]
-    Url(#[from] url::ParseError),
-    #[error("file URLs require an absolute or relative path to the repository")]
-    MissingRepositoryPath,
-    #[error("Relative URLs are not permitted: {url:?}")]
+    #[error("{} \"{url}\" is not valid UTF-8", .kind.get_error_str())]
+    Utf8 {
+        url: BString,
+        kind: UrlKind,
+        source: std::str::Utf8Error,
+    },
+    #[error("{} {url:?} can not be parsed as valid URL", .kind.get_error_str())]
+    Url {
+        url: String,
+        kind: UrlKind,
+        source: url::ParseError,
+    },
+    #[error("{} \"{url}\" does not specify a path to a repository", .kind.get_error_str())]
+    MissingRepositoryPath { url: BString, kind: UrlKind },
+    #[error("URL {url:?} is relative which is not allowed in this context")]
     RelativeUrl { url: String },
 }
 
@@ -21,6 +29,27 @@ impl From<Infallible> for Error {
     }
 }
 
+///
+#[derive(Debug)]
+pub enum UrlKind {
+    ///
+    Url,
+    ///
+    Scp,
+    ///
+    Local,
+}
+
+impl UrlKind {
+    fn get_error_str(&self) -> &'static str {
+        match self {
+            UrlKind::Url => "URL",
+            UrlKind::Scp => "SCP-like target",
+            UrlKind::Local => "local path",
+        }
+    }
+}
+
 enum InputScheme {
     Url { protocol_end: usize },
     Scp { colon: usize },
@@ -61,7 +90,16 @@ pub fn parse(input: &BStr) -> Result<crate::Url, Error> {
 }
 
 fn parse_url(input: &BStr) -> Result<crate::Url, Error> {
-    let url = url::Url::parse(std::str::from_utf8(input)?)?;
+    let input = std::str::from_utf8(input).map_err(|source| Error::Utf8 {
+        url: input.to_owned(),
+        kind: UrlKind::Url,
+        source,
+    })?;
+    let url = url::Url::parse(input).map_err(|source| Error::Url {
+        url: input.to_owned(),
+        kind: UrlKind::Url,
+        source,
+    })?;
 
     Ok(crate::Url {
         serialize_alternative_form: false,
@@ -79,7 +117,11 @@ fn parse_url(input: &BStr) -> Result<crate::Url, Error> {
 }
 
 fn parse_scp(input: &BStr, colon: usize) -> Result<crate::Url, Error> {
-    let input = std::str::from_utf8(input)?;
+    let input = std::str::from_utf8(input).map_err(|source| Error::Utf8 {
+        url: input.to_owned(),
+        kind: UrlKind::Scp,
+        source,
+    })?;
 
     // TODO: this incorrectly splits at IPv6 addresses, check for `[]` before splitting
     let (host, path) = input.split_at(colon);
@@ -89,7 +131,11 @@ fn parse_scp(input: &BStr, colon: usize) -> Result<crate::Url, Error> {
     // should never differ in any other way (ssh URLs should not contain a query or fragment part).
     // To avoid the various off-by-one errors caused by the `/` characters, we keep using the path
     // determined above and can therefore skip parsing it here as well.
-    let url = url::Url::parse(&format!("ssh://{host}"))?;
+    let url = url::Url::parse(&format!("ssh://{host}")).map_err(|source| Error::Url {
+        url: input.to_owned(),
+        kind: UrlKind::Scp,
+        source,
+    })?;
 
     Ok(crate::Url {
         serialize_alternative_form: true,

gix-url/src/parse/mod.rs

@@ -1,43 +1,42 @@
-use gix_url::parse::Error;
+use assert_matches::assert_matches;
 
-use crate::parse::assert_failure;
+use gix_url::parse::Error::*;
+
+use crate::parse::parse;
 
 #[test]
 fn relative_path_due_to_double_colon() {
-    assert_failure(
-        "invalid:://host.xz/path/to/repo.git/",
-        "Relative URLs are not permitted: \"invalid:://host.xz/path/to/repo.git/\"",
-    )
+    assert_matches!(parse("invalid:://host.xz/path/to/repo.git/"), Err(RelativeUrl { .. }))
 }
 
 #[test]
 fn ssh_missing_path() {
-    assert_failure("ssh://host.xz", Error::MissingRepositoryPath)
+    assert_matches!(parse("ssh://host.xz"), Err(MissingRepositoryPath { .. }))
 }
 
 #[test]
 fn git_missing_path() {
-    assert_failure("git://host.xz", Error::MissingRepositoryPath)
+    assert_matches!(parse("git://host.xz"), Err(MissingRepositoryPath { .. }))
 }
 
 #[test]
 fn file_missing_path() {
-    assert_failure("file://", Error::MissingRepositoryPath);
+    assert_matches!(parse("file://"), Err(MissingRepositoryPath { .. }));
 }
 
 #[test]
 fn empty() {
-    assert_failure("", Error::MissingRepositoryPath);
-    assert_failure("file://..", Error::MissingRepositoryPath);
-    assert_failure("file://.", Error::MissingRepositoryPath);
+    assert_matches!(parse(""), Err(MissingRepositoryPath { .. }));
+    assert_matches!(parse("file://.."), Err(MissingRepositoryPath { .. }));
+    assert_matches!(parse("file://."), Err(MissingRepositoryPath { .. }));
     #[cfg(not(windows))]
     {
-        assert_failure("file://.\\", Error::MissingRepositoryPath);
+        assert_matches!(parse("file://.\\"), Err(MissingRepositoryPath { .. }));
     }
-    assert_failure("file://a", Error::MissingRepositoryPath);
+    assert_matches!(parse("file://a"), Err(MissingRepositoryPath { .. }));
 }
 
 #[test]
 fn missing_port_despite_indication() {
-    assert_failure("ssh://host.xz:", Error::MissingRepositoryPath)
+    assert_matches!(parse("ssh://host.xz:"), Err(MissingRepositoryPath { .. }))
 }

gix-url/tests/parse/invalid.rs

@@ -1,4 +1,4 @@
-use bstr::ByteSlice;
+use bstr::{BStr, ByteSlice};
 use gix_url::Scheme;
 
 fn assert_url(url: &str, expected: gix_url::Url) -> Result<gix_url::Url, crate::Error> {
@@ -22,11 +22,8 @@ fn assert_url_roundtrip(url: &str, expected: gix_url::Url) -> crate::Result {
     Ok(())
 }
 
-fn assert_failure(url: &str, expected_err: impl ToString) {
-    assert_eq!(
-        gix_url::parse(url.into()).unwrap_err().to_string(),
-        expected_err.to_string()
-    );
+fn parse<'a>(input: impl Into<&'a BStr>) -> Result<gix_url::Url, gix_url::parse::Error> {
+    gix_url::parse(input.into())
 }
 
 fn url<'a, 'b>(