add TurkishId::from_seq()

Author: ssg

CHANGES.md

@@ -6,6 +6,9 @@
 
 - `TurkishIdError` is renamed to `Error` to conform to Rust semantics. Perhaps,
   I shouldn't have been so hesitant to make this package 1.0.0, huh :)
+  
+- Added `from_seq()` method that can generate a valid TurkishId from a given
+  sequence number.
 
 ## 4.0.0
 

src/lib.rs

@@ -31,14 +31,16 @@
 use core::{
     convert::TryInto,
     fmt::{Display, Formatter},
+    ops::Range,
     str::{self, FromStr},
 };
 
 pub const LENGTH: usize = 11;
 
 pub(crate) type Bytes = [u8; LENGTH];
 
-/// Turkish citizenship ID number.
+/// Turkish citizenship ID number. The number is stored as ASCII digits
+/// "0".."9" in the structure.
 #[derive(Debug, Eq, PartialEq, Hash, Copy, Clone)]
 pub struct TurkishId(Bytes);
 
@@ -115,6 +117,8 @@ fn validate(str: &str) -> Result<(), Error> {
         return Err(Error::InvalidChecksum);
     }
 
+    // we use euclidian remainder due to the possibility that the final
+    // checksum wmight be negative.
     let first_checksum_computed = ((odd_sum * 7) - even_sum).rem_euclid(10);
     if first_checksum_computed != first_checksum {
         return Err(Error::InvalidChecksum);
@@ -134,6 +138,51 @@ impl Display for TurkishId {
     }
 }
 
+#[derive(Debug, Eq, PartialEq)]
+pub enum FromSeqError {
+    OutOfRange,
+}
+
+impl TurkishId {
+    /// Generate a valid TurkishId from a sequence number by calculating
+    /// checksums and building the buffer for it.
+    ///
+    /// # Arguments
+    /// - seq - A number between 100,000,000 and 999,999,999
+    ///
+    /// # Returns
+    /// A Result with `TurkishId` if the values are in range, otherwise
+    /// `FromSeqError`
+    pub fn from_seq(seq: u32) -> Result<TurkishId, FromSeqError> {
+        fn to_ascii(digit: i32) -> u8 {
+            digit as u8 + b'0'
+        }
+        const VALID_SEQ_RANGE: Range<u32> = 100_000_000..1_000_000_000;
+        if !VALID_SEQ_RANGE.contains(&seq) {
+            return Err(FromSeqError::OutOfRange);
+        }
+        let mut d: Bytes = [0; LENGTH];
+        let mut odd_sum: i32 = 0;
+        let mut even_sum: i32 = 0;
+        let mut divisor = VALID_SEQ_RANGE.start;
+        for (i, item) in d.iter_mut().enumerate().take(9) {
+            let digit = (seq / divisor % 10) as i32;
+            if i % 2 == 0 {
+                odd_sum += digit;
+            } else {
+                even_sum += digit;
+            }
+            *item = to_ascii(digit);
+            divisor /= 10;
+        }
+        let first_checksum = ((odd_sum * 7) - even_sum).rem_euclid(10);
+        let second_checksum = (odd_sum + even_sum + first_checksum) % 10;
+        d[9] = to_ascii(first_checksum);
+        d[10] = to_ascii(second_checksum);
+        Ok(TurkishId(d))
+    }
+}
+
 /// TurkishId can only be constructed from a string despite that it's stored
 /// as a fixed-length byte array internally.
 impl FromStr for TurkishId {

src/tests.rs

@@ -49,6 +49,8 @@ const INVALID_NUMBERS: &[(&str, Error)] = &[
     ("765582422781", Error::InvalidLength),
 ];
 
+const OUT_OF_RANGE_SEQUENCES: &[u32] = &[0, 99_999_999, 1_000_000_001, u32::MAX];
+
 #[test]
 fn is_valid_validnumbers_returns_true() {
     for number in VALID_NUMBERS {
@@ -84,8 +86,25 @@ fn hashset_compatible() {
 #[test]
 fn display_returnsthesamerepresentation() {
     for number in VALID_NUMBERS {
-        let id: TurkishId = number.parse().unwrap();
+        let id = TurkishId::from_str(number).unwrap();
         let idstr = format!("{id}");
         assert_eq!(idstr, *number);
     }
 }
+
+#[test]
+fn from_seq_produces_valid_numbers() {
+    for number in VALID_NUMBERS {
+        let seq: u32 = number[..9].parse().unwrap();
+        let id = TurkishId::from_seq(seq).unwrap();
+        assert_eq!(*number, id.to_string());
+    }
+}
+
+#[test]
+fn from_seq_out_of_range_values_return_error() {
+    for seq in OUT_OF_RANGE_SEQUENCES {
+        let result = TurkishId::from_seq(*seq);
+        assert_eq!(result.err(), Some(FromSeqError::OutOfRange));
+    }
+}