extract helper utility from RefMap::new()

Author: djc

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

@@ -1,18 +1,21 @@
 use std::collections::HashSet;
 
-use bstr::{BString, ByteVec};
+use bstr::{BString, ByteSlice, ByteVec};
 use gix_features::progress::Progress;
+use gix_refspec::RefSpec;
+use gix_transport::client::Capabilities;
 
 #[cfg(feature = "async-client")]
 use crate::transport::client::async_io::Transport;
 #[cfg(feature = "blocking-client")]
 use crate::transport::client::blocking_io::Transport;
 use crate::{
-    fetch,
     fetch::{
+        self,
         refmap::{Mapping, Source, SpecIndex},
         RefMap,
     },
+    handshake::Ref,
 };
 
 /// The error returned by [`RefMap::new()`].
@@ -78,8 +81,6 @@ impl RefMap {
         T: Transport,
     {
         let _span = gix_trace::coarse!("gix_protocol::fetch::RefMap::new()");
-        let null = gix_hash::ObjectId::null(gix_hash::Kind::Sha1); // OK to hardcode Sha1, it's not supposed to match, ever.
-
         let all_refspecs = {
             let mut s: Vec<_> = fetch_refspecs.to_vec();
             s.extend(extra_refspecs.clone());
@@ -115,8 +116,26 @@ impl RefMap {
                 .await?
             }
         };
+
+        Self::from_refs(
+            remote_refs,
+            &handshake.capabilities,
+            fetch_refspecs,
+            all_refspecs,
+            extra_refspecs,
+        )
+    }
+
+    fn from_refs(
+        remote_refs: Vec<Ref>,
+        capabilities: &Capabilities,
+        fetch_refspecs: &[RefSpec],
+        all_refspecs: Vec<RefSpec>,
+        extra_refspecs: Vec<RefSpec>,
+    ) -> Result<Self, Error> {
         let num_explicit_specs = fetch_refspecs.len();
         let group = gix_refspec::MatchGroup::from_fetch_specs(all_refspecs.iter().map(gix_refspec::RefSpec::to_ref));
+        let null = gix_hash::ObjectId::null(gix_hash::Kind::Sha1); // OK to hardcode Sha1, it's not supposed to match, ever.
         let (res, fixes) = group
             .match_lhs(remote_refs.iter().map(|r| {
                 let (full_ref_name, target, object) = r.unpack();
@@ -150,24 +169,9 @@ impl RefMap {
             })
             .collect();
 
-        let object_hash = extract_object_format(handshake)?;
-        Ok(RefMap {
-            mappings,
-            refspecs: fetch_refspecs.to_vec(),
-            extra_refspecs,
-            fixes,
-            remote_refs,
-            object_hash,
-        })
-    }
-}
-
-/// Assume sha1 if server says nothing, otherwise configure anything beyond sha1 in the local repo configuration
-#[allow(clippy::result_large_err)]
-fn extract_object_format(outcome: &crate::handshake::Outcome) -> Result<gix_hash::Kind, Error> {
-    use bstr::ByteSlice;
-    let object_hash =
-        if let Some(object_format) = outcome.capabilities.capability("object-format").and_then(|c| c.value()) {
+        // Assume sha1 if server says nothing, otherwise configure anything beyond sha1 in the local repo configuration
+        let object_hash = if let Some(object_format) = capabilities.capability("object-format").and_then(|c| c.value())
+        {
             let object_format = object_format.to_str().map_err(|_| Error::UnknownObjectFormat {
                 format: object_format.into(),
             })?;
@@ -178,5 +182,14 @@ fn extract_object_format(outcome: &crate::handshake::Outcome) -> Result<gix_hash
         } else {
             gix_hash::Kind::Sha1
         };
-    Ok(object_hash)
+
+        Ok(Self {
+            mappings,
+            refspecs: fetch_refspecs.to_vec(),
+            extra_refspecs,
+            fixes,
+            remote_refs,
+            object_hash,
+        })
+    }
 }

gix-protocol/src/fetch/types.rs

@@ -39,10 +39,7 @@ pub struct Context<'a, T> {
 
 #[cfg(feature = "fetch")]
 mod with_fetch {
-    use crate::{
-        fetch,
-        fetch::{negotiate, refmap},
-    };
+    use crate::fetch::{self, negotiate, refmap};
 
     /// For use in [`fetch`](crate::fetch()).
     pub struct NegotiateContext<'a, 'b, 'c, Objects, Alternates, AlternatesOut, AlternatesErr, Find>