Cleaned up dependencies (2 removed, 1 updated)

Author: qbasic16

CHANGELOG.md

@@ -5,11 +5,22 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 ---
 
+[1.1.1]: https://github.com/qbasic16/swiss_uid/releases/tag/1.1.1
 [1.1.0]: https://github.com/qbasic16/swiss_uid/releases/tag/1.1.0
 [1.0.2]: https://github.com/qbasic16/swiss_uid/releases/tag/1.0.2
 [1.0.1]: https://github.com/qbasic16/swiss_uid/releases/tag/1.0.1
 [1.0.0]: https://github.com/qbasic16/swiss_uid/releases/tag/1.0.0
 
+## [1.1.1] - 2025-04-26
+
+### Changed
+
+- Updated crate `rand` to `0.9.*`
+
+### Removed
+
+- Removed crates `itertools` and `num` to simplify dependencies
+
 ## [1.1.0] - 2025-01-26
 
 ### Breaking

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "swiss_uid"
-version = "1.1.0"
+version = "1.1.1"
 edition = "2021"
 resolver = "2"
 authors = ["Peter <qbasic16@gmail.com>"]
@@ -18,6 +18,4 @@ default = ["rand"]
 rand = ["dep:rand"]
 
 [dependencies]
-itertools = "0.14.*"
-num = "0.4.*"
-rand = { version = "0.8.*", optional = true }
+rand = { version = "0.9.*", optional = true }

Cargo.toml

@@ -1,7 +1,6 @@
+use ::std::iter::zip;
 use ::std::{error::Error, fmt, str::FromStr};
 
-use ::itertools::Itertools;
-
 use crate::utils::IntoNibblesNum;
 
 // Factors as defined in the specification
@@ -11,19 +10,19 @@ const DIGIT_FACTORS: [u8; SwissUid::NUM_CHARS_DIGITS] = [5, 4, 3, 2, 7, 6, 5, 4]
 /// Calculates the check digit for the given 8 normal digits of the UID.
 #[inline]
 pub fn calculate_checkdigit(main_digits: &[u8]) -> Result<u8, UidError> {
-    if main_digits.len() != DIGIT_FACTORS.len() {
-        Err(UidError::InvalidFormat("UID must have 8 digits".to_owned()))
-    } else {
-        let checksum: u32 = DIGIT_FACTORS
-            .iter()
-            .zip_eq(main_digits.iter())
-            .map(|v| (v.0 * v.1) as u32)
-            .sum();
-        match 11 - (checksum % 11) {
-            11 => Ok(0u8),
-            10 => Err(UidError::InvalidCheckDigit(10.to_string())),
-            n => Ok(n as u8),
-        }
+    if main_digits.len() < DIGIT_FACTORS.len() {
+        return Err(UidError::InvalidFormat(
+            "UID must have at least 8 digits".to_owned(),
+        ));
+    }
+
+    let checksum: u32 = zip(main_digits, &DIGIT_FACTORS)
+        .map(|v| (v.0 * v.1) as u32)
+        .sum();
+    match 11 - (checksum % 11) {
+        11 => Ok(0u8),
+        10 => Err(UidError::InvalidCheckDigit(10.to_string())),
+        n => Ok(n as u8),
     }
 }
 
@@ -91,15 +90,15 @@ impl SwissUid {
     pub fn rand() -> Result<Self, UidError> {
         use rand::Rng;
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let mut n = [0u8; Self::NUM_CHARS_DIGITS];
         let mut n_iter = n.iter_mut();
 
         // The first digit must be between 1 and 9
-        *n_iter.next().unwrap() = rng.gen_range(1..10);
+        *n_iter.next().unwrap() = rng.random_range(1..10);
         // The rest can be between 0 and 9
         for d in n_iter {
-            *d = rng.gen_range(0..10);
+            *d = rng.random_range(0..10);
         }
 
         let p = calculate_checkdigit(&n).or_else(|_| {

src/uid.rs

@@ -1,78 +1,3 @@
-use ::std::ops::{BitAnd, BitOr, Shl, Shr};
+mod nibble;
 
-use ::num::cast::AsPrimitive;
-
-pub trait FromNibbles:
-    Shl<usize, Output = Self> + Default + BitOr<Output = Self> + From<u8>
-{
-    fn from_nibbles(digits: &[u8]) -> Self {
-        digits
-            .iter()
-            .take(size_of::<Self>() * 2)
-            .fold(Self::default(), |acc, &d| (acc << 4) | d.into())
-    }
-}
-
-impl FromNibbles for u16 {}
-impl FromNibbles for u32 {}
-
-pub trait IntoNibblesNum<T>
-where
-    T: FromNibbles,
-{
-    fn into_nibbles_num(&self) -> T;
-}
-
-impl<T> IntoNibblesNum<T> for [u8]
-where
-    T: FromNibbles,
-{
-    fn into_nibbles_num(&self) -> T {
-        T::from_nibbles(self)
-    }
-}
-
-pub trait IntoNibbles:
-    FromNibbles + Shr<usize, Output = Self> + BitAnd<Output = Self> + AsPrimitive<u8>
-{
-    /// Returns an iterator over the nibbles (4-bit digits) of the number.
-    /// The iterator starts with the most significant nibble.
-    #[inline(always)]
-    fn into_iter_nibbles(self) -> impl Iterator<Item = u8> {
-        let n = self;
-        (0..(size_of::<Self>() * 2))
-            .into_iter()
-            .rev()
-            .map(move |i| (n >> (i * 4)).as_() & 0x0f)
-    }
-}
-
-impl IntoNibbles for u16 {}
-impl IntoNibbles for u32 {}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_to_nibbles() {
-        let n: u16 = 0x1234;
-        let n_split: Vec<u8> = n.into_iter_nibbles().collect();
-        assert_eq!(n_split, [1, 2, 3, 4]);
-    }
-
-    #[test]
-    fn test_from_nibbles() {
-        let n = [1u8, 2u8, 3u8, 4u8];
-        let n_quad: u16 = n.into_nibbles_num();
-        assert_eq!(n_quad, 0x1234);
-    }
-
-    #[test]
-    fn test_to_quad_nibble_above_10() {
-        let n = [11u8, 12u8, 13u8, 14u8];
-        let n_quad: u16 = n.into_nibbles_num();
-        assert_eq!(n_quad, 0xbcde);
-        assert_eq!(format!("{n_quad:#x}"), format!("{:#x}", 0xbcde));
-    }
-}
+pub use nibble::*;