[pack-gen] tag support for tree traversal

Author: Byron

git-object/src/immutable/commit.rs

@@ -179,8 +179,8 @@ pub mod iter {
         /// Returns the object id of this commits tree if it is the first function called and if there is no error in decoding
         /// the data.
         ///
-        /// Note that this method must only be called once or else will always return None while consuming a single token by calling
-        /// Errors are coerced into options, hiding whether there was an error or not. THe caller should assume an error if they
+        /// Note that this method must only be called once or else will always return None while consuming a single token.
+        /// 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 tree_id(&mut self) -> Option<ObjectId> {

git-object/src/immutable/tag.rs

@@ -167,6 +167,17 @@ pub mod iter {
                 state: State::default(),
             }
         }
+
+        /// Returns the target id of this tag if it is the first function called and if there is no error in decoding
+        /// the data.
+        ///
+        /// Note that this method must only be called once or else will always return None while consuming a single token.
+        /// 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) -> Option<ObjectId> {
+            self.next().and_then(Result::ok).and_then(Token::into_id)
+        }
     }
 
     impl<'a> Iter<'a> {

git-odb/src/pack/data/output/objects_to_entries.rs

@@ -214,17 +214,24 @@ where
                                         break;
                                     }
                                     Commit => {
-                                        let tree_id = immutable::CommitIter::from_bytes(obj.data)
+                                        id = immutable::CommitIter::from_bytes(obj.data)
                                             .tree_id()
                                             .expect("every commit has a tree");
-                                        obj = db.find_existing(tree_id, buf1, cache).map_err(|_| Error::NotFound {
-                                            oid: tree_id.to_owned(),
-                                        })?;
-                                        id = tree_id;
+                                        obj = db
+                                            .find_existing(id, buf1, cache)
+                                            .map_err(|_| Error::NotFound { oid: id.to_owned() })?;
                                         continue;
                                     }
                                     Blob => break,
-                                    Tag => todo!("expand tag objects (here and in other places)"),
+                                    Tag => {
+                                        id = immutable::TagIter::from_bytes(obj.data)
+                                            .target_id()
+                                            .expect("every tag has a target");
+                                        obj = db
+                                            .find_existing(id, buf1, cache)
+                                            .map_err(|_| Error::NotFound { oid: id.to_owned() })?;
+                                        continue;
+                                    }
                                 }
                             }
                         }

git-odb/tests/odb/pack/data/output.rs

@@ -66,25 +66,27 @@ mod entries {
                 trees: usize,
                 commits: usize,
                 blobs: usize,
+                tags: usize,
             }
             impl Count {
                 fn total(&self) -> usize {
-                    self.trees + self.commits + self.blobs
+                    self.tags + self.trees + self.commits + self.blobs
                 }
                 fn add(&mut self, kind: git_object::Kind) {
                     use git_object::Kind::*;
                     match kind {
                         Tree => self.trees += 1,
                         Commit => self.commits += 1,
                         Blob => self.blobs += 1,
-                        Tag => unreachable!("tags are not in our test repository"),
+                        Tag => self.tags += 1,
                     }
                 }
             }
             let whole_pack = Count {
-                trees: 39,
-                commits: 15,
-                blobs: 810,
+                trees: 40,
+                commits: 16,
+                blobs: 811,
+                tags: 1,
             };
             for (expansion_mode, expected_count) in [
                 (
@@ -93,6 +95,7 @@ mod entries {
                         trees: 0,
                         commits: 15,
                         blobs: 0,
+                        tags: 1,
                     },
                 ),
                 (output::objects_to_entries::ObjectExpansion::TreeContents, whole_pack),