migrate gix_object::{try_ =>}compute_hash users

emilazy · emilazy · commit 74eec435a9dc · 2025-04-02T17:36:18.000+01:00
Trivial rename.
diff --git a/gix-diff/tests/diff/main.rs b/gix-diff/tests/diff/main.rs
@@ -52,7 +52,7 @@ mod util {
     impl ObjectDb {
         /// Insert `data` and return its hash. That can be used to find it again.
         pub fn insert(&mut self, data: &str) -> Result<gix_hash::ObjectId, Error> {
-            let id = gix_object::try_compute_hash(gix_hash::Kind::Sha1, gix_object::Kind::Blob, data.as_bytes())?;
+            let id = gix_object::compute_hash(gix_hash::Kind::Sha1, gix_object::Kind::Blob, data.as_bytes())?;
             self.data_by_id.insert(id, data.into());
             Ok(id)
         }
diff --git a/gix-filter/src/ident.rs b/gix-filter/src/ident.rs
@@ -68,7 +68,7 @@ pub fn apply(src: &[u8], object_hash: gix_hash::Kind, buf: &mut Vec<u8>) -> Resu
     while let Some(pos) = src[ofs..].find(b"$Id$") {
         let id = match id {
             None => {
-                let new_id = gix_object::try_compute_hash(object_hash, gix_object::Kind::Blob, src)?;
+                let new_id = gix_object::compute_hash(object_hash, gix_object::Kind::Blob, src)?;
                 id = new_id.into();
                 clear_and_set_capacity(buf, src.len() + HASH_LEN)?; // pre-allocate for one ID
                 new_id
diff --git a/gix-merge/tests/merge/blob/mod.rs b/gix-merge/tests/merge/blob/mod.rs
@@ -44,7 +44,7 @@ mod util {
     impl ObjectDb {
         /// Insert `data` and return its hash. That can be used to find it again.
         pub fn insert(&mut self, data: &str) -> Result<gix_hash::ObjectId, Error> {
-            let id = gix_object::try_compute_hash(gix_hash::Kind::Sha1, gix_object::Kind::Blob, data.as_bytes())?;
+            let id = gix_object::compute_hash(gix_hash::Kind::Sha1, gix_object::Kind::Blob, data.as_bytes())?;
             self.data_by_id.insert(id, data.into());
             Ok(id)
         }
diff --git a/gix-object/benches/edit_tree.rs b/gix-object/benches/edit_tree.rs
@@ -147,7 +147,7 @@ fn new_inmemory_writes() -> (
         move |tree: &Tree| {
             buf.clear();
             tree.write_to(&mut buf)?;
-            let id = gix_object::try_compute_hash(gix_hash::Kind::Sha1, gix_object::Kind::Tree, &buf)?;
+            let id = gix_object::compute_hash(gix_hash::Kind::Sha1, gix_object::Kind::Tree, &buf)?;
             let mut borrowed = store.borrow_mut();
             match borrowed.entry(id) {
                 Entry::Occupied(_) => {}
diff --git a/gix-object/src/data.rs b/gix-object/src/data.rs
@@ -66,7 +66,7 @@ pub mod verify {
         /// If the hashes do not match, an [`Error`] is returned, containing the actual
         /// hash of `self`.
         pub fn verify_checksum(&self, expected: &gix_hash::oid) -> Result<gix_hash::ObjectId, Error> {
-            let actual = crate::try_compute_hash(expected.kind(), self.kind, self.data)?;
+            let actual = crate::compute_hash(expected.kind(), self.kind, self.data)?;
             actual.verify(expected)?;
             Ok(actual)
         }
diff --git a/gix-object/tests/object/main.rs b/gix-object/tests/object/main.rs
@@ -12,11 +12,11 @@ mod tree;
 fn compute_hash() {
     let hk = gix_hash::Kind::Sha1;
     assert_eq!(
-        gix_object::try_compute_hash(hk, gix_object::Kind::Blob, &[]).expect("empty hash doesn’t collide"),
+        gix_object::compute_hash(hk, gix_object::Kind::Blob, &[]).expect("empty hash doesn’t collide"),
         gix_hash::ObjectId::empty_blob(hk)
     );
     assert_eq!(
-        gix_object::try_compute_hash(hk, gix_object::Kind::Tree, &[]).expect("empty hash doesn’t collide"),
+        gix_object::compute_hash(hk, gix_object::Kind::Tree, &[]).expect("empty hash doesn’t collide"),
         gix_hash::ObjectId::empty_tree(hk)
     );
 }
diff --git a/gix-object/tests/object/tree/editor.rs b/gix-object/tests/object/tree/editor.rs
@@ -805,7 +805,7 @@ mod utils {
             move |tree: &Tree| {
                 buf.clear();
                 tree.write_to(&mut buf)?;
-                let id = gix_object::try_compute_hash(gix_hash::Kind::Sha1, gix_object::Kind::Tree, &buf)?;
+                let id = gix_object::compute_hash(gix_hash::Kind::Sha1, gix_object::Kind::Tree, &buf)?;
                 store.borrow_mut().insert(id, tree.clone());
                 let old = num_writes.get();
                 num_writes.set(old + 1);
diff --git a/gix-odb/src/memory.rs b/gix-odb/src/memory.rs
@@ -219,7 +219,7 @@ where
         let mut buf = Vec::new();
         from.read_to_end(&mut buf)?;
 
-        let id = gix_object::try_compute_hash(self.object_hash, kind, &buf)?;
+        let id = gix_object::compute_hash(self.object_hash, kind, &buf)?;
         map.borrow_mut().insert(id, (kind, buf));
         Ok(id)
     }
diff --git a/gix-pack/src/index/write/mod.rs b/gix-pack/src/index/write/mod.rs
@@ -258,7 +258,7 @@ fn modify_base(
     hash: gix_hash::Kind,
 ) -> Result<(), hasher::Error> {
     let object_kind = pack_entry.header.as_kind().expect("base object as source of iteration");
-    let id = gix_object::try_compute_hash(hash, object_kind, decompressed)?;
+    let id = gix_object::compute_hash(hash, object_kind, decompressed)?;
     entry.id = id;
     Ok(())
 }
diff --git a/gix-status/src/index_as_worktree/traits.rs b/gix-status/src/index_as_worktree/traits.rs
@@ -143,15 +143,15 @@ impl CompareBlobs for HashEq {
         let mut stream = data.stream_worktree_file()?;
         match stream.as_bytes() {
             Some(buffer) => {
-                let file_hash = gix_object::try_compute_hash(entry.id.kind(), gix_object::Kind::Blob, buffer)
+                let file_hash = gix_object::compute_hash(entry.id.kind(), gix_object::Kind::Blob, buffer)
                     .map_err(hasher::io::Error::from)?;
                 Ok((entry.id != file_hash).then_some(file_hash))
             }
             None => {
                 let file_hash = match stream.size() {
                     None => {
                         stream.read_to_end(buf).map_err(hasher::io::Error::from)?;
-                        gix_object::try_compute_hash(entry.id.kind(), gix_object::Kind::Blob, buf)
+                        gix_object::compute_hash(entry.id.kind(), gix_object::Kind::Blob, buf)
                             .map_err(hasher::io::Error::from)?
                     }
                     Some(len) => gix_object::compute_stream_hash(
diff --git a/gix-status/src/index_as_worktree_with_renames/mod.rs b/gix-status/src/index_as_worktree_with_renames/mod.rs
@@ -536,22 +536,20 @@ pub(super) mod function {
                             should_interrupt,
                         )
                         .map_err(Error::HashFile)?,
-                        ToGitOutcome::Buffer(buf) => {
-                            gix_object::try_compute_hash(object_hash, gix_object::Kind::Blob, buf)
-                                .map_err(|err| Error::HashFile(err.into()))?
-                        }
+                        ToGitOutcome::Buffer(buf) => gix_object::compute_hash(object_hash, gix_object::Kind::Blob, buf)
+                            .map_err(|err| Error::HashFile(err.into()))?,
                         ToGitOutcome::Process(mut stream) => {
                             buf.clear();
                             stream.read_to_end(buf).map_err(|err| Error::HashFile(err.into()))?;
-                            gix_object::try_compute_hash(object_hash, gix_object::Kind::Blob, buf)
+                            gix_object::compute_hash(object_hash, gix_object::Kind::Blob, buf)
                                 .map_err(|err| Error::HashFile(err.into()))?
                         }
                     }
                 }
                 Kind::Symlink => {
                     let path = worktree_root.join(gix_path::from_bstr(rela_path));
                     let target = gix_path::into_bstr(std::fs::read_link(path).map_err(Error::ReadLink)?);
-                    gix_object::try_compute_hash(object_hash, gix_object::Kind::Blob, &target)
+                    gix_object::compute_hash(object_hash, gix_object::Kind::Blob, &target)
                         .map_err(|err| Error::HashFile(err.into()))?
                 }
                 Kind::Directory | Kind::Repository => object_hash.null(),
diff --git a/gix/src/repository/impls.rs b/gix/src/repository/impls.rs
@@ -106,7 +106,7 @@ impl gix_object::Write for crate::Repository {
     }
 
     fn write_buf(&self, object: gix_object::Kind, from: &[u8]) -> Result<gix_hash::ObjectId, gix_object::write::Error> {
-        let oid = gix_object::try_compute_hash(self.object_hash(), object, from)?;
+        let oid = gix_object::compute_hash(self.object_hash(), object, from)?;
         if self.objects.exists(&oid) {
             return Ok(oid);
         }
diff --git a/gix/src/repository/object.rs b/gix/src/repository/object.rs
@@ -172,7 +172,7 @@ impl crate::Repository {
     }
 
     fn write_object_inner(&self, buf: &[u8], kind: gix_object::Kind) -> Result<Id<'_>, object::write::Error> {
-        let oid = gix_object::try_compute_hash(self.object_hash(), kind, buf)
+        let oid = gix_object::compute_hash(self.object_hash(), kind, buf)
             .map_err(|err| Box::new(err) as Box<dyn std::error::Error + Send + Sync>)?;
         if self.objects.exists(&oid) {
             return Ok(oid.attach(self));
@@ -190,7 +190,7 @@ impl crate::Repository {
     /// pre-hashing the data, and checking if the object is already present.
     pub fn write_blob(&self, bytes: impl AsRef<[u8]>) -> Result<Id<'_>, object::write::Error> {
         let bytes = bytes.as_ref();
-        let oid = gix_object::try_compute_hash(self.object_hash(), gix_object::Kind::Blob, bytes)
+        let oid = gix_object::compute_hash(self.object_hash(), gix_object::Kind::Blob, bytes)
             .map_err(|err| Box::new(err) as Box<dyn std::error::Error + Send + Sync>)?;
         if self.objects.exists(&oid) {
             return Ok(oid.attach(self));
@@ -216,7 +216,7 @@ impl crate::Repository {
     }
 
     fn write_blob_stream_inner(&self, buf: &[u8]) -> Result<Id<'_>, object::write::Error> {
-        let oid = gix_object::try_compute_hash(self.object_hash(), gix_object::Kind::Blob, buf)
+        let oid = gix_object::compute_hash(self.object_hash(), gix_object::Kind::Blob, buf)
             .map_err(|err| Box::new(err) as Box<dyn std::error::Error + Send + Sync>)?;
         if self.objects.exists(&oid) {
             return Ok(oid.attach(self));
diff --git a/tests/it/src/commands/git_to_sh.rs b/tests/it/src/commands/git_to_sh.rs
@@ -115,7 +115,7 @@ pub(super) mod function {
                             })?;
                             let mapped = crate::commands::copy_royal::remapped(data);
                             (
-                                gix::objs::try_compute_hash(
+                                gix::objs::compute_hash(
                                     repo.object_hash(),
                                     gix::object::Kind::Blob,
                                     mapped.as_bytes(),

Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ mod util {`
`52`	`52`	`impl ObjectDb {`
`53`	`53`	/// Insert `data` and return its hash. That can be used to find it again.
`54`	`54`	`pub fn insert(&mut self, data: &str) -> Result<gix_hash::ObjectId, Error> {`
`55`		`- let id = gix_object::try_compute_hash(gix_hash::Kind::Sha1, gix_object::Kind::Blob, data.as_bytes())?;`
	`55`	`+ let id = gix_object::compute_hash(gix_hash::Kind::Sha1, gix_object::Kind::Blob, data.as_bytes())?;`
`56`	`56`	`self.data_by_id.insert(id, data.into());`
`57`	`57`	`Ok(id)`
`58`	`58`	`}`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ mod util {`
`44`	`44`	`impl ObjectDb {`
`45`	`45`	/// Insert `data` and return its hash. That can be used to find it again.
`46`	`46`	`pub fn insert(&mut self, data: &str) -> Result<gix_hash::ObjectId, Error> {`
`47`		`- let id = gix_object::try_compute_hash(gix_hash::Kind::Sha1, gix_object::Kind::Blob, data.as_bytes())?;`
	`47`	`+ let id = gix_object::compute_hash(gix_hash::Kind::Sha1, gix_object::Kind::Blob, data.as_bytes())?;`
`48`	`48`	`self.data_by_id.insert(id, data.into());`
`49`	`49`	`Ok(id)`
`50`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ pub mod verify {`
`66`	`66`	/// If the hashes do not match, an [`Error`] is returned, containing the actual
`67`	`67`	/// hash of `self`.
`68`	`68`	`pub fn verify_checksum(&self, expected: &gix_hash::oid) -> Result<gix_hash::ObjectId, Error> {`
`69`		`- let actual = crate::try_compute_hash(expected.kind(), self.kind, self.data)?;`
	`69`	`+ let actual = crate::compute_hash(expected.kind(), self.kind, self.data)?;`
`70`	`70`	`actual.verify(expected)?;`
`71`	`71`	`Ok(actual)`
`72`	`72`	`}`
Original file line number	Diff line number	Diff line change
`@@ -219,7 +219,7 @@ where`
`219`	`219`	`let mut buf = Vec::new();`
`220`	`220`	`from.read_to_end(&mut buf)?;`
`221`	`221`
`222`		`- let id = gix_object::try_compute_hash(self.object_hash, kind, &buf)?;`
	`222`	`+ let id = gix_object::compute_hash(self.object_hash, kind, &buf)?;`
`223`	`223`	`map.borrow_mut().insert(id, (kind, buf));`
`224`	`224`	`Ok(id)`
`225`	`225`	`}`
Original file line number	Diff line number	Diff line change
`@@ -258,7 +258,7 @@ fn modify_base(`
`258`	`258`	`hash: gix_hash::Kind,`
`259`	`259`	`) -> Result<(), hasher::Error> {`
`260`	`260`	`let object_kind = pack_entry.header.as_kind().expect("base object as source of iteration");`
`261`		`- let id = gix_object::try_compute_hash(hash, object_kind, decompressed)?;`
	`261`	`+ let id = gix_object::compute_hash(hash, object_kind, decompressed)?;`
`262`	`262`	`entry.id = id;`
`263`	`263`	`Ok(())`
`264`	`264`	`}`