[pack-gen] the first green test for Tag iterators

Author: Byron

git-object/src/immutable/mod.rs

@@ -15,8 +15,9 @@ pub use commit::{iter::Iter as CommitIter, Commit};
 pub mod object;
 pub use object::{Object, Signature};
 
-mod tag;
-pub use tag::Tag;
+///
+pub mod tag;
+pub use tag::{iter::Iter as TagIter, Tag};
 
 ///
 pub mod tree;

git-object/src/immutable/tag.rs

@@ -27,7 +27,7 @@ pub struct Tag<'a> {
     /// The message describing this release.
     pub message: &'a BStr,
     /// The author of the tag.
-    pub signature: Option<Signature<'a>>,
+    pub tagger: Option<Signature<'a>>,
     /// A cryptographic signature over the entire content of the serialized tag object thus far.
     pub pgp_signature: Option<&'a BStr>,
 }
@@ -64,7 +64,7 @@ fn parse(i: &[u8]) -> IResult<&[u8], Tag<'_>, decode::Error> {
             name: tag_version.as_bstr(),
             target_kind: kind,
             message,
-            signature,
+            tagger: signature,
             pgp_signature,
         },
     ))
@@ -117,3 +117,156 @@ fn parse_message(i: &[u8]) -> IResult<&[u8], (&BStr, Option<&BStr>), decode::Err
         ),
     ))
 }
+
+///
+pub mod iter {
+    use crate::{
+        bstr::ByteSlice,
+        immutable::{
+            object::decode,
+            parse::NL,
+            tag::{parse, parse_message},
+            Signature,
+        },
+        Kind,
+    };
+    use bstr::BStr;
+    use git_hash::{oid, ObjectId};
+    use nom::{
+        bytes::complete::take_while1,
+        character::is_alphabetic,
+        combinator::{all_consuming, opt},
+    };
+
+    enum State {
+        Target,
+        TargetKind,
+        Name,
+        Tagger,
+        Message,
+    }
+
+    impl Default for State {
+        fn default() -> Self {
+            State::Target
+        }
+    }
+
+    /// Like [`immutable::Tag`][super::Tag], but as `Iterator` to support entirely allocation free parsing.
+    /// It's particularly useful to dereference only the target chain.
+    pub struct Iter<'a> {
+        data: &'a [u8],
+        state: State,
+    }
+
+    impl<'a> Iter<'a> {
+        /// Create a tag iterator from data.
+        pub fn from_bytes(data: &'a [u8]) -> Iter<'a> {
+            Iter {
+                data,
+                state: State::default(),
+            }
+        }
+    }
+
+    impl<'a> Iter<'a> {
+        fn next_inner(i: &'a [u8], state: &mut State) -> Result<(&'a [u8], Token<'a>), decode::Error> {
+            use State::*;
+            Ok(match state {
+                Target => {
+                    let (i, target) = parse::header_field(i, b"object", parse::hex_sha1)
+                        .map_err(decode::Error::context("object <40 lowercase hex char>"))?;
+                    *state = State::TargetKind;
+                    (
+                        i,
+                        Token::Target {
+                            id: ObjectId::from_hex(target).expect("parsing validation"),
+                        },
+                    )
+                }
+                TargetKind => {
+                    let (i, kind) = parse::header_field(i, b"type", take_while1(is_alphabetic))
+                        .map_err(decode::Error::context("type <object kind>"))?;
+                    let kind =
+                        crate::Kind::from_bytes(kind).map_err(|e| nom::Err::Error(decode::Error::ParseKindError(e)))?;
+                    *state = State::Name;
+                    (i, Token::TargetKind(kind))
+                }
+                Name => {
+                    let (i, tag_version) = parse::header_field(i, b"tag", take_while1(|b| b != NL[0]))
+                        .map_err(decode::Error::context("tag <version>"))?;
+                    *state = State::Tagger;
+                    (i, Token::Name(tag_version.as_bstr()))
+                }
+                Tagger => {
+                    let (i, signature) = opt(|i| parse::header_field(i, b"tagger", parse::signature))(i)
+                        .map_err(decode::Error::context("tagger <signature>"))?;
+                    *state = State::Message;
+                    (i, Token::Tagger(signature))
+                }
+                Message => {
+                    let (i, (message, pgp_signature)) = all_consuming(parse_message)(i)?;
+                    debug_assert!(
+                        i.is_empty(),
+                        "we should have consumed all data - otherwise iter may go forever"
+                    );
+                    return Ok((i, Token::Body { message, pgp_signature }));
+                }
+            })
+        }
+    }
+
+    impl<'a> Iterator for Iter<'a> {
+        type Item = Result<Token<'a>, decode::Error>;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            if self.data.is_empty() {
+                return None;
+            }
+            match Self::next_inner(self.data, &mut self.state) {
+                Ok((data, token)) => {
+                    self.data = data;
+                    Some(Ok(token))
+                }
+                Err(err) => {
+                    self.data = &[];
+                    Some(Err(err))
+                }
+            }
+        }
+    }
+
+    /// A token returned by the [commit iterator][Iter].
+    #[allow(missing_docs)]
+    #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
+    pub enum Token<'a> {
+        Target {
+            id: ObjectId,
+        },
+        TargetKind(Kind),
+        Name(&'a BStr),
+        Tagger(Option<Signature<'a>>),
+        Body {
+            message: &'a BStr,
+            pgp_signature: Option<&'a BStr>,
+        },
+    }
+
+    impl<'a> Token<'a> {
+        /// Return the object id of this token if its a [Target][Token::Target].
+        pub fn id(&self) -> Option<&oid> {
+            match self {
+                Token::Target { id } => Some(id.as_ref()),
+                _ => None,
+            }
+        }
+
+        /// Return the owned object id of this token if its a [Target][Token::Target].
+        pub fn into_id(self) -> Option<ObjectId> {
+            match self {
+                Token::Target { id } => Some(id),
+                _ => None,
+            }
+        }
+    }
+}

git-object/src/mutable/convert.rs

@@ -18,7 +18,7 @@ impl From<immutable::Tag<'_>> for mutable::Tag {
             name,
             target_kind,
             message,
-            signature,
+            tagger: signature,
             pgp_signature,
         } = other;
         mutable::Tag {

git-object/tests/immutable/commit.rs

@@ -137,7 +137,7 @@ mod method {
     use pretty_assertions::assert_eq;
 
     #[test]
-    fn tree() -> Result<(), Box<dyn std::error::Error>> {
+    fn tree() -> crate::Result {
         let fixture = fixture_bytes("commit", "unsigned.txt");
         let commit = Commit::from_bytes(&fixture)?;
         assert_eq!(commit.tree(), hex_to_id("1b2dfb4ac5e42080b682fc676e9738c94ce6d54d"));
@@ -157,7 +157,7 @@ mod iter {
     use git_object::{bstr::ByteSlice, immutable::commit::iter::Token, immutable::CommitIter};
 
     #[test]
-    fn newline_right_after_signature_multiline_header() -> Result<(), Box<dyn std::error::Error>> {
+    fn newline_right_after_signature_multiline_header() -> crate::Result {
         let data = fixture_bytes("commit", "signed-whitespace.txt");
         let tokens = CommitIter::from_bytes(&data).collect::<Result<Vec<_>, _>>()?;
         assert_eq!(tokens.len(), 7, "mainly a parsing exercise");
@@ -171,7 +171,7 @@ mod iter {
     }
 
     #[test]
-    fn signed_with_encoding() -> Result<(), Box<dyn std::error::Error>> {
+    fn signed_with_encoding() -> crate::Result {
         assert_eq!(
             CommitIter::from_bytes(&fixture_bytes("commit", "signed-with-encoding.txt"))
                 .collect::<Result<Vec<_>, _>>()?,
@@ -197,7 +197,7 @@ mod iter {
     }
 
     #[test]
-    fn whitespace() -> Result<(), Box<dyn std::error::Error>> {
+    fn whitespace() -> crate::Result {
         assert_eq!(
             CommitIter::from_bytes(&fixture_bytes("commit", "whitespace.txt")).collect::<Result<Vec<_>, _>>()?,
             vec![
@@ -220,7 +220,7 @@ mod iter {
     }
 
     #[test]
-    fn unsigned() -> Result<(), Box<dyn std::error::Error>> {
+    fn unsigned() -> crate::Result {
         assert_eq!(
             CommitIter::from_bytes(&fixture_bytes("commit", "unsigned.txt")).collect::<Result<Vec<_>, _>>()?,
             vec![
@@ -240,7 +240,7 @@ mod iter {
     }
 
     #[test]
-    fn signed_singleline() -> Result<(), Box<dyn std::error::Error>> {
+    fn signed_singleline() -> crate::Result {
         assert_eq!(
             CommitIter::from_bytes(&fixture_bytes("commit", "signed-singleline.txt")).collect::<Result<Vec<_>, _>>()?,
             vec![
@@ -264,7 +264,7 @@ mod iter {
     }
 
     #[test]
-    fn error_handling() -> Result<(), Box<dyn std::error::Error>> {
+    fn error_handling() -> crate::Result {
         let data = fixture_bytes("commit", "unsigned.txt");
         let iter = CommitIter::from_bytes(&data[..data.len() / 2]);
         let tokens = iter.collect::<Vec<_>>();
@@ -276,7 +276,7 @@ mod iter {
     }
 
     #[test]
-    fn mergetag() -> Result<(), Box<dyn std::error::Error>> {
+    fn mergetag() -> crate::Result {
         assert_eq!(
             CommitIter::from_bytes(&fixture_bytes("commit", "mergetag.txt")).collect::<Result<Vec<_>, _>>()?,
             vec![
@@ -310,7 +310,7 @@ mod iter {
         use git_object::immutable::CommitIter;
 
         #[test]
-        fn tree_id() -> Result<(), Box<dyn std::error::Error>> {
+        fn tree_id() -> crate::Result {
             assert_eq!(
                 CommitIter::from_bytes(&fixture_bytes("commit", "unsigned.txt")).tree_id(),
                 Some(hex_to_id("1b2dfb4ac5e42080b682fc676e9738c94ce6d54d"))
@@ -325,7 +325,7 @@ mod iter {
         }
 
         #[test]
-        fn signatures() -> Result<(), Box<dyn std::error::Error>> {
+        fn signatures() -> crate::Result {
             assert_eq!(
                 CommitIter::from_bytes(&fixture_bytes("commit", "unsigned.txt"))
                     .signatures()
@@ -346,7 +346,7 @@ mod from_bytes {
     use smallvec::SmallVec;
 
     #[test]
-    fn unsigned() -> Result<(), Box<dyn std::error::Error>> {
+    fn unsigned() -> crate::Result {
         assert_eq!(
             Commit::from_bytes(&fixture_bytes("commit", "unsigned.txt"))?,
             Commit {
@@ -363,7 +363,7 @@ mod from_bytes {
     }
 
     #[test]
-    fn whitespace() -> Result<(), Box<dyn std::error::Error>> {
+    fn whitespace() -> crate::Result {
         assert_eq!(
             Commit::from_bytes(&fixture_bytes("commit", "whitespace.txt"))?,
             Commit {
@@ -380,7 +380,7 @@ mod from_bytes {
     }
 
     #[test]
-    fn signed_singleline() -> Result<(), Box<dyn std::error::Error>> {
+    fn signed_singleline() -> crate::Result {
         assert_eq!(
             Commit::from_bytes(&fixture_bytes("commit", "signed-singleline.txt"))?,
             Commit {
@@ -397,7 +397,7 @@ mod from_bytes {
     }
 
     #[test]
-    fn mergetag() -> Result<(), Box<dyn std::error::Error>> {
+    fn mergetag() -> crate::Result {
         let fixture = fixture_bytes("commit", "mergetag.txt");
         let commit = Commit {
             tree: b"1c61918031bf2c7fab9e17dde3c52a6a9884fcb5".as_bstr(),
@@ -421,7 +421,7 @@ mod from_bytes {
     }
 
     #[test]
-    fn signed() -> Result<(), Box<dyn std::error::Error>> {
+    fn signed() -> crate::Result {
         assert_eq!(
             Commit::from_bytes(&fixture_bytes("commit", "signed.txt"))?,
             Commit {
@@ -438,7 +438,7 @@ mod from_bytes {
     }
 
     #[test]
-    fn signed_with_encoding() -> Result<(), Box<dyn std::error::Error>> {
+    fn signed_with_encoding() -> crate::Result {
         assert_eq!(
             Commit::from_bytes(&fixture_bytes("commit", "signed-with-encoding.txt"))?,
             Commit {
@@ -455,7 +455,7 @@ mod from_bytes {
     }
 
     #[test]
-    fn with_encoding() -> Result<(), Box<dyn std::error::Error>> {
+    fn with_encoding() -> crate::Result {
         assert_eq!(
             Commit::from_bytes(&fixture_bytes("commit", "with-encoding.txt"))?,
             Commit {
@@ -472,7 +472,7 @@ mod from_bytes {
     }
 
     #[test]
-    fn merge() -> Result<(), Box<dyn std::error::Error>> {
+    fn merge() -> crate::Result {
         assert_eq!(
             Commit::from_bytes(&fixture_bytes("commit", "merge.txt"))?,
             Commit {
@@ -504,7 +504,7 @@ iyBBl69jASy41Ug/BlFJbw4+ItkShpXwkJKuBBV/JExChmvbxYWaS7QnyYC9UO0=
 ";
 
     #[test]
-    fn newline_right_after_signature_multiline_header() -> Result<(), Box<dyn std::error::Error>> {
+    fn newline_right_after_signature_multiline_header() -> crate::Result {
         let fixture = fixture_bytes("commit", "signed-whitespace.txt");
         let commit = Commit::from_bytes(&fixture)?;
         let pgp_sig = OTHER_SIGNATURE.as_bstr();