use alloc::boxed::Box;
use alloc::string::String;
use crate::alphabet::Alphabet;
use crate::error::MoidError;
use crate::rng::SeededRng;
fn next_symbol(alphabet: &Alphabet, rng: &mut impl FnMut() -> u8) -> char {
let radix = alphabet.radix();
let limit = 256 - (256 % radix);
loop {
let b = rng() as usize;
if b < limit {
return alphabet.symbol(b % radix);
}
}
}
#[derive(Debug, Clone)]
pub struct Minter {
alphabet: Alphabet,
random_len: usize,
check: bool,
prefix: Option<Box<str>>,
}
impl Minter {
pub fn new(alphabet: Alphabet, random_len: usize) -> Self {
Self {
alphabet,
random_len,
check: true,
prefix: None,
}
}
pub fn without_check(mut self) -> Self {
self.check = false;
self
}
pub fn with_prefix(mut self, prefix: impl Into<Box<str>>) -> Result<Self, MoidError> {
let prefix = prefix.into();
if !prefix.chars().all(|c| self.alphabet.contains(c)) {
return Err(MoidError::PrefixOutOfAlphabet);
}
self.prefix = Some(prefix);
Ok(self)
}
pub fn alphabet(&self) -> &Alphabet {
&self.alphabet
}
pub fn len(&self) -> usize {
self.prefix.as_ref().map_or(0, |p| p.chars().count())
+ self.random_len
+ usize::from(self.check)
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn mint(&self, rng: &mut impl FnMut() -> u8) -> String {
let mut s = String::with_capacity(self.len());
if let Some(p) = &self.prefix {
s.push_str(p);
}
for _ in 0..self.random_len {
s.push(next_symbol(&self.alphabet, rng));
}
if self.check {
let c = self.alphabet.check_char(&s);
s.push(c);
}
s
}
pub fn mint_unique(
&self,
rng: &mut impl FnMut() -> u8,
is_taken: impl Fn(&str) -> bool,
) -> String {
loop {
let id = self.mint(rng);
if !is_taken(&id) {
return id;
}
}
}
pub fn mint_seeded(&self, rng: &mut SeededRng) -> String {
self.mint(&mut || rng.next_byte())
}
pub fn mint_unique_seeded(
&self,
rng: &mut SeededRng,
is_taken: impl Fn(&str) -> bool,
) -> String {
self.mint_unique(&mut || rng.next_byte(), is_taken)
}
#[cfg(feature = "os")]
pub fn mint_os(&self) -> Result<String, MoidError> {
let mut buf = [0u8; 64];
let mut pos = buf.len();
let mut failed = false;
let id = self.mint(&mut || {
if pos >= buf.len() {
if getrandom::getrandom(&mut buf).is_err() {
failed = true;
return 0;
}
pos = 0;
}
let b = buf[pos];
pos += 1;
b
});
if failed {
Err(MoidError::Entropy)
} else {
Ok(id)
}
}
pub fn validate(&self, s: &str) -> Result<(), MoidError> {
if s.chars().count() != self.len() {
return Err(MoidError::BadLength);
}
if let Some(p) = &self.prefix {
if !s.starts_with(&**p) {
return Err(MoidError::BadPrefix);
}
}
if !self.alphabet.all_in(s) {
return Err(MoidError::BadChar);
}
if self.check && !self.alphabet.verify_check(s) {
return Err(MoidError::BadCheck);
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use alloc::format;
use alloc::vec;
use alloc::vec::Vec;
fn seq(bytes: Vec<u8>) -> impl FnMut() -> u8 {
let mut i = 0;
move || {
let b = bytes[i % bytes.len()];
i += 1;
b
}
}
#[test]
fn mints_expected_length_and_validates() {
let m = Minter::new(Alphabet::betanumeric(), 6);
assert_eq!(m.len(), 7);
let mut rng = SeededRng::new(1);
for _ in 0..1000 {
let id = m.mint_seeded(&mut rng);
assert_eq!(id.chars().count(), 7);
assert!(m.validate(&id).is_ok(), "{id}");
}
}
#[test]
fn rejection_sampling_skips_biasing_bytes() {
let m = Minter::new(Alphabet::betanumeric(), 1).without_check();
let mut rng = seq(vec![252, 253, 254, 255, 0]);
assert_eq!(m.mint(&mut rng), "b");
}
#[test]
fn with_prefix_rejects_out_of_alphabet_chars() {
let err = Minter::new(Alphabet::betanumeric(), 6)
.with_prefix("a1")
.unwrap_err();
assert_eq!(err, MoidError::PrefixOutOfAlphabet);
}
#[test]
fn prefix_check_covers_the_prefix() {
let m = Minter::new(Alphabet::betanumeric(), 6)
.with_prefix("dx")
.unwrap();
assert_eq!(m.len(), 9);
let mut rng = SeededRng::new(7);
let id = m.mint_seeded(&mut rng);
assert!(id.starts_with("dx"));
assert!(m.validate(&id).is_ok());
assert_eq!(
m.validate(&format!("b{}", &id[1..])),
Err(MoidError::BadPrefix)
);
let a = Alphabet::betanumeric();
assert_eq!(a.check_char("dxbbbbbb"), 'm'); assert_eq!(a.check_char("dybbbbbb"), 'p'); assert_ne!(a.check_char("dxbbbbbb"), a.check_char("dybbbbbb"));
}
#[test]
fn validate_catches_corruption() {
let m = Minter::new(Alphabet::betanumeric(), 6);
assert_eq!(m.validate("bcdfg"), Err(MoidError::BadLength));
assert_eq!(m.validate("bcdfgha"), Err(MoidError::BadChar));
let mut rng = SeededRng::new(3);
let id = m.mint_seeded(&mut rng);
let mut chars: Vec<char> = id.chars().collect();
let last = chars.len() - 1;
chars[last] = if chars[last] == 'b' { 'c' } else { 'b' };
let bad: String = chars.into_iter().collect();
assert_eq!(m.validate(&bad), Err(MoidError::BadCheck));
}
#[test]
fn mint_unique_avoids_taken() {
let m = Minter::new(Alphabet::betanumeric(), 6);
let first = m.mint_seeded(&mut SeededRng::new(5));
let taken_first = first.clone();
let out = m.mint_unique_seeded(&mut SeededRng::new(5), move |s| s == taken_first);
assert_ne!(out, first);
assert!(m.validate(&out).is_ok());
}
#[test]
fn without_check_drops_the_trailing_char() {
let m = Minter::new(Alphabet::betanumeric(), 6).without_check();
assert_eq!(m.len(), 6);
let id = m.mint_seeded(&mut SeededRng::new(1));
assert_eq!(id.chars().count(), 6);
assert!(m.validate(&id).is_ok());
}
#[cfg(feature = "os")]
#[test]
fn mint_os_produces_valid_ids() {
let m = Minter::new(Alphabet::betanumeric(), 6);
let id = m.mint_os().expect("os entropy");
assert!(m.validate(&id).is_ok(), "{id}");
}
}