sketch all possible instructions of fetch and push refspecs (#450)

Author: Byron

git-refspec/src/lib.rs

@@ -24,6 +24,83 @@ pub enum Operation {
     Fetch,
 }
 
+pub enum Instruction<'a> {
+    Push(Push<'a>),
+    Fetch(Fetch<'a>),
+}
+
+pub enum Push<'a> {
+    /// Push a single ref knowing only one ref name.
+    SingleMatching {
+        /// The name of the ref to push from `src` to `dest`.
+        src_and_dest: &'a BStr,
+        /// If true, allow non-fast-forward updates of `dest`.
+        allow_non_fast_forward: bool,
+    },
+    /// Exclude a single ref.
+    ExcludeSingle {
+        /// A single full ref name to exclude.
+        src: &'a BStr,
+    },
+    /// Exclude multiple refs with single `*` glob.
+    ExcludeMultipleWithGlob {
+        /// A ref pattern with a single `*`.
+        src: &'a BStr,
+    },
+    /// Push a single ref or refspec to a known destination ref.
+    Single {
+        /// The source ref or refspec to push.
+        src: &'a BStr,
+        /// The ref to update with the object from `src`.
+        dest: &'a BStr,
+        /// If true, allow non-fast-forward updates of `dest`.
+        allow_non_fast_forward: bool,
+    },
+    /// Push a multiple refs to matching destination refs, with exactly a single glob on both sides.
+    MultipleWithGlob {
+        /// The source ref to match against all refs for pushing.
+        src: &'a BStr,
+        /// The ref to update with object obtained from `src`, filling in the `*` with the portion that matched in `src`.
+        dest: &'a BStr,
+        /// If true, allow non-fast-forward updates of `dest`.
+        allow_non_fast_forward: bool,
+    },
+}
+
+pub enum Fetch<'a> {
+    Only {
+        /// The ref name to fetch on the remote side, without updating the local side.
+        src: &'a BStr,
+    },
+    /// Exclude a single ref.
+    ExcludeSingle {
+        /// A single full ref name to exclude.
+        src: &'a BStr,
+    },
+    /// Exclude multiple refs with single `*` glob.
+    ExcludeMultipleWithGlob {
+        /// A ref pattern with a single `*`.
+        src: &'a BStr,
+    },
+    AndUpdateSingle {
+        /// The ref name to fetch on the remote side.
+        src: &'a BStr,
+        /// The local destination to update with what was fetched.
+        dest: &'a BStr,
+        /// If true, allow non-fast-forward updates of `dest`.
+        allow_non_fast_forward: bool,
+    },
+    /// Similar to `FetchAndUpdate`, but src and destination contain a single glob to fetch and update multiple refs.
+    AndUpdateMultipleWithGlob {
+        /// The ref glob to match against all refs on the remote side for fetching.
+        src: &'a BStr,
+        /// The local destination to update with what was fetched by replacing the single `*` with the matching portion from `src`.
+        dest: &'a BStr,
+        /// If true, allow non-fast-forward updates of `dest`.
+        allow_non_fast_forward: bool,
+    },
+}
+
 /// A refspec with references to the memory it was parsed from.
 #[derive(PartialEq, Eq, Copy, Clone, Hash, Debug)]
 pub struct RefSpecRef<'a> {
@@ -46,8 +123,22 @@ pub mod parse;
 pub use parse::function::parse;
 
 mod spec {
-    use crate::{RefSpec, RefSpecRef};
+    use crate::{Instruction, Mode, RefSpec, RefSpecRef};
+
+    /// Access
+    impl RefSpecRef<'_> {
+        /// Return the refspec mode.
+        pub fn mode(&self) -> Mode {
+            self.mode
+        }
+
+        /// Transform the state of the refspec into an instruction making clear what to do with it.
+        pub fn instruction(&self) -> Instruction<'_> {
+            todo!()
+        }
+    }
 
+    /// Conversion
     impl RefSpecRef<'_> {
         /// Convert this ref into a standalone, owned copy.
         pub fn to_owned(&self) -> RefSpec {

git-refspec/tests/fixtures/generated-archives/make_baseline.tar.xz

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5aac946f32882b76ca1a1d980cdd56fb812e9059ba59074ef141dd0bb4b32903
-size 9320
+oid sha256:588dd4f20c618e60aff39c9cd47dd1300c83c39572f0c1db2c751ccbaca5709c
+size 9328

git-refspec/tests/fixtures/make_baseline.sh

@@ -31,6 +31,9 @@ baseline fetch '^a:b'
 baseline fetch '^:'
 baseline fetch '^:b'
 
+baseline fetch '^refs/heads/qa/*/*'
+baseline push '^refs/heads/qa/*/*'
+
 baseline push 'refs/heads/*:refs/remotes/frotz'
 baseline push 'refs/heads:refs/remotes/frotz/*'
 

git-refspec/tests/parse/mod.rs

@@ -70,14 +70,28 @@ mod invalid {
 
     mod fetch {}
 
-    mod push {}
+    mod push {
+        use crate::parse::assert_parse;
+        use git_refspec::{Mode, Operation};
+
+        #[test]
+        #[ignore]
+        fn colon_alone_is_for_pushing_matching_refs() {
+            assert_parse(":", Operation::Push, None, None, Mode::Normal);
+        }
+    }
 }
 
 mod util {
-    use git_refspec::{Operation, RefSpecRef};
+    use git_refspec::{Mode, Operation, RefSpecRef};
 
     pub fn try_parse(spec: &str, op: Operation) -> Result<RefSpecRef<'_>, git_refspec::parse::Error> {
         git_refspec::parse(spec.into(), op)
     }
+
+    pub fn assert_parse(spec: &str, op: Operation, _src: Option<&str>, _dest: Option<&str>, mode: Mode) {
+        let spec = try_parse(spec, op).expect("no error");
+        assert_eq!(spec.mode(), mode);
+    }
 }
 pub use util::*;