feat: Repository::rev_parse*() now supports branch@{upstream|push|u|p}.

Previously it would be parsed, but always error as the implementation didn't exist.
Now it will return the fetch and push tracking branches respectively.

Author: Byron

gix/src/revision/spec/parse/delegate/mod.rs

@@ -199,10 +199,9 @@ impl<'repo> Delegate<'repo> {
         }
     }
     fn follow_refs_to_objects_if_needed(&mut self) -> Option<()> {
-        assert_eq!(self.refs.len(), self.objs.len());
         let repo = self.repo;
         for (r, obj) in self.refs.iter().zip(self.objs.iter_mut()) {
-            if let (_ref_opt @ Some(ref_), obj_opt @ None) = (r, obj) {
+            if let (Some(ref_), obj_opt @ None) = (r, obj) {
                 if let Some(id) = ref_.target.try_id().map(ToOwned::to_owned).or_else(|| {
                     ref_.clone()
                         .attach(repo)

gix/src/revision/spec/parse/delegate/revision.rs

@@ -9,6 +9,7 @@ use gix_revision::spec::parse::{
 use crate::{
     bstr::{BStr, BString, ByteSlice},
     ext::ReferenceExt,
+    remote,
     revision::spec::parse::{Delegate, Error, RefsHint},
 };
 
@@ -106,6 +107,7 @@ impl<'repo> delegate::Revision for Delegate<'repo> {
         self.unset_disambiguate_call();
         match query {
             ReflogLookup::Date(_date) => {
+                // TODO: actually do this - this should be possible now despite incomplete date parsing
                 self.err.push(Error::Planned {
                     dependency: "remote handling and ref-specs are fleshed out more",
                 });
@@ -215,11 +217,51 @@ impl<'repo> delegate::Revision for Delegate<'repo> {
         }
     }
 
-    fn sibling_branch(&mut self, _kind: SiblingBranch) -> Option<()> {
+    fn sibling_branch(&mut self, kind: SiblingBranch) -> Option<()> {
         self.unset_disambiguate_call();
-        self.err.push(Error::Planned {
-            dependency: "remote handling and ref-specs are fleshed out more",
-        });
+        let reference = match &mut self.refs[self.idx] {
+            val @ None => match self.repo.head().map(crate::Head::try_into_referent) {
+                Ok(Some(r)) => {
+                    *val = Some(r.clone().detach());
+                    r
+                }
+                Ok(None) => {
+                    self.err.push(Error::UnbornHeadForSibling);
+                    return None;
+                }
+                Err(err) => {
+                    self.err.push(err.into());
+                    return None;
+                }
+            },
+            Some(r) => r.clone().attach(self.repo),
+        };
+        let direction = match kind {
+            SiblingBranch::Upstream => remote::Direction::Fetch,
+            SiblingBranch::Push => remote::Direction::Push,
+        };
+        match reference.remote_tracking_ref_name(direction) {
+            None => self.err.push(Error::NoTrackingBranch {
+                name: reference.inner.name,
+                direction,
+            }),
+            Some(Err(err)) => self.err.push(Error::GetTrackingBranch {
+                name: reference.inner.name,
+                direction,
+                source: Box::new(err),
+            }),
+            Some(Ok(name)) => match self.repo.find_reference(name.as_ref()) {
+                Err(err) => self.err.push(Error::GetTrackingBranch {
+                    name: reference.inner.name,
+                    direction,
+                    source: Box::new(err),
+                }),
+                Ok(r) => {
+                    self.refs[self.idx] = r.inner.into();
+                    return Some(());
+                }
+            },
+        };
         None
     }
 }

gix/src/revision/spec/parse/types.rs

@@ -1,4 +1,4 @@
-use crate::{bstr::BString, object, reference};
+use crate::{bstr::BString, object, reference, remote};
 
 /// A hint to know what to do if refs and object names are equal.
 #[derive(Default, Debug, Copy, Clone, PartialEq, Eq)]
@@ -59,6 +59,19 @@ pub enum Error {
     Malformed,
     #[error("Unborn heads do not have a reflog yet")]
     UnbornHeadsHaveNoRefLog,
+    #[error("Unborn heads cannot have push or upstream tracking branches")]
+    UnbornHeadForSibling,
+    #[error("Branch named {name} does not have a {} tracking branch configured", direction.as_str())]
+    NoTrackingBranch {
+        name: gix_ref::FullName,
+        direction: remote::Direction,
+    },
+    #[error("Error when obtaining {} tracking branch for {name}", direction.as_str())]
+    GetTrackingBranch {
+        name: gix_ref::FullName,
+        direction: remote::Direction,
+        source: Box<dyn std::error::Error + Send + Sync + 'static>,
+    },
     #[error("This feature will be implemented once {dependency}")]
     Planned { dependency: &'static str },
     #[error("Reference {reference:?} does not have a reference log, cannot {action}")]

gix/tests/fixtures/generated-archives/make_rev_spec_parse_repos.tar.xz

@@ -338,6 +338,16 @@ git init complex_graph
   git add file && git commit -m A
   git branch a
 
+  git remote add origin .
+  cat <<EOF>>.git/config
+
+  [branch "main"]
+  	remote = origin
+  	merge = refs/heads/main
+EOF
+
+  git fetch
+
   baseline ":/message" # finds 'message recent' instead of 'initial message'
   baseline ":/!-message" # above, negated
   baseline ":/mes.age" # regexes work too
@@ -391,6 +401,11 @@ git init complex_graph
   baseline "@:"
   baseline "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
 
+  baseline @{push}
+  baseline main@{push}
+  baseline main@{upstream}
+  baseline @{upstream}
+
   baseline "^"
   baseline "^!"
   baseline "..."

gix/tests/fixtures/make_rev_spec_parse_repos.sh

@@ -13,22 +13,27 @@ mod traverse;
 mod peel;
 
 mod sibling_branch {
-    use gix::revision::spec::parse::Error;
-
-    use crate::revision::spec::from_bytes::{parse_spec_no_baseline, repo};
+    use crate::revision::spec::from_bytes::{parse_spec, repo};
+    use crate::util::hex_to_id;
 
     #[test]
-    fn is_planned_and_delayed_until_remotes_are_sorted() {
+    fn push_and_upstream() -> crate::Result {
         let repo = repo("complex_graph").unwrap();
-        assert!(matches!(
-            parse_spec_no_baseline("main@{push}", &repo).unwrap_err(),
-            Error::Planned { .. }
-        ));
-
-        assert!(matches!(
-            parse_spec_no_baseline("main@{upstream}", &repo).unwrap_err(),
-            Error::Planned { .. }
-        ));
+        for op in ["upstream", "push"] {
+            for branch in ["", "main"] {
+                let actual = parse_spec(format!("{branch}@{{{op}}}"), &repo)?;
+                assert_eq!(
+                    actual.first_reference().expect("set").name.as_bstr(),
+                    "refs/remotes/origin/main"
+                );
+                assert_eq!(actual.second_reference(), None);
+                assert_eq!(
+                    actual.single().expect("just one"),
+                    hex_to_id("55e825ebe8fd2ff78cad3826afb696b96b576a7e")
+                );
+            }
+        }
+        Ok(())
     }
 }
 

gix/tests/revision/spec/from_bytes/mod.rs

@@ -189,11 +189,11 @@ fn compare_with_baseline(
     }
 }
 
-pub fn parse_spec<'a>(
-    spec: &str,
-    repo: &'a gix::Repository,
-) -> Result<gix::revision::Spec<'a>, gix::revision::spec::parse::Error> {
-    parse_spec_opts(spec, repo, Default::default())
+pub fn parse_spec(
+    spec: impl AsRef<str>,
+    repo: &gix::Repository,
+) -> Result<gix::revision::Spec<'_>, gix::revision::spec::parse::Error> {
+    parse_spec_opts(spec.as_ref(), repo, Default::default())
 }
 
 pub fn repo(name: &str) -> crate::Result<gix::Repository> {