feat: TagRefIter::tagger(). (#389)

Additionally ergonomics have been improved as the iterator is now
`Copy`, similarly to the other iterators.

Author: Byron

git-object/src/commit/ref_iter.rs

@@ -77,7 +77,6 @@ impl<'a> CommitRefIter<'a> {
     }
 
     /// Returns the committer signature if there is no decoding error.
-    /// Errors are coerced into options, hiding whether there was an error or not. The caller knows if there was an error or not.
     pub fn committer(mut self) -> Result<git_actor::SignatureRef<'a>, crate::decode::Error> {
         self.find_map(|t| match t {
             Ok(Token::Committer { signature }) => Some(Ok(signature)),
@@ -90,7 +89,6 @@ impl<'a> CommitRefIter<'a> {
     /// Returns the author signature if there is no decoding error.
     ///
     /// It may contain white space surrounding it, and is exactly as parsed.
-    /// Errors are coerced into options, hiding whether there was an error or not. The caller knows if there was an error or not.
     pub fn author(mut self) -> Result<git_actor::SignatureRef<'a>, crate::decode::Error> {
         self.find_map(|t| match t {
             Ok(Token::Author { signature }) => Some(Ok(signature)),
@@ -104,7 +102,6 @@ impl<'a> CommitRefIter<'a> {
     ///
     /// It may contain white space surrounding it, and is exactly as
     //  parsed.
-    /// Errors are coerced into options, hiding whether there was an error or not. The caller knows if there was an error or not.
     pub fn message(mut self) -> Result<&'a BStr, crate::decode::Error> {
         self.find_map(|t| match t {
             Ok(Token::Message(msg)) => Some(Ok(msg)),

git-object/src/lib.rs

@@ -148,6 +148,7 @@ pub struct TagRef<'a> {
 
 /// Like [`TagRef`], but as `Iterator` to support entirely allocation free parsing.
 /// It's particularly useful to dereference only the target chain.
+#[derive(Copy, Clone)]
 pub struct TagRefIter<'a> {
     data: &'a [u8],
     state: tag::ref_iter::State,

git-object/src/tag/ref_iter.rs

@@ -9,6 +9,7 @@ use nom::{
 
 use crate::{bstr::ByteSlice, parse, parse::NL, tag::decode, Kind, TagRefIter};
 
+#[derive(Copy, Clone)]
 pub(crate) enum State {
     Target,
     TargetKind,
@@ -39,10 +40,21 @@ impl<'a> TagRefIter<'a> {
     /// Errors are coerced into options, hiding whether there was an error or not. The caller should assume an error if they
     /// call the method as intended. Such a squelched error cannot be recovered unless the objects data is retrieved and parsed again.
     /// `next()`.
-    pub fn target_id(&mut self) -> Result<ObjectId, crate::decode::Error> {
+    pub fn target_id(mut self) -> Result<ObjectId, crate::decode::Error> {
         let token = self.next().ok_or_else(missing_field)??;
         Token::into_id(token).ok_or_else(missing_field)
     }
+
+    /// Returns the taggers signature if there is no decoding error, and if this field exists.
+    /// Errors are coerced into options, hiding whether there was an error or not. The caller knows if there was an error or not.
+    pub fn tagger(mut self) -> Result<Option<git_actor::SignatureRef<'a>>, crate::decode::Error> {
+        self.find_map(|t| match t {
+            Ok(Token::Tagger(signature)) => Some(Ok(signature)),
+            Err(err) => Some(Err(err)),
+            _ => None,
+        })
+        .ok_or_else(missing_field)?
+    }
 }
 
 fn missing_field() -> crate::decode::Error {

git-object/tests/immutable/tag.rs

@@ -26,17 +26,21 @@ mod iter {
 
     #[test]
     fn empty() -> crate::Result {
+        let tag = fixture_bytes("tag", "empty.txt");
+        let tag_iter = TagRefIter::from_bytes(&tag);
+        let target_id = hex_to_id("01dd4e2a978a9f5bd773dae6da7aa4a5ac1cdbbc");
+        let tagger = Some(signature(1592381636));
         assert_eq!(
-            TagRefIter::from_bytes(&fixture_bytes("tag", "empty.txt")).collect::<Result<Vec<_>, _>>()?,
+            tag_iter.collect::<Result<Vec<_>, _>>()?,
             vec![
-                Token::Target {
-                    id: hex_to_id("01dd4e2a978a9f5bd773dae6da7aa4a5ac1cdbbc")
-                },
+                Token::Target { id: target_id },
                 Token::TargetKind(Kind::Commit),
                 Token::Name(b"empty".as_bstr()),
-                Token::Tagger(Some(signature(1592381636))),
+                Token::Tagger(tagger),
             ]
         );
+        assert_eq!(tag_iter.target_id()?, target_id);
+        assert_eq!(tag_iter.tagger()?, tagger);
         Ok(())
     }