fix: make sure ordinary capitalized partial names can be found by partial name.

For instance, previously, a ref named `A` could not be found even though `refs/heads/A` existed.

Author: Byron

gix-ref/src/name.rs

@@ -62,16 +62,21 @@ impl PartialNameRef {
 }
 
 impl PartialNameRef {
-    pub(crate) fn looks_like_full_name(&self) -> bool {
+    pub(crate) fn looks_like_full_name(&self, consider_pseudo_ref: bool) -> bool {
         let name = self.0.as_bstr();
         name.starts_with_str("refs/")
             || name.starts_with(Category::MainPseudoRef.prefix())
             || name.starts_with(Category::LinkedPseudoRef { name: "".into() }.prefix())
-            || is_pseudo_ref(name)
+            || (consider_pseudo_ref && is_pseudo_ref(name))
     }
-    pub(crate) fn construct_full_name_ref<'buf>(&self, inbetween: &str, buf: &'buf mut BString) -> &'buf FullNameRef {
+    pub(crate) fn construct_full_name_ref<'buf>(
+        &self,
+        inbetween: &str,
+        buf: &'buf mut BString,
+        consider_pseudo_ref: bool,
+    ) -> &'buf FullNameRef {
         buf.clear();
-        if !self.looks_like_full_name() {
+        if !self.looks_like_full_name(consider_pseudo_ref) {
             buf.push_str("refs/");
         }
         if !inbetween.is_empty() {

gix-ref/src/store/file/find.rs

@@ -6,6 +6,7 @@ use std::{
 
 pub use error::Error;
 
+use crate::name::is_pseudo_ref;
 use crate::{
     file,
     store_impl::{file::loose, packed},
@@ -103,13 +104,28 @@ impl file::Store {
         let precomposed_partial_name = precomposed_partial_name_storage
             .as_ref()
             .map(std::convert::AsRef::as_ref);
-        for inbetween in &["", "tags", "heads", "remotes"] {
-            match self.find_inner(inbetween, partial_name, precomposed_partial_name, packed, &mut buf) {
-                Ok(Some(r)) => return Ok(Some(decompose_if(r, precomposed_partial_name.is_some()))),
-                Ok(None) => {
-                    continue;
+        for consider_pseudo_ref in [true, false] {
+            if !consider_pseudo_ref && !is_pseudo_ref(partial_name.as_bstr()) {
+                break;
+            }
+            'try_directories: for inbetween in &["", "tags", "heads", "remotes"] {
+                match self.find_inner(
+                    inbetween,
+                    partial_name,
+                    precomposed_partial_name,
+                    packed,
+                    &mut buf,
+                    consider_pseudo_ref,
+                ) {
+                    Ok(Some(r)) => return Ok(Some(decompose_if(r, precomposed_partial_name.is_some()))),
+                    Ok(None) => {
+                        if consider_pseudo_ref && is_pseudo_ref(partial_name.as_bstr()) {
+                            break 'try_directories;
+                        }
+                        continue;
+                    }
+                    Err(err) => return Err(err),
                 }
-                Err(err) => return Err(err),
             }
         }
         if partial_name.as_bstr() != "HEAD" {
@@ -129,6 +145,7 @@ impl file::Store {
                     .map(std::convert::AsRef::as_ref),
                 None,
                 &mut buf,
+                true, /* consider-pseudo-ref */
             )
             .map(|res| res.map(|r| decompose_if(r, precomposed_partial_name_storage.is_some())))
         } else {
@@ -143,10 +160,11 @@ impl file::Store {
         precomposed_partial_name: Option<&PartialNameRef>,
         packed: Option<&packed::Buffer>,
         path_buf: &mut BString,
+        consider_pseudo_ref: bool,
     ) -> Result<Option<Reference>, Error> {
         let full_name = precomposed_partial_name
             .unwrap_or(partial_name)
-            .construct_full_name_ref(inbetween, path_buf);
+            .construct_full_name_ref(inbetween, path_buf, consider_pseudo_ref);
         let content_buf = self.ref_contents(full_name).map_err(|err| Error::ReadFileContents {
             source: err,
             path: self.reference_path(full_name),

gix-ref/src/store/packed/find.rs

@@ -17,15 +17,15 @@ impl packed::Buffer {
         let name = name.try_into()?;
         let mut buf = BString::default();
         for inbetween in &["", "tags", "heads", "remotes"] {
-            let (name, was_absolute) = if name.looks_like_full_name() {
+            let (name, was_absolute) = if name.looks_like_full_name(false) {
                 let name = FullNameRef::new_unchecked(name.as_bstr());
                 let name = match transform_full_name_for_lookup(name) {
                     None => return Ok(None),
                     Some(name) => name,
                 };
                 (name, true)
             } else {
-                let full_name = name.construct_full_name_ref(inbetween, &mut buf);
+                let full_name = name.construct_full_name_ref(inbetween, &mut buf, false);
                 (full_name, false)
             };
             match self.try_find_full_name(name)? {

gix-ref/tests/Cargo.toml

@@ -17,7 +17,7 @@ serde = ["gix-ref/serde"]
 
 [[test]]
 name = "refs"
-path = "refs.rs"
+path = "refs/main.rs"
 
 [dev-dependencies]
 gix-ref = { path = ".." }

gix-ref/tests/fixtures/generated-archives/make_packed_ref_repository.tar

@@ -7,6 +7,7 @@ git checkout -q -b main
 git commit -q --allow-empty -m c1
 git branch dt1
 git branch d1
+git branch A
 
 mkdir -p .git/refs/remotes/origin
 

gix-ref/tests/fixtures/generated-archives/make_packed_ref_repository_for_overlay.tar

@@ -6,6 +6,7 @@ git init -q
 git checkout -q -b main
 git commit -q --allow-empty -m c1
 git branch newer-as-loose
+git branch A
 git tag -m "tag object" tag-object
 
 mkdir -p .git/refs/remotes/origin

gix-ref/tests/fixtures/generated-archives/make_ref_repository.tar

@@ -7,6 +7,7 @@ git checkout -q -b main
 git commit -q --allow-empty -m c1
 git branch dt1
 git branch d1
+git branch A
 
 mkdir -p .git/refs/remotes/origin
 

gix-ref/tests/fixtures/make_packed_ref_repository.sh

@@ -2,12 +2,22 @@ mod existing {
     use crate::{file::store_at, hex_to_id};
 
     #[test]
-    fn with_packed_refs() -> crate::Result {
-        let store = store_at("make_packed_ref_repository_for_overlay.sh")?;
-        let c1 = hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03");
-        let r = store.find("main")?;
-        assert_eq!(r.target.into_id(), c1);
-        assert_eq!(r.name.as_bstr(), "refs/heads/main");
+    fn various_repositories() -> crate::Result {
+        for fixture in [
+            "make_ref_repository.sh",
+            "make_packed_ref_repository.sh",
+            "make_packed_ref_repository_for_overlay.sh",
+        ] {
+            let store = store_at(fixture)?;
+            let c1 = hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03");
+            let r = store.find("main")?;
+            assert_eq!(r.target.into_id(), c1);
+            assert_eq!(r.name.as_bstr(), "refs/heads/main");
+            let r = store
+                .find("A")
+                .unwrap_or_else(|_| panic!("{fixture}: should find capitalized refs"));
+            assert_eq!(r.target.into_id(), c1);
+        }
         Ok(())
     }
 
@@ -98,6 +108,17 @@ mod loose {
 
         use crate::file::store;
 
+        #[test]
+        fn capitalized_branch() -> crate::Result {
+            let store = store()?;
+            assert_eq!(
+                store.find("A")?.name.as_bstr(),
+                "refs/heads/A",
+                "capitalized loose refs can be found fine"
+            );
+            Ok(())
+        }
+
         #[test]
         fn success_and_failure() -> crate::Result {
             let store = store()?;

gix-ref/tests/fixtures/make_packed_ref_repository_for_overlay.sh

@@ -253,7 +253,7 @@ fn no_packed_available_thus_no_iteration_possible() -> crate::Result {
 #[test]
 fn packed_file_iter() -> crate::Result {
     let store = store_with_packed_refs()?;
-    assert_eq!(store.open_packed_buffer()?.expect("pack available").iter()?.count(), 8);
+    assert_eq!(store.open_packed_buffer()?.expect("pack available").iter()?.count(), 9);
     Ok(())
 }
 
@@ -262,7 +262,7 @@ fn loose_iter_with_broken_refs() -> crate::Result {
     let store = store()?;
 
     let mut actual: Vec<_> = store.loose_iter()?.collect();
-    assert_eq!(actual.len(), 15);
+    assert_eq!(actual.len(), 16);
     actual.sort_by_key(Result::is_err);
     let first_error = actual
         .iter()
@@ -271,7 +271,7 @@ fn loose_iter_with_broken_refs() -> crate::Result {
         .expect("there is an error");
 
     assert_eq!(
-        first_error, 14,
+        first_error, 15,
         "there is exactly one invalid item, and it didn't abort the iterator most importantly"
     );
     #[cfg(not(windows))]
@@ -291,6 +291,7 @@ fn loose_iter_with_broken_refs() -> crate::Result {
         ref_paths,
         vec![
             "d1",
+            "heads/A",
             "heads/d1",
             "heads/dt1",
             "heads/main",
@@ -343,6 +344,7 @@ fn loose_iter_with_prefix() -> crate::Result {
     assert_eq!(
         actual,
         vec![
+            "refs/heads/A",
             "refs/heads/d1",
             "refs/heads/dt1",
             "refs/heads/main",
@@ -394,7 +396,8 @@ fn overlay_iter() -> crate::Result {
     assert_eq!(
         ref_names,
         vec![
-            (b"refs/heads/main".as_bstr().to_owned(), Object(c1)),
+            (b"refs/heads/A".as_bstr().to_owned(), Object(c1)),
+            (b"refs/heads/main".into(), Object(c1)),
             ("refs/heads/newer-as-loose".into(), Object(c2)),
             (
                 "refs/remotes/origin/HEAD".into(),
@@ -440,7 +443,8 @@ fn overlay_prefixed_iter() -> crate::Result {
     assert_eq!(
         ref_names,
         vec![
-            (b"refs/heads/main".as_bstr().to_owned(), Object(c1)),
+            (b"refs/heads/A".as_bstr().to_owned(), Object(c1)),
+            (b"refs/heads/main".into(), Object(c1)),
             ("refs/heads/newer-as-loose".into(), Object(c2)),
         ]
     );

gix-ref/tests/fixtures/make_ref_repository.sh

@@ -791,7 +791,7 @@ fn packed_refs_creation_with_packed_refs_mode_prune_removes_original_loose_refs(
 
     assert_eq!(
         edits.len(),
-        8,
+        9,
         "there are a certain amount of loose refs that are packed"
     );
 

gix-ref/tests/file/log.rs renamed to gix-ref/tests/refs/file/log.rs

@@ -14,6 +14,19 @@ fn a_lock_file_would_not_be_a_valid_partial_name() {
     assert_eq!(err.to_string(), "A reference must be a valid tag name as well");
 }
 
+#[test]
+fn capitalized_branch() -> crate::Result {
+    let store = store_with_packed_refs()?;
+    let packed_refs = store.open_packed_buffer()?.expect("packed-refs exist");
+
+    assert_eq!(
+        packed_refs.find("A")?.name.as_bstr(),
+        "refs/heads/A",
+        "fully capitalized refs aren't just considered pseudorefs"
+    );
+    Ok(())
+}
+
 #[test]
 fn all_iterable_refs_can_be_found() -> crate::Result {
     let store = store_with_packed_refs()?;

gix-ref/tests/file/mod.rs renamed to gix-ref/tests/refs/file/mod.rs

@@ -18,7 +18,7 @@ fn packed_refs_with_header() -> crate::Result {
     let dir = gix_testtools::scripted_fixture_read_only_standalone("make_packed_ref_repository.sh")?;
     let buf = std::fs::read(dir.join(".git").join("packed-refs"))?;
     let iter = packed::Iter::new(&buf)?;
-    assert_eq!(iter.count(), 8, "it finds the right amount of items");
+    assert_eq!(iter.count(), 9, "it finds the right amount of items");
     Ok(())
 }
 
@@ -31,7 +31,8 @@ fn iter_prefix() -> crate::Result {
             .map(|r| r.map(|r| r.name.as_bstr()))
             .collect::<Result<Vec<_>, _>>()?,
         vec![
-            "refs/heads/d1".as_bytes().as_bstr(),
+            "refs/heads/A".as_bytes().as_bstr(),
+            "refs/heads/d1".into(),
             "refs/heads/dt1".into(),
             "refs/heads/main".into()
         ]