fix!: remove ref_map from fetch() function.

It's only uses for validation of the ref-maps own state, which
is something that can be separate.

Author: Byron

gix-protocol/src/fetch/error.rs

@@ -4,11 +4,6 @@
 pub enum Error {
     #[error("Could not decode server reply")]
     FetchResponse(#[from] crate::fetch::response::Error),
-    #[error("Cannot fetch from a remote that uses {remote} while local repository uses {local} for object hashes")]
-    IncompatibleObjectHash {
-        local: gix_hash::Kind,
-        remote: gix_hash::Kind,
-    },
     #[error(transparent)]
     Negotiate(#[from] crate::fetch::negotiate::Error),
     #[error(transparent)]
@@ -26,11 +21,6 @@ pub enum Error {
     LockShallowFile(#[from] gix_lock::acquire::Error),
     #[error("Receiving objects from shallow remotes is prohibited due to the value of `clone.rejectShallow`")]
     RejectShallowRemote,
-    #[error("None of the refspec(s) {} matched any of the {num_remote_refs} refs on the remote", refspecs.iter().map(|r| r.to_ref().instruction().to_bstring().to_string()).collect::<Vec<_>>().join(", "))]
-    NoMapping {
-        refspecs: Vec<gix_refspec::RefSpec>,
-        num_remote_refs: usize,
-    },
     #[error("Failed to consume the pack sent by the remove")]
     ConsumePack(Box<dyn std::error::Error + Send + Sync + 'static>),
     #[error("Failed to read remaining bytes in stream")]

gix-protocol/src/fetch/function.rs

@@ -1,13 +1,12 @@
 use crate::fetch::{
-    negotiate, Context, Error, Negotiate, NegotiateOutcome, Options, Outcome, ProgressId, RefMap, Shallow, Tags,
+    negotiate, Context, Error, Negotiate, NegotiateOutcome, Options, Outcome, ProgressId, Shallow, Tags,
 };
 use crate::{fetch::Arguments, transport::packetline::read::ProgressAction};
 use gix_features::progress::DynNestedProgress;
 use std::path::Path;
 use std::sync::atomic::{AtomicBool, Ordering};
 
-/// Perform one fetch operation, relying on a `transport`, right after a [`ref_map`](RefMap::new()) was created so
-/// it's clear what the remote has.
+/// Perform one fetch operation, relying on a `transport`.
 /// `negotiate` is used to run the negotiation of objects that should be contained in the pack, *if* one is to be received.
 /// `progress` and `should_interrupt` is passed to all potentially long-running parts of the operation.
 ///
@@ -31,7 +30,6 @@ use std::sync::atomic::{AtomicBool, Ordering};
 /// to inform about all the changes that were made.
 #[maybe_async::maybe_async]
 pub async fn fetch<P, T, E>(
-    ref_map: &RefMap,
     negotiate: &mut impl Negotiate,
     consume_pack: impl FnOnce(&mut dyn std::io::BufRead, &mut dyn DynNestedProgress, &AtomicBool) -> Result<bool, E>,
     mut progress: P,
@@ -46,7 +44,6 @@ pub async fn fetch<P, T, E>(
         shallow_file,
         shallow,
         tags,
-        expected_object_hash,
         reject_shallow_remote,
     }: Options<'_>,
 ) -> Result<Option<Outcome>, Error>
@@ -57,16 +54,6 @@ where
     E: Into<Box<dyn std::error::Error + Send + Sync + 'static>>,
 {
     let _span = gix_trace::coarse!("gix_protocol::fetch()");
-
-    if ref_map.mappings.is_empty() && !ref_map.remote_refs.is_empty() {
-        let mut specs = ref_map.refspecs.clone();
-        specs.extend(ref_map.extra_refspecs.clone());
-        return Err(Error::NoMapping {
-            refspecs: specs,
-            num_remote_refs: ref_map.remote_refs.len(),
-        });
-    }
-
     let v1_shallow_updates = handshake.v1_shallow_updates.take();
     let protocol_version = handshake.server_protocol_version;
 
@@ -93,13 +80,6 @@ where
     }
     let (shallow_commits, mut shallow_lock) = add_shallow_args(&mut arguments, shallow, &shallow_file)?;
 
-    if ref_map.object_hash != expected_object_hash {
-        return Err(Error::IncompatibleObjectHash {
-            local: expected_object_hash,
-            remote: ref_map.object_hash,
-        });
-    }
-
     let negotiate_span = gix_trace::detail!(
         "negotiate",
         protocol_version = handshake.server_protocol_version as usize

gix-protocol/src/fetch/types.rs

@@ -12,8 +12,6 @@ pub struct Options<'a> {
     pub shallow: &'a Shallow,
     /// Describe how to handle tags when fetching.
     pub tags: Tags,
-    /// The hash the remote repository is expected to use, as it's what the local repository is initialized as.
-    pub expected_object_hash: gix_hash::Kind,
     /// If `true`, if we fetch from a remote that only offers shallow clones, the operation will fail with an error
     /// instead of writing the shallow boundary to the shallow file.
     pub reject_shallow_remote: bool,