the first succeeding tests for streaming decoding :D

Author: Byron

README.md

@@ -95,8 +95,10 @@ Please see _'Development Status'_ for a listing of all crates and their capabili
     start out with a sync implementation, and later add an async one that reuses all the protocol code.
   * [ ] [PKT-Line](https://github.com/git/git/blob/master/Documentation/technical/protocol-common.txt#L52:L52)
     * [ ] encode
-    * [ ] decode
+    * [ ] decode (zero-copy)
     * [ ] [error line](https://github.com/git/git/blob/master/Documentation/technical/pack-protocol.txt#L28:L28)
+    * [ ] [V2 additions](https://github.com/git/git/blob/master/Documentation/technical/protocol-v2.txt#L35:L36)
+    * [ ]
   * [ ] `Iterator` for multi-plexed pack lines from `Read`
   * [ ] parse and serialize [capabilities](https://github.com/git/git/blob/master/Documentation/technical/protocol-capabilities.txt#L1:L1)
   * [ ] **Version 1**

git-protocol/src/packet_line/decode.rs

@@ -1,4 +1,3 @@
-use crate::packet_line::Borrowed::Flush;
 use crate::packet_line::{self, FLUSH_LINE, MAX_DATA_LEN, MAX_LINE_LEN, U16_HEX_BYTES};
 use bstr::BString;
 use quick_error::quick_error;
@@ -23,41 +22,46 @@ quick_error! {
     }
 }
 
-pub enum ParseResult<'a> {
+pub enum Stream<'a> {
     Complete {
-        result: Result<packet_line::Borrowed<'a>, Error>,
+        line: packet_line::Borrowed<'a>,
         bytes_consumed: usize,
     },
     Incomplete {
         bytes_needed: usize,
     },
 }
 
-pub fn streaming(data: &[u8]) -> ParseResult {
+pub fn streaming(data: &[u8]) -> Result<Stream, Error> {
     let data_len = data.len();
     if data_len < U16_HEX_BYTES {
-        return ParseResult::Incomplete {
+        return Ok(Stream::Incomplete {
             bytes_needed: U16_HEX_BYTES - data_len,
-        };
+        });
     }
     let hex_bytes = &data[..U16_HEX_BYTES];
     if hex_bytes == FLUSH_LINE {
-        return ParseResult::Complete {
-            result: Ok(packet_line::Borrowed::Flush),
+        return Ok(Stream::Complete {
+            line: packet_line::Borrowed::Flush,
             bytes_consumed: 4,
-        };
+        });
     }
 
     let mut buf = [0u8; U16_HEX_BYTES / 2];
     hex::decode_to_slice(hex_bytes, &mut buf)?;
     let wanted_bytes = u16::from_be_bytes(buf) as usize;
     if data_len < wanted_bytes {
-        return ParseResult::Incomplete {
+        return Ok(Stream::Incomplete {
             bytes_needed: wanted_bytes,
-        };
+        });
     }
     if wanted_bytes > MAX_LINE_LEN {
         return Err(Error::DataLengthLimitExceeded(wanted_bytes));
     }
-    ParseResult::Complete { result }
+
+    // todo: error line
+    Ok(Stream::Complete {
+        line: packet_line::Borrowed::Data(&data[U16_HEX_BYTES..wanted_bytes]),
+        bytes_consumed: wanted_bytes,
+    })
 }

git-protocol/src/packet_line/mod.rs

@@ -19,6 +19,13 @@ impl<'a> Borrowed<'a> {
             Borrowed::Data(d) => encode::data_to_write(d, out),
         }
     }
+
+    pub fn as_slice(&self) -> &[u8] {
+        match self {
+            Borrowed::Data(d) => d,
+            Borrowed::Flush => &[],
+        }
+    }
 }
 
 pub mod decode;

git-protocol/tests/packet_line/decode.rs

@@ -1,16 +1,20 @@
 mod streaming {
     use git_protocol::{
-        packet_line::decode::{streaming, ParseResult},
+        packet_line::decode::{self, streaming, Stream},
         PacketLine,
     };
 
-    fn assert_complete(res: ParseResult, expected_consumed: usize, expected_value: PacketLine) -> crate::Result {
-        match res {
-            ParseResult::Complete { result, bytes_consumed } => {
+    fn assert_complete(
+        res: Result<Stream, decode::Error>,
+        expected_consumed: usize,
+        expected_value: PacketLine,
+    ) -> crate::Result {
+        match res? {
+            Stream::Complete { line, bytes_consumed } => {
                 assert_eq!(bytes_consumed, expected_consumed);
-                assert_eq!(result?, expected_value);
+                assert_eq!(line, expected_value);
             }
-            ParseResult::Incomplete { .. } => panic!("expected parsing to be complete, not partial"),
+            Stream::Incomplete { .. } => panic!("expected parsing to be complete, not partial"),
         }
         Ok(())
     }
@@ -19,4 +23,14 @@ mod streaming {
     fn flush() -> crate::Result {
         assert_complete(streaming(b"0000someotherstuff"), 4, PacketLine::Flush)
     }
+
+    #[test]
+    fn round_trips() -> crate::Result {
+        for (line, bytes) in &[(PacketLine::Flush, 4), (PacketLine::Data(b"hello there"), 15)] {
+            let mut out = Vec::new();
+            line.to_write(&mut out)?;
+            assert_complete(streaming(&out), *bytes, *line)?;
+        }
+        Ok(())
+    }
 }