Merge branch 'kalkin-improve-prefix'

Author: Byron

etc/check-package-size.sh

@@ -30,7 +30,7 @@ echo "in root: gitoxide CLI"
 (enter git-tempfile && indent cargo diet -n --package-size-limit 25KB)
 (enter git-lock && indent cargo diet -n --package-size-limit 15KB)
 (enter git-config && indent cargo diet -n --package-size-limit 70KB)
-(enter git-hash && indent cargo diet -n --package-size-limit 15KB)
+(enter git-hash && indent cargo diet -n --package-size-limit 20KB)
 (enter git-chunk && indent cargo diet -n --package-size-limit 10KB)
 (enter git-rebase && indent cargo diet -n --package-size-limit 5KB)
 (enter git-sequencer && indent cargo diet -n --package-size-limit 5KB)

git-hash/src/lib.rs

@@ -144,6 +144,16 @@ impl Kind {
         }
     }
 
+    /// Returns the kind of hash that would fit the given `hex_len`, or `None` if there is no fitting hash.
+    /// Note that 0 as `hex_len` fits always yields Sha1.
+    #[inline]
+    pub const fn from_hex_len(hex_len: usize) -> Option<Self> {
+        Some(match hex_len {
+            0..=40 => Kind::Sha1,
+            _ => return None,
+        })
+    }
+
     /// Converts a size in bytes as obtained by `Kind::len_in_bytes()` into the corresponding hash kind, if possible.
     ///
     /// **Panics** if the hash length doesn't match a known hash.

git-hash/src/owned.rs

@@ -4,7 +4,7 @@ use crate::{borrowed::oid, Kind, SIZE_OF_SHA1_DIGEST};
 
 /// An partial owned hash possibly identifying an object uniquely,
 /// whose non-prefix bytes are zeroed.
-#[derive(PartialEq, Eq, Hash, Ord, PartialOrd, Clone, Copy)]
+#[derive(PartialEq, Eq, Hash, Ord, PartialOrd, Clone, Copy, Debug)]
 #[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
 pub struct Prefix {
     bytes: ObjectId,

git-hash/src/owned/prefix.rs

@@ -1,23 +1,47 @@
 use std::cmp::Ordering;
+use std::convert::TryFrom;
 
 use quick_error::quick_error;
 
 use crate::{oid, ObjectId, Prefix};
 
+const MIN_HEX_LEN: usize = 4;
+
 quick_error! {
     /// The error returned by [Prefix::try_from_id()][super::Prefix::try_from_id()].
     #[derive(Debug)]
     #[allow(missing_docs)]
     pub enum Error {
         TooShort { hex_len: usize } {
-            display("The minimum hex length of a short object id is 4, got {}", hex_len)
+            display("The minimum hex length of a short object id is {}, got {}", MIN_HEX_LEN, hex_len)
         }
         TooLong { object_kind: crate::Kind, hex_len: usize } {
             display("An object of kind {} cannot be larger than {} in hex, but {} was requested", object_kind, object_kind.len_in_hex(), hex_len)
         }
     }
 }
 
+///
+pub mod from_hex {
+    use quick_error::quick_error;
+    quick_error! {
+        /// The error returned by [Prefix::from_hex][super::Prefix::from_hex()].
+        #[derive(Debug, PartialEq)]
+        #[allow(missing_docs)]
+        pub enum Error {
+            TooShort { hex_len: usize } {
+                display("The minimum hex length of a short object id is {}, got {}", super::MIN_HEX_LEN, hex_len)
+            }
+            TooLong { hex_len: usize } {
+                display("An id cannot be larger than {} chars in hex, but {} was requested", crate::Kind::longest().len_in_hex(), hex_len)
+            }
+            Invalid { c: char, index: usize } {
+                display("Invalid character {} at position {}", c, index)
+            }
+        }
+    }
+}
+
 impl Prefix {
     /// Create a new instance by taking a full `id` as input and truncating it to `hex_len`.
     ///
@@ -30,7 +54,7 @@ impl Prefix {
                 object_kind: id.kind(),
                 hex_len,
             })
-        } else if hex_len < 4 {
+        } else if hex_len < MIN_HEX_LEN {
             Err(Error::TooShort { hex_len })
         } else {
             let mut prefix = ObjectId::null(id.kind());
@@ -75,9 +99,46 @@ impl Prefix {
             })
     }
 
-    /// Create an instance from the given hexadecimal prefix, e.g. `35e77c16` would yield a `Prefix` with `hex_len()` = 8.
-    pub fn from_hex(_hex: &str) -> Self {
-        todo!("Prefix::from_hex()")
+    /// Create an instance from the given hexadecimal prefix `value`, e.g. `35e77c16` would yield a `Prefix` with `hex_len()` = 8.
+    pub fn from_hex(value: &str) -> Result<Self, from_hex::Error> {
+        use hex::FromHex;
+        let hex_len = value.len();
+
+        if hex_len > crate::Kind::longest().len_in_hex() {
+            return Err(from_hex::Error::TooLong { hex_len });
+        } else if hex_len < MIN_HEX_LEN {
+            return Err(from_hex::Error::TooShort { hex_len });
+        };
+
+        let src = if value.len() % 2 == 0 {
+            Vec::from_hex(value)
+        } else {
+            let mut buf = [0u8; crate::Kind::longest().len_in_hex()];
+            buf[..value.len()].copy_from_slice(value.as_bytes());
+            buf[value.len()] = b'0';
+            Vec::from_hex(&buf[..value.len() + 1])
+        }
+        .map_err(|e| match e {
+            hex::FromHexError::InvalidHexCharacter { c, index } => from_hex::Error::Invalid { c, index },
+            hex::FromHexError::OddLength | hex::FromHexError::InvalidStringLength => panic!("This is already checked"),
+        })?;
+
+        let mut bytes = ObjectId::null(crate::Kind::from_hex_len(value.len()).expect("hex-len is already checked"));
+        let dst = bytes.as_mut_slice();
+        let copy_len = src.len();
+        dst[..copy_len].copy_from_slice(&src);
+
+        Ok(Prefix { bytes, hex_len })
+    }
+}
+
+/// Create an instance from the given hexadecimal prefix, e.g. `35e77c16` would yield a `Prefix`
+/// with `hex_len()` = 8.
+impl TryFrom<&str> for Prefix {
+    type Error = from_hex::Error;
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        Prefix::from_hex(value)
     }
 }
 

git-hash/tests/integration.rs

@@ -1 +1,2 @@
+mod kind;
 mod oid;

git-hash/tests/kind/mod.rs

@@ -0,0 +1,16 @@
+mod from_hex_len {
+    use git_hash::Kind;
+
+    #[test]
+    fn some_sha1() {
+        assert_eq!(Kind::from_hex_len(0), Some(Kind::Sha1));
+        assert_eq!(Kind::from_hex_len(10), Some(Kind::Sha1));
+        assert_eq!(Kind::from_hex_len(20), Some(Kind::Sha1));
+        assert_eq!(Kind::from_hex_len(40), Some(Kind::Sha1));
+    }
+
+    #[test]
+    fn none_if_there_is_no_fit() {
+        assert_eq!(Kind::from_hex_len(65), None);
+    }
+}

git-hash/tests/oid/mod.rs

@@ -70,6 +70,57 @@ mod prefix {
             ));
         }
     }
+
+    mod try_from {
+        use std::{cmp::Ordering, convert::TryFrom};
+
+        use git_hash::prefix::from_hex::Error;
+        use git_hash::Prefix;
+        use git_testtools::hex_to_id;
+
+        #[test]
+        fn id_8_chars() {
+            let oid_hex = "abcdefabcdefabcdefabcdefabcdefabcdefabcd";
+            let input = "abcdef";
+
+            let expected = hex_to_id(oid_hex);
+            let actual = Prefix::try_from(input).expect("No errors");
+            assert_eq!(actual.cmp_oid(&expected), Ordering::Equal);
+        }
+
+        #[test]
+        fn id_9_chars() {
+            let oid_hex = "abcdefabcdefabcdefabcdefabcdefabcdefabcd";
+            let input = "abcdefa";
+
+            let expected = hex_to_id(oid_hex);
+            let actual = Prefix::try_from(input).expect("No errors");
+            assert_eq!(actual.cmp_oid(&expected), Ordering::Equal);
+        }
+        #[test]
+        fn id_to_short() {
+            let input = "ab";
+            let expected = Error::TooShort { hex_len: 2 };
+            let actual = Prefix::try_from(input).unwrap_err();
+            assert_eq!(actual, expected);
+        }
+
+        #[test]
+        fn id_to_long() {
+            let input = "abcdefabcdefabcdefabcdefabcdefabcdefabcd123123123123123123";
+            let expected = Error::TooLong { hex_len: 58 };
+            let actual = Prefix::try_from(input).unwrap_err();
+            assert_eq!(actual, expected);
+        }
+
+        #[test]
+        fn invalid_chars() {
+            let input = "abcdfOsd";
+            let expected = Error::Invalid { c: 'O', index: 5 };
+            let actual = Prefix::try_from(input).unwrap_err();
+            assert_eq!(actual, expected);
+        }
+    }
 }
 
 mod short_hex {