lael-labs/gitoxide

Cargo.lock+0−1

@@ -1646,7 +1646,6 @@ dependencies = [ · 1645 unmodified lines
1646	"git-url",	1646	"git-url",
1647	"maybe-async",	1647	"maybe-async",
1648	"pin-project-lite",	1648	"pin-project-lite",
1649	"quick-error",
1650	"serde",	1649	"serde",
1651	"thiserror",	1650	"thiserror",
1652	]	1651	]

git-transport/Cargo.toml+0−1

@@ -56,7 +56,6 @@ git-sec = { version = "^0.3.0", path = "../git-sec" } · 55 unmodified lines
56	git-packetline = { version = "^0.12.5", path = "../git-packetline" }	56	git-packetline = { version = "^0.12.5", path = "../git-packetline" }
57		57
58	serde = { version = "1.0.114", optional = true, default-features = false, features = ["std", "derive"]}	58	serde = { version = "1.0.114", optional = true, default-features = false, features = ["std", "derive"]}
59	quick-error = "2.0.0"
60	bstr = { version = "0.2.13", default-features = false, features = ["std"] }	59	bstr = { version = "0.2.13", default-features = false, features = ["std"] }
61		60
62	# for async-client	61	# for async-client

git-transport/src/client/blocking_io/connect.rs+60−50

@@ -1,61 +1,71 @@
1	pub use crate::client::non_io_types::connect::Error;	1	pub use crate::client::non_io_types::connect::Error;
2	use crate::client::Transport;
3		2
4	/// A general purpose connector connecting to a repository identified by the given `url`.	3	pub(crate) mod function {
5	///	4	use crate::client::non_io_types::connect::Error;
6	/// This includes connections to	5	use crate::client::Transport;
7	/// [local repositories][crate::client::file::connect()],	6
8	/// [repositories over ssh][crate::client::ssh::connect()],	7	/// A general purpose connector connecting to a repository identified by the given `url`.
9	/// [git daemons][crate::client::git::connect()],	8	///
10	/// and if compiled in connections to [git repositories over https][crate::client::http::connect()].	9	/// This includes connections to
11	///	10	/// [local repositories][crate::client::file::connect()],
12	/// Use `desired_version` to set the desired protocol version to use when connecting, but not that the server may downgrade it.	11	/// [repositories over ssh][crate::client::ssh::connect()],
13	pub fn connect(url: &[u8], desired_version: crate::Protocol) -> Result<Box<dyn Transport + Send>, Error> {	12	/// [git daemons][crate::client::git::connect()],
14	let urlb = url;	13	/// and if compiled in connections to [git repositories over https][crate::client::http::connect()].
15	let mut url = git_url::parse(urlb)?;	14	///
16	Ok(match url.scheme {	15	/// Use `desired_version` to set the desired protocol version to use when connecting, but not that the server may downgrade it.
17	git_url::Scheme::Radicle => return Err(Error::UnsupportedScheme(url.scheme)),	16	pub fn connect(url: &[u8], desired_version: crate::Protocol) -> Result<Box<dyn Transport + Send>, Error> {
18	git_url::Scheme::File => {	17	let urlb = url;
19	if url.user().is_some() \|\| url.host().is_some() \|\| url.port.is_some() {	18	let mut url = git_url::parse(urlb)?;
20	return Err(Error::UnsupportedUrlTokens(urlb.into(), url.scheme));	19	Ok(match url.scheme {
21	}	20	git_url::Scheme::Radicle => return Err(Error::UnsupportedScheme(url.scheme)),
22	Box::new(	21	git_url::Scheme::File => {
23	crate::client::blocking_io::file::connect(url.path, desired_version)	22	if url.user().is_some() \|\| url.host().is_some() \|\| url.port.is_some() {
24	.map_err(\|e\| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)?,	23	return Err(Error::UnsupportedUrlTokens {
25	)	24	url: urlb.into(),
26	}	25	scheme: url.scheme,
27	git_url::Scheme::Ssh => Box::new({	26	});
28	let path = std::mem::take(&mut url.path);	27	}
29	crate::client::blocking_io::ssh::connect(	28	Box::new(
30	url.host().expect("host is present in url"),	29	crate::client::blocking_io::file::connect(url.path, desired_version)
31	path,	30	.map_err(\|e\| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)?,
32	desired_version,	31	)
33	url.user(),
34	url.port,
35	)
36	.map_err(\|e\| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)?
37	}),
38	git_url::Scheme::Git => {
39	if url.user().is_some() {
40	return Err(Error::UnsupportedUrlTokens(urlb.into(), url.scheme));
41	}	32	}
42	Box::new({	33	git_url::Scheme::Ssh => Box::new({
43	let path = std::mem::take(&mut url.path);	34	let path = std::mem::take(&mut url.path);
44	crate::client::git::connect(	35	crate::client::blocking_io::ssh::connect(
45	url.host().expect("host is present in url"),	36	url.host().expect("host is present in url"),
46	path,	37	path,
47	desired_version,	38	desired_version,
		39	url.user(),
48	url.port,	40	url.port,
49	)	41	)
50	.map_err(\|e\| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)?	42	.map_err(\|e\| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)?
51	})	43	}),
52	}	44	git_url::Scheme::Git => {
53	#[cfg(not(feature = "http-client-curl"))]	45	if url.user().is_some() {
54	git_url::Scheme::Https \| git_url::Scheme::Http => return Err(Error::CompiledWithoutHttp(url.scheme)),	46	return Err(Error::UnsupportedUrlTokens {
55	#[cfg(feature = "http-client-curl")]	47	url: urlb.into(),
56	git_url::Scheme::Https \| git_url::Scheme::Http => Box::new(	48	scheme: url.scheme,
57	crate::client::http::connect(urlb.into(), desired_version)	49	});
58	.map_err(\|e\| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)?,	50	}
59	),	51	Box::new({
60	})	52	let path = std::mem::take(&mut url.path);
		53	crate::client::git::connect(
		54	url.host().expect("host is present in url"),
		55	path,
		56	desired_version,
		57	url.port,
		58	)
		59	.map_err(\|e\| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)?
		60	})
		61	}
		62	#[cfg(not(feature = "http-client-curl"))]
		63	git_url::Scheme::Https \| git_url::Scheme::Http => return Err(Error::CompiledWithoutHttp(url.scheme)),
		64	#[cfg(feature = "http-client-curl")]
		65	git_url::Scheme::Https \| git_url::Scheme::Http => Box::new(
		66	crate::client::http::connect(urlb.into(), desired_version)
		67	.map_err(\|e\| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)?,
		68	),
		69	})
		70	}
61	}	71	}

git-transport/src/client/blocking_io/http/curl/remote.rs+3−1

@@ -182,6 +182,8 @@ pub fn new() -> ( · 181 unmodified lines
182		182
183	impl From<curl::Error> for http::Error {	183	impl From<curl::Error> for http::Error {
184	fn from(err: curl::Error) -> Self {	184	fn from(err: curl::Error) -> Self {
185	http::Error::Detail(err.to_string())	185	http::Error::Detail {
		186	description: err.to_string(),
		187	}
186	}	188	}
187	}	189	}

git-transport/src/client/blocking_io/http/mod.rs+28−24

 use std::{
     borrow::Cow,
     convert::Infallible,
-    io::{self, BufRead, Read},
+    io::{BufRead, Read},
 };
 use git_packetline::PacketLineRef;
 pub struct Transport<H: Http> {
     url: BString,
     user_agent_header: &'static str,
-    desired_version: crate::Protocol,
+    desired_version: Protocol,
-    supported_versions: [crate::Protocol; 1],
+    supported_versions: [Protocol; 1],
-    actual_version: crate::Protocol,
+    actual_version: Protocol,
     http: H,
     service: Option<Service>,
     line_provider: Option<git_packetline::StreamingPeekableIter<H::ResponseBody>>,
 impl Transport<Impl> {
     /// Create a new instance to communicate to `url` using the given `desired_version` of the `git` protocol.
-    pub fn new(url: &BStr, desired_version: crate::Protocol) -> Self {
+    pub fn new(url: &BStr, desired_version: Protocol) -> Self {
         Transport {
             url: url.to_owned(),
             user_agent_header: concat!("User-Agent: git/oxide-", env!("CARGO_PKG_VERSION")),
             .iter()
             .any(|l| l == &wanted_content_type)
         {
-            return Err(client::Error::Http(Error::Detail(format!(
+            return Err(client::Error::Http(Error::Detail {
-                "Didn't find '{}' header to indicate 'smart' protocol, and 'dumb' protocol is not supported.",
+                description: format!(
-                wanted_content_type
+                    "Didn't find '{}' header to indicate 'smart' protocol, and 'dumb' protocol is not supported.",
-            ))));
+                    wanted_content_type
+                ),
+            }));
         }
         Ok(())
     }
     fn request(
         &mut self,
         write_mode: client::WriteMode,
-        on_into_read: client::MessageKind,
+        on_into_read: MessageKind,
-    ) -> Result<client::RequestWriter<'_>, client::Error> {
+    ) -> Result<RequestWriter<'_>, client::Error> {
         let service = self.service.expect("handshake() must have been called first");
         let url = append_url(self.url.as_ref(), service.as_str());
         let static_headers = &[
         line_reader.as_read().read_to_string(&mut announced_service)?;
         let expected_service_announcement = format!("# service={}", service.as_str());
         if announced_service.trim() != expected_service_announcement {
-            return Err(client::Error::Http(Error::Detail(format!(
+            return Err(client::Error::Http(Error::Detail {
-                "Expected to see {:?}, but got {:?}",
+                description: format!(
-                expected_service_announcement,
+                    "Expected to see {:?}, but got {:?}",
-                announced_service.trim()
+                    expected_service_announcement,
-            ))));
+                    announced_service.trim()
+                ),
+            }));
         }
         let capabilities::recv::Outcome {
 }
 impl<H: Http, B: Unpin> HeadersThenBody<H, B> {
-    fn handle_headers(&mut self) -> io::Result<()> {
+    fn handle_headers(&mut self) -> std::io::Result<()> {
         if let Some(headers) = self.headers.take() {
             <Transport<H>>::check_content_type(self.service, "result", headers)
-                .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?
+                .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?
         }
         Ok(())
     }
 }
-impl<H: Http, B: ExtendedBufRead + Unpin> io::Read for HeadersThenBody<H, B> {
+impl<H: Http, B: ExtendedBufRead + Unpin> Read for HeadersThenBody<H, B> {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
         self.handle_headers()?;
         self.body.read(buf)
     }
 }
-impl<H: Http, B: ExtendedBufRead + Unpin> io::BufRead for HeadersThenBody<H, B> {
+impl<H: Http, B: ExtendedBufRead + Unpin> BufRead for HeadersThenBody<H, B> {
-    fn fill_buf(&mut self) -> io::Result<&[u8]> {
+    fn fill_buf(&mut self) -> std::io::Result<&[u8]> {
         self.handle_headers()?;
         self.body.fill_buf()
     }
         self.body.set_progress_handler(handle_progress)
     }
-    fn peek_data_line(&mut self) -> Option<io::Result<Result<&[u8], client::Error>>> {
+    fn peek_data_line(&mut self) -> Option<std::io::Result<Result<&[u8], client::Error>>> {
         if let Err(err) = self.handle_headers() {
             return Some(Err(err));
         }
 }
 /// Connect to the given `url` via HTTP/S using the `desired_version` of the `git` protocol.
-pub fn connect(url: &BStr, desired_version: crate::Protocol) -> Result<Transport<Impl>, Infallible> {
+pub fn connect(url: &BStr, desired_version: Protocol) -> Result<Transport<Impl>, Infallible> {
     Ok(Transport::new(url, desired_version))
 }

git-transport/src/client/blocking_io/http/traits.rs+11−20

@@ -1,22 +1,13 @@
1	use bstr::BStr;	1	use bstr::BStr;
2	use std::io;
3		2
4	use quick_error::quick_error;	3	/// The error used by the [Http] trait.
5		4	#[derive(Debug, thiserror::Error)]
6	quick_error! {	5	#[allow(missing_docs)]
7	/// The error used by the [Http] trait.	6	pub enum Error {
8	#[derive(Debug)]	7	#[error("{description}")]
9	#[allow(missing_docs)]	8	Detail { description: String },
10	pub enum Error {	9	#[error("An IO error occurred while uploading the body of a POST request")]
11	Detail(description: String) {	10	PostBody(#[from] std::io::Error),
12	display("{}", description)
13	}
14	PostBody(err: io::Error) {
15	display("An IO error occurred while uploading the body of a POST request")
16	from()
17	source(err)
18	}
19	}
20	}	11	}
21		12
22	/// The return value of [Http::get()].	13	/// The return value of [Http::get()].
@@ -52,11 +43,11 @@ impl<A, B, C> From<PostResponse<A, B, C>> for GetResponse<A, B> { · 29 unmodified lines
52	#[allow(clippy::type_complexity)]	43	#[allow(clippy::type_complexity)]
53	pub trait Http {	44	pub trait Http {
54	/// A type providing headers line by line.	45	/// A type providing headers line by line.
55	type Headers: io::BufRead + Unpin;	46	type Headers: std::io::BufRead + Unpin;
56	/// A type providing the response.	47	/// A type providing the response.
57	type ResponseBody: io::BufRead;	48	type ResponseBody: std::io::BufRead;
58	/// A type allowing to write the content to post.	49	/// A type allowing to write the content to post.
59	type PostBody: io::Write;	50	type PostBody: std::io::Write;
60		51
61	/// Initiate a `GET` request to `url` provided the given `headers`.	52	/// Initiate a `GET` request to `url` provided the given `headers`.
62	///	53	///

git-transport/src/client/blocking_io/ssh.rs+6−10

 use std::borrow::Cow;
 use bstr::BString;
-use quick_error::quick_error;
 use crate::{client::blocking_io, Protocol};
-quick_error! {
+/// The error used in [`connect()`].
-    /// The error used in [`connect()`].
+#[derive(Debug, thiserror::Error)]
-    #[derive(Debug)]
+#[allow(missing_docs)]
-    #[allow(missing_docs)]
+pub enum Error {
-    pub enum Error {
+    #[error("The ssh command {0:?} is not currently supported")]
-        UnsupportedSshCommand(command: String) {
+    UnsupportedSshCommand(String),
-            display("The ssh command '{}' is not currently supported", command)
-        }
-    }
 }
 /// Connect to `host` using the ssh program to obtain data from the repository at `path` on the remote.

git-transport/src/client/capabilities.rs+21−31

-use std::io;
 use bstr::{BStr, BString, ByteSlice};
-use quick_error::quick_error;
 #[cfg(any(feature = "blocking-client", feature = "async-client"))]
 use crate::client;
 use crate::Protocol;
-quick_error! {
+/// The error used in [`Capabilities::from_bytes()`] and [`Capabilities::from_lines()`].
-    /// The error used in [`Capabilities::from_bytes()`] and [`Capabilities::from_lines()`].
+#[derive(Debug, thiserror::Error)]
-    #[derive(Debug)]
+#[allow(missing_docs)]
-    #[allow(missing_docs)]
+pub enum Error {
-    pub enum Error {
+    #[error("Capabilities were missing entirely as there was no 0 byte")]
-        MissingDelimitingNullByte {
+    MissingDelimitingNullByte,
-            display("Capabilities were missing entirely as there was no 0 byte")
+    #[error("there was not a single capability behind the delimiter")]
-        }
+    NoCapabilities,
-        NoCapabilities {
+    #[error("a version line was expected, but none was retrieved")]
-            display("there was not a single capability behind the delimiter")
+    MissingVersionLine,
-        }
+    #[error("expected 'version X', got {0:?}")]
-        MissingVersionLine {
+    MalformattedVersionLine(String),
-            display("a version line was expected, but none was retrieved")
+    #[error("Got unsupported version '{}', expected {actual:?}", *desired as u8)]
-        }
+    UnsupportedVersion { desired: Protocol, actual: String },
-        MalformattedVersionLine(actual: String) {
+    #[error("An IO error occurred while reading V2 lines")]
-            display("expected 'version X', got '{}'", actual)
+    Io(#[from] std::io::Error),
-        }
-        UnsupportedVersion(wanted: Protocol, got: String) {
-            display("Got unsupported version '{}', expected '{}'", got, *wanted as usize)
-        }
-        Io(err: io::Error) {
-            display("An IO error occurred while reading V2 lines")
-            from()
-            source(err)
-        }
-    }
 }
 /// A structure to represent multiple [capabilities][Capability] or features supported by the server.
             return Err(Error::MalformattedVersionLine(version_line));
         }
         if value != " 2" {
-            return Err(Error::UnsupportedVersion(Protocol::V2, value.to_owned()));
+            return Err(Error::UnsupportedVersion {
+                desired: Protocol::V2,
+                actual: value.to_owned(),
+            });
         }
         Ok(Capabilities {
             value_sep: b'\n',
         ///
         /// This is `Some` only when protocol v1 is used. The [`io::BufRead`] must be exhausted by
         /// the caller.
-        pub refs: Option<Box<dyn io::BufRead + 'a>>,
+        pub refs: Option<Box<dyn std::io::BufRead + 'a>>,
         /// The [`Protocol`] the remote advertised.
         pub protocol: Protocol,
     }

git-transport/src/client/git/blocking_io.rs+17−27

-use std::{io, io::Write};
+use std::io::Write;
 use bstr::BString;
 use git_packetline::PacketLineRef;
 impl<R, W> client::TransportWithoutIO for git::Connection<R, W>
 where
-    R: io::Read,
+    R: std::io::Read,
-    W: io::Write,
+    W: std::io::Write,
 {
     fn request(
         &mut self,
 impl<R, W> client::Transport for git::Connection<R, W>
 where
-    R: io::Read,
+    R: std::io::Read,
-    W: io::Write,
+    W: std::io::Write,
 {
     fn handshake<'a>(
         &mut self,
 impl<R, W> git::Connection<R, W>
 where
-    R: io::Read,
+    R: std::io::Read,
-    W: io::Write,
+    W: std::io::Write,
 {
     /// Create a connection from the given `read` and `write`, asking for `desired_version` as preferred protocol
     /// and the transfer of the repository at `repository_path`.
 ///
 pub mod connect {
-    use std::{
+    use std::net::{TcpStream, ToSocketAddrs};
-        io,
-        net::{TcpStream, ToSocketAddrs},
-    };
     use bstr::BString;
-    use quick_error::quick_error;
     use crate::client::git;
-    quick_error! {
+    /// The error used in [`connect()`].
-        /// The error used in [`connect()`].
+    #[derive(Debug, thiserror::Error)]
-        #[derive(Debug)]
+    #[allow(missing_docs)]
-        #[allow(missing_docs)]
+    pub enum Error {
-        pub enum Error {
+        #[error("An IO error occurred when connecting to the server")]
-            Io(err: io::Error){
+        Io(#[from] std::io::Error),
-                display("An IO error occurred when connecting to the server")
+        #[error("Could not parse {host:?} as virtual host with format <host>[:port]")]
-                from()
+        VirtualHostInvalid { host: String },
-                source(err)
-            }
-            VirtualHostInvalid(host: String) {
-                display("Could not parse '{}' as virtual host with format <host>[:port]", host)
-            }
-        }
     }
     fn parse_host(input: String) -> Result<(String, Option<u16>), Error> {
             (Some(host), None) => (host.to_owned(), None),
             (Some(host), Some(port)) => (
                 host.to_owned(),
-                Some(port.parse().map_err(|_| Error::VirtualHostInvalid(input))?),
+                Some(port.parse().map_err(|_| Error::VirtualHostInvalid { host: input })?),
             ),
             _ => unreachable!("we expect at least one token, the original string"),
         })

git-transport/src/client/mod.rs+1−1

@@ -18,7 +18,7 @@ pub use blocking_io::{ · 17 unmodified lines
18	};	18	};
19	#[cfg(feature = "blocking-client")]	19	#[cfg(feature = "blocking-client")]
20	#[doc(inline)]	20	#[doc(inline)]
21	pub use connect::connect;	21	pub use connect::function::connect;
22		22
23	///	23	///
24	pub mod capabilities;	24	pub mod capabilities;

git-transport/src/client/non_io_types.rs+21−32

@@ -29,39 +29,28 @@ pub enum MessageKind { · 28 unmodified lines
29	Text(&'static [u8]),	29	Text(&'static [u8]),
30	}	30	}
31		31
		32	#[cfg(any(feature = "blocking-client", feature = "async-client"))]
32	pub(crate) mod connect {	33	pub(crate) mod connect {
33	use quick_error::quick_error;	34	/// The error used in [`connect()`][crate::connect()].
34	quick_error! {	35	#[derive(Debug, thiserror::Error)]
35	/// The error used in [`connect()`][crate::connect()].	36	#[allow(missing_docs)]
36	#[derive(Debug)]	37	pub enum Error {
37	#[allow(missing_docs)]	38	#[error(transparent)]
38	pub enum Error {	39	Url(#[from] git_url::parse::Error),
39	Url(err: git_url::parse::Error) {	40	#[error("The git repository path could not be converted to UTF8")]
40	display("The URL could not be parsed")	41	PathConversion(#[from] bstr::Utf8Error),
41	from()	42	#[error("connection failed")]
42	source(err)	43	Connection(#[from] Box<dyn std::error::Error + Send + Sync>),
43	}	44	#[error("The url {url:?} contains information that would not be used by the {scheme} protocol")]
44	PathConversion(err: bstr::Utf8Error) {	45	UnsupportedUrlTokens {
45	display("The git repository paths could not be converted to UTF8")	46	url: bstr::BString,
46	from()	47	scheme: git_url::Scheme,
47	source(err)	48	},
48	}	49	#[error("The '{0}' protocol is currently unsupported")]
49	Connection(err: Box<dyn std::error::Error + Send + Sync>) {	50	UnsupportedScheme(git_url::Scheme),
50	display("connection failed")	51	#[cfg(not(feature = "http-client-curl"))]
51	from()	52	#[error("'{0}' is not compiled in. Compile with the 'http-client-curl' cargo feature")]
52	source(&**err)	53	CompiledWithoutHttp(git_url::Scheme),
53	}
54	UnsupportedUrlTokens(url: bstr::BString, scheme: git_url::Scheme) {
55	display("The url '{}' contains information that would not be used by the '{}' protocol", url, scheme)
56	}
57	UnsupportedScheme(scheme: git_url::Scheme) {
58	display("The '{}' protocol is currently unsupported", scheme)
59	}
60	#[cfg(not(feature = "http-client-curl"))]
61	CompiledWithoutHttp(scheme: git_url::Scheme) {
62	display("'{}' is not compiled in. Compile with the 'http-client-curl' cargo feature", scheme)
63	}
64	}
65	}	54	}
66	}	55	}
67		56