lael-labs/gitoxide

git-packetline/src/provider/mod.rs+4−0

         ReadWithSidebands::with_progress_handler(self, handle_progress)
     }
+    pub fn as_read_without_sidebands<F: FnMut(bool, &[u8])>(&mut self) -> ReadWithSidebands<T, F> {
+        ReadWithSidebands::without_progress_handler(self)
+    }
     pub fn as_read(&mut self) -> ReadWithSidebands<T, fn(bool, &[u8])> {
         ReadWithSidebands::new(self)
     }

git-packetline/src/provider/read.rs+10−0

@@ -54,6 +54,16 @@ where · 53 unmodified lines
54	}	54	}
55	}	55	}
56		56
		57	pub fn without_progress_handler(parent: &'a mut Provider<T>) -> Self {
		58	ReadWithSidebands {
		59	parent,
		60	handle_progress: None,
		61	buf: vec![0; MAX_DATA_LEN],
		62	pos: 0,
		63	cap: 0,
		64	}
		65	}
		66
57	pub fn set_progress_handler(&mut self, handle_progress: Option<F>) {	67	pub fn set_progress_handler(&mut self, handle_progress: Option<F>) {
58	self.handle_progress = handle_progress;	68	self.handle_progress = handle_progress;
59	}	69	}

git-transport/src/client/git/mod.rs+2−4

         &mut self,
         write_mode: client::WriteMode,
         on_drop: Vec<client::MessageKind>,
-        handle_progress: Option<client::HandleProgress>,
     ) -> Result<client::RequestWriter, client::Error> {
-        Ok(client::RequestWriter::new(
+        Ok(client::RequestWriter::new_from_bufread(
             &mut self.writer,
-            &mut self.line_provider,
+            Box::new(self.line_provider.as_read_without_sidebands()),
             write_mode,
             on_drop,
-            handle_progress,
         ))
     }
 }

git-transport/src/client/http/mod.rs+4−5

         &mut self,
         write_mode: client::WriteMode,
         on_drop: Vec<client::MessageKind>,
-        handle_progress: Option<client::HandleProgress>,
     ) -> Result<client::RequestWriter, client::Error> {
         let service = self.service.expect("handshake() must have been called first");
         let url = append_url(&self.url, service.as_str());
             "Expect:".into(),
         ];
         let PostResponse {
-            headers,
+            headers: _,
             body,
             post_body,
         } = self.http.post(&url, headers)?;
+        // TODO: combine header handling with body reader
         // <Transport<H>>::check_content_type(service, "result", headers)?;
         let line_provider = self
             .line_provider
             .as_mut()
             .expect("handshake to have been called first");
         line_provider.replace(body);
-        Ok(RequestWriter::new(
+        Ok(RequestWriter::new_from_bufread(
             post_body,
-            line_provider,
+            Box::new(line_provider.as_read_without_sidebands()),
             write_mode,
             on_drop,
-            handle_progress,
         ))
     }
 }

git-transport/src/client/mod.rs+10−26

 /// A type implementing `Write`, which when done can be transformed into a `Read` for obtaining the response.
 pub struct RequestWriter<'a> {
     pub(crate) writer: Box<dyn io::Write + 'a>,
-    pub(crate) reader: Box<dyn io::BufRead + 'a>,
+    pub(crate) reader: Box<dyn SetProgressHandlerBufRead + 'a>,
 }
 impl<'a> io::Write for RequestWriter<'a> {
 }
 impl<'a> RequestWriter<'a> {
-    pub fn new<R: io::Read, W: io::Write + 'a>(
-        writer: W,
-        line_provider: &'a mut git_packetline::Provider<R>,
-        write_mode: WriteMode,
-        on_drop: Vec<MessageKind>,
-        handle_progress: Option<HandleProgress>,
-    ) -> Self {
-        Self::new_from_bufread(
-            writer,
-            match handle_progress {
-                Some(handler) => Box::new(line_provider.as_read_with_sidebands(handler)),
-                None => Box::new(line_provider.as_read()),
-            },
-            write_mode,
-            on_drop,
-        )
-    }
     pub fn new_from_bufread<W: io::Write + 'a>(
         writer: W,
-        reader: Box<dyn io::BufRead + 'a>,
+        reader: Box<dyn SetProgressHandlerBufRead + 'a>,
         write_mode: WriteMode,
         on_drop: Vec<MessageKind>,
     ) -> Self {
     }
 }
+impl<'a> SetProgressHandlerBufRead for ResponseReader<'a> {
+    fn set_progress_handler(&mut self, handle_progress: Option<HandleProgress>) {
+        self.reader.set_progress_handler(handle_progress)
+    }
+}
 /// A type implementing `Read` to obtain the server response.
 pub struct ResponseReader<'a> {
-    reader: Box<dyn io::BufRead + 'a>,
+    reader: Box<dyn SetProgressHandlerBufRead + 'a>,
 }
 impl<'a> io::Read for ResponseReader<'a> {
     /// `send_mode` determines how calls to the `write(…)` method are interpreted, and `on_drop` determines what
     /// to do when the writer is consumed or dropped.
     /// If `handle_progress` is not None, it's function passed a text line without trailing LF from which progress information can be parsed.
-    fn request(
+    fn request(&mut self, write_mode: WriteMode, on_drop: Vec<MessageKind>) -> Result<RequestWriter, Error>;
-        &mut self,
-        write_mode: WriteMode,
-        on_drop: Vec<MessageKind>,
-        handle_progress: Option<HandleProgress>,
-    ) -> Result<RequestWriter, Error>;
 }

git-transport/tests/client/git.rs+14−12

 use crate::fixture_bytes;
 use bstr::ByteSlice;
+use git_transport::client::SetProgressHandlerBufRead;
 use git_transport::{
     client::{self, git, Transport},
     Protocol, Service,
     );
     drop(res);
-    let writer = c.request(client::WriteMode::Binary, Vec::new(), None)?;
+    let writer = c.request(client::WriteMode::Binary, Vec::new())?;
     assert_eq!(writer.into_read().lines().next().expect("exactly one line")?, "NAK");
-    let sidebands = Rc::new(RefCell::new(Vec::<String>::new()));
     let mut writer = c.request(
         client::WriteMode::OneLFTerminatedLinePerWriteCall,
         vec![client::MessageKind::Flush, client::MessageKind::Text(b"done")],
-        Some(Box::new({
-            let sb = sidebands.clone();
-            move |is_err, data| {
-                assert!(!is_err);
-                sb.deref()
-                    .borrow_mut()
-                    .push(std::str::from_utf8(data).expect("valid utf8").to_owned())
-            }
-        })),
     )?;
     writer.write_all(b"hello")?;
     writer.write_all(b"world")?;
     let mut reader = writer.into_read();
+    let messages = Rc::new(RefCell::new(Vec::<String>::new()));
+    reader.set_progress_handler(Some(Box::new({
+        let sb = messages.clone();
+        move |is_err, data| {
+            assert!(!is_err);
+            sb.deref()
+                .borrow_mut()
+                .push(std::str::from_utf8(data).expect("valid utf8").to_owned())
+        }
+    })));
     let mut pack = Vec::new();
     reader.read_to_end(&mut pack)?;
     assert_eq!(pack.len(), 876, "we receive the whole pack…");
     drop(reader);
-    let sidebands = Rc::try_unwrap(sidebands).expect("no other handle").into_inner();
+    let sidebands = Rc::try_unwrap(messages).expect("no other handle").into_inner();
     assert_eq!(sidebands.len(), 6, "…along with some status messages");
     assert_eq!(
         out.as_slice().as_bstr(),

git-transport/tests/client/http.rs+22−2

 use crate::fixture_bytes;
 use bstr::{ByteSlice, ByteVec};
+use git_transport::client::SetProgressHandlerBufRead;
 use git_transport::{client, client::http, client::SetServiceResponse, client::Transport, Protocol, Service};
 use std::{
+    cell::RefCell,
     error::Error,
     io::{self, BufRead, Read, Write},
     net::SocketAddr,
+    ops::Deref,
+    rc::Rc,
     time::Duration,
 };
         client::WriteMode::OneLFTerminatedLinePerWriteCall,
         // vec![client::MessageKind::Flush, client::MessageKind::Text(b"done")],
         Vec::new(),
-        None,
     )?;
     eprintln!("about to write data");
     writer.write_all(b"hello")?;
     let mut reader = writer.into_read();
     let mut line = String::new();
     reader.read_line(&mut line)?;
-    // TODO: switch to binary with progress and
+    assert_eq!(line, "NAK", "we received a NAK in text mode");
+    let messages = Rc::new(RefCell::new(Vec::<String>::new()));
+    reader.set_progress_handler(Some(Box::new({
+        let sb = messages.clone();
+        move |is_err, data| {
+            assert!(!is_err);
+            sb.deref()
+                .borrow_mut()
+                .push(std::str::from_utf8(data).expect("valid utf8").to_owned())
+        }
+    })));
+    let mut pack = Vec::new();
+    reader.read_to_end(&mut pack)?;
+    assert_eq!(pack.len(), 876, "we receive the whole pack…");
+    drop(reader);
+    let sidebands = Rc::try_unwrap(messages).expect("no other handle").into_inner();
+    assert_eq!(sidebands.len(), 6);
     assert_eq!(
         server.received_as_string(),
         "hello world with packet lines and on-drop flush and done"