Don't try to find 'ERR ' in every packet line we parse…

…as error checking really is in the hands of the consumer.

git-packetline/src/borrowed.rs

@@ -1,4 +1,4 @@
-use crate::{encode, Channel};
+use crate::{encode, Channel, ERR_PREFIX};
 use bstr::BStr;
 use std::io;
 
@@ -33,6 +33,15 @@ impl<'a> Borrowed<'a> {
     pub fn to_error(&self) -> Option<Error> {
         self.as_slice().map(Error)
     }
+    pub fn check_error(&self) -> Option<Error> {
+        self.as_slice().and_then(|data| {
+            if data.len() >= ERR_PREFIX.len() && &data[..ERR_PREFIX.len()] == ERR_PREFIX {
+                Some(Error(&data[ERR_PREFIX.len()..]))
+            } else {
+                None
+            }
+        })
+    }
     pub fn to_text(&self) -> Option<Text> {
         self.as_slice().map(Into::into)
     }

git-packetline/src/decode.rs

@@ -1,5 +1,5 @@
 use crate::{
-    PacketLine, {DELIMITER_LINE, ERR_PREFIX, FLUSH_LINE, MAX_DATA_LEN, MAX_LINE_LEN, RESPONSE_END_LINE, U16_HEX_BYTES},
+    PacketLine, {DELIMITER_LINE, FLUSH_LINE, MAX_DATA_LEN, MAX_LINE_LEN, RESPONSE_END_LINE, U16_HEX_BYTES},
 };
 use bstr::BString;
 use quick_error::quick_error;
@@ -77,9 +77,6 @@ pub fn to_data_line(data: &[u8]) -> Result<PacketLine, Error> {
         return Err(Error::DataLengthLimitExceeded(data.len()));
     }
 
-    if data.len() >= ERR_PREFIX.len() && &data[..ERR_PREFIX.len()] == ERR_PREFIX {
-        return Err(Error::Line(data[ERR_PREFIX.len()..].into(), data.len()));
-    }
     Ok(PacketLine::Data(data))
 }
 

git-packetline/src/lib.rs

@@ -15,6 +15,8 @@ pub enum Channel {
     Error = 3,
 }
 
+/// The information usually found in remote progress messages as sent by a git server during
+/// fetch, clone and push.
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
 #[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
 pub struct RemoteProgress<'a> {
@@ -32,5 +34,10 @@ 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 decode;
 pub mod encode;

git-packetline/tests/packet_line/decode.rs

@@ -1,6 +1,7 @@
 mod streaming {
     use crate::packet_line::assert_err_display;
     use bstr::ByteSlice;
+    use git_packetline::borrowed::Error;
     use git_packetline::{
         decode::{self, streaming, Stream},
         Channel, PacketLine,
@@ -62,11 +63,18 @@ mod streaming {
     }
 
     #[test]
-    fn error_on_error_line() {
-        assert_err_display(
+    fn error_on_error_line() -> crate::Result {
+        let line = PacketLine::Data(b"ERR the error");
+        assert_complete(
             streaming(b"0011ERR the error-and just ignored because not part of the size"),
-            "the error",
+            17,
+            line,
+        )?;
+        assert_eq!(
+            line.check_error().expect("error to be parsed here"),
+            Error(b"the error")
         );
+        Ok(())
     }
 
     #[test]
@@ -104,7 +112,10 @@ mod streaming {
             .to_error()
             .expect("data line")
             .to_write(&mut out)?;
-        assert_err_display(streaming(&out), "the error");
+        match streaming(&out).expect("decode success") {
+            Stream::Complete { line, .. } => assert_eq!(line.check_error().expect("err").0, b"the error"),
+            Stream::Incomplete { .. } => unreachable!(),
+        };
         Ok(())
     }
 

tasks.md

@@ -10,7 +10,8 @@
       * [x] Progress parsing, with 'info(…)' fallback if that fails
       * [x] SetName in Progress trait (to allow setting the correct progress information)
       * [x] Disable sideband support (e.g. github http V2 doesn't have it)
-    * [ ] don't coerce line delimiters into empty slices.
+    * [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.
   * **git-url**
     * [ ] parse into components to make them easy to understand
   * **connect**