feat(generator): create a seeded DataGenerator

Author: t-webber

Cargo.lock

@@ -21,5 +21,6 @@ chrono = { version = "0.4.41", features = [] }
 clap = { version = "4.5.42", features = ["derive"] }
 dialoguer = { version = "0.12.0", features = ["fuzzy-select"] }
 rand = "0.9.2"
+rand_chacha = "0.9.0"
 random-data = "0.1.1"
 serde_json = "1.0.142"

Cargo.toml

@@ -0,0 +1,33 @@
+//! Wrapper around [`DataGenerator`] for internal usage.
+
+use rand::rngs::ThreadRng;
+use rand_chacha::ChaCha20Rng;
+use random_data::{DataGenerator, DataType};
+
+/// Wrapper around [`DataGenerator`] to hide a different random generator,
+/// depending on whether we wand to generate with a seed or with a non
+/// determinastic generator.
+pub enum RandomDataGenerator {
+    /// Non-deterministic generator
+    NonDeterministic(DataGenerator<ThreadRng>),
+    /// Determinastic with a seed
+    Seeded(Box<DataGenerator<ChaCha20Rng>>),
+}
+
+impl RandomDataGenerator {
+    /// Creates a new [`RandomDataGenerator`] with a seed or not.
+    pub fn new(seed: Option<u64>) -> Self {
+        seed.map_or_else(
+            || Self::NonDeterministic(DataGenerator::default()),
+            |inner| Self::Seeded(Box::new(DataGenerator::new_with_seed(inner))),
+        )
+    }
+
+    /// Generates a value randomly from the given [`DataType`]
+    pub fn random_value(&mut self, data_type: DataType) -> String {
+        match self {
+            Self::NonDeterministic(data_generator) => data_type.random(data_generator),
+            Self::Seeded(data_generator) => data_type.random(data_generator),
+        }
+    }
+}

src/data_generator.rs

@@ -4,7 +4,6 @@
 
 use dialoguer::FuzzySelect;
 use dialoguer::theme::ColorfulTheme as ColourfulTheme;
-use rand::RngCore;
 
 use crate::errors::Res;
 use crate::generator::{Data, Generator as _};
@@ -15,7 +14,7 @@ pub struct Dialog;
 impl Dialog {
     /// Generate data from a dialogue selection.
     #[expect(clippy::indexing_slicing, reason = "can't be out of bounds")]
-    pub fn generate<Rng: RngCore>(mut data: Data<Rng>) -> Res<String> {
+    pub fn generate(mut data: Data) -> Res<String> {
         let data_list = data.list();
 
         let selection = FuzzySelect::with_theme(&ColourfulTheme::default())

src/dialog/mod.rs

@@ -6,31 +6,32 @@ use std::collections::{HashMap, HashSet};
 
 use rand::rngs::ThreadRng;
 use rand::seq::IndexedRandom as _;
-use rand::{Rng as _, RngCore, rng};
-use random_data::{DataGenerator, DataType};
+use rand::{Rng as _, rng};
+use random_data::DataType;
 use serde_json::{Number, Value};
 
+use crate::data_generator::RandomDataGenerator;
 use crate::errors::{Error, Res};
 ///
 /// Generate random data of the given type.
 pub trait Generator<T>: Sized {
     /// Generate random data of the given type.
-    fn generate<Rng: RngCore>(&self, data: &mut Data<Rng>) -> Res<T>;
+    fn generate(&self, data: &mut Data) -> Res<T>;
 }
 
 /// Generate random data of the given type, but with a nullable type.
 pub trait NullableGenerator<T>: Sized {
     /// Generate random data of the given type, but with a nullable type.
     ///
     /// This can sometimes returns None.
-    fn generate_nullable<Rng: RngCore>(&self, data: &mut Data<Rng>) -> Res<Option<T>>;
+    fn generate_nullable(&self, data: &mut Data) -> Res<Option<T>>;
 }
 
 /// Contains the list of data types and the random generator to apply
 /// generators.
-pub struct Data<Rng: RngCore> {
+pub struct Data {
     /// Radnom data generator
-    random_data_generator: DataGenerator<Rng>,
+    random_data_generator: RandomDataGenerator,
     /// Pseudo-random refs
     ///
     /// This represents data that is randomly generated once, then used in
@@ -44,7 +45,7 @@ pub struct Data<Rng: RngCore> {
     user_defined: HashMap<String, Vec<String>>,
 }
 
-impl<Rng: RngCore> Data<Rng> {
+impl Data {
     /// Generate non-nullable data of the provided data type.
     fn generate(&mut self, data_type: &str) -> Res<OutputData> {
         if let Some(parsed) = data_type.strip_suffix(']')
@@ -77,9 +78,10 @@ impl<Rng: RngCore> Data<Rng> {
             OutputData::Float(self.rng.random_range(0.0f64..=f64::MAX))
         } else {
             OutputData::String(
-                DataType::try_from(data_type)
-                    .map_err(|()| Error::InvalidDataType(data_type.to_owned()))?
-                    .random(&mut self.random_data_generator),
+                self.random_data_generator.random_value(
+                    DataType::try_from(data_type)
+                        .map_err(|()| Error::InvalidDataType(data_type.to_owned()))?,
+                ),
             )
         };
 
@@ -199,6 +201,27 @@ impl<Rng: RngCore> Data<Rng> {
         list
     }
 
+    /// Build the [`Data`] handler from user inputs
+    pub fn new(input_data: Vec<String>, seed: Option<u64>) -> Res<Self> {
+        let mut user_defined = HashMap::new();
+
+        for data_type in input_data {
+            let (name, values) = Self::parse_user_defined(&data_type)?;
+
+            if user_defined.insert(name, values).is_some() {
+                return Err(Error::DuplicateDataType(data_type));
+            }
+        }
+
+        Ok(Self {
+            random_data_generator: RandomDataGenerator::new(seed),
+            user_defined,
+            rng: rng(),
+            refs: HashMap::new(),
+            uniq_types: HashMap::new(),
+        })
+    }
+
     /// Parse a user-defined data-type, with the format
     /// `Name:Value1|Value2|Value3`.
     fn parse_user_defined(user_input: &str) -> Res<(String, Vec<String>)> {
@@ -242,37 +265,14 @@ impl<Rng: RngCore> Data<Rng> {
     }
 }
 
-impl Data<ThreadRng> {
-    /// Build the [`Data`] handler from user inputs
-    pub fn new(input_data: Vec<String>, _seed: Option<u64>) -> Res<Self> {
-        let mut user_defined = HashMap::new();
-
-        for data_type in input_data {
-            let (name, values) = Self::parse_user_defined(&data_type)?;
-
-            if user_defined.insert(name, values).is_some() {
-                return Err(Error::DuplicateDataType(data_type));
-            }
-        }
-
-        Ok(Self {
-            random_data_generator: DataGenerator::default(),
-            user_defined,
-            rng: rng(),
-            refs: HashMap::new(),
-            uniq_types: HashMap::new(),
-        })
-    }
-}
-
 impl Generator<OutputData> for String {
-    fn generate<Rng: RngCore>(&self, data: &mut Data<Rng>) -> Res<OutputData> {
+    fn generate(&self, data: &mut Data) -> Res<OutputData> {
         data.generate(self)
     }
 }
 
 impl NullableGenerator<OutputData> for String {
-    fn generate_nullable<Rng: RngCore>(&self, data: &mut Data<Rng>) -> Res<Option<OutputData>> {
+    fn generate_nullable(&self, data: &mut Data) -> Res<Option<OutputData>> {
         data.generate_nullable(self)
     }
 }

src/generator.rs

@@ -2,14 +2,14 @@
 
 use core::iter::repeat_with;
 
-use rand::{Rng as _, RngCore};
+use rand::Rng as _;
 use serde_json::{Map, Value};
 
 use crate::errors::{Error, Res};
 use crate::generator::{Data, Generator, NullableGenerator};
 
 impl Generator<Value> for Map<String, Value> {
-    fn generate<Rng: RngCore>(&self, data: &mut Data<Rng>) -> Res<Value> {
+    fn generate(&self, data: &mut Data) -> Res<Value> {
         let mut new_map = Self::with_capacity(self.len());
         for (key, json_value) in self {
             if let Some(parsed_key) = key.strip_suffix('!') {
@@ -45,7 +45,7 @@ impl Generator<Value> for Vec<Value> {
     /// ["FreeEmail"] // produce a random number of emails
     /// ["FirstName", 1] // produce 1 first name
     /// ["LicencePlate", 1, 10] // produce between 1 and 9 licence plates
-    fn generate<Rng: RngCore>(&self, data: &mut Data<Rng>) -> Res<Value> {
+    fn generate(&self, data: &mut Data) -> Res<Value> {
         let mut iter = self.iter();
 
         let array_item_type = iter.next().ok_or(Error::ArrayMissingDataType)?;
@@ -67,7 +67,7 @@ impl Generator<Value> for Vec<Value> {
 }
 
 impl Generator<Self> for Value {
-    fn generate<Rng: RngCore>(&self, data: &mut Data<Rng>) -> Res<Self> {
+    fn generate(&self, data: &mut Data) -> Res<Self> {
         match self {
             Self::Null | Self::Bool(_) | Self::Number(_) =>
                 Err(Error::InvalidSchemaType(format!("{self:?}"))),
@@ -79,7 +79,7 @@ impl Generator<Self> for Value {
 }
 
 impl NullableGenerator<Self> for Value {
-    fn generate_nullable<Rng: RngCore>(&self, data: &mut Data<Rng>) -> Res<Option<Self>> {
+    fn generate_nullable(&self, data: &mut Data) -> Res<Option<Self>> {
         let generated_json = match self {
             Self::Null | Self::Bool(_) | Self::Number(_) =>
                 return Err(Error::InvalidSchemaType(format!("{self:?}"))),

src/json/generator.rs

@@ -4,27 +4,26 @@ mod generator;
 
 use core::fmt::Write as _;
 
-use rand::RngCore;
 use serde_json::Value;
 
 use crate::errors::{Error, Res};
 use crate::generator::{Data, NullableGenerator as _};
 
 /// Arguments for generating JSON data based on a schema file.
-pub struct JsonArgs<Rng: RngCore> {
+pub struct JsonArgs {
     /// String to print after every data generation of the JSON schema.
     after: String,
     /// String to print before every data generation of the JSON schema.
     before: String,
     /// Number of times to repeat the JSON generation.
     count: u32,
     /// Data generator
-    data: Data<Rng>,
+    data: Data,
     /// JSON schema content
     json: String,
 }
 
-impl<Rng: RngCore> JsonArgs<Rng> {
+impl JsonArgs {
     /// Generate the JSON data based on the schema file and the provided
     /// parameters.
     pub fn generate(mut self) -> Res<String> {
@@ -43,13 +42,7 @@ impl<Rng: RngCore> JsonArgs<Rng> {
     }
 
     /// Create a new instance of `JsonArgs` with the provided parameters.
-    pub const fn new(
-        before: String,
-        after: String,
-        count: u32,
-        json: String,
-        data: Data<Rng>,
-    ) -> Self {
+    pub const fn new(before: String, after: String, count: u32, json: String, data: Data) -> Self {
         Self { after, before, count, data, json }
     }
 }

src/json/mod.rs

@@ -42,6 +42,7 @@
 #![allow(clippy::unwrap_in_result, reason = "unwrap_used is active")]
 
 mod clap;
+mod data_generator;
 mod dialog;
 mod errors;
 mod generator;