[git-packetline] refactor

Author: Byron

git-packetline/src/lib.rs

@@ -29,9 +29,9 @@ pub mod immutable;
 pub use immutable::PacketLine;
 
 ///
-pub mod provider;
+pub mod read;
 #[doc(inline)]
-pub use provider::Provider;
+pub use read::StreamingPeekReader;
 
 ///
 pub mod write;

git-packetline/src/provider/mod.rs renamed to git-packetline/src/read/mod.rs

@@ -2,13 +2,13 @@ use crate::{decode, PacketLine, MAX_LINE_LEN, U16_HEX_BYTES};
 use bstr::ByteSlice;
 use std::io;
 
-mod read;
-pub use read::ReadWithSidebands;
+mod sidebands;
+pub use sidebands::WithSidebands;
 
 /// Read pack lines one after another, without consuming more than needed from the underlying
 /// [`Read`][io::Read]. [`Flush`][PacketLine::Flush] lines cause the reader to stop producing lines forever,
 /// leaving [`Read`][io::Read] at the start of whatever comes next.
-pub struct Provider<T> {
+pub struct StreamingPeekReader<T> {
     inner: T,
     peek_buf: Vec<u8>,
     fail_on_err_lines: bool,
@@ -18,13 +18,13 @@ pub struct Provider<T> {
     stopped_at: Option<PacketLine<'static>>,
 }
 
-impl<T> Provider<T>
+impl<T> StreamingPeekReader<T>
 where
     T: io::Read,
 {
     /// Return a new instance from `read` which will stop decoding packet lines when receiving one of the given `delimiters`.
     pub fn new(read: T, delimiters: &'static [PacketLine<'static>]) -> Self {
-        Provider {
+        StreamingPeekReader {
             inner: read,
             buf: vec![0; MAX_LINE_LEN],
             peek_buf: Vec::new(),
@@ -192,22 +192,22 @@ where
     /// being true in case the `text` is to be interpreted as error.
     ///
     /// _Please note_ that side bands need to be negotiated with the server.
-    pub fn as_read_with_sidebands<F: FnMut(bool, &[u8])>(&mut self, handle_progress: F) -> ReadWithSidebands<'_, T, F> {
-        ReadWithSidebands::with_progress_handler(self, handle_progress)
+    pub fn as_read_with_sidebands<F: FnMut(bool, &[u8])>(&mut self, handle_progress: F) -> WithSidebands<'_, T, F> {
+        WithSidebands::with_progress_handler(self, handle_progress)
     }
 
     /// Same as [`as_read_with_sidebands(…)`][Provider::as_read_with_sidebands()], but for channels without side band support.
     ///
     /// The type parameter `F` needs to be configured for this method to be callable using the 'turbofish' operator.
     /// Use [`as_read()`][Provider::as_read()].
-    pub fn as_read_without_sidebands<F: FnMut(bool, &[u8])>(&mut self) -> ReadWithSidebands<'_, T, F> {
-        ReadWithSidebands::without_progress_handler(self)
+    pub fn as_read_without_sidebands<F: FnMut(bool, &[u8])>(&mut self) -> WithSidebands<'_, T, F> {
+        WithSidebands::without_progress_handler(self)
     }
 
     /// Same as [`as_read_with_sidebands(…)`][Provider::as_read_with_sidebands()], but for channels without side band support.
     ///
     /// Due to the preconfigured function type this method can be called without 'turbofish'.
-    pub fn as_read(&mut self) -> ReadWithSidebands<'_, T, fn(bool, &[u8])> {
-        ReadWithSidebands::new(self)
+    pub fn as_read(&mut self) -> WithSidebands<'_, T, fn(bool, &[u8])> {
+        WithSidebands::new(self)
     }
 }

git-packetline/src/provider/read.rs renamed to git-packetline/src/read/sidebands.rs

@@ -1,6 +1,6 @@
 use crate::{
     immutable::{Band, Text},
-    PacketLine, Provider, MAX_DATA_LEN,
+    PacketLine, StreamingPeekReader, MAX_DATA_LEN,
 };
 use std::io;
 
@@ -12,18 +12,18 @@ use std::io;
 /// Reading from this intermediary copies bytes 3 times:
 /// OS -> (parent) line provider buffer -> our buffer -> caller's output buffer
 /// which won't make this very efficient for huge bandwidths.
-pub struct ReadWithSidebands<'a, T, F>
+pub struct WithSidebands<'a, T, F>
 where
     T: io::Read,
 {
-    parent: &'a mut Provider<T>,
+    parent: &'a mut StreamingPeekReader<T>,
     handle_progress: Option<F>,
     buf: Vec<u8>,
     pos: usize,
     cap: usize,
 }
 
-impl<'a, T, F> Drop for ReadWithSidebands<'a, T, F>
+impl<'a, T, F> Drop for WithSidebands<'a, T, F>
 where
     T: io::Read,
 {
@@ -32,13 +32,13 @@ where
     }
 }
 
-impl<'a, T> ReadWithSidebands<'a, T, fn(bool, &[u8])>
+impl<'a, T> WithSidebands<'a, T, fn(bool, &[u8])>
 where
     T: io::Read,
 {
     /// Create a new instance with the given provider as `parent`.
-    pub fn new(parent: &'a mut Provider<T>) -> Self {
-        ReadWithSidebands {
+    pub fn new(parent: &'a mut StreamingPeekReader<T>) -> Self {
+        WithSidebands {
             parent,
             handle_progress: None,
             buf: vec![0; MAX_DATA_LEN],
@@ -48,7 +48,7 @@ where
     }
 }
 
-impl<'a, T, F> ReadWithSidebands<'a, T, F>
+impl<'a, T, F> WithSidebands<'a, T, F>
 where
     T: io::Read,
     F: FnMut(bool, &[u8]),
@@ -57,8 +57,8 @@ where
     ///
     /// Progress or error information will be passed to the given `handle_progress(is_error, text)` function, with `is_error: bool`
     /// being true in case the `text` is to be interpreted as error.
-    pub fn with_progress_handler(parent: &'a mut Provider<T>, handle_progress: F) -> Self {
-        ReadWithSidebands {
+    pub fn with_progress_handler(parent: &'a mut StreamingPeekReader<T>, handle_progress: F) -> Self {
+        WithSidebands {
             parent,
             handle_progress: Some(handle_progress),
             buf: vec![0; MAX_DATA_LEN],
@@ -68,8 +68,8 @@ where
     }
 
     /// Create a new instance without a progress handler.
-    pub fn without_progress_handler(parent: &'a mut Provider<T>) -> Self {
-        ReadWithSidebands {
+    pub fn without_progress_handler(parent: &'a mut StreamingPeekReader<T>) -> Self {
+        WithSidebands {
             parent,
             handle_progress: None,
             buf: vec![0; MAX_DATA_LEN],
@@ -105,7 +105,7 @@ where
     }
 }
 
-impl<'a, T, F> io::BufRead for ReadWithSidebands<'a, T, F>
+impl<'a, T, F> io::BufRead for WithSidebands<'a, T, F>
 where
     T: io::Read,
     F: FnMut(bool, &[u8]),
@@ -173,7 +173,7 @@ where
     }
 }
 
-impl<'a, T, F> io::Read for ReadWithSidebands<'a, T, F>
+impl<'a, T, F> io::Read for WithSidebands<'a, T, F>
 where
     T: io::Read,
     F: FnMut(bool, &[u8]),

git-packetline/tests/packet_line/decode.rs renamed to git-packetline/tests/decode/mod.rs

@@ -1,9 +1,9 @@
 mod streaming {
-    use crate::packet_line::assert_err_display;
+    use crate::assert_err_display;
     use bstr::ByteSlice;
-    use git_packetline::immutable::Error;
     use git_packetline::{
         decode::{self, streaming, Stream},
+        immutable::Error,
         Channel, PacketLine,
     };
 

git-packetline/tests/packet_line/encode.rs renamed to git-packetline/tests/encode/mod.rs

@@ -1,5 +1,5 @@
 mod data_to_write {
-    use crate::packet_line::assert_err_display;
+    use crate::assert_err_display;
     use bstr::ByteSlice;
     use git_packetline::encode::{
         data_to_write, delim_to_write, error_to_write, flush_to_write, response_end_to_write, text_to_write,

git-packetline/tests/packet_line/mod.rs

@@ -1,3 +1,16 @@
 pub type Result = std::result::Result<(), Box<dyn std::error::Error>>;
 
-mod packet_line;
+fn assert_err_display<T: std::fmt::Debug, E: std::error::Error>(
+    res: std::result::Result<T, E>,
+    expected: impl AsRef<str>,
+) {
+    match res {
+        Ok(v) => assert!(false, "Expected error '{}', got value {:?}", expected.as_ref(), v),
+        Err(err) => assert_eq!(err.to_string(), expected.as_ref()),
+    }
+}
+
+mod decode;
+mod encode;
+mod read;
+mod write;