fix: Allow negative refspecs when pushing

This effectively reverts 9c280b2

Author: Byron

gix-refspec/src/instruction.rs

@@ -37,6 +37,11 @@ pub enum Push<'a> {
         /// If true, allow non-fast-forward updates of `dest`.
         allow_non_fast_forward: bool,
     },
+    /// Exclude a single ref.
+    Exclude {
+        /// A full or partial ref name to exclude, or multiple if a single `*` is used.
+        src: &'a BStr,
+    },
 }
 
 /// Any source can either be a ref name (full or partial) or a fully spelled out hex-sha for an object, on the remote side.

gix-refspec/src/parse.rs

@@ -8,8 +8,6 @@ pub enum Error {
     NegativeWithDestination,
     #[error("Negative specs must not be empty")]
     NegativeEmpty,
-    #[error("Negative specs are only supported when fetching")]
-    NegativeUnsupported,
     #[error("Negative specs must be object hashes")]
     NegativeObjectHash,
     #[error("Negative specs must be full ref names, starting with \"refs/\"")]
@@ -62,9 +60,6 @@ pub(crate) mod function {
         let mode = match spec.first() {
             Some(&b'^') => {
                 spec = &spec[1..];
-                if operation == Operation::Push {
-                    return Err(Error::NegativeUnsupported);
-                }
                 Mode::Negative
             }
             Some(&b'+') => {

gix-refspec/src/spec.rs

@@ -209,6 +209,7 @@ impl<'a> RefSpecRef<'a> {
                     dst,
                     allow_non_fast_forward: matches!(self.mode, Mode::Force),
                 }),
+                (Mode::Negative, Some(src), None) => Instruction::Push(Push::Exclude { src }),
                 (mode, src, dest) => {
                     unreachable!(
                         "BUG: push instructions with {:?} {:?} {:?} are not possible",

gix-refspec/src/write.rs

@@ -53,7 +53,7 @@ impl Instruction<'_> {
                 out.write_all(ref_or_pattern)
             }
             Instruction::Fetch(Fetch::Only { src }) => out.write_all(src),
-            Instruction::Fetch(Fetch::Exclude { src }) => {
+            Instruction::Fetch(Fetch::Exclude { src }) | Instruction::Push(Push::Exclude { src }) => {
                 out.write_all(b"^")?;
                 out.write_all(src)
             }

gix-refspec/tests/fixtures/generated-archives/parse_baseline.tar

@@ -97,7 +97,7 @@ baseline fetch 'HEAD'
 baseline push '@'
 baseline fetch '@'
 
-baseline push '^@' fail
+baseline push '^@'
 baseline fetch '^@'
 baseline fetch '^refs/heads/main'
 baseline fetch '^refs/heads/*'

gix-refspec/tests/fixtures/parse_baseline.sh

@@ -1,21 +1,52 @@
+use crate::parse::{assert_parse, b, try_parse};
 use gix_refspec::{
     instruction::Push,
     parse::{Error, Operation},
     Instruction,
 };
 
-use crate::parse::{assert_parse, b, try_parse};
+#[test]
+fn negative_must_not_be_empty() {
+    assert!(matches!(
+        try_parse("^", Operation::Push).unwrap_err(),
+        Error::NegativeEmpty
+    ));
+}
+
+#[test]
+fn negative_must_not_be_object_hash() {
+    assert!(matches!(
+        try_parse("^e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", Operation::Push).unwrap_err(),
+        Error::NegativeObjectHash
+    ));
+}
 
 #[test]
-fn negative_unsupported() {
-    for spec in ["^a:b", "^a:", "^:", "^:b", "^"] {
+fn negative_with_destination() {
+    for spec in ["^a:b", "^a:", "^:", "^:b"] {
         assert!(matches!(
             try_parse(spec, Operation::Push).unwrap_err(),
-            Error::NegativeUnsupported
+            Error::NegativeWithDestination
         ));
     }
 }
 
+#[test]
+fn exclude() {
+    assert!(matches!(
+        try_parse("^a", Operation::Push).unwrap_err(),
+        Error::NegativePartialName
+    ));
+    assert!(matches!(
+        try_parse("^a*", Operation::Push).unwrap_err(),
+        Error::NegativeGlobPattern
+    ));
+    assert_parse(
+        "^refs/heads/a",
+        Instruction::Push(Push::Exclude { src: b("refs/heads/a") }),
+    );
+}
+
 #[test]
 fn revspecs_with_ref_name_destination() {
     assert_parse(