Adapt to changes in gix-object

Co-authored-by: Sebastian Thiel <sebastian.thiel@icloud.com>

Author: codex

gitoxide-core/src/hours/mod.rs

@@ -83,8 +83,9 @@ fn parse_trailer_identity(trailer: gix::objs::commit::message::body::TrailerRef<
 /// Return `(commit_author, [commit_author, co_authors...])`. Use the `commit_author` for easy access to the commit author itself.
 fn commit_author_identities(
     commit_data: &[u8],
+    hash_kind: gix::hash::Kind,
 ) -> Result<(gix::actor::SignatureRef<'_>, SmallVec<[ParsedIdentity<'_>; 2]>), gix::objs::decode::Error> {
-    let commit = gix::objs::CommitRef::from_bytes(commit_data)?;
+    let commit = gix::objs::CommitRef::from_bytes(commit_data, hash_kind)?;
     let author = commit.author()?.trim();
     let mut authors = smallvec![ParsedIdentity::Borrowed(gix::actor::IdentityRef::from(author))];
     authors.extend(commit.co_authored_by_trailers().filter_map(parse_trailer_identity));
@@ -130,7 +131,7 @@ where
             let extract_signatures = scope.spawn(move || -> anyhow::Result<Vec<_>> {
                 let mut out = Vec::new();
                 for (commit_idx, commit_data) in rx {
-                    if let Ok((commit_author, authors)) = commit_author_identities(&commit_data) {
+                    if let Ok((commit_author, authors)) = commit_author_identities(&commit_data, commit_id.kind()) {
                         let mut string_ref = |s: &[u8]| -> &'static BStr {
                             match string_heap.get(s) {
                                 Some(n) => n.as_bstr(),
@@ -445,7 +446,7 @@ body\n\
 \n\
 Co-authored-by: Second Author <second@example.com>\n\
 Co-authored-by: Third Author <third@example.com>\n";
-        let (author, authors) = commit_author_identities(commit).expect("valid commit");
+        let (author, authors) = commit_author_identities(commit, gix::hash::Kind::Sha1).expect("valid commit");
         assert_eq!(author.time, "1710000000 +0000");
         assert_eq!(
             authors
@@ -478,7 +479,7 @@ committer Main Author <main@example.com> 1710000000 +0000\n\
 subject\n\
 \n\
 Co-authored-by: not a signature\n";
-        let (_, authors) = commit_author_identities(commit).expect("valid commit");
+        let (_, authors) = commit_author_identities(commit, gix::hash::Kind::Sha1).expect("valid commit");
         assert_eq!(authors.len(), 1);
         assert_eq!(authors[0].name(), "Main Author".as_bytes().as_bstr());
         assert_eq!(authors[0].email(), "main@example.com".as_bytes().as_bstr());

gitoxide-core/src/query/engine/update.rs

@@ -395,7 +395,7 @@ pub fn update(
                 self.progress.inc();
                 if self.known_commits.binary_search(&id.to_owned()).is_err() {
                     let res = {
-                        let mut parents = gix::objs::CommitRefIter::from_bytes(obj.data).parent_ids();
+                        let mut parents = gix::objs::CommitRefIter::from_bytes(obj.data, obj.hash_kind).parent_ids();
                         let res = parents.next().map(|first_parent| (Some(first_parent), id.to_owned()));
                         match parents.next() {
                             Some(_) => None,

gix-pack/src/data/output/count/objects/mod.rs

@@ -175,7 +175,7 @@ mod expand {
                         match obj.kind {
                             Tree | Blob => break,
                             Tag => {
-                                id = TagRefIter::from_bytes(obj.data)
+                                id = TagRefIter::from_bytes(obj.data, obj.hash_kind)
                                     .target_id()
                                     .expect("every tag has a target");
                                 let tmp = db.find(&id, buf1)?;
@@ -188,7 +188,7 @@ mod expand {
                             }
                             Commit => {
                                 let current_tree_iter = {
-                                    let mut commit_iter = CommitRefIter::from_bytes(obj.data);
+                                    let mut commit_iter = CommitRefIter::from_bytes(obj.data, obj.hash_kind);
                                     let tree_id = commit_iter.tree_id().expect("every commit has a tree");
                                     parent_commit_ids.clear();
                                     for token in commit_iter {
@@ -227,9 +227,12 @@ mod expand {
                                             push_obj_count_unique(
                                                 &mut out, seen_objs, commit_id, location, objects, stats, true,
                                             );
-                                            CommitRefIter::from_bytes(parent_commit_obj.data)
-                                                .tree_id()
-                                                .expect("every commit has a tree")
+                                            CommitRefIter::from_bytes(
+                                                parent_commit_obj.data,
+                                                parent_commit_obj.hash_kind,
+                                            )
+                                            .tree_id()
+                                            .expect("every commit has a tree")
                                         };
                                         let parent_tree = {
                                             let (parent_tree_obj, location) = db.find(&parent_tree_id, buf2)?;
@@ -296,7 +299,7 @@ mod expand {
                                 break;
                             }
                             Commit => {
-                                id = CommitRefIter::from_bytes(obj.0.data)
+                                id = CommitRefIter::from_bytes(obj.0.data, obj.0.hash_kind)
                                     .tree_id()
                                     .expect("every commit has a tree");
                                 stats.expanded_objects += 1;
@@ -305,7 +308,7 @@ mod expand {
                             }
                             Blob => break,
                             Tag => {
-                                id = TagRefIter::from_bytes(obj.0.data)
+                                id = TagRefIter::from_bytes(obj.0.data, obj.0.hash_kind)
                                     .target_id()
                                     .expect("every tag has a target");
                                 stats.expanded_objects += 1;

gix-ref/src/store/file/raw_ext.rs

@@ -160,24 +160,21 @@ impl ReferenceExt for Reference {
                 let mut oid = self.follow_to_object_packed(store, packed)?;
                 let mut buf = Vec::new();
                 let peeled_id = loop {
-                    let gix_object::Data {
-                        kind,
-                        data,
-                        hash_kind: _,
-                    } = objects
-                        .try_find(&oid, &mut buf)?
-                        .ok_or_else(|| peel::to_id::Error::NotFound {
-                            oid,
-                            name: self.name.0.clone(),
-                        })?;
+                    let gix_object::Data { kind, data, hash_kind } =
+                        objects
+                            .try_find(&oid, &mut buf)?
+                            .ok_or_else(|| peel::to_id::Error::NotFound {
+                                oid,
+                                name: self.name.0.clone(),
+                            })?;
                     match kind {
                         gix_object::Kind::Tag => {
-                            oid = gix_object::TagRefIter::from_bytes(data).target_id().map_err(|_err| {
-                                peel::to_id::Error::NotFound {
+                            oid = gix_object::TagRefIter::from_bytes(data, hash_kind)
+                                .target_id()
+                                .map_err(|_err| peel::to_id::Error::NotFound {
                                     oid,
                                     name: self.name.0.clone(),
-                                }
-                            })?;
+                                })?;
                         }
                         _ => break oid,
                     }

gix-ref/src/store/packed/transaction.rs

@@ -107,14 +107,20 @@ impl packed::Transaction {
             {
                 let mut next_id = new;
                 edit.peeled = loop {
-                    let kind = objects.try_find(&next_id, &mut buf)?.map(|d| d.kind);
-                    match kind {
-                        Some(gix_object::Kind::Tag) => {
-                            next_id = gix_object::TagRefIter::from_bytes(&buf).target_id().map_err(|_| {
-                                prepare::Error::Resolve(
-                                    format!("Couldn't get target object id from tag {next_id}").into(),
-                                )
-                            })?;
+                    let data = objects.try_find(&next_id, &mut buf)?;
+                    match data {
+                        Some(gix_object::Data {
+                            kind: gix_object::Kind::Tag,
+                            data,
+                            hash_kind,
+                        }) => {
+                            next_id = gix_object::TagRefIter::from_bytes(data, hash_kind)
+                                .target_id()
+                                .map_err(|_| {
+                                    prepare::Error::Resolve(
+                                        format!("Couldn't get target object id from tag {next_id}").into(),
+                                    )
+                                })?;
                         }
                         Some(_) => {
                             break if next_id == new { None } else { Some(next_id) };

gix-revwalk/src/graph/commit.rs

@@ -8,7 +8,7 @@ impl<'graph, 'cache> LazyCommit<'graph, 'cache> {
     /// Return an iterator over the parents of this commit.
     pub fn iter_parents(&self) -> Parents<'graph, 'cache> {
         let backing = match &self.backing {
-            Either::Left(buf) => Either::Left(gix_object::CommitRefIter::from_bytes(buf)),
+            Either::Left(buf) => Either::Left(gix_object::CommitRefIter::from_bytes(buf, self.hash_kind)),
             Either::Right((cache, pos)) => Either::Right((*cache, cache.commit_at(*pos).iter_parents())),
         };
         Parents { backing }
@@ -20,7 +20,9 @@ impl<'graph, 'cache> LazyCommit<'graph, 'cache> {
     /// Note that this can only fail if the commit is backed by the object database *and* parsing fails.
     pub fn committer_timestamp(&self) -> Result<SecondsSinceUnixEpoch, gix_object::decode::Error> {
         Ok(match &self.backing {
-            Either::Left(buf) => gix_object::CommitRefIter::from_bytes(buf).committer()?.seconds(),
+            Either::Left(buf) => gix_object::CommitRefIter::from_bytes(buf, self.hash_kind)
+                .committer()?
+                .seconds(),
             Either::Right((cache, pos)) => cache.commit_at(*pos).committer_timestamp() as SecondsSinceUnixEpoch, // a cast as we cannot represent the error and trying seems overkill
         })
     }
@@ -38,7 +40,12 @@ impl<'graph, 'cache> LazyCommit<'graph, 'cache> {
         &self,
     ) -> Result<(Option<Generation>, SecondsSinceUnixEpoch), gix_object::decode::Error> {
         Ok(match &self.backing {
-            Either::Left(buf) => (None, gix_object::CommitRefIter::from_bytes(buf).committer()?.seconds()),
+            Either::Left(buf) => (
+                None,
+                gix_object::CommitRefIter::from_bytes(buf, self.hash_kind)
+                    .committer()?
+                    .seconds(),
+            ),
             Either::Right((cache, pos)) => {
                 let commit = cache.commit_at(*pos);
                 (
@@ -57,7 +64,7 @@ impl<'graph, 'cache> LazyCommit<'graph, 'cache> {
         Ok(match &self.backing {
             Either::Left(buf) => {
                 use gix_object::commit::ref_iter::Token;
-                let iter = gix_object::CommitRefIter::from_bytes(buf);
+                let iter = gix_object::CommitRefIter::from_bytes(buf, self.hash_kind);
                 let mut parents = SmallVec::default();
                 let mut timestamp = None;
                 for token in iter {

gix-revwalk/src/graph/mod.rs

@@ -369,6 +369,7 @@ fn try_lookup<'graph, 'cache>(
     if let Some(cache) = cache {
         if let Some(pos) = cache.lookup(id) {
             return Ok(Some(LazyCommit {
+                hash_kind: id.kind(),
                 backing: Either::Right((cache, pos)),
             }));
         }
@@ -380,6 +381,7 @@ fn try_lookup<'graph, 'cache>(
             .map_err(gix_object::find::existing_iter::Error::Find)?
         {
             Some(data) => data.kind.is_commit().then_some(LazyCommit {
+                hash_kind: data.hash_kind,
                 backing: Either::Left(buf),
             }),
             None => None,
@@ -439,6 +441,7 @@ where
 ///
 /// The owned version of this type is called [`Commit`] and can be obtained by calling [`LazyCommit::to_owned()`].
 pub struct LazyCommit<'graph, 'cache> {
+    hash_kind: gix_hash::Kind,
     backing: Either<&'graph [u8], (&'cache gix_commitgraph::Graph, gix_commitgraph::Position)>,
 }
 

gix-traverse/src/commit/simple.rs

@@ -138,6 +138,10 @@ pub(super) struct State {
     queue: CommitDateQueue,
     /// Backing storage for the currently yielded commit.
     buf: Vec<u8>,
+    /// The object hash kind of the currently yielded commit data in `buf`.
+    /// It's used to know the kind of hash to expect when a new iterator is returned from `buf`
+    /// via `Simple::commit_iter()`.
+    object_hash: gix_hash::Kind,
     /// Set of commits that were already enqueued for the visible traversal, for cycle-checking.
     seen: gix_hashtable::HashSet<ObjectId>,
     /// Hidden frontier commits that must not be yielded or crossed during traversal.
@@ -247,6 +251,7 @@ mod init {
                 next: Default::default(),
                 queue: gix_revwalk::PriorityQueue::new(),
                 buf: vec![],
+                object_hash: gix_hash::Kind::Sha1,
                 seen: Default::default(),
                 hidden: Default::default(),
                 hidden_tips: Vec::new(),
@@ -262,6 +267,7 @@ mod init {
                 next,
                 queue,
                 buf,
+                object_hash,
                 seen,
                 hidden,
                 hidden_tips,
@@ -271,6 +277,7 @@ mod init {
             next.clear();
             queue.clear();
             buf.clear();
+            *object_hash = gix_hash::Kind::Sha1;
             seen.clear();
             hidden.clear();
             hidden_tips.clear();
@@ -464,7 +471,7 @@ mod init {
     impl<Find, Predicate> Simple<Find, Predicate> {
         /// Return an iterator for accessing data of the current commit, parsed lazily.
         pub fn commit_iter(&self) -> CommitRefIter<'_> {
-            CommitRefIter::from_bytes(self.commit_data())
+            CommitRefIter::from_bytes(self.commit_data(), self.state.object_hash)
         }
 
         /// Return the current commits' raw data, which can be parsed using [`gix_object::CommitRef::from_bytes()`].
@@ -519,6 +526,7 @@ mod init {
                 let (commit_time, oid) = match next.pop()? {
                     (Ok(t) | Err(Reverse(t)), o) => (t, o),
                 };
+                state.object_hash = oid.kind();
                 if state.hidden.contains_key(&oid) {
                     continue;
                 }
@@ -592,6 +600,7 @@ mod init {
 
             loop {
                 let oid = next.pop_front()?;
+                state.object_hash = oid.kind();
                 if state.hidden.contains_key(&oid) {
                     continue;
                 }

gix/src/object/commit.rs

@@ -86,7 +86,7 @@ impl<'repo> Commit<'repo> {
     /// # Ok(()) }
     /// ```
     pub fn message_raw(&self) -> Result<&'_ BStr, gix_object::decode::Error> {
-        gix_object::CommitRefIter::from_bytes(&self.data).message()
+        gix_object::CommitRefIter::from_bytes(&self.data, self.id.kind()).message()
     }
     /// Obtain the message by using intricate knowledge about the encoding, which is fastest and
     /// can't fail at the expense of error handling.
@@ -114,24 +114,24 @@ impl<'repo> Commit<'repo> {
     /// used for successive calls to string-ish information to avoid decoding the object
     /// more than once.
     pub fn decode(&self) -> Result<gix_object::CommitRef<'_>, gix_object::decode::Error> {
-        gix_object::CommitRef::from_bytes(&self.data)
+        gix_object::CommitRef::from_bytes(&self.data, self.id.kind())
     }
 
     /// Return an iterator over tokens, representing this commit piece by piece.
     pub fn iter(&self) -> gix_object::CommitRefIter<'_> {
-        gix_object::CommitRefIter::from_bytes(&self.data)
+        gix_object::CommitRefIter::from_bytes(&self.data, self.id.kind())
     }
 
     /// Return the commits author, with surrounding whitespace trimmed.
     pub fn author(&self) -> Result<gix_actor::SignatureRef<'_>, gix_object::decode::Error> {
-        gix_object::CommitRefIter::from_bytes(&self.data)
+        gix_object::CommitRefIter::from_bytes(&self.data, self.id.kind())
             .author()
             .map(|s| s.trim())
     }
 
     /// Return the commits committer. with surrounding whitespace trimmed.
     pub fn committer(&self) -> Result<gix_actor::SignatureRef<'_>, gix_object::decode::Error> {
-        gix_object::CommitRefIter::from_bytes(&self.data)
+        gix_object::CommitRefIter::from_bytes(&self.data, self.id.kind())
             .committer()
             .map(|s| s.trim())
     }
@@ -153,7 +153,7 @@ impl<'repo> Commit<'repo> {
     pub fn parent_ids(&self) -> impl Iterator<Item = crate::Id<'repo>> + '_ {
         use crate::ext::ObjectIdExt;
         let repo = self.repo;
-        gix_object::CommitRefIter::from_bytes(&self.data)
+        gix_object::CommitRefIter::from_bytes(&self.data, self.id.kind())
             .parent_ids()
             .map(move |id| id.attach(repo))
     }
@@ -181,7 +181,7 @@ impl<'repo> Commit<'repo> {
 
     /// Parse the commit and return the tree id it points to.
     pub fn tree_id(&self) -> Result<crate::Id<'repo>, gix_object::decode::Error> {
-        gix_object::CommitRefIter::from_bytes(&self.data)
+        gix_object::CommitRefIter::from_bytes(&self.data, self.id.kind())
             .tree_id()
             .map(|id| crate::Id::from_id(id, self.repo))
     }
@@ -217,7 +217,7 @@ impl<'repo> Commit<'repo> {
         &self,
     ) -> Result<Option<(std::borrow::Cow<'_, BStr>, gix_object::commit::SignedData<'_>)>, gix_object::decode::Error>
     {
-        gix_object::CommitRefIter::signature(&self.data)
+        gix_object::CommitRefIter::signature(&self.data, self.id.kind())
     }
 }
 

gix/src/object/tag.rs

@@ -9,19 +9,19 @@ impl<'repo> Tag<'repo> {
     /// used for successive calls to string-ish information to avoid decoding the object
     /// more than once.
     pub fn decode(&self) -> Result<gix_object::TagRef<'_>, gix_object::decode::Error> {
-        gix_object::TagRef::from_bytes(&self.data)
+        gix_object::TagRef::from_bytes(&self.data, self.id.kind())
     }
 
     /// Decode this tag partially and return the id of its target.
     pub fn target_id(&self) -> Result<crate::Id<'repo>, gix_object::decode::Error> {
-        gix_object::TagRefIter::from_bytes(&self.data)
+        gix_object::TagRefIter::from_bytes(&self.data, self.id.kind())
             .target_id()
             .map(|id| id.attach(self.repo))
     }
 
     /// Decode this tag partially and return the tagger, if the field exists.
     pub fn tagger(&self) -> Result<Option<gix_actor::SignatureRef<'_>>, gix_object::decode::Error> {
-        gix_object::TagRefIter::from_bytes(&self.data).tagger()
+        gix_object::TagRefIter::from_bytes(&self.data, self.id.kind()).tagger()
     }
 }