no panics in packet line to let caller handle invariants; read…

…read wont' skip over non-data lines either, but fail with an unexpected
EOF.
This is usually an error that really has to be handled or should abort
the current operation.

Author: Byron

git-packetline/src/borrowed.rs

@@ -21,43 +21,31 @@ impl<'a> Borrowed<'a> {
         }
     }
 
-    pub fn as_slice(&self) -> &[u8] {
+    pub fn as_slice(&self) -> Option<&[u8]> {
         match self {
-            Borrowed::Data(d) => d,
-            Borrowed::Flush | Borrowed::Delimiter | Borrowed::ResponseEnd => &[],
+            Borrowed::Data(d) => Some(d),
+            Borrowed::Flush | Borrowed::Delimiter | Borrowed::ResponseEnd => None,
         }
     }
-    pub fn as_bstr(&self) -> &BStr {
-        self.as_slice().into()
+    pub fn as_bstr(&self) -> Option<&BStr> {
+        self.as_slice().map(Into::into)
     }
-    pub fn to_error(&self) -> Error {
-        Error(self.as_slice())
+    pub fn to_error(&self) -> Option<Error> {
+        self.as_slice().map(Error)
     }
-    pub fn to_text(&self) -> Text {
-        let d = match self {
-            Borrowed::Data(d) => *d,
-            _ => panic!("cannot convert non-data to text"),
-        };
-        d.into()
+    pub fn to_text(&self) -> Option<Text> {
+        self.as_slice().map(Into::into)
     }
-    pub fn to_band(&self, kind: Channel) -> Band {
-        let d = match self {
-            Borrowed::Data(d) => d,
-            _ => panic!("cannot side-channel non-data lines"),
-        };
-
-        match kind {
+    pub fn to_band(&self, kind: Channel) -> Option<Band> {
+        self.as_slice().map(|d| match kind {
             Channel::Data => Band::Data(d),
             Channel::Progress => Band::Progress(d),
             Channel::Error => Band::Error(d),
-        }
+        })
     }
     /// Decode the band of the line, or panic if it is not actually a side-band line
     pub fn decode_band(&self) -> Result<Band, DecodeBandError> {
-        let d = match self {
-            Borrowed::Data(d) => d,
-            _ => panic!("cannot decode side-channel information from non-data lines"),
-        };
+        let d = self.as_slice().ok_or(DecodeBandError::NonDataLine)?;
         Ok(match d[0] {
             1 => Band::Data(&d[1..]),
             2 => Band::Progress(&d[1..]),
@@ -74,6 +62,9 @@ quick_error! {
         InvalidSideBand(band: u8) {
             display("attempt to decode a non-side channel line or input was malformed: {}", band)
         }
+        NonDataLine {
+            display("attempt to decode a non-data line into a side-channel band")
+        }
     }
 }
 

git-packetline/src/read.rs

@@ -170,7 +170,17 @@ where
                             Band::Error(d) => progress.fail(progress_name(None, Text::from(d).0)),
                         };
                     }
-                    None => break line.as_slice().read(&mut self.buf)?,
+                    None => {
+                        break match line.as_slice() {
+                            Some(ref mut d) => d.read(&mut self.buf)?,
+                            None => {
+                                return Err(io::Error::new(
+                                    io::ErrorKind::UnexpectedEof,
+                                    "encountered non-data line in a data-line only context",
+                                ))
+                            }
+                        }
+                    }
                 }
             };
             self.pos = 0;

git-packetline/tests/packet_line/decode.rs

@@ -35,9 +35,13 @@ mod streaming {
     fn trailing_line_feeds_are_removed_explicitly_roundtrip() -> crate::Result {
         match streaming(b"0006a\n")? {
             Stream::Complete { line, .. } => {
-                assert_eq!(line.to_text().0.as_bstr(), b"a".as_bstr());
+                assert_eq!(line.to_text().expect("text").0.as_bstr(), b"a".as_bstr());
                 let mut out = Vec::new();
-                line.to_text().to_write(&mut out).expect("write to memory works");
+                line.to_text()
+                    .expect("text")
+                    .to_write(&mut out)
+                    .expect("write to memory works");
+                assert_eq!(out, b"0006a\n", "it appends a newline in text mode");
             }
             Stream::Incomplete { .. } => panic!("should be complete"),
         }
@@ -96,7 +100,10 @@ mod streaming {
     #[test]
     fn roundtrip_error_line() -> crate::Result {
         let mut out = Vec::new();
-        PacketLine::Data(b"the error").to_error().to_write(&mut out)?;
+        PacketLine::Data(b"the error")
+            .to_error()
+            .expect("data line")
+            .to_write(&mut out)?;
         assert_err_display(streaming(&out), "the error");
         Ok(())
     }
@@ -105,7 +112,9 @@ mod streaming {
     fn roundtrip_side_bands() -> crate::Result {
         for channel in &[Channel::Data, Channel::Error, Channel::Progress] {
             let mut out = Vec::new();
-            let band = PacketLine::Data(b"band data").to_band(*channel);
+            let band = PacketLine::Data(b"band data")
+                .to_band(*channel)
+                .expect("data is valid for band");
             band.to_write(&mut out)?;
             match streaming(&out)? {
                 Stream::Complete { line, bytes_consumed } => {

git-packetline/tests/packet_line/read.rs

@@ -28,7 +28,15 @@ mod to_read {
         assert_eq!(out.as_bstr(), b"808e50d724f604f69ab93c6da2919c014667bedb HEAD\0multi_ack thin-pack side-band side-band-64k ofs-delta shallow deepen-since deepen-not deepen-relative no-progress include-tag multi_ack_detailed symref=HEAD:refs/heads/master object-format=sha1 agent=git/2.28.0\n808e50d724f604f69ab93c6da2919c014667bedb refs/heads/master\n".as_bstr());
 
         rd.reset();
-        assert_eq!(rd.read_line().expect("line")??.to_text().0.as_bstr(), b"NAK".as_bstr());
+        assert_eq!(
+            rd.read_line()
+                .expect("line")??
+                .to_text()
+                .expect("data line")
+                .0
+                .as_bstr(),
+            b"NAK".as_bstr()
+        );
         fn no_parsing(_: &[u8]) -> Option<RemoteProgress> {
             None
         }