feat!: large portions of the API for greater ease of use

Author: djc

gix-filter/src/driver/process/client.rs

@@ -1,6 +1,7 @@
 use std::{collections::HashSet, io::Write, str::FromStr};
 
 use bstr::{BStr, BString, ByteVec};
+use gix_packetline::blocking_io::{encode, StreamingPeekableIter, Writer};
 
 use crate::driver::{
     process,
@@ -65,17 +66,15 @@ impl Client {
         versions: &[usize],
         desired_capabilities: &[&str],
     ) -> Result<Self, handshake::Error> {
-        let mut out = gix_packetline::write::blocking_io::Writer::new(
-            process.stdin.take().expect("configured stdin when spawning"),
-        );
+        let mut out = Writer::new(process.stdin.take().expect("configured stdin when spawning"));
         out.write_all(format!("{welcome_prefix}-client").as_bytes())?;
         for version in versions {
             out.write_all(format!("version={version}").as_bytes())?;
         }
-        gix_packetline::encode::blocking_io::flush_to_write(out.inner_mut())?;
+        encode::flush_to_write(out.inner_mut())?;
         out.flush()?;
 
-        let mut input = gix_packetline::read::blocking_io::StreamingPeekableIter::new(
+        let mut input = StreamingPeekableIter::new(
             process.stdout.take().expect("configured stdout when spawning"),
             &[gix_packetline::PacketLineRef::Flush],
             false, /* packet tracing */
@@ -127,7 +126,7 @@ impl Client {
         for capability in desired_capabilities {
             out.write_all(format!("capability={capability}").as_bytes())?;
         }
-        gix_packetline::encode::blocking_io::flush_to_write(out.inner_mut())?;
+        encode::flush_to_write(out.inner_mut())?;
         out.flush()?;
 
         read.reset_with(&[gix_packetline::PacketLineRef::Flush]);
@@ -169,7 +168,7 @@ impl Client {
     ) -> Result<process::Status, invoke::Error> {
         self.send_command_and_meta(command, meta)?;
         std::io::copy(content, &mut self.input)?;
-        gix_packetline::encode::blocking_io::flush_to_write(self.input.inner_mut())?;
+        encode::flush_to_write(self.input.inner_mut())?;
         self.input.flush()?;
         Ok(self.read_status()?)
     }
@@ -227,7 +226,7 @@ impl Client {
             buf.push_str(&value);
             self.input.write_all(&buf)?;
         }
-        gix_packetline::encode::blocking_io::flush_to_write(self.input.inner_mut())?;
+        encode::flush_to_write(self.input.inner_mut())?;
         Ok(())
     }
 }

gix-filter/src/driver/process/mod.rs

@@ -1,5 +1,7 @@
 use std::collections::HashSet;
 
+use gix_packetline::blocking_io::{StreamingPeekableIter, WithSidebands, Writer};
+
 /// A set of capabilities that have been negotiated between client and server.
 pub type Capabilities = HashSet<String>;
 
@@ -12,9 +14,9 @@ pub struct Client {
     /// The negotiated version of the protocol.
     version: usize,
     /// A way to send packet-line encoded information to the process.
-    input: gix_packetline::write::blocking_io::Writer<std::process::ChildStdin>,
+    input: Writer<std::process::ChildStdin>,
     /// A way to read information sent to us by the process.
-    out: gix_packetline::read::blocking_io::StreamingPeekableIter<std::process::ChildStdout>,
+    out: StreamingPeekableIter<std::process::ChildStdout>,
 }
 
 /// A handle to facilitate typical server interactions that include the handshake and command-invocations.
@@ -24,9 +26,9 @@ pub struct Server {
     /// The negotiated version of the protocol, it's the highest supported one.
     version: usize,
     /// A way to receive information from the client.
-    input: gix_packetline::read::blocking_io::StreamingPeekableIter<std::io::StdinLock<'static>>,
+    input: StreamingPeekableIter<std::io::StdinLock<'static>>,
     /// A way to send information to the client.
-    out: gix_packetline::write::blocking_io::Writer<std::io::StdoutLock<'static>>,
+    out: Writer<std::io::StdoutLock<'static>>,
 }
 
 /// The return status of an [invoked command][Client::invoke()].
@@ -110,4 +112,4 @@ pub mod client;
 pub mod server;
 
 type PacketlineReader<'a, T = std::process::ChildStdout> =
-    gix_packetline::read::blocking_io::WithSidebands<'a, T, fn(bool, &[u8]) -> gix_packetline::read::ProgressAction>;
+    WithSidebands<'a, T, fn(bool, &[u8]) -> gix_packetline::read::ProgressAction>;

gix-filter/src/driver/process/server.rs

@@ -1,6 +1,7 @@
 use std::{collections::HashSet, io::Write, str::FromStr};
 
 use bstr::{BString, ByteSlice};
+use gix_packetline::blocking_io::{encode, StreamingPeekableIter, Writer};
 
 use crate::driver::process::Server;
 
@@ -63,7 +64,7 @@ impl Server {
         pick_version: &mut dyn FnMut(&[usize]) -> Option<usize>,
         available_capabilities: &[&str],
     ) -> Result<Self, handshake::Error> {
-        let mut input = gix_packetline::read::blocking_io::StreamingPeekableIter::new(
+        let mut input = StreamingPeekableIter::new(
             stdin.lock(),
             &[gix_packetline::PacketLineRef::Flush],
             false, /* packet tracing */
@@ -105,10 +106,10 @@ impl Server {
         }
         let version = pick_version(&versions).ok_or(handshake::Error::VersionMismatch { actual: versions })?;
         read.reset_with(&[gix_packetline::PacketLineRef::Flush]);
-        let mut out = gix_packetline::write::blocking_io::Writer::new(stdout.lock());
+        let mut out = Writer::new(stdout.lock());
         out.write_all(format!("{welcome_prefix}-server").as_bytes())?;
         out.write_all(format!("version={version}").as_bytes())?;
-        gix_packetline::encode::blocking_io::flush_to_write(out.inner_mut())?;
+        encode::flush_to_write(out.inner_mut())?;
         out.flush()?;
 
         let mut capabilities = HashSet::new();
@@ -132,7 +133,7 @@ impl Server {
         for cap in &capabilities {
             out.write_all(format!("capability={cap}").as_bytes())?;
         }
-        gix_packetline::encode::blocking_io::flush_to_write(out.inner_mut())?;
+        encode::flush_to_write(out.inner_mut())?;
         out.flush()?;
 
         drop(read);
@@ -209,6 +210,8 @@ impl Server {
 mod request {
     use std::io::Write;
 
+    use gix_packetline::blocking_io::{encode, Writer};
+
     use crate::driver::{
         process,
         process::{server::Request, PacketlineReader},
@@ -233,7 +236,7 @@ mod request {
             if let Some(message) = status.message() {
                 out.write_all(format!("status={message}").as_bytes())?;
             }
-            gix_packetline::encode::blocking_io::flush_to_write(out.inner_mut())?;
+            encode::flush_to_write(out.inner_mut())?;
             out.flush()
         }
     }
@@ -248,7 +251,7 @@ mod request {
     }
 
     struct WriteAndFlushOnDrop<'a> {
-        inner: &'a mut gix_packetline::write::blocking_io::Writer<std::io::StdoutLock<'static>>,
+        inner: &'a mut Writer<std::io::StdoutLock<'static>>,
     }
 
     impl std::io::Write for WriteAndFlushOnDrop<'_> {
@@ -263,7 +266,7 @@ mod request {
 
     impl Drop for WriteAndFlushOnDrop<'_> {
         fn drop(&mut self) {
-            gix_packetline::encode::blocking_io::flush_to_write(self.inner.inner_mut()).ok();
+            encode::flush_to_write(self.inner.inner_mut()).ok();
             self.inner.flush().ok();
         }
     }

gix-packetline/src/encode/async_io.rs renamed to gix-packetline/src/async_io/encode.rs

@@ -7,10 +7,10 @@ use std::{
 use futures_io::AsyncWrite;
 use futures_lite::AsyncWriteExt;
 
-use super::u16_to_hex;
 use crate::{
-    encode::Error, BandRef, Channel, ErrorRef, PacketLineRef, TextRef, DELIMITER_LINE, ERR_PREFIX, FLUSH_LINE,
-    MAX_DATA_LEN, RESPONSE_END_LINE,
+    encode::{u16_to_hex, Error},
+    BandRef, Channel, ErrorRef, PacketLineRef, TextRef, DELIMITER_LINE, ERR_PREFIX, FLUSH_LINE, MAX_DATA_LEN,
+    RESPONSE_END_LINE,
 };
 
 pin_project_lite::pin_project! {

gix-packetline/src/read/async_io.rs renamed to gix-packetline/src/async_io/read.rs

@@ -7,7 +7,7 @@ use bstr::ByteSlice;
 use futures_io::AsyncRead;
 use futures_lite::AsyncReadExt;
 
-pub use super::sidebands::async_io::WithSidebands;
+pub use super::sidebands::WithSidebands;
 use crate::{
     decode,
     read::{ExhaustiveOutcome, ProgressAction},

gix-packetline/src/read/sidebands/async_io.rs renamed to gix-packetline/src/async_io/sidebands.rs

@@ -6,7 +6,7 @@ use std::{
 
 use futures_io::{AsyncBufRead, AsyncRead};
 
-use crate::read::async_io::StreamingPeekableIter;
+use super::read::StreamingPeekableIter;
 use crate::{decode, read::ProgressAction, BandRef, PacketLineRef, TextRef, U16_HEX_BYTES};
 
 type ReadLineResult<'a> = Option<std::io::Result<Result<PacketLineRef<'a>, decode::Error>>>;

gix-packetline/src/write/async_io.rs renamed to gix-packetline/src/async_io/write.rs

@@ -6,14 +6,15 @@ use std::{
 
 use futures_io::AsyncWrite;
 
-use crate::{encode, MAX_DATA_LEN, U16_HEX_BYTES};
+use super::encode::LineWriter;
+use crate::{MAX_DATA_LEN, U16_HEX_BYTES};
 
 pin_project_lite::pin_project! {
     /// An implementor of [`Write`][io::Write] which passes all input to an inner `Write` in packet line data encoding,
     /// one line per `write(…)` call or as many lines as it takes if the data doesn't fit into the maximum allowed line length.
     pub struct Writer<T> {
         #[pin]
-        inner: encode::async_io::LineWriter<'static, T>,
+        inner: LineWriter<'static, T>,
         state: State,
     }
 }
@@ -27,7 +28,7 @@ impl<T: AsyncWrite + Unpin> Writer<T> {
     /// Create a new instance from the given `write`
     pub fn new(write: T) -> Self {
         Writer {
-            inner: encode::async_io::LineWriter::new(write, &[], &[]),
+            inner: LineWriter::new(write, &[], &[]),
             state: State::Idle,
         }
     }

gix-packetline/src/encode/blocking_io.rs renamed to gix-packetline/src/blocking_io/encode.rs

@@ -1,9 +1,9 @@
 use std::io;
 
-use super::u16_to_hex;
 use crate::{
-    encode::Error, BandRef, Channel, ErrorRef, PacketLineRef, TextRef, DELIMITER_LINE, ERR_PREFIX, FLUSH_LINE,
-    MAX_DATA_LEN, RESPONSE_END_LINE,
+    encode::{u16_to_hex, Error},
+    BandRef, Channel, ErrorRef, PacketLineRef, TextRef, DELIMITER_LINE, ERR_PREFIX, FLUSH_LINE, MAX_DATA_LEN,
+    RESPONSE_END_LINE,
 };
 
 /// Write a response-end message to `out`.

gix-packetline/src/read/blocking_io.rs renamed to gix-packetline/src/blocking_io/read.rs

@@ -5,11 +5,11 @@ use std::{
 
 use bstr::ByteSlice;
 
-pub use super::sidebands::blocking_io::WithSidebands;
+pub use super::sidebands::WithSidebands;
 use crate::{
     decode,
-    read::{ExhaustiveOutcome, ProgressAction},
-    PacketLineRef, StreamingPeekableIterState, MAX_LINE_LEN, U16_HEX_BYTES,
+    read::{ExhaustiveOutcome, ProgressAction, StreamingPeekableIterState},
+    PacketLineRef, MAX_LINE_LEN, U16_HEX_BYTES,
 };
 
 /// Read pack lines one after another, without consuming more than needed from the underlying

gix-packetline/src/read/sidebands/blocking_io.rs renamed to gix-packetline/src/blocking_io/sidebands.rs

@@ -1,9 +1,7 @@
 use std::{io, io::BufRead};
 
-use crate::{
-    read::{blocking_io::StreamingPeekableIter, ProgressAction},
-    BandRef, PacketLineRef, TextRef, U16_HEX_BYTES,
-};
+use super::read::StreamingPeekableIter;
+use crate::{read::ProgressAction, BandRef, PacketLineRef, TextRef, U16_HEX_BYTES};
 
 /// An implementor of [`BufRead`][io::BufRead] yielding packet lines on each call to [`read_line()`][io::BufRead::read_line()].
 /// It's also possible to hide the underlying packet lines using the [`Read`][io::Read] implementation which is useful