refactor!: hoist handshake ref handling out of transport code

Author: djc

gitoxide-core/src/pack/receive.rs

@@ -82,15 +82,22 @@ where
         })
         .collect::<Result<_, _>>()?;
     let user_agent = ("agent", Some(agent.clone().into()));
-    let refmap = gix::protocol::fetch::RefMap::new(
-        &mut progress,
-        &mut handshake,
-        &mut transport.inner,
-        user_agent.clone(),
-        trace_packetlines,
-        gix::protocol::fetch::refmap::init::Options::fetch(fetch_refspecs.clone()),
-    )
-    .await?;
+
+    let fetch_opts = gix::protocol::fetch::refmap::init::Options::fetch(fetch_refspecs.clone());
+    let refmap = match handshake.refs.take() {
+        Some(refs) => gix::protocol::fetch::RefMap::from_refs(refs, &handshake.capabilities, fetch_opts)?,
+        None => {
+            gix::protocol::fetch::RefMap::new(
+                &mut progress,
+                &handshake.capabilities,
+                &mut transport.inner,
+                user_agent.clone(),
+                trace_packetlines,
+                fetch_opts,
+            )
+            .await?
+        }
+    };
 
     if refmap.mappings.is_empty() && !refmap.remote_refs.is_empty() {
         return Err(Error::NoMapping {

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

@@ -13,7 +13,7 @@ use crate::{
         refmap::{Mapping, Source, SpecIndex},
         RefMap,
     },
-    handshake::{Outcome, Ref},
+    handshake::Ref,
 };
 
 /// The error returned by [`RefMap::new()`].
@@ -96,7 +96,7 @@ impl RefMap {
     #[maybe_async::maybe_async]
     pub async fn new<T>(
         mut progress: impl Progress,
-        handshake: &mut Outcome,
+        capabilities: &Capabilities,
         transport: &mut T,
         user_agent: (&'static str, Option<Cow<'static, str>>),
         trace_packetlines: bool,
@@ -106,28 +106,24 @@ impl RefMap {
         T: Transport,
     {
         let _span = gix_trace::coarse!("gix_protocol::fetch::RefMap::new()");
-        let remote_refs = match handshake.refs.take() {
-            Some(refs) => refs,
-            None => {
-                crate::ls_refs(
-                    transport,
-                    &handshake.capabilities,
-                    |_capabilities, arguments| {
-                        options.push_prefix_arguments(arguments);
-                        Ok(crate::ls_refs::Action::Continue)
-                    },
-                    &mut progress,
-                    trace_packetlines,
-                    user_agent,
-                )
-                .await?
-            }
-        };
-
-        Self::from_refs(remote_refs, &handshake.capabilities, options)
+        let remote_refs = crate::ls_refs(
+            transport,
+            capabilities,
+            |_capabilities, arguments| {
+                options.push_prefix_arguments(arguments);
+                Ok(crate::ls_refs::Action::Continue)
+            },
+            &mut progress,
+            trace_packetlines,
+            user_agent,
+        )
+        .await?;
+
+        Self::from_refs(remote_refs, capabilities, options)
     }
 
-    fn from_refs(remote_refs: Vec<Ref>, capabilities: &Capabilities, options: Options) -> Result<RefMap, Error> {
+    /// Create a ref-map from already obtained `remote_refs`.
+    pub fn from_refs(remote_refs: Vec<Ref>, capabilities: &Capabilities, options: Options) -> Result<RefMap, Error> {
         let Options {
             fetch_refspecs,
             extra_refspecs,

gix/src/remote/connection/ref_map.rs

@@ -150,20 +150,32 @@ where
             &mut progress,
         )
         .await?;
-        let refmap = gix_protocol::fetch::RefMap::new(
-            progress,
-            &mut handshake,
-            &mut self.transport.inner,
-            self.remote.repo.config.user_agent_tuple(),
-            self.trace,
-            gix_protocol::fetch::refmap::init::Options::new(
-                self.remote.fetch_specs.clone(),
-                prefix_from_spec_as_filter_on_remote,
-                extra_refspecs,
-            ),
-        )
-        .await?;
-        self.handshake = Some(handshake);
-        Ok(refmap)
+
+        let fetch_opts = gix_protocol::fetch::refmap::init::Options::new(
+            self.remote.fetch_specs.clone(),
+            prefix_from_spec_as_filter_on_remote,
+            extra_refspecs,
+        );
+
+        Ok(match handshake.refs.take() {
+            Some(refs) => {
+                let refmap = fetch::RefMap::from_refs(refs, &handshake.capabilities, fetch_opts)?;
+                self.handshake = Some(handshake);
+                refmap
+            }
+            None => {
+                let refmap = gix_protocol::fetch::RefMap::new(
+                    progress,
+                    &handshake.capabilities,
+                    &mut self.transport.inner,
+                    self.remote.repo.config.user_agent_tuple(),
+                    self.trace,
+                    fetch_opts,
+                )
+                .await?;
+                self.handshake = Some(handshake);
+                refmap
+            }
+        })
     }
 }