refactor

Author: Byron

gix-transport/Cargo.toml

@@ -18,6 +18,8 @@ doctest = false
 default = []
 
 ## If set, blocking implementations of the typical git transports become available in `crate::client::blocking_io`
+##
+## If used in conjunction with an async implementation, this one takes precedence.
 blocking-client = ["gix-packetline/blocking-io"]
 ## Implies `blocking-client`, and adds support for the http and https transports.
 http-client = [
@@ -27,10 +29,12 @@ http-client = [
     "gix-credentials",
 ]
 ## Implies `http-client`, and adds support for the http and https transports using the Rust bindings for `libcurl`.
+##
+## If used in conjunction with other blocking implementations like `http-client-reqwest`, this one takes precedence.
 http-client-curl = ["curl", "http-client"]
 ## Implies `http-client-curl` and enables `rustls` for creating `https://` connections.
 http-client-curl-rust-tls = ["http-client-curl", "curl/rustls"]
-### Implies `http-client` and adds support for http and https transports using the blocking version of `reqwest`.
+## Implies `http-client` and adds support for http and https transports using the blocking version of `reqwest`.
 http-client-reqwest = ["reqwest", "http-client"]
 ## Stacks with `blocking-http-transport-reqwest` and enables `https://` via the `rustls` crate.
 http-client-reqwest-rust-tls = ["http-client-reqwest", "reqwest/rustls-tls"]

gix-transport/src/client/blocking_io/http/mod.rs

@@ -19,7 +19,7 @@ use crate::{
             http::options::{HttpVersion, SslVersionRangeInclusive},
             ExtendedBufRead, HandleProgress, RequestWriter, SetServiceResponse,
         },
-        capabilities::blocking_recv::Outcome,
+        capabilities::blocking_recv::Handshake,
         MessageKind,
     },
     packetline::{blocking_io::StreamingPeekableIter, PacketLineRef},
@@ -403,11 +403,11 @@ impl<H: Http> blocking_io::Transport for Transport<H> {
             line_reader.as_read().read_to_end(&mut Vec::new())?;
         }
 
-        let Outcome {
+        let Handshake {
             capabilities,
             refs,
             protocol: actual_protocol,
-        } = Outcome::from_lines_with_version_detection(line_reader)?;
+        } = Handshake::from_lines_with_version_detection(line_reader)?;
         self.actual_version = actual_protocol;
         self.service = Some(service);
         Ok(SetServiceResponse {

gix-transport/src/client/capabilities.rs

@@ -165,8 +165,8 @@ impl Capabilities {
     }
 }
 
-#[cfg(feature = "blocking-client")]
 ///
+#[cfg(feature = "blocking-client")]
 pub mod blocking_recv {
     use std::io;
 
@@ -178,8 +178,8 @@ pub mod blocking_recv {
         Protocol,
     };
 
-    /// Success outcome of [`Outcome::from_lines_with_version_detection`].
-    pub struct Outcome<'a> {
+    /// The information provided by the server upon first connection.
+    pub struct Handshake<'a> {
         /// The [`Capabilities`] the remote advertised.
         pub capabilities: Capabilities,
         /// The remote refs as a [`io::BufRead`].
@@ -191,14 +191,14 @@ pub mod blocking_recv {
         pub protocol: Protocol,
     }
 
-    impl Outcome<'_> {
+    impl Handshake<'_> {
         /// Read the capabilities and version advertisement from the given packetline reader.
         ///
         /// If [`Protocol::V1`] was requested, or the remote decided to downgrade, the remote refs
-        /// advertisement will also be included in the [`Outcome`].
+        /// advertisement will also be included in the [`Handshake`].
         pub fn from_lines_with_version_detection<T: io::Read>(
             rd: &mut StreamingPeekableIter<T>,
-        ) -> Result<Outcome<'_>, client::Error> {
+        ) -> Result<Handshake<'_>, client::Error> {
             // NOTE that this is vitally important - it is turned on and stays on for all following requests so
             // we automatically abort if the server sends an ERR line anywhere.
             // We are sure this can't clash with binary data when sent due to the way the PACK
@@ -214,13 +214,13 @@ pub mod blocking_recv {
                         Protocol::V1 => {
                             let (capabilities, delimiter_position) = Capabilities::from_bytes(line.0)?;
                             rd.peek_buffer_replace_and_truncate(delimiter_position, b'\n');
-                            Outcome {
+                            Handshake {
                                 capabilities,
                                 refs: Some(Box::new(rd.as_read())),
                                 protocol: Protocol::V1,
                             }
                         }
-                        Protocol::V2 => Outcome {
+                        Protocol::V2 => Handshake {
                             capabilities: {
                                 let mut rd = rd.as_read();
                                 let mut buf = Vec::new();
@@ -243,7 +243,7 @@ pub mod blocking_recv {
                         },
                     }
                 }
-                None => Outcome {
+                None => Handshake {
                     capabilities: Capabilities::default(),
                     refs: Some(Box::new(rd.as_read())),
                     protocol: Protocol::V0,
@@ -253,9 +253,9 @@ pub mod blocking_recv {
     }
 }
 
+///
 #[cfg(feature = "async-client")]
 #[allow(missing_docs)]
-///
 pub mod async_recv {
     use bstr::ByteVec;
     use futures_io::AsyncRead;
@@ -266,8 +266,8 @@ pub mod async_recv {
         Protocol,
     };
 
-    /// Success outcome of [`Outcome::from_lines_with_version_detection`].
-    pub struct Outcome<'a> {
+    /// The information provided by the server upon first connection.
+    pub struct Handshake<'a> {
         /// The [`Capabilities`] the remote advertised.
         pub capabilities: Capabilities,
         /// The remote refs as an [`AsyncBufRead`].
@@ -279,14 +279,14 @@ pub mod async_recv {
         pub protocol: Protocol,
     }
 
-    impl Outcome<'_> {
+    impl Handshake<'_> {
         /// Read the capabilities and version advertisement from the given packetline reader.
         ///
         /// If [`Protocol::V1`] was requested, or the remote decided to downgrade, the remote refs
-        /// advertisement will also be included in the [`Outcome`].
+        /// advertisement will also be included in the [`Handshake`].
         pub async fn from_lines_with_version_detection<T: AsyncRead + Unpin>(
             rd: &mut StreamingPeekableIter<T>,
-        ) -> Result<Outcome<'_>, client::Error> {
+        ) -> Result<Handshake<'_>, client::Error> {
             // NOTE that this is vitally important - it is turned on and stays on for all following requests so
             // we automatically abort if the server sends an ERR line anywhere.
             // We are sure this can't clash with binary data when sent due to the way the PACK
@@ -302,13 +302,13 @@ pub mod async_recv {
                         Protocol::V1 => {
                             let (capabilities, delimiter_position) = Capabilities::from_bytes(line.0)?;
                             rd.peek_buffer_replace_and_truncate(delimiter_position, b'\n');
-                            Outcome {
+                            Handshake {
                                 capabilities,
                                 refs: Some(Box::new(rd.as_read())),
                                 protocol: Protocol::V1,
                             }
                         }
-                        Protocol::V2 => Outcome {
+                        Protocol::V2 => Handshake {
                             capabilities: {
                                 let mut rd = rd.as_read();
                                 let mut buf = Vec::new();
@@ -331,7 +331,7 @@ pub mod async_recv {
                         },
                     }
                 }
-                None => Outcome {
+                None => Handshake {
                     capabilities: Capabilities::default(),
                     refs: Some(Box::new(rd.as_read())),
                     protocol: Protocol::V0,

gix-transport/src/client/git/async_io.rs

@@ -9,7 +9,7 @@ use crate::{
     client::{
         self,
         async_io::{RequestWriter, SetServiceResponse},
-        capabilities::async_recv::Outcome,
+        capabilities::async_recv::Handshake,
         git::{self, ConnectionState},
     },
     packetline::{
@@ -96,11 +96,11 @@ where
             line_writer.flush().await?;
         }
 
-        let Outcome {
+        let Handshake {
             capabilities,
             refs,
             protocol: actual_protocol,
-        } = Outcome::from_lines_with_version_detection(&mut self.line_provider).await?;
+        } = Handshake::from_lines_with_version_detection(&mut self.line_provider).await?;
         Ok(SetServiceResponse {
             actual_protocol,
             capabilities,

gix-transport/src/client/git/blocking_io.rs

@@ -6,7 +6,7 @@ use crate::{
     client::{
         self,
         blocking_io::{RequestWriter, SetServiceResponse},
-        capabilities::blocking_recv::Outcome,
+        capabilities::blocking_recv::Handshake,
         git::{self, ConnectionState},
     },
     packetline::{
@@ -91,11 +91,11 @@ where
             line_writer.flush()?;
         }
 
-        let Outcome {
+        let Handshake {
             capabilities,
             refs,
             protocol: actual_protocol,
-        } = Outcome::from_lines_with_version_detection(&mut self.line_provider)?;
+        } = Handshake::from_lines_with_version_detection(&mut self.line_provider)?;
         Ok(SetServiceResponse {
             actual_protocol,
             capabilities,

gix-transport/tests/client/capabilities.rs

@@ -4,9 +4,9 @@ use gix_packetline::async_io::{encode, StreamingPeekableIter};
 #[cfg(all(feature = "blocking-client", not(feature = "async-client")))]
 use gix_packetline::blocking_io::{encode, StreamingPeekableIter};
 #[cfg(all(feature = "async-client", not(feature = "blocking-client")))]
-use gix_transport::client::capabilities::async_recv::Outcome;
+use gix_transport::client::capabilities::async_recv::Handshake;
 #[cfg(all(feature = "blocking-client", not(feature = "async-client")))]
-use gix_transport::client::capabilities::blocking_recv::Outcome;
+use gix_transport::client::capabilities::blocking_recv::Handshake;
 use gix_transport::client::Capabilities;
 
 #[test]
@@ -63,7 +63,7 @@ async fn from_lines_with_version_detection_v0() -> crate::Result {
     let mut buf = Vec::<u8>::new();
     encode::flush_to_write(&mut buf).await?;
     let mut stream = StreamingPeekableIter::new(buf.as_slice(), &[gix_packetline::PacketLineRef::Flush], false);
-    let caps = Outcome::from_lines_with_version_detection(&mut stream)
+    let caps = Handshake::from_lines_with_version_detection(&mut stream)
         .await
         .expect("we can parse V0 as very special case, useful for testing stateful connections in other crates")
         .capabilities;