refactor!: inline RefMap::fetch() into Handshake::fetch_or_extract_refmap()

Author: djc

gix-protocol/src/fetch/negotiate.rs

@@ -111,7 +111,7 @@ pub struct Round {
 /// * `graph`
 ///     - The commit-graph for use by the `negotiator` - we populate it with tips to initialize the graph traversal.
 /// * `ref_map`
-///     - The references known on the remote, as previously obtained with [`RefMap::fetch()`].
+///     - The references known on the remote, as previously obtained with [`crate::Handshake::fetch_or_extract_refmap()`].
 /// * `shallow`
 ///     - How to deal with shallow repositories. It does affect how negotiations are performed.
 /// * `mapping_is_ignored`

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

@@ -1,13 +1,6 @@
-use std::borrow::Cow;
-
 use bstr::{BString, ByteSlice};
-use gix_features::progress::Progress;
 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::{
         refmap::{Mapping, Source, SpecIndex},
@@ -16,7 +9,7 @@ use crate::{
     handshake::Ref,
 };
 
-/// The error returned by [`RefMap::fetch()`].
+/// The error returned by [`crate::Handshake::fetch_or_extract_refmap()`].
 #[derive(Debug, thiserror::Error)]
 #[allow(missing_docs)]
 pub enum Error {
@@ -28,7 +21,7 @@ pub enum Error {
     ListRefs(#[from] crate::ls_refs::Error),
 }
 
-/// For use in [`RefMap::fetch()`].
+/// For use in [`RefMap::from_refs()`].
 #[derive(Debug, Clone)]
 pub struct Context {
     /// All explicit refspecs to identify references on the remote that you are interested in.
@@ -41,49 +34,14 @@ pub struct Context {
 }
 
 impl Context {
-    fn aggregate_refspecs(&self) -> Vec<gix_refspec::RefSpec> {
+    pub(crate) fn aggregate_refspecs(&self) -> Vec<gix_refspec::RefSpec> {
         let mut all_refspecs = self.fetch_refspecs.clone();
         all_refspecs.extend(self.extra_refspecs.iter().cloned());
         all_refspecs
     }
 }
 
 impl RefMap {
-    /// Create a new instance by obtaining all references on the remote that have been filtered through our remote's specs
-    /// for _fetching_.
-    ///
-    /// * `progress` is used if `ls-refs` is invoked on the remote. Always the case when V2 is used.
-    /// * `capabilities` are the capabilities of the server, obtained by a [handshake](crate::handshake()).
-    /// * `transport` is a way to communicate with the server to obtain the reference listing.
-    /// * `user_agent` is passed to the server.
-    /// * `trace_packetlines` traces all packet lines if `true`, for debugging primarily.
-    /// * `prefix_from_spec_as_filter_on_remote`
-    ///     - Use a two-component prefix derived from the ref-spec's source, like `refs/heads/`  to let the server pre-filter refs
-    ///       with great potential for savings in traffic and local CPU time.
-    /// * `context` to provide more [configuration](Context).
-    #[allow(clippy::result_large_err)]
-    #[maybe_async::maybe_async]
-    pub async fn fetch<T>(
-        mut progress: impl Progress,
-        capabilities: &Capabilities,
-        transport: &mut T,
-        user_agent: (&'static str, Option<Cow<'static, str>>),
-        trace_packetlines: bool,
-        prefix_from_spec_as_filter_on_remote: bool,
-        context: Context,
-    ) -> Result<Self, Error>
-    where
-        T: Transport,
-    {
-        let _span = gix_trace::coarse!("gix_protocol::fetch::RefMap::new()");
-        let all_refspecs = context.aggregate_refspecs();
-        let prefix_refspecs = prefix_from_spec_as_filter_on_remote.then_some(&all_refspecs[..]);
-        let remote_refs = crate::LsRefsCommand::new(prefix_refspecs, capabilities, user_agent)
-            .invoke(transport, &mut progress, trace_packetlines)
-            .await?;
-        Self::from_refs(remote_refs, capabilities, context)
-    }
-
     /// 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> {

gix-protocol/src/fetch/types.rs

@@ -18,7 +18,7 @@ pub struct Options<'a> {
     pub reject_shallow_remote: bool,
 }
 
-/// For use in [`RefMap::fetch()`] and [`fetch`](crate::fetch()).
+/// For use in [`crate::Handshake::fetch_or_extract_refmap()`] and [`fetch`](crate::fetch()).
 #[cfg(feature = "handshake")]
 pub struct Context<'a, T> {
     /// The outcome of the handshake performed with the remote.
@@ -29,7 +29,7 @@ pub struct Context<'a, T> {
     ///
     /// This is always done if the underlying protocol is V2, which is implied by the absence of refs in the `handshake` outcome.
     pub transport: &'a mut T,
-    /// How to self-identify during the `ls-refs` call in [`RefMap::fetch()`] or the `fetch` call in [`fetch()`](crate::fetch()).
+    /// How to self-identify during the `ls-refs` call in [`crate::Handshake::fetch_or_extract_refmap()`] or the `fetch` call in [`fetch()`](crate::fetch()).
     ///
     /// This could be read from the `gitoxide.userAgent` configuration variable.
     pub user_agent: (&'static str, Option<std::borrow::Cow<'static, str>>),

gix-protocol/src/handshake/mod.rs

@@ -75,7 +75,7 @@ pub(crate) mod hero {
         use crate::transport::client::async_io::Transport;
         #[cfg(feature = "blocking-client")]
         use crate::transport::client::blocking_io::Transport;
-        use crate::Handshake;
+        use crate::{fetch::RefMap, Handshake};
         use gix_features::progress::Progress;
         use std::borrow::Cow;
 
@@ -96,21 +96,17 @@ pub(crate) mod hero {
             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?
-                    }
-                })
+                if let Some(refs) = self.refs.take() {
+                    return crate::fetch::RefMap::from_refs(refs, &self.capabilities, refmap_context);
+                }
+
+                let _span = gix_trace::coarse!("gix_protocol::handshake::fetch_or_extract_refmap()");
+                let all_refspecs = refmap_context.aggregate_refspecs();
+                let prefix_refspecs = prefix_from_spec_as_filter_on_remote.then_some(&all_refspecs[..]);
+                let remote_refs = crate::LsRefsCommand::new(prefix_refspecs, &self.capabilities, user_agent)
+                    .invoke(transport, &mut progress, trace_packetlines)
+                    .await?;
+                RefMap::from_refs(remote_refs, &self.capabilities, refmap_context)
             }
         }
     }