fix!: remove panicking version of ObjectId::from() in favor of ObjectId::from_bytes_or_panic().

We also add an `&oid::try_from()` implementation for good measure, which is hard to call in
practice but certainly not impossible.

Author: Byron

gix-hash/src/lib.rs

@@ -11,7 +11,7 @@
 
 #[path = "oid.rs"]
 mod borrowed;
-pub use borrowed::oid;
+pub use borrowed::{oid, Error};
 
 mod object_id;
 pub use object_id::{decode, ObjectId};

gix-hash/src/object_id.rs

@@ -1,6 +1,5 @@
 use std::{
     borrow::Borrow,
-    convert::TryInto,
     hash::{Hash, Hasher},
     ops::Deref,
 };
@@ -152,6 +151,19 @@ impl ObjectId {
     }
 }
 
+/// Lifecycle
+impl ObjectId {
+    /// Convert `bytes` into an owned object Id or panic if the slice length doesn't indicate a supported hash.
+    ///
+    /// Use `Self::try_from(bytes)` for a fallible version.
+    pub fn from_bytes_or_panic(bytes: &[u8]) -> Self {
+        match bytes.len() {
+            20 => Self::Sha1(bytes.try_into().expect("prior length validation")),
+            other => panic!("BUG: unsupported hash len: {other}"),
+        }
+    }
+}
+
 /// Sha1 hash specific methods
 impl ObjectId {
     /// Instantiate an Digest from 20 bytes of a Sha1 digest.
@@ -195,15 +207,6 @@ impl From<[u8; SIZE_OF_SHA1_DIGEST]> for ObjectId {
     }
 }
 
-impl From<&[u8]> for ObjectId {
-    fn from(v: &[u8]) -> Self {
-        match v.len() {
-            20 => Self::Sha1(v.try_into().expect("prior length validation")),
-            other => panic!("BUG: unsupported hash len: {other}"),
-        }
-    }
-}
-
 impl From<&oid> for ObjectId {
     fn from(v: &oid) -> Self {
         match v.kind() {
@@ -212,6 +215,14 @@ impl From<&oid> for ObjectId {
     }
 }
 
+impl TryFrom<&[u8]> for ObjectId {
+    type Error = crate::Error;
+
+    fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
+        Ok(oid::try_from_bytes(bytes)?.into())
+    }
+}
+
 impl Deref for ObjectId {
     type Target = oid;
 

gix-hash/src/oid.rs

@@ -1,4 +1,4 @@
-use std::{convert::TryInto, fmt, hash};
+use std::{convert::TryInto, hash};
 
 use crate::{Kind, ObjectId, SIZE_OF_SHA1_DIGEST};
 
@@ -41,28 +41,30 @@ pub struct HexDisplay<'a> {
     hex_len: usize,
 }
 
-impl<'a> fmt::Display for HexDisplay<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut hex = crate::Kind::hex_buf();
+impl<'a> std::fmt::Display for HexDisplay<'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut hex = Kind::hex_buf();
         let max_len = self.inner.hex_to_buf(hex.as_mut());
         let hex = std::str::from_utf8(&hex[..self.hex_len.min(max_len)]).expect("ascii only in hex");
         f.write_str(hex)
     }
 }
 
-impl fmt::Debug for oid {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::fmt::Result {
+impl std::fmt::Debug for oid {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
             "{}({})",
             match self.kind() {
-                crate::Kind::Sha1 => "Sha1",
+                Kind::Sha1 => "Sha1",
             },
             self.to_hex(),
         )
     }
 }
 
+/// The error returned when trying to convert a byte slice to an [`oid`] or [`ObjectId`]
+#[allow(missing_docs)]
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
     #[error("Cannot instantiate git hash from a digest of length {0}")]
@@ -104,8 +106,8 @@ impl oid {
 impl oid {
     /// The kind of hash used for this instance.
     #[inline]
-    pub fn kind(&self) -> crate::Kind {
-        crate::Kind::from_len_in_bytes(self.bytes.len())
+    pub fn kind(&self) -> Kind {
+        Kind::from_len_in_bytes(self.bytes.len())
     }
 
     /// The first byte of the hash, commonly used to partition a set of object ids.
@@ -164,7 +166,7 @@ impl oid {
     /// Write ourselves to `out` in hexadecimal notation.
     #[inline]
     pub fn write_hex_to(&self, out: &mut dyn std::io::Write) -> std::io::Result<()> {
-        let mut hex = crate::Kind::hex_buf();
+        let mut hex = Kind::hex_buf();
         let hex_len = self.hex_to_buf(&mut hex);
         out.write_all(&hex[..hex_len])
     }
@@ -182,12 +184,20 @@ impl AsRef<oid> for &oid {
     }
 }
 
+impl<'a> TryFrom<&'a [u8]> for &'a oid {
+    type Error = Error;
+
+    fn try_from(value: &'a [u8]) -> Result<Self, Self::Error> {
+        oid::try_from_bytes(value)
+    }
+}
+
 impl ToOwned for oid {
-    type Owned = crate::ObjectId;
+    type Owned = ObjectId;
 
     fn to_owned(&self) -> Self::Owned {
         match self.kind() {
-            crate::Kind::Sha1 => crate::ObjectId::Sha1(self.bytes.try_into().expect("no bug in hash detection")),
+            Kind::Sha1 => ObjectId::Sha1(self.bytes.try_into().expect("no bug in hash detection")),
         }
     }
 }
@@ -198,16 +208,16 @@ impl<'a> From<&'a [u8; SIZE_OF_SHA1_DIGEST]> for &'a oid {
     }
 }
 
-impl fmt::Display for &oid {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl std::fmt::Display for &oid {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         for b in self.as_bytes() {
             write!(f, "{b:02x}")?;
         }
         Ok(())
     }
 }
 
-impl PartialEq<crate::ObjectId> for &oid {
+impl PartialEq<ObjectId> for &oid {
     fn eq(&self, other: &ObjectId) -> bool {
         *self == other.as_ref()
     }