packet line encoding with flush support

Author: Byron

Cargo.lock

@@ -7,6 +7,13 @@ description = "A WIP crate of the gitoxide project for implementing git protocol
 authors = ["Sebastian Thiel <[email protected]>"]
 edition = "2018"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+doctest = false
 
 [dependencies]
+quick-error = "2.0.0"
+hex = "0.4.2"
+
+[dev-dependencies]
+bstr = { version = "0.2.13", default-features = false, features = ["std"] }

git-protocol/Cargo.toml

@@ -1 +1,3 @@
 #![forbid(unsafe_code)]
+
+pub mod packet_line;

git-protocol/src/lib.rs

@@ -0,0 +1,42 @@
+pub mod encode {
+    use quick_error::quick_error;
+    use std::io;
+
+    const MAX_DATA_LEN: usize = 65516;
+
+    quick_error! {
+        #[derive(Debug)]
+        pub enum Error {
+            Io(err: io::Error) {
+                display("An error occurred while writing")
+                from()
+                source(err)
+            }
+            DataLengthLimitExceeded(length_in_bytes: usize) {
+                display("Cannot encode more than {} bytes, got {}", MAX_DATA_LEN, length_in_bytes)
+            }
+            DataIsEmpty {
+                display("Empty lines are invalid")
+            }
+        }
+    }
+    pub fn flush_to_write(mut out: impl io::Write) -> io::Result<usize> {
+        out.write_all(b"0000").map(|_| 4)
+    }
+
+    pub fn data_to_write(data: &[u8], mut out: impl io::Write) -> Result<usize, Error> {
+        if data.len() > MAX_DATA_LEN {
+            return Err(Error::DataLengthLimitExceeded(data.len()));
+        }
+        if data.is_empty() {
+            return Err(Error::DataIsEmpty);
+        }
+
+        let mut buf = [0u8; 4];
+        let data_len = data.len() + 4;
+        hex::encode_to_slice((data_len as u16).to_be_bytes(), &mut buf).expect("two bytes to 4 hex chars never fails");
+        out.write_all(&buf)?;
+        out.write_all(data)?;
+        Ok(data_len)
+    }
+}

git-protocol/src/packet_line.rs

@@ -0,0 +1,52 @@
+mod encode {
+    mod data_to_write {
+        use bstr::ByteSlice;
+        use git_protocol::packet_line::encode::{data_to_write, flush_to_write};
+        use std::io;
+
+        fn vec_sized(size: usize) -> Vec<u8> {
+            let mut v = Vec::new();
+            v.resize(size, 0);
+            v
+        }
+
+        fn assert_err_display<T, E: std::error::Error>(res: Result<T, E>, expected: impl AsRef<str>) {
+            match res {
+                Ok(_) => assert!(false, "Expected error '{}', got value", expected.as_ref()),
+                Err(err) => assert_eq!(err.to_string(), expected.as_ref()),
+            }
+        }
+
+        #[test]
+        fn success_binary_and_non_binary() -> crate::Result {
+            let mut out = Vec::new();
+            assert_eq!(data_to_write(b"\0", &mut out)?, 5);
+            assert_eq!(out.as_bstr(), b"0005\0".as_bstr());
+
+            out.clear();
+            assert_eq!(data_to_write("hello world, it works\n".as_bytes(), &mut out)?, 26);
+            assert_eq!(out.as_bstr(), b"001ahello world, it works\n".as_bstr());
+            Ok(())
+        }
+
+        #[test]
+        fn success_flush() -> crate::Result {
+            let mut out = Vec::new();
+            assert_eq!(flush_to_write(&mut out)?, 4);
+            assert_eq!(out.as_bstr(), b"0000".as_bstr());
+            Ok(())
+        }
+
+        #[test]
+        fn error_if_data_exceeds_limit() {
+            assert_err_display(
+                data_to_write(&vec_sized(65516 + 1), io::sink()),
+                "Cannot encode more than 65516 bytes, got 65517",
+            );
+        }
+        #[test]
+        fn error_if_data_is_empty() {
+            assert_err_display(data_to_write(&[], io::sink()), "Empty lines are invalid");
+        }
+    }
+}

git-protocol/tests/packet_line/mod.rs

@@ -0,0 +1,3 @@
+pub type Result = std::result::Result<(), Box<dyn std::error::Error>>;
+
+mod packet_line;

git-protocol/tests/protocol.rs

@@ -6,6 +6,7 @@
     * to be used to obtain more real-world samples of typical git interactions for use in the test-suite
   * **git-protocol**
     * [ ] parse pkt-lines support
+      * [x] encoding including flush lines
     * [ ] basic V1 parsing to understand data frames to allow placing them into individual files
 * **a way to intercept git-http communication**
   * Maybe with a custom proxy as well, can't hurt to try APIs in real-world programs