refactor

Author: Byron

git-protocol/src/packet_line.rs

@@ -0,0 +1 @@
+// pub fn decode(data: &[u8]) -> Result<>

git-protocol/src/packet_line/decode.rs

@@ -0,0 +1,40 @@
+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/encode.rs

@@ -0,0 +1,2 @@
+pub mod decode;
+pub mod encode;

git-protocol/src/packet_line/mod.rs

@@ -0,0 +1,50 @@
+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/decode.rs

@@ -1,52 +1,2 @@
-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");
-        }
-    }
-}
+mod decode;
+mod encode;

git-protocol/tests/packet_line/encode.rs

@@ -5,8 +5,9 @@
     * `PATH="$PWD:$PATH" git -c core.gitproxy="git-proxy" clone git://localhost:9419/small-test`
     * 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
+    * [ ] pkt-lines support
       * [x] encoding including flush lines
+      * [ ] decoding
     * [ ] 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