the first sketch of parsing a tag with Nom and half-decent errors

Author: Byron

git-object/src/parsed/mod.rs

@@ -6,6 +6,7 @@ use std::str;
 mod tag;
 mod util;
 
+use nom::error::ParseError;
 pub use tag::Tag;
 
 #[cfg(test)]
@@ -21,13 +22,36 @@ quick_error! {
         ParseError(msg: &'static str, kind: Vec<u8>) {
             display("{}: {:?}", msg, std::str::from_utf8(&kind))
         }
+        Nom(input: bstr::BString, msg: &'static str) {
+            display("{}: '{}' could not be parsed", msg, input)
+        }
         ObjectKind(err: crate::Error) {
             from()
             cause(err)
         }
     }
 }
 
+impl Error {
+    pub fn parse_context(mut self, ctx: &'static str) -> Self{
+        match self {
+            Error::Nom(_, ref mut message) => *message = ctx,
+            _ => {}
+        };
+        self
+    }
+}
+
+impl ParseError<&[u8]> for Error {
+    fn from_error_kind(input: &[u8], kind: nom::error::ErrorKind) -> Self {
+        Error::Nom(input.into(), "parse error")
+    }
+
+    fn append(_: &[u8], _: nom::error::ErrorKind, other: Self) -> Self {
+        other
+    }
+}
+
 #[derive(PartialEq, Eq, Debug, Hash)]
 pub enum Object<'data> {
     Tag(Tag<'data>),

git-object/src/parsed/tag.rs

@@ -6,6 +6,10 @@ use crate::{parsed::Signature, Time};
 use bstr::{BStr, ByteSlice};
 use btoi::btoi;
 use hex::FromHex;
+use nom::{bytes::complete::tag, IResult, };
+use nom::sequence::{tuple, preceded, terminated};
+use nom::bytes::complete::{take, take_while, take_while_m_n};
+use nom::combinator::map;
 
 #[derive(PartialEq, Eq, Debug, Hash)]
 pub struct Tag<'data> {
@@ -71,6 +75,29 @@ fn parse_signature(d: &[u8]) -> Result<Signature, Error> {
     })
 }
 
+fn context(msg: &'static str) -> impl Fn(nom::Err<Error>) -> nom::Err<Error> {
+    move |e: nom::Err<Error>| e.map(|e| e.parse_context(msg))
+}
+
+fn is_hex_digit_lc(b: u8) -> bool {
+    match b {
+        b'0'..=b'9' => true,
+        b'a'..=b'f' => true,
+        _ => false,
+    }
+}
+
+pub(crate) fn parse_tag_nom(i: &[u8]) -> IResult<&[u8], Tag, Error> {
+    const NL: &[u8] = b"\n";
+    let (i, _) = terminated(preceded(tag(b"object "), take_while_m_n(40usize, 40, is_hex_digit_lc)), tag(NL))(i).map_err(context("object <40 lowercase hex char>"))?;
+    unimplemented!("parse message nom")
+}
+
+pub(crate) fn parse_message_nom(i: &[u8]) -> IResult<&[u8], (Option<&BStr>, Option<&BStr>), Error> {
+    let (i, _) = tag(b"\n")(i)?;
+    unimplemented!("parse message nom")
+}
+
 fn parse_message<'data>(
     d: &'data [u8],
     mut lines: impl Iterator<Item = &'data [u8]>,

git-object/src/parsed/tests/tag.rs

@@ -6,8 +6,20 @@ use crate::{
 use bstr::ByteSlice;
 use pretty_assertions::assert_eq;
 
+mod message {
+    use super::fixture_bytes;
+    use super::parsed::tag::parse_tag_nom;
+    use crate::parsed::tests::tag::tag_fixture;
+
+    #[test]
+    fn parse() {
+        let fixture = fixture_bytes("tag.txt");
+        assert_eq!(parse_tag_nom(&fixture).unwrap().1, tag_fixture(9000));
+    }
+}
+
 #[test]
-fn tag_parse() {
+fn parse() {
     let fixture = fixture_bytes("tag.txt");
     let actual = parsed::Tag::from_bytes(&fixture).unwrap();
     assert_eq!(actual, tag_fixture(9000));