Assure main-worktree is also resolved in the main worktree (#301)

Author: Byron

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

@@ -163,17 +163,15 @@ impl file::Store {
 
 impl file::Store {
     fn base_dir_and_rela_path_for_name<'a>(&self, name: FullNameRef<'a>) -> (&Path, Cow<'a, Path>) {
-        let (base, relative_path) = self
-            .common_dir
-            .as_deref()
-            .and_then(|commondir| {
-                name.category_and_short_name().and_then(|(c, sn)| {
-                    use crate::Category::*;
-                    Some(match c {
-                        Tag | LocalBranch | RemoteBranch | Note => (commondir, name.as_bstr()),
-                        MainRef | MainPseudoRef | LinkedRef | LinkedPseudoRef => (commondir, sn),
-                        PseudoRef | Bisect | Rewritten | WorktreePrivate => return None,
-                    })
+        let commondir = self.common_dir_resolved();
+        let (base, relative_path) = name
+            .category_and_short_name()
+            .and_then(|(c, sn)| {
+                use crate::Category::*;
+                Some(match c {
+                    Tag | LocalBranch | RemoteBranch | Note => (commondir, name.as_bstr()),
+                    MainRef | MainPseudoRef | LinkedRef | LinkedPseudoRef => (commondir, sn),
+                    PseudoRef | Bisect | Rewritten | WorktreePrivate => return None,
                 })
             })
             .unwrap_or((self.git_dir.as_path(), name.as_bstr()));

git-ref/src/store/file/mod.rs

@@ -53,8 +53,11 @@ mod access {
             self.common_dir.as_deref()
         }
 
-        /// The directory in which the packed references file would be placed.
-        pub fn packed_refs_dir(&self) -> &Path {
+        /// Similar to [`common_dir()`][file::Store::common_dir()], but it will produce either the common-dir, or the git-dir if the former
+        /// isn't present.
+        ///
+        /// This is also the directory in which the packed references file would be placed.
+        pub fn common_dir_resolved(&self) -> &Path {
             self.common_dir.as_deref().unwrap_or(&self.git_dir)
         }
     }

git-ref/src/store/file/packed.rs

@@ -42,7 +42,7 @@ impl file::Store {
 
     /// Return the path at which packed-refs would usually be stored
     pub fn packed_refs_path(&self) -> PathBuf {
-        self.packed_refs_dir().join("packed-refs")
+        self.common_dir_resolved().join("packed-refs")
     }
 }
 

git-ref/tests/file/worktree.rs

@@ -1,40 +1,78 @@
+use git_odb::Find;
+use git_ref::file::ReferenceExt;
 use std::path::PathBuf;
 
-fn dir(packed: bool) -> PathBuf {
+fn dir(packed: bool) -> crate::Result<PathBuf> {
     let name = "make_worktree_repo.sh";
     if packed {
         git_testtools::scripted_fixture_repo_read_only_with_args(name, Some("packed"))
     } else {
         git_testtools::scripted_fixture_repo_read_only(name)
     }
-    .unwrap()
 }
 
-fn main_store(packed: bool) -> git_ref::file::Store {
-    let dir = dir(packed);
-    git_ref::file::Store::at(dir.join("repo").join(".git"), Default::default(), Default::default())
+fn main_store(packed: bool) -> crate::Result<(git_ref::file::Store, git_odb::Handle)> {
+    let dir = dir(packed)?;
+    let git_dir = dir.join("repo").join(".git");
+    Ok((
+        git_ref::file::Store::at(&git_dir, Default::default(), Default::default()),
+        git_odb::at(git_dir.join("objects"))?,
+    ))
 }
 
-fn worktree_store(packed: bool) -> git_ref::file::Store {
-    let dir = dir(packed);
-    let (git_dir, _work_tree) = git_discover::upwards(dir.join("w1"))
-        .unwrap()
+fn worktree_store(packed: bool) -> crate::Result<(git_ref::file::Store, git_odb::Handle)> {
+    let dir = dir(packed)?;
+    let (git_dir, _work_tree) = git_discover::upwards(dir.join("w1"))?
         .0
         .into_repository_and_work_tree_directories();
     let common_dir = git_dir.join("../..");
-    git_ref::file::Store::for_linked_worktree(git_dir, common_dir, Default::default(), Default::default())
+    Ok((
+        git_ref::file::Store::for_linked_worktree(git_dir, &common_dir, Default::default(), Default::default()),
+        git_odb::at(common_dir.join("objects"))?,
+    ))
+}
+
+fn into_peel(
+    store: &git_ref::file::Store,
+    odb: git_odb::Handle,
+) -> impl Fn(git_ref::Reference) -> git_hash::ObjectId + '_ {
+    move |mut r: git_ref::Reference| {
+        r.peel_to_id_in_place(
+            store,
+            |id, buf| -> Result<Option<(git_object::Kind, &[u8])>, git_odb::store::find::Error> {
+                let data = odb.try_find(id, buf)?;
+                Ok(data.map(|d| (d.kind, d.data)))
+            },
+        )
+        .unwrap()
+    }
 }
 
 #[test]
-fn with_common_dir() {
+fn linked() {
     for packed in [false, true] {
-        let _store = worktree_store(packed);
+        let (store, odb) = worktree_store(packed).unwrap();
+        let peel = into_peel(&store, odb);
+        assert_ne!(
+            peel(store.find("HEAD").unwrap()),
+            peel(store.find("main-worktree/HEAD").unwrap())
+        );
     }
 }
 
 #[test]
-fn with_git_dir() {
+fn main() {
     for packed in [false, true] {
-        let _store = main_store(packed);
+        let (store, odb) = main_store(packed).unwrap();
+        let peel = into_peel(&store, odb);
+
+        assert_eq!(
+            peel(store.find("HEAD").unwrap()),
+            peel(store.find("main-worktree/HEAD").unwrap())
+        );
+        assert_eq!(
+            peel(store.find("main").unwrap()),
+            peel(store.find("main-worktree/refs/heads/main").unwrap())
+        );
     }
 }