feat: add Handshake::ref_map() to produce a ref-map from a V1 or V2 handshake.

Author: Byron

gitoxide-core/src/pack/receive.rs

@@ -4,6 +4,7 @@ use std::{
     sync::{atomic::AtomicBool, Arc},
 };
 
+use crate::{net, pack::receive::protocol::fetch::negotiate, OutputFormat};
 #[cfg(feature = "async-client")]
 use gix::protocol::transport::client::async_io::connect;
 #[cfg(feature = "blocking-client")]
@@ -23,8 +24,6 @@ pub use gix::{
     NestedProgress, Progress,
 };
 
-use crate::{net, pack::receive::protocol::fetch::negotiate, OutputFormat};
-
 pub const PROGRESS_RANGE: std::ops::RangeInclusive<u8> = 1..=3;
 pub struct Context<W> {
     pub thread_limit: Option<usize>,
@@ -65,7 +64,7 @@ where
     .is_some();
 
     let agent = gix::protocol::agent(gix::env::agent());
-    let mut handshake = gix::protocol::fetch::handshake(
+    let mut handshake: gix::protocol::Handshake = gix::protocol::fetch::handshake(
         &mut transport.inner,
         gix::protocol::credentials::builtin,
         vec![("agent".into(), Some(agent.clone()))],
@@ -87,21 +86,16 @@ where
         fetch_refspecs: fetch_refspecs.clone(),
         extra_refspecs: vec![],
     };
-    let refmap = match handshake.refs.take() {
-        Some(refs) => gix::protocol::fetch::RefMap::from_refs(refs, &handshake.capabilities, context)?,
-        None => {
-            gix::protocol::fetch::RefMap::fetch(
-                &mut progress,
-                &handshake.capabilities,
-                &mut transport.inner,
-                user_agent.clone(),
-                trace_packetlines,
-                true,
-                context,
-            )
-            .await?
-        }
-    };
+    let refmap = handshake
+        .fetch_or_extract_refmap(
+            &mut progress,
+            &mut transport.inner,
+            user_agent.clone(),
+            trace_packetlines,
+            true,
+            context,
+        )
+        .await?;
 
     if refmap.mappings.is_empty() && !refmap.remote_refs.is_empty() {
         return Err(Error::NoMapping {

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

@@ -94,6 +94,7 @@ impl RefMap {
     }
 
     /// Create a ref-map from already obtained `remote_refs`. Use `context` to pass in refspecs.
+    /// `capabilities` are used to determine the object format.
     pub fn from_refs(remote_refs: Vec<Ref>, capabilities: &Capabilities, context: Context) -> Result<RefMap, Error> {
         let all_refspecs = context.aggregate_refspecs();
         let Context {

gix-protocol/src/fetch/response/mod.rs

@@ -185,7 +185,7 @@ impl Response {
     }
 
     /// Append the given `updates` which may have been obtained from a
-    /// (handshake::Outcome)[crate::handshake::Handshake::v1_shallow_updates].
+    /// (handshake::Outcome)[crate::Handshake::v1_shallow_updates].
     ///
     /// In V2, these are received as part of the pack, but V1 sends them early, so we
     /// offer to re-integrate them here.

gix-protocol/src/handshake/mod.rs

@@ -68,6 +68,52 @@ pub(crate) mod hero {
         /// The server capabilities.
         pub capabilities: gix_transport::client::Capabilities,
     }
+
+    #[cfg(feature = "fetch")]
+    mod fetch {
+        #[cfg(feature = "async-client")]
+        use crate::transport::client::async_io::Transport;
+        #[cfg(feature = "blocking-client")]
+        use crate::transport::client::blocking_io::Transport;
+        use crate::Handshake;
+        use gix_features::progress::Progress;
+        use std::borrow::Cow;
+
+        impl Handshake {
+            /// Obtain a [refmap](crate::fetch::RefMap) either from this instance, taking it out in the process, if the handshake was
+            /// created from a V1 connection, or use `transport` to fetch the refmap as a separate command invocation.
+            #[allow(clippy::result_large_err)]
+            #[maybe_async::maybe_async]
+            pub async fn fetch_or_extract_refmap<T>(
+                &mut self,
+                mut progress: impl Progress,
+                transport: &mut T,
+                user_agent: (&'static str, Option<Cow<'static, str>>),
+                trace_packetlines: bool,
+                prefix_from_spec_as_filter_on_remote: bool,
+                refmap_context: crate::fetch::refmap::init::Context,
+            ) -> Result<crate::fetch::RefMap, crate::fetch::refmap::init::Error>
+            where
+                T: Transport,
+            {
+                Ok(match self.refs.take() {
+                    Some(refs) => crate::fetch::RefMap::from_refs(refs, &self.capabilities, refmap_context)?,
+                    None => {
+                        crate::fetch::RefMap::fetch(
+                            &mut progress,
+                            &self.capabilities,
+                            transport,
+                            user_agent,
+                            trace_packetlines,
+                            prefix_from_spec_as_filter_on_remote,
+                            refmap_context,
+                        )
+                        .await?
+                    }
+                })
+            }
+        }
+    }
 }
 
 #[cfg(feature = "handshake")]

gix/src/remote/connection/ref_map.rs

@@ -143,33 +143,28 @@ where
         if let Some(config) = self.transport_options.as_ref() {
             self.transport.inner.configure(&**config)?;
         }
-        let mut handshake = gix_protocol::fetch::handshake(
+        let mut handshake: gix_protocol::Handshake = gix_protocol::fetch::handshake(
             &mut self.transport.inner,
             authenticate,
             handshake_parameters,
             &mut progress,
         )
         .await?;
 
-        let context = gix_protocol::fetch::refmap::init::Context {
+        let context = fetch::refmap::init::Context {
             fetch_refspecs: self.remote.fetch_specs.clone(),
             extra_refspecs,
         };
-        let ref_map = match handshake.refs.take() {
-            Some(refs) => fetch::RefMap::from_refs(refs, &handshake.capabilities, context)?,
-            None => {
-                gix_protocol::fetch::RefMap::fetch(
-                    progress,
-                    &handshake.capabilities,
-                    &mut self.transport.inner,
-                    self.remote.repo.config.user_agent_tuple(),
-                    self.trace,
-                    prefix_from_spec_as_filter_on_remote,
-                    context,
-                )
-                .await?
-            }
-        };
+        let ref_map = handshake
+            .fetch_or_extract_refmap(
+                progress,
+                &mut self.transport.inner,
+                self.remote.repo.config.user_agent_tuple(),
+                self.trace,
+                prefix_from_spec_as_filter_on_remote,
+                context,
+            )
+            .await?;
         self.handshake = Some(handshake);
         Ok(ref_map)
     }