feat: revision::Spec::path_and_mode()

Provide additional information about revspecs for use with
worktree filters.

Author: Byron

Diff for: gix/src/ext/rev_spec.rs

@@ -12,6 +12,7 @@ impl RevSpecExt for gix_revision::Spec {
     fn attach(self, repo: &crate::Repository) -> crate::revision::Spec<'_> {
         crate::revision::Spec {
             inner: self,
+            path: None,
             first_ref: None,
             second_ref: None,
             repo,

Diff for: gix/src/revision/mod.rs

@@ -7,6 +7,7 @@ pub use gix_revision as plumbing;
 
 ///
 pub mod walk;
+use crate::bstr::BString;
 pub use walk::iter::Walk;
 
 ///
@@ -22,6 +23,8 @@ pub mod spec;
 #[cfg(feature = "revision")]
 pub struct Spec<'repo> {
     pub(crate) inner: gix_revision::Spec,
+    /// The path we encountered in the revspec, like `@:<path>` or `@..@~1:<path>`.
+    pub(crate) path: Option<(BString, gix_object::tree::EntryMode)>,
     /// The first name of a reference as seen while parsing a `RevSpec`, for completeness.
     pub(crate) first_ref: Option<gix_ref::Reference>,
     /// The second name of a reference as seen while parsing a `RevSpec`, for completeness.

Diff for: gix/src/revision/spec/mod.rs

@@ -1,3 +1,4 @@
+use crate::bstr::BStr;
 use crate::{ext::ReferenceExt, revision::Spec, Id, Reference};
 
 ///
@@ -37,6 +38,7 @@ impl<'repo> Spec<'repo> {
     pub fn from_id(id: Id<'repo>) -> Self {
         Spec {
             inner: gix_revision::Spec::Include(id.inner),
+            path: None,
             repo: id.repo,
             first_ref: None,
             second_ref: None,
@@ -62,6 +64,13 @@ impl<'repo> Spec<'repo> {
         )
     }
 
+    /// Return the path encountered in specs like `@:<path>` or `:<path>`, along with the kind of object it represents.
+    ///
+    /// Note that there can only be one as paths always terminates further revspec parsing.
+    pub fn path_and_mode(&self) -> Option<(&BStr, gix_object::tree::EntryMode)> {
+        self.path.as_ref().map(|(p, mode)| (p.as_ref(), *mode))
+    }
+
     /// Return the name of the first reference we encountered while resolving the rev-spec, or `None` if a short hash
     /// was used. For example, `@` might yield `Some(HEAD)`, but `abcd` yields `None`.
     pub fn first_reference(&self) -> Option<&gix_ref::Reference> {

Diff for: gix/src/revision/spec/parse/delegate/mod.rs

@@ -17,6 +17,7 @@ impl<'repo> Delegate<'repo> {
         Delegate {
             refs: Default::default(),
             objs: Default::default(),
+            paths: Default::default(),
             ambiguous_objects: Default::default(),
             idx: 0,
             kind: None,
@@ -100,6 +101,7 @@ impl<'repo> Delegate<'repo> {
 
         let range = zero_or_one_objects_or_ambiguity_err(self.objs, self.prefix, self.err, self.repo)?;
         Ok(crate::revision::Spec {
+            path: self.paths[0].take().or(self.paths[1].take()),
             first_ref: self.refs[0].take(),
             second_ref: self.refs[1].take(),
             inner: kind_to_spec(self.kind, range)?,

Diff for: gix/src/revision/spec/parse/delegate/navigate.rs

@@ -121,7 +121,7 @@ impl<'repo> delegate::Navigate for Delegate<'repo> {
                 let lookup_path = |obj: &ObjectId| {
                     let tree_id = peel(repo, obj, gix_object::Kind::Tree)?;
                     if path.is_empty() {
-                        return Ok(tree_id);
+                        return Ok((tree_id, gix_object::tree::EntryKind::Tree.into()));
                     }
                     let mut tree = repo.find_object(tree_id)?.into_tree();
                     let entry =
@@ -131,11 +131,17 @@ impl<'repo> delegate::Navigate for Delegate<'repo> {
                                 object: obj.attach(repo).shorten_or_id(),
                                 tree: tree_id.attach(repo).shorten_or_id(),
                             })?;
-                    Ok(entry.object_id())
+                    Ok((entry.object_id(), entry.mode()))
                 };
                 for obj in objs.iter() {
                     match lookup_path(obj) {
-                        Ok(replace) => replacements.push((*obj, replace)),
+                        Ok((replace, mode)) => {
+                            if !path.is_empty() {
+                                // Technically this is letting the last one win, but so be it.
+                                self.paths[self.idx] = Some((path.to_owned(), mode));
+                            }
+                            replacements.push((*obj, replace))
+                        }
                         Err(err) => errors.push((*obj, err)),
                     }
                 }
@@ -306,6 +312,14 @@ impl<'repo> delegate::Navigate for Delegate<'repo> {
                     self.objs[self.idx]
                         .get_or_insert_with(HashSet::default)
                         .insert(entry.id);
+
+                    self.paths[self.idx] = Some((
+                        path.to_owned(),
+                        entry
+                            .mode
+                            .to_tree_entry_mode()
+                            .unwrap_or(gix_object::tree::EntryKind::Blob.into()),
+                    ));
                     Some(())
                 }
                 None => {

Diff for: gix/src/revision/spec/parse/mod.rs

@@ -7,6 +7,7 @@ use gix_revision::spec::parse;
 use crate::{bstr::BStr, revision::Spec, Repository};
 
 mod types;
+use crate::bstr::BString;
 pub use types::{Error, ObjectKindHint, Options, RefsHint};
 
 ///
@@ -45,6 +46,9 @@ impl<'repo> Spec<'repo> {
 struct Delegate<'repo> {
     refs: [Option<gix_ref::Reference>; 2],
     objs: [Option<HashSet<ObjectId>>; 2],
+    /// Path specified like `@:<path>` or `:<path>` for later use when looking up specs.
+    /// Note that it terminates spec parsing, so it's either `0` or `1`, never both.
+    paths: [Option<(BString, gix_object::tree::EntryMode)>; 2],
     /// The originally encountered ambiguous objects for potential later use in errors.
     ambiguous_objects: [Option<HashSet<ObjectId>>; 2],
     idx: usize,

Diff for: gix/tests/revision/spec/from_bytes/ambiguous.rs

@@ -106,11 +106,16 @@ fn blob_and_tree_can_be_disambiguated_by_type() {
 #[test]
 fn trees_can_be_disambiguated_by_blob_access() {
     let repo = repo("ambiguous_blob_tree_commit").unwrap();
+    let actual = parse_spec_better_than_baseline("0000000000:a0blgqsjc", &repo).unwrap();
     assert_eq!(
-        parse_spec_better_than_baseline("0000000000:a0blgqsjc", &repo).unwrap(),
+        actual,
         Spec::from_id(hex_to_id("0000000000b36b6aa7ea4b75318ed078f55505c3").attach(&repo)),
         "we can disambiguate by providing a path, but git cannot"
     );
+    assert_eq!(
+        actual.path_and_mode().expect("set"),
+        ("a0blgqsjc".into(), gix_object::tree::EntryKind::Blob.into())
+    );
 }
 
 #[test]

Diff for: gix/tests/revision/spec/from_bytes/mod.rs

@@ -43,10 +43,16 @@ mod index {
     #[test]
     fn at_stage() {
         let repo = repo("complex_graph").unwrap();
+        let actual = parse_spec(":file", &repo).unwrap();
         assert_eq!(
-            parse_spec(":file", &repo).unwrap(),
+            actual,
             Spec::from_id(hex_to_id("fe27474251f7f8368742f01fbd3bd5666b630a82").attach(&repo))
         );
+        assert_eq!(
+            actual.path_and_mode().expect("set"),
+            ("file".into(), gix_object::tree::EntryKind::Blob.into()),
+            "index paths (that are present) are captured"
+        );
 
         assert_eq!(
             parse_spec(":1:file", &repo).unwrap_err().to_string(),
@@ -116,10 +122,16 @@ fn bad_objects_are_valid_until_they_are_actually_read_from_the_odb() {
 #[test]
 fn access_blob_through_tree() {
     let repo = repo("ambiguous_blob_tree_commit").unwrap();
+    let actual = parse_spec("0000000000cdc:a0blgqsjc", &repo).unwrap();
     assert_eq!(
-        parse_spec("0000000000cdc:a0blgqsjc", &repo).unwrap(),
+        actual,
         Spec::from_id(hex_to_id("0000000000b36b6aa7ea4b75318ed078f55505c3").attach(&repo))
     );
+    assert_eq!(
+        actual.path_and_mode().expect("set"),
+        ("a0blgqsjc".into(), gix_object::tree::EntryKind::Blob.into()),
+        "we capture tree-paths"
+    );
 
     assert_eq!(
         parse_spec("0000000000cdc:missing", &repo).unwrap_err().to_string(),

Diff for: gix/tests/revision/spec/from_bytes/peel.rs

@@ -21,5 +21,7 @@ fn peel_to_object() {
 #[test]
 fn trailing_colon_is_equivalent_to_peel_to_tree() {
     let repo = &repo("complex_graph").unwrap();
-    assert_eq!(parse_spec("@^{tree}", repo).unwrap(), parse_spec("@:", repo).unwrap());
+    let empty_path = parse_spec("@:", repo).unwrap();
+    assert_eq!(parse_spec("@^{tree}", repo).unwrap(), empty_path);
+    assert_eq!(empty_path.path_and_mode(), None, "empty tree paths are ignored");
 }