fix!: bare() can now make sure it detects bare repos, at an expense. (#980)

In order to be very sure it's the correct guess, we have to open and quick-parse
a the bare line.

Author: Byron

gix-discover/src/is.rs

@@ -10,13 +10,99 @@ pub fn bare(git_dir_candidate: impl AsRef<Path>) -> bool {
     !(git_dir.join("index").exists() || (git_dir.file_name() == Some(OsStr::new(DOT_GIT_DIR))))
 }
 
+/// Parse `<git_dir_candidate>/config` quickly to evaluate the value of the `bare` line, or return `true` if the file doesn't exist
+/// similar to what`guess_repository_type` seems to be doing.
+/// Return `None` if the `bare` line can't be found or the value of `bare` can't be determined.
+fn bare_by_config(git_dir_candidate: impl AsRef<Path>) -> std::io::Result<Option<bool>> {
+    match std::fs::read(git_dir_candidate.as_ref().join("config")) {
+        Ok(buf) => Ok(config::parse_bare(&buf)),
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(Some(true)),
+        Err(err) => Err(err),
+    }
+}
+
+// Copied and adapted from `gix-config-value::boolean`.
+mod config {
+    use bstr::{BStr, ByteSlice};
+
+    pub(crate) fn parse_bare(buf: &[u8]) -> Option<bool> {
+        buf.lines().find_map(|line| {
+            let line = line.trim().strip_prefix(b"bare")?;
+            match line.first() {
+                None => Some(true),
+                Some(c) if *c == b'=' => parse_bool(line.get(1..)?.trim_start().as_bstr()),
+                Some(c) if c.is_ascii_whitespace() => match line.split_once_str(b"=") {
+                    Some((_left, right)) => parse_bool(right.trim_start().as_bstr()),
+                    None => Some(true),
+                },
+                Some(_other_char_) => None,
+            }
+        })
+    }
+
+    fn parse_bool(value: &BStr) -> Option<bool> {
+        Some(if parse_true(value) {
+            true
+        } else if parse_false(value) {
+            false
+        } else {
+            use std::str::FromStr;
+            if let Some(integer) = value.to_str().ok().and_then(|s| i64::from_str(s).ok()) {
+                integer != 0
+            } else {
+                return None;
+            }
+        })
+    }
+
+    fn parse_true(value: &BStr) -> bool {
+        value.eq_ignore_ascii_case(b"yes") || value.eq_ignore_ascii_case(b"on") || value.eq_ignore_ascii_case(b"true")
+    }
+
+    fn parse_false(value: &BStr) -> bool {
+        value.eq_ignore_ascii_case(b"no")
+            || value.eq_ignore_ascii_case(b"off")
+            || value.eq_ignore_ascii_case(b"false")
+            || value.is_empty()
+    }
+
+    #[cfg(test)]
+    mod tests {
+        use super::*;
+
+        #[test]
+        fn various() {
+            for (input, expected) in [
+                ("bare=true", Some(true)),
+                ("bare=1", Some(true)),
+                ("bare =1", Some(true)),
+                ("bare= yes", Some(true)),
+                ("bare=false", Some(false)),
+                ("bare=0", Some(false)),
+                ("bare=blah", None),
+                ("bare=", Some(false)),
+                ("bare=  \n", Some(false)),
+                ("bare = true \n", Some(true)),
+                ("\t bare = false \n", Some(false)),
+                ("\n\tbare=true", Some(true)),
+                ("\n\tbare=true\n\tfoo", Some(true)),
+                ("\n\tbare ", Some(true)),
+                ("\n\tbare", Some(true)),
+                ("not found\nreally", None),
+            ] {
+                assert_eq!(parse_bare(input.as_bytes()), expected, "{input:?}");
+            }
+        }
+    }
+}
+
 /// Returns true if `git_dir` is located within a `.git/modules` directory, indicating it's a submodule clone.
 pub fn submodule_git_dir(git_dir: impl AsRef<Path>) -> bool {
     let git_dir = git_dir.as_ref();
 
     let mut last_comp = None;
     git_dir.file_name() != Some(OsStr::new(DOT_GIT_DIR))
-        && git_dir.components().rev().any(|c| {
+        && git_dir.components().rev().skip(1).any(|c| {
             if c.as_os_str() == OsStr::new(DOT_GIT_DIR) {
                 true
             } else {
@@ -154,8 +240,17 @@ pub(crate) fn git_with_metadata(
                 crate::repository::Kind::Bare
             } else if submodule_git_dir(conformed_git_dir.as_ref()) {
                 crate::repository::Kind::SubmoduleGitDir
-            } else {
+            } else if conformed_git_dir.file_name() == Some(OsStr::new(DOT_GIT_DIR))
+                || !bare_by_config(conformed_git_dir.as_ref())
+                    .map_err(|err| crate::is_git::Error::Metadata {
+                        source: err,
+                        path: conformed_git_dir.join("config"),
+                    })?
+                    .ok_or(crate::is_git::Error::Inconclusive)?
+            {
                 crate::repository::Kind::WorkTree { linked_git_dir: None }
+            } else {
+                crate::repository::Kind::Bare
             }
         }
     })

gix-discover/src/lib.rs

@@ -37,6 +37,8 @@ pub mod is_git {
         GitFile(#[from] crate::path::from_gitdir_file::Error),
         #[error("Could not retrieve metadata of \"{path}\"")]
         Metadata { source: std::io::Error, path: PathBuf },
+        #[error("The repository's config file doesn't exist or didn't have a 'bare' configuration")]
+        Inconclusive,
     }
 }
 

gix-discover/tests/fixtures/make_basic_repo.sh

@@ -52,6 +52,17 @@ git init --bare bare-with-index.git
   touch index
 )
 
+git init --bare bare-with-index-bare
+(cd bare-with-index-bare
+  touch index
+)
+
+git init --bare bare-with-index-no-config-bare
+(cd bare-with-index-no-config-bare
+  touch index
+  rm config
+)
+
 git init non-bare-without-index
 (cd non-bare-without-index
   touch this

gix-discover/tests/is_git/mod.rs

@@ -58,6 +58,16 @@ fn bare_repo_with_index_file_looks_still_looks_like_bare() -> crate::Result {
     Ok(())
 }
 
+#[test]
+fn bare_repo_with_index_file_looks_still_looks_like_bare_if_it_was_renamed() -> crate::Result {
+    for repo_name in ["bare-with-index-bare", "bare-with-index-no-config-bare"] {
+        let repo = repo_path()?.join(repo_name);
+        let kind = gix_discover::is_git(repo)?;
+        assert_eq!(kind, gix_discover::repository::Kind::Bare);
+    }
+    Ok(())
+}
+
 #[test]
 fn no_bare_repo_without_index_file_looks_like_worktree() -> crate::Result {
     let repo = repo_path()?.join("non-bare-without-index").join(".git");