refactor!: take extra arguments as a separate argument

Author: djc

gix-protocol/src/fetch/refmap/init.rs

@@ -80,10 +80,8 @@ impl RefMap {
         let remote_refs = crate::ls_refs(
             transport,
             capabilities,
-            |_capabilities, arguments| {
-                push_prefix_arguments(prefix_from_spec_as_filter_on_remote, arguments, &all_refspecs);
-                Ok(crate::ls_refs::Action::Continue)
-            },
+            |_capabilities| Ok(crate::ls_refs::Action::Continue),
+            push_prefix_arguments(prefix_from_spec_as_filter_on_remote, &all_refspecs),
             &mut progress,
             trace_packetlines,
             user_agent,
@@ -164,13 +162,13 @@ impl RefMap {
 
 fn push_prefix_arguments(
     prefix_from_spec_as_filter_on_remote: bool,
-    arguments: &mut Vec<BString>,
     all_refspecs: &[gix_refspec::RefSpec],
-) {
+) -> Vec<BString> {
     if !prefix_from_spec_as_filter_on_remote {
-        return;
+        return Vec::new();
     }
 
+    let mut arguments = Vec::new();
     let mut seen = HashSet::new();
     for spec in all_refspecs {
         let spec = spec.to_ref();
@@ -183,4 +181,6 @@ fn push_prefix_arguments(
             }
         }
     }
+
+    arguments
 }

gix-protocol/src/ls_refs.rs

@@ -61,15 +61,17 @@ pub(crate) mod function {
     };
 
     /// Invoke a ls-refs V2 command on `transport`, which requires a prior handshake that yielded
-    /// server `capabilities`. `prepare_ls_refs(capabilities, arguments)` can be used to alter the _ls-refs_.
+    /// server `capabilities`. `prepare_ls_refs(capabilities)` can be used to alter the _ls-refs_.
+    /// `arguments` are extra arguments to send to the server.
     /// `progress` is used to provide feedback.
     /// The `agent` information will be added to the features sent to the server.
     /// If `trace` is `true`, all packetlines received or sent will be passed to the facilities of the `gix-trace` crate.
     #[maybe_async]
     pub async fn ls_refs(
         mut transport: impl Transport,
         capabilities: &Capabilities,
-        prepare_ls_refs: impl FnOnce(&Capabilities, &mut Vec<BString>) -> std::io::Result<Action>,
+        prepare_ls_refs: impl FnOnce(&Capabilities) -> std::io::Result<Action>,
+        extra_args: Vec<BString>,
         progress: &mut impl Progress,
         trace: bool,
         agent: (&'static str, Option<Cow<'static, str>>),
@@ -86,7 +88,9 @@ pub(crate) mod function {
         {
             ls_args.push("unborn".into());
         }
-        let refs = match prepare_ls_refs(capabilities, &mut ls_args) {
+
+        ls_args.extend(extra_args);
+        let refs = match prepare_ls_refs(capabilities) {
             Ok(Action::Skip) => Vec::new(),
             Ok(Action::Continue) => {
                 ls_refs.validate_argument_prefixes(

gix-protocol/tests/protocol/fetch/_impl.rs

@@ -95,7 +95,8 @@ mod fetch_fn {
                 gix_protocol::ls_refs(
                     &mut transport,
                     &capabilities,
-                    |a, _b| delegate.prepare_ls_refs(a),
+                    |a| delegate.prepare_ls_refs(a),
+                    Vec::new(),
                     &mut progress,
                     trace,
                     ("agent", Some(Cow::Owned(agent.clone()))),
@@ -327,10 +328,7 @@ mod delegate {
             self.deref().handshake_extra_parameters()
         }
 
-        fn prepare_ls_refs(
-            &mut self,
-            _server: &Capabilities,
-        ) -> io::Result<ls_refs::Action> {
+        fn prepare_ls_refs(&mut self, _server: &Capabilities) -> io::Result<ls_refs::Action> {
             self.deref_mut().prepare_ls_refs(_server)
         }
 

gix-protocol/tests/protocol/fetch/mod.rs

@@ -102,10 +102,7 @@ pub struct CloneRefInWantDelegate {
 }
 
 impl DelegateBlocking for CloneRefInWantDelegate {
-    fn prepare_ls_refs(
-        &mut self,
-        _server: &Capabilities,
-    ) -> io::Result<ls_refs::Action> {
+    fn prepare_ls_refs(&mut self, _server: &Capabilities) -> io::Result<ls_refs::Action> {
         Ok(ls_refs::Action::Skip)
     }
 
@@ -144,10 +141,7 @@ impl DelegateBlocking for LsRemoteDelegate {
     fn handshake_extra_parameters(&self) -> Vec<(String, Option<String>)> {
         vec![("value-only".into(), None), ("key".into(), Some("value".into()))]
     }
-    fn prepare_ls_refs(
-        &mut self,
-        _server: &Capabilities,
-    ) -> std::io::Result<ls_refs::Action> {
+    fn prepare_ls_refs(&mut self, _server: &Capabilities) -> std::io::Result<ls_refs::Action> {
         match self.abort_with.take() {
             Some(err) => Err(err),
             None => Ok(ls_refs::Action::Continue),