git forge auto-detection: Streamline user experience

- Added a log message for the detected forge type, and debug log
messages to make it easier to figure out what is happening when
auto-detection fails
- When explicitly specifying a forge via `--forge`, auto-detection
failures are a hard error instead of falling back to generic git forges

Author: piegamesde

CHANGELOG.md

@@ -3,6 +3,7 @@
 ## Unreleased
 
 - `npins show` now accepts a list of pin entries to show instead of always showing the complete list (https://github.com/andir/npins/pull/190)
+- Tweaked forge auto-detection for `git add` (https://github.com/andir/npins/pull/202)
 
 ## 0.4.0
 

libnpins/src/git.rs

@@ -134,40 +134,67 @@ impl Repository {
     pub async fn git_auto(url: Url) -> Self {
         let url2 = url.clone();
         match (url.scheme(), url.domain()) {
-            ("http" | "https", Some("github.com")) => Self::github_from_url(url),
-            ("http" | "https", Some("gitlab.com")) => Self::gitlab_from_url(url),
-            ("http" | "https", Some("codeberg.org")) => Self::forgejo_from_url(url),
+            ("http" | "https", Some("github.com")) => {
+                log::debug!("Trying to parse URL as GitHub repository based on the domain name (github.com)");
+                Self::github_from_url(url)
+                    .inspect(|_| log::info!("Auto-detected GitHub repository (github.com)"))
+            },
+            ("http" | "https", Some("gitlab.com")) => {
+                log::debug!("Trying to parse URL as GitLab repository based on the domain name (gitlab.com)");
+                Self::gitlab_from_url(url)
+                    .inspect(|_| log::info!("Auto-detected GitLab repository (gitlab.com)"))
+            },
+            ("http" | "https", Some("codeberg.org")) => {
+                log::debug!("Trying to parse URL as Forgejo repository based on the domain name (codeberg.org)");
+                Self::forgejo_from_url(url)
+                    .inspect(|_| log::info!("Auto-detected Forgejo repository (codeberg.org)"))
+            },
             ("http" | "https", _) => Self::probe_forge(url).await,
             _ => None,
         }
-        .unwrap_or(Self::git(url2))
+        .unwrap_or_else(|| {
+            log::info!("No forge was auto-detected, treating as plain git repository");
+            Self::git(url2)
+        })
     }
 
     ///
     /// Takes in a URL of unknown forge and tries to determine which forge the hoster is
     /// And then parse the url into the according Repository Variant
     async fn probe_forge(url: Url) -> Option<Self> {
-        async fn probe(mut test_url: Url, path: &str) -> Result<()> {
-            test_url.set_path(path);
-            let _: serde_json::Value = get_and_deserialize(test_url).await?;
-            Ok(())
-        }
+        log::debug!("Probing {url} for Forgejo and GitLab API endpoints");
 
         /* We probe some known endpoints unique to the respective GitLab and Forgejo APIs to determine if a corresponding server is running */
         let distinct_api_endpoints = [
             (
+                "GitLab",
                 "/api/v4/projects",
                 Self::gitlab_from_url as fn(Url) -> Option<Self>,
             ),
             (
+                "Forgejo",
                 "/api/v1/settings/api",
                 Self::forgejo_from_url as fn(Url) -> Option<Self>,
             ),
         ];
 
-        for (path, func) in distinct_api_endpoints {
-            match probe(url.clone(), path).await {
-                Ok(_) => return func(url),
+        for (forge_type, path, func) in distinct_api_endpoints {
+            let probe = |mut test_url: Url| async {
+                test_url.set_path(path);
+                log::debug!("Probing {test_url} to check for {forge_type}");
+                let _: serde_json::Value = get_and_deserialize(test_url).await?;
+                Ok::<(), anyhow::Error>(())
+            };
+
+            match probe(url.clone()).await {
+                Ok(_) => {
+                    return func(url.clone()).inspect(|_| {
+                        log::info!(
+                            "Auto-detected {forge_type} repository ({})",
+                            url.domain().unwrap()
+                        )
+                    })
+                },
                 _ => {},
             }
         }

src/main.rs

@@ -273,15 +273,19 @@ impl GitAddOpts {
         let name = name.strip_suffix(".git").unwrap_or(&name);
 
         use git::Repository;
-        let url2 = url.clone();
         let repository = match self.forge {
-            GitForgeOpts::Auto => Some(Repository::git_auto(url).await),
-            GitForgeOpts::None => Some(Repository::git(url)),
-            GitForgeOpts::Github => Repository::github_from_url(url),
-            GitForgeOpts::Gitlab => Repository::gitlab_from_url(url),
-            GitForgeOpts::Forgejo => Repository::forgejo_from_url(url),
-        }
-        .unwrap_or(Repository::git(url2));
+            GitForgeOpts::Auto => Repository::git_auto(url).await,
+            GitForgeOpts::None => Repository::git(url),
+            GitForgeOpts::Github => Repository::github_from_url(url).ok_or_else(|| {
+                anyhow::format_err!("Could not parse the URL as GitHub repository")
+            })?,
+            GitForgeOpts::Gitlab => Repository::gitlab_from_url(url).ok_or_else(|| {
+                anyhow::format_err!("Could not parse the URL as GitLab repository")
+            })?,
+            GitForgeOpts::Forgejo => Repository::forgejo_from_url(url).ok_or_else(|| {
+                anyhow::format_err!("Could not parse the URL as Forgejo repository")
+            })?,
+        };
 
         Ok((Some(name.to_owned()), self.more.add(repository)?))
     }
@@ -786,7 +790,7 @@ impl Opts {
         let length = if opts.names.is_empty() {
             pins.pins
                 .iter()
-                .filter(|(_, pin)| (opts.update_frozen || !pin.is_frozen()))
+                .filter(|(_, pin)| opts.update_frozen || !pin.is_frozen())
                 .count()
         } else {
             selected_pins.len()