feat!: move all possible code from gix to gix-protocol.

For now, just move the code down and immediately re-integrate in `gix`
to be able to use its tests to validate it.

This is a breaking change as some types move and change the layout.

Author: Byron

Cargo.lock

@@ -210,7 +210,7 @@ pub(crate) mod function {
         mut out: impl std::io::Write,
         mut err: impl std::io::Write,
     ) -> anyhow::Result<()> {
-        let mut last_spec_index = gix::remote::fetch::SpecIndex::ExplicitInRemote(usize::MAX);
+        let mut last_spec_index = gix::remote::fetch::refmap::SpecIndex::ExplicitInRemote(usize::MAX);
         let mut updates = update_refs
             .iter_mapping_updates(&map.mappings, refspecs, &map.extra_refspecs)
             .filter_map(|(update, mapping, spec, edit)| spec.map(|spec| (update, mapping, spec, edit)))
@@ -258,10 +258,10 @@ pub(crate) mod function {
 
             write!(out, "\t")?;
             match &mapping.remote {
-                gix::remote::fetch::Source::ObjectId(id) => {
+                gix::remote::fetch::refmap::Source::ObjectId(id) => {
                     write!(out, "{}", id.attach(repo).shorten_or_id())?;
                 }
-                gix::remote::fetch::Source::Ref(r) => {
+                gix::remote::fetch::refmap::Source::Ref(r) => {
                     crate::repository::remote::refs::print_ref(&mut out, r)?;
                 }
             };

gitoxide-core/src/repository/fetch.rs

@@ -4,7 +4,7 @@ mod refs_impl {
     use gix::{
         protocol::handshake,
         refspec::{match_group::validate::Fix, RefSpec},
-        remote::fetch::Source,
+        remote::fetch::refmap::Source,
     };
 
     use super::by_name_or_url;
@@ -119,7 +119,7 @@ mod refs_impl {
         mut out: impl std::io::Write,
         mut err: impl std::io::Write,
     ) -> anyhow::Result<()> {
-        let mut last_spec_index = gix::remote::fetch::SpecIndex::ExplicitInRemote(usize::MAX);
+        let mut last_spec_index = gix::remote::fetch::refmap::SpecIndex::ExplicitInRemote(usize::MAX);
         map.mappings.sort_by_key(|m| m.spec_index);
         for mapping in &map.mappings {
             if mapping.spec_index != last_spec_index {
@@ -146,11 +146,11 @@ mod refs_impl {
 
             write!(out, "\t")?;
             let target_id = match &mapping.remote {
-                gix::remote::fetch::Source::ObjectId(id) => {
+                gix::remote::fetch::refmap::Source::ObjectId(id) => {
                     write!(out, "{id}")?;
                     id
                 }
-                gix::remote::fetch::Source::Ref(r) => print_ref(&mut out, r)?,
+                gix::remote::fetch::refmap::Source::Ref(r) => print_ref(&mut out, r)?,
             };
             match &mapping.local {
                 Some(local) => {

gitoxide-core/src/repository/remote.rs

@@ -23,18 +23,38 @@ doctest = false
 #! Specifying both causes a compile error, preventing the use of `--all-features`.
 
 ## If set, blocking command implementations are available and will use the blocking version of the `gix-transport` crate.
-blocking-client = ["gix-transport/blocking-client", "maybe-async/is_sync"]
+blocking-client = [
+    "gix-transport/blocking-client",
+    "maybe-async/is_sync",
+    "handshake",
+    "fetch"
+]
 ## As above, but provides async implementations instead.
 async-client = [
     "gix-transport/async-client",
-    "async-trait",
-    "futures-io",
-    "futures-lite",
+    "dep:async-trait",
+    "dep:futures-io",
+    "dep:futures-lite",
+    "handshake",
+    "fetch"
+]
+
+## Add implementations for performing a `handshake` along with the dependencies needed for it.
+handshake = ["dep:gix-credentials"]
+
+## Add implementations for performing a `fetch` (for packs) along with the dependencies needed for it.
+fetch = [
+    "dep:gix-negotiate",
+    "dep:gix-object",
+    "dep:gix-revwalk",
+    "dep:gix-lock",
+    "dep:gix-refspec",
+    "dep:gix-trace",
 ]
 
 #! ### Other
 ## Data structures implement `serde::Serialize` and `serde::Deserialize`.
-serde = ["dep:serde", "bstr/serde", "gix-transport/serde", "gix-hash/serde"]
+serde = ["dep:serde", "bstr/serde", "gix-transport/serde", "gix-hash/serde", "gix-shallow/serde"]
 
 [[test]]
 name = "blocking"
@@ -54,8 +74,16 @@ gix-transport = { version = "^0.43.1", path = "../gix-transport" }
 gix-hash = { version = "^0.15.1", path = "../gix-hash" }
 gix-shallow = { version = "^0.1.0", path = "../gix-shallow" }
 gix-date = { version = "^0.9.2", path = "../gix-date" }
-gix-credentials = { version = "^0.25.1", path = "../gix-credentials" }
 gix-utils = { version = "^0.1.13", path = "../gix-utils" }
+gix-ref = { version = "^0.49.0", path = "../gix-ref" }
+
+gix-trace = { version = "^0.1.11", path = "../gix-trace", optional = true }
+gix-negotiate = { version = "^0.17.0", path = "../gix-negotiate", optional = true }
+gix-object = { version = "^0.46.0", path = "../gix-object", optional = true }
+gix-revwalk = { version = "^0.17.0", path = "../gix-revwalk", optional = true }
+gix-credentials = { version = "^0.25.1", path = "../gix-credentials", optional = true }
+gix-refspec = { version = "^0.27.0", path = "../gix-refspec", optional = true }
+gix-lock = { version = "^15.0.0", path = "../gix-lock", optional = true }
 
 thiserror = "2.0.0"
 serde = { version = "1.0.114", optional = true, default-features = false, features = [

gix-protocol/Cargo.toml

@@ -24,6 +24,7 @@ pub struct Arguments {
     #[cfg(any(feature = "async-client", feature = "blocking-client"))]
     version: gix_transport::Protocol,
 
+    #[cfg(any(feature = "async-client", feature = "blocking-client"))]
     trace: bool,
 }
 
@@ -164,6 +165,7 @@ impl Arguments {
     /// Permanently allow the server to include tags that point to commits or objects it would return.
     ///
     /// Needs to only be called once.
+    #[cfg(any(feature = "async-client", feature = "blocking-client"))]
     pub fn use_include_tag(&mut self) {
         debug_assert!(self.supports_include_tag, "'include-tag' feature required");
         if self.supports_include_tag {
@@ -176,6 +178,7 @@ impl Arguments {
     /// Note that sending an unknown or unsupported feature may cause the remote to terminate
     /// the connection. Use this method if you know what you are doing *and* there is no specialized
     /// method for this, e.g. [`Self::use_include_tag()`].
+    #[cfg(any(feature = "async-client", feature = "blocking-client"))]
     pub fn add_feature(&mut self, feature: &str) {
         match self.version {
             gix_transport::Protocol::V0 | gix_transport::Protocol::V1 => {

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

@@ -1,21 +1,48 @@
-use std::io;
-
-use gix_transport::client;
-
-use crate::{fetch::response, handshake, ls_refs};
-
-/// The error used in [`fetch()`][crate::fetch()].
+/// The error returned by [`fetch()`](crate::fetch()).
 #[derive(Debug, thiserror::Error)]
 #[allow(missing_docs)]
 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)]
-    Handshake(#[from] handshake::Error),
-    #[error("Could not access repository or failed to read streaming pack file")]
-    Io(#[from] io::Error),
-    #[error(transparent)]
-    Transport(#[from] client::Error),
+    Negotiate(#[from] crate::fetch::negotiate::Error),
     #[error(transparent)]
-    LsRefs(#[from] ls_refs::Error),
-    #[error(transparent)]
-    Response(#[from] response::Error),
+    Client(#[from] crate::transport::client::Error),
+    #[error("Server lack feature {feature:?}: {description}")]
+    MissingServerFeature {
+        feature: &'static str,
+        description: &'static str,
+    },
+    #[error("Could not write 'shallow' file to incorporate remote updates after fetching")]
+    WriteShallowFile(#[from] gix_shallow::write::Error),
+    #[error("Could not read 'shallow' file to send current shallow boundary")]
+    ReadShallowFile(#[from] gix_shallow::read::Error),
+    #[error("'shallow' file could not be locked in preparation for writing changes")]
+    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")]
+    ReadRemainingBytes(#[source] std::io::Error),
+}
+
+impl crate::transport::IsSpuriousError for Error {
+    fn is_spurious(&self) -> bool {
+        match self {
+            Error::FetchResponse(err) => err.is_spurious(),
+            Error::Client(err) => err.is_spurious(),
+            _ => false,
+        }
+    }
 }