refactor

Sebastian Thiel committed 6 years ago

Commit 8ebdcbd1 parent 58543cb2 files · +56 −33Browse files

Unified · Split

2 files

git-protocol/src/packet_line/decode.rs +45 −24
git-protocol/src/packet_line/mod.rs +11 −9

git-protocol/src/packet_line/decode.rs+45−24

 };
 use bstr::BString;
 use quick_error::quick_error;
+use std::convert::TryInto;
 quick_error! {
     #[derive(Debug)]
     },
 }
+pub enum PacketLineOrWantedSize<'a> {
+    Line(PacketLine<'a>),
+    Wanted(u16),
+}
+pub fn hex_prefix(data: &[u8; 4]) -> Result<PacketLineOrWantedSize, Error> {
+    for (line_bytes, line_type) in &[
+        (FLUSH_LINE, PacketLine::Flush),
+        (DELIMITER_LINE, PacketLine::Delimiter),
+        (RESPONSE_END_LINE, PacketLine::ResponseEnd),
+    ] {
+        if data == *line_bytes {
+            return Ok(PacketLineOrWantedSize::Line(*line_type));
+        }
+    }
+    let mut buf = [0u8; U16_HEX_BYTES / 2];
+    hex::decode_to_slice(data, &mut buf)?;
+    let wanted_bytes = u16::from_be_bytes(buf);
+    if wanted_bytes == 4 {
+        return Err(Error::DataIsEmpty);
+    }
+    Ok(PacketLineOrWantedSize::Wanted(wanted_bytes))
+}
+pub fn to_data_line(data: &[u8]) -> Result<PacketLine, Error> {
+    if data.len() > MAX_LINE_LEN {
+        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))
+}
+// TODO: verify this one is actually needed in the end
 pub fn streaming(data: &[u8]) -> Result<Stream, Error> {
     let data_len = data.len();
     if data_len < U16_HEX_BYTES {
             bytes_needed: U16_HEX_BYTES - data_len,
         });
     }
-    let hex_bytes = &data[..U16_HEX_BYTES];
+    let wanted_bytes = match hex_prefix(data[..U16_HEX_BYTES].try_into().expect("sizes to match"))? {
-    for (line_bytes, line_type) in &[
+        PacketLineOrWantedSize::Wanted(s) => s as usize,
-        (FLUSH_LINE, PacketLine::Flush),
+        PacketLineOrWantedSize::Line(line) => {
-        (DELIMITER_LINE, PacketLine::Delimiter),
-        (RESPONSE_END_LINE, PacketLine::ResponseEnd),
-    ] {
-        if hex_bytes == *line_bytes {
             return Ok(Stream::Complete {
-                line: *line_type,
+                line,
                 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 wanted_bytes > MAX_LINE_LEN {
         return Err(Error::DataLengthLimitExceeded(wanted_bytes));
     }
         });
     }
-    if wanted_bytes == 4 {
-        return Err(Error::DataIsEmpty);
-    }
-    let data = &data[U16_HEX_BYTES..wanted_bytes];
-    if data.len() >= ERR_PREFIX.len() && &data[..ERR_PREFIX.len()] == ERR_PREFIX {
-        return Err(Error::Line(data[ERR_PREFIX.len()..].into(), wanted_bytes));
-    }
     Ok(Stream::Complete {
-        line: PacketLine::Data(data),
+        line: to_data_line(&data[U16_HEX_BYTES..wanted_bytes])?,
         bytes_consumed: wanted_bytes,
     })
 }

git-protocol/src/packet_line/mod.rs+11−9

         ) -> io::Result<Result<Borrowed<'a>, decode::Error>> {
             let mut buf_end = 4;
             reader.read_exact(&mut buf[..buf_end])?;
-            let (from, rest) = buf.split_at_mut(buf_end);
+            let (hex_bytes, potential_data) = buf.split_at_mut(buf_end);
-            match decode::streaming(from) {
+            match decode::streaming(hex_bytes) {
                 Err(err) => Ok(Err(err)),
                 Ok(stream) => match stream {
                     decode::Stream::Complete {
                         bytes_consumed: _,
                     } => Ok(Ok(line)),
                     decode::Stream::Incomplete { bytes_needed } => {
-                        reader.read_exact(rest)?;
+                        reader.read_exact(potential_data)?;
                         buf_end += bytes_needed;
-                        Ok(decode::streaming(&rest[..buf_end]).map(|stream| match stream {
+                        Ok(
-                            decode::Stream::Complete { line, .. } => line,
+                            decode::streaming(&potential_data[..buf_end]).map(|stream| match stream {
-                            decode::Stream::Incomplete { .. } => {
+                                decode::Stream::Complete { line, .. } => line,
-                                unreachable!("we know that our streamer is happy once the missing bytes are provided")
+                                decode::Stream::Incomplete { .. } => unreachable!(
-                            }
+                                    "we know that our streamer is happy once the missing bytes are provided"
-                        }))
+                                ),
+                            }),
+                        )
                     }
                 },
             }