[clone] decouple packet line from git-features and progress

Now all progress handling can truly be done where it is known:
in the protocol layer

Author: Byron

Cargo.lock

@@ -17,7 +17,6 @@ serde1 = ["serde", "bstr/serde1"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-git-features = { version = "^0.4.0", path = "../git-features" }
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["std", "derive"]}
 quick-error = "2.0.0"
 hex = "0.4.2"

git-packetline/Cargo.toml

@@ -15,18 +15,6 @@ pub enum Channel {
     Error = 3,
 }
 
-/// The information usually found in remote progress messages as sent by a git server during
-/// fetch, clone and push.
-#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
-#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
-pub struct RemoteProgress<'a> {
-    #[cfg_attr(feature = "serde1", serde(borrow))]
-    pub action: &'a bstr::BStr,
-    pub percent: Option<u32>,
-    pub step: Option<usize>,
-    pub max: Option<usize>,
-}
-
 pub mod borrowed;
 pub use borrowed::Borrowed as PacketLine;
 

git-packetline/src/lib.rs

@@ -1,11 +1,10 @@
+use crate::PacketLine;
 use crate::{decode, MAX_LINE_LEN, U16_HEX_BYTES};
-use crate::{PacketLine, RemoteProgress};
 use bstr::ByteSlice;
-use git_features::{progress, progress::Progress};
 use std::io;
 
 mod read;
-pub use read::ReadWithProgress;
+pub use read::ReadWithSidebands;
 
 /// Read pack lines one after another, without consuming more than needed from the underlying
 /// `Read`. `Flush` lines cause the reader to stop producing lines forever, leaving `Read` at the
@@ -141,15 +140,11 @@ where
         })
     }
 
-    pub fn as_read_with_sidebands<P: Progress>(
-        &mut self,
-        progress: P,
-        parse_progress: fn(&[u8]) -> Option<RemoteProgress>,
-    ) -> ReadWithProgress<T, P> {
-        ReadWithProgress::with_progress(self, progress, parse_progress)
+    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(&mut self) -> ReadWithProgress<T, progress::Discard> {
-        ReadWithProgress::new(self)
+    pub fn as_read(&mut self) -> ReadWithSidebands<T, fn(bool, &[u8])> {
+        ReadWithSidebands::new(self)
     }
 }

git-packetline/src/reader/mod.rs

@@ -1,25 +1,21 @@
 use crate::{
     borrowed::{Band, Text},
-    Reader, RemoteProgress, MAX_DATA_LEN,
+    Reader, MAX_DATA_LEN,
 };
-use bstr::ByteSlice;
-use git_features::{progress, progress::Progress};
 use std::io;
 
-type ProgressAndParser<P> = (P, fn(&[u8]) -> Option<RemoteProgress>);
-
-pub struct ReadWithProgress<'a, T, P>
+pub struct ReadWithSidebands<'a, T, F>
 where
     T: io::Read,
 {
     parent: &'a mut Reader<T>,
-    progress_and_parse: Option<ProgressAndParser<P>>,
+    handle_progress: Option<F>,
     buf: Vec<u8>,
     pos: usize,
     cap: usize,
 }
 
-impl<'a, T, P> Drop for ReadWithProgress<'a, T, P>
+impl<'a, T, F> Drop for ReadWithSidebands<'a, T, F>
 where
     T: io::Read,
 {
@@ -28,45 +24,41 @@ where
     }
 }
 
-impl<'a, T> ReadWithProgress<'a, T, progress::Discard>
+impl<'a, T> ReadWithSidebands<'a, T, fn(bool, &[u8])>
 where
     T: io::Read,
 {
     pub fn new(parent: &'a mut Reader<T>) -> Self {
-        ReadWithProgress {
+        ReadWithSidebands {
             parent,
-            progress_and_parse: None,
+            handle_progress: None,
             buf: vec![0; MAX_DATA_LEN],
             pos: 0,
             cap: 0,
         }
     }
 }
 
-impl<'a, T, P> ReadWithProgress<'a, T, P>
+impl<'a, T, F> ReadWithSidebands<'a, T, F>
 where
     T: io::Read,
-    P: Progress,
+    F: FnMut(bool, &[u8]),
 {
-    pub fn with_progress(
-        parent: &'a mut Reader<T>,
-        progress: P,
-        parse_progress: fn(&[u8]) -> Option<RemoteProgress>,
-    ) -> Self {
-        ReadWithProgress {
+    pub fn with_progress_handler(parent: &'a mut Reader<T>, handle_progress: F) -> Self {
+        ReadWithSidebands {
             parent,
-            progress_and_parse: Some((progress, parse_progress)),
+            handle_progress: Some(handle_progress),
             buf: vec![0; MAX_DATA_LEN],
             pos: 0,
             cap: 0,
         }
     }
 }
 
-impl<'a, T, P> io::BufRead for ReadWithProgress<'a, T, P>
+impl<'a, T, F> io::BufRead for ReadWithSidebands<'a, T, F>
 where
     T: io::Read,
-    P: Progress,
+    F: FnMut(bool, &[u8]),
 {
     fn fill_buf(&mut self) -> io::Result<&[u8]> {
         use io::Read;
@@ -77,38 +69,21 @@ where
                     Some(line) => line?.map_err(|err| io::Error::new(io::ErrorKind::Other, err))?,
                     None => break 0,
                 };
-                match self.progress_and_parse.as_mut() {
-                    Some((progress, parse_progress)) => {
+                match self.handle_progress.as_mut() {
+                    Some(handle_progress) => {
                         let mut band = line
                             .decode_band()
                             .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
-                        fn progress_name(current: Option<String>, action: &[u8]) -> String {
-                            match current {
-                                Some(current) => format!("{}: {}", current, action.as_bstr()),
-                                None => action.as_bstr().to_string(),
-                            }
-                        }
                         match band {
                             Band::Data(ref mut d) => break d.read(&mut self.buf)?,
                             Band::Progress(d) => {
                                 let text = Text::from(d).0;
-                                match (parse_progress)(text) {
-                                    Some(RemoteProgress {
-                                        action,
-                                        percent: _,
-                                        step,
-                                        max,
-                                    }) => {
-                                        progress.set_name(progress_name(progress.name(), action));
-                                        progress.init(max, git_features::progress::count("objects"));
-                                        if let Some(step) = step {
-                                            progress.set(step);
-                                        }
-                                    }
-                                    None => progress.set_name(progress_name(progress.name(), text)),
-                                };
+                                (handle_progress)(false, text);
+                            }
+                            Band::Error(d) => {
+                                let text = Text::from(d).0;
+                                (handle_progress)(true, text);
                             }
-                            Band::Error(d) => progress.fail(progress_name(None, Text::from(d).as_slice())),
                         };
                     }
                     None => {
@@ -134,10 +109,10 @@ where
     }
 }
 
-impl<'a, T, P> io::Read for ReadWithProgress<'a, T, P>
+impl<'a, T, F> io::Read for ReadWithSidebands<'a, T, F>
 where
     T: io::Read,
-    P: Progress,
+    F: FnMut(bool, &[u8]),
 {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         use std::io::BufRead;

git-packetline/src/reader/read.rs

@@ -1,7 +1,6 @@
 use bstr::ByteSlice;
 use git_packetline::PacketLine;
-use std::io;
-use std::path::PathBuf;
+use std::{io, path::PathBuf};
 
 fn fixture_path(path: &str) -> PathBuf {
     PathBuf::from("tests/fixtures").join(path)
@@ -15,7 +14,6 @@ mod to_read {
     use crate::packet_line::read::fixture_bytes;
     use bstr::ByteSlice;
     use git_odb::pack;
-    use git_packetline::RemoteProgress;
     use std::io::Read;
 
     #[test]
@@ -37,10 +35,8 @@ mod to_read {
                 .as_bstr(),
             b"NAK".as_bstr()
         );
-        fn no_parsing(_: &[u8]) -> Option<RemoteProgress> {
-            None
-        }
-        let pack_read = rd.as_read_with_sidebands(git_features::progress::Discard, no_parsing);
+        fn do_nothing(_is_err: bool, _data: &[u8]) {}
+        let pack_read = rd.as_read_with_sidebands(do_nothing);
         let pack_entries = pack::data::Iter::new_from_header(
             pack_read,
             pack::data::iter::Mode::Verify,