First rough implementation of packet line writer

Author: Byron

README.md

@@ -123,6 +123,7 @@ Please see _'Development Status'_ for a listing of all crates and their capabili
   * [x] [V2 additions](https://github.com/git/git/blob/master/Documentation/technical/protocol-v2.txt#L35:L36)
   * [x] [side-band mode](https://github.com/git/git/blob/master/Documentation/technical/pack-protocol.txt#L467:L467)
   * [x] `Read` from packet line with (optional) progress support via sidebands
+  * [ ] `Write` with built-in packet line encoding
 
 ### git-transport
   * [ ] general purpose `connect(…)` for clients

git-packetline/src/lib.rs

@@ -34,10 +34,8 @@ pub mod read;
 #[doc(inline)]
 pub use read::Reader;
 
-pub mod write {
-    /// An implementor of `Write` which passes all input to an inner `Write` in packet line data encoding.
-    pub struct Writer {}
-}
+pub mod write;
+pub use write::Writer;
 
 pub mod decode;
 pub mod encode;

git-packetline/src/write.rs

@@ -0,0 +1,52 @@
+use std::io;
+
+/// An implementor of `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> {
+    pub inner: T,
+    binary: bool,
+}
+
+impl<T: io::Write> Writer<T> {
+    pub fn new(inner: T) -> Self {
+        Writer { inner, binary: true }
+    }
+    pub fn text_mode(mut self) -> Self {
+        self.binary = false;
+        self
+    }
+    pub fn binary_mode(mut self) -> Self {
+        self.binary = true;
+        self
+    }
+}
+
+impl<T: io::Write> io::Write for Writer<T> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        if buf.is_empty() {
+            return Err(io::Error::new(
+                io::ErrorKind::Other,
+                "empty packet lines are not permitted as '0004' is invalid",
+            ));
+        }
+
+        if self.binary {
+            crate::encode::data_to_write(buf, &mut self.inner)
+        } else {
+            crate::encode::text_to_write(buf, &mut self.inner)
+        }
+        .map_err(|err| {
+            use crate::encode::Error::*;
+            match err {
+                Io(err) => err,
+                DataIsEmpty | DataLengthLimitExceeded(_) => {
+                    unreachable!("We are handling empty and large data here, so this can't ever happen")
+                }
+            }
+        })
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.inner.flush()
+    }
+}

git-packetline/tests/packet_line/mod.rs

@@ -8,3 +8,4 @@ fn assert_err_display<T: std::fmt::Debug, E: std::error::Error>(res: Result<T, E
 mod decode;
 mod encode;
 mod read;
+mod write;

git-packetline/tests/packet_line/write.rs

@@ -0,0 +1,46 @@
+use bstr::ByteSlice;
+use git_packetline::Writer;
+use std::io::Write;
+
+const MAX_DATA_LEN: usize = 65516;
+const MAX_LINE_LEN: usize = 4 + MAX_DATA_LEN;
+
+#[test]
+fn each_write_results_in_one_line() -> crate::Result {
+    let mut w = Writer::new(Vec::new());
+    w.write(b"hello")?;
+    w.write(b"world!")?;
+    assert_eq!(w.inner.as_bstr(), b"0009hello000aworld!".as_bstr());
+    Ok(())
+}
+
+#[test]
+fn write_text_and_write_binary() -> crate::Result {
+    let mut w = Writer::new(Vec::new()).text_mode();
+    w.write(b"hello")?;
+    w = w.binary_mode();
+    w.write(b"world")?;
+    assert_eq!(w.inner.as_bstr(), b"000ahello\n0009world".as_bstr());
+    Ok(())
+}
+
+#[test]
+fn huge_writes_are_split_into_lines() -> crate::Result {
+    let data = {
+        let mut v = Vec::new();
+        v.resize(MAX_DATA_LEN * 2, 0);
+        v
+    };
+    let mut w = Writer::new(Vec::new());
+    w.write(&data)?;
+    assert_eq!(w.inner.len(), MAX_LINE_LEN * 2);
+    Ok(())
+}
+
+#[test]
+fn empty_writes_fail_with_error() {
+    assert_eq!(
+        Writer::new(Vec::new()).write(&[]).unwrap_err().to_string(),
+        "empty packet lines are not permitted as '0004' is invalid"
+    )
+}

tasks.md

@@ -12,6 +12,7 @@
       * [x] Disable sideband support (e.g. github http V2 doesn't have it)
     * [x] don't coerce line delimiters into empty slices.
     * [x] Make 'ERR <error>' handling as error optional, as it may occur only in certain contexts.
+    * [ ] `Write` with packet line encoding
   * **git-url**
     * [ ] parse into components to make them easy to understand
   * **connect**