implement parse_signature with nom, starting to like it

Author: Byron

git-object/src/parsed/tag.rs

@@ -2,21 +2,36 @@ use super::{
     util::{parse_timezone_offset, split2_at_space},
     Error,
 };
-use crate::{parsed::Signature, Time};
+use crate::{parsed::Signature, Sign, Time};
 use bstr::{BStr, ByteSlice};
 use btoi::btoi;
 use hex::FromHex;
 use nom::{
-    bytes::complete::tag,
-    bytes::complete::{take_while1, take_while_m_n},
-    character::is_alphabetic,
-    sequence::{preceded, terminated},
-    IResult,
+    bytes::{
+        complete::{
+            take_till,
+            take_until,
+            take_while,
+            tag,
+            take_while1,
+            take_while_m_n
+        }
+    },
+    branch::alt,
+    character::{
+        is_digit,
+        is_alphabetic
+    },
+    sequence::{
+        delimited,
+        pair,
+        tuple,
+        preceded,
+        terminated
+    },
+    IResult
 };
-use nom::sequence::{delimited, pair, tuple};
-use nom::bytes::complete::{take_until, take_till, take_while};
-use nom::character::is_digit;
-use nom::branch::alt;
+use nom::bytes::complete::take;
 
 #[derive(PartialEq, Eq, Debug, Hash)]
 pub struct Tag<'data> {
@@ -93,11 +108,40 @@ fn is_hex_digit_lc(b: u8) -> bool {
 const NL: &[u8] = b"\n";
 const SPACE: &[u8] = b" ";
 pub(crate) fn parse_signature_nom(i: &[u8]) -> IResult<&[u8], Signature, Error> {
-    let (i, (name, email, time_in_seconds, tzofs)) = tuple((terminated(take_till(|b| b == b'<'), tag(b"<")),
-                                                           terminated(take_till(|b| b == b'>'), tag(b"> ")),
-                                                           terminated(take_till(|b| b == SPACE[0]), tag(SPACE)),
-                                                           pair(alt((tag(b"-"), tag(b"+"))), take_while_m_n(4usize, 4, |b| is_digit(b)))))(i)?;
-    unimplemented!("parse signature")
+    let (i, (name, email, time_in_seconds, tzsign, tzhour, tzminute)) = tuple((
+        terminated(take_until(&b" <"[..]), take(2usize)),
+        terminated(take_until(&b"> "[..]), take(2usize)),
+        terminated(take_until(SPACE), take(1usize)),
+        alt((tag(b"-"), tag(b"+"))),
+        take_while_m_n(2usize, 2, |b| is_digit(b)),
+        take_while_m_n(2usize, 2, |b| is_digit(b)),
+    ))(i)
+    .map_err(Error::context(
+        "tagger <name> <<email>> <time seconds since epoch> <+|-><HHMM>",
+    ))?;
+
+    let sign = if tzsign[0] == b'-' {
+        Sign::Minus
+    } else {
+        Sign::Plus
+    };
+    let hours = btoi::<i32>(&tzhour)
+        .map_err(|e| nom::Err::Error(Error::ParseIntegerError("invalid 'hours' string", tzhour.to_owned(), e)))?;
+    let minutes = btoi::<i32>(&tzminute)
+        .map_err(|e| nom::Err::Error(Error::ParseIntegerError("invalid 'minutes' string", tzminute.to_owned(), e)))?;
+    let offset = (hours * 3600 + minutes * 60);
+
+    Ok((i, Signature {
+        name: name.as_bstr(),
+        email: email.as_bstr(),
+        time: Time {
+            time: btoi::<u32>(time_in_seconds).map_err(|e| {
+                nom::Err::Error(Error::ParseIntegerError("Could parse to seconds", time_in_seconds.to_owned(), e))
+            })?,
+            offset,
+            sign
+        }
+    }))
 }
 
 pub(crate) fn parse_tag_nom(i: &[u8]) -> IResult<&[u8], Tag, Error> {
@@ -114,11 +158,15 @@ pub(crate) fn parse_tag_nom(i: &[u8]) -> IResult<&[u8], Tag, Error> {
         .map_err(Error::context("type <object kind>"))?;
     let kind = crate::Kind::from_bytes(kind)?;
 
-    let (i, tag_version) = terminated(preceded(tag(b"tag "), take_while1(|b| b != NL[0])), tag(NL))(i)
-        .map_err(Error::context("tag <version>"))?;
+    let (i, tag_version) =
+        terminated(preceded(tag(b"tag "), take_while1(|b| b != NL[0])), tag(NL))(i)
+            .map_err(Error::context("tag <version>"))?;
 
-    let (i, tagger) = terminated(preceded(tag(b"tagger "), take_while1(|b| b != NL[0])), tag(NL))(i)
-        .map_err(Error::context("tagger <signature>"))?;
+    let (i, tagger) = terminated(
+        preceded(tag(b"tagger "), take_while1(|b| b != NL[0])),
+        tag(NL),
+    )(i)
+    .map_err(Error::context("tagger <signature>"))?;
     unimplemented!("parse message nom")
 }
 

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

@@ -1,9 +1,9 @@
 use super::*;
-use hex::FromHex;
-use std::path::PathBuf;
 use crate::parsed::tag::parse_signature_nom;
 use crate::{parsed, Sign};
 use bstr::ByteSlice;
+use hex::FromHex;
+use std::path::PathBuf;
 
 pub fn bin(hex: &str) -> [u8; 20] {
     <[u8; 20]>::from_hex(hex).unwrap()
@@ -21,13 +21,18 @@ mod tag;
 
 #[test]
 fn parse_signature() {
-    assert_eq!(parse_signature_nom(b"Sebastian Thiel <byronimo@gmail.com> 1528473343 +0230").unwrap().1, parsed::Signature {
-        name: b"Sebastian Thiel".as_bstr(),
-        email: b"byronimo@gmail.com".as_bstr(),
-        time: Time {
-            time: 1528473343,
-            offset: 9000,
-            sign: Sign::Plus,
-        },
-    });
+    assert_eq!(
+        parse_signature_nom(b"Sebastian Thiel <byronimo@gmail.com> 1528473343 +0230")
+            .unwrap()
+            .1,
+        parsed::Signature {
+            name: b"Sebastian Thiel".as_bstr(),
+            email: b"byronimo@gmail.com".as_bstr(),
+            time: Time {
+                time: 1528473343,
+                offset: 9000,
+                sign: Sign::Plus,
+            },
+        }
+    );
 }

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

@@ -8,15 +8,14 @@ use pretty_assertions::assert_eq;
 
 mod nom {
     use super::fixture_bytes;
-    use crate::parsed::tests::tag::tag_fixture;
     use crate::parsed::tag::{parse_signature_nom, parse_tag_nom};
+    use crate::parsed::tests::tag::tag_fixture;
 
     #[test]
     fn parse_tag() {
         let fixture = fixture_bytes("tag.txt");
         assert_eq!(parse_tag_nom(&fixture).unwrap().1, tag_fixture(9000));
     }
-
 }
 
 #[test]