fix(generator): use same generator for all data

Author: t-webber

src/data_generator.rs

@@ -1,6 +1,9 @@
 //! Wrapper around [`DataGenerator`] for internal usage.
 
+use rand::Rng as _;
+use rand::distr::uniform::{SampleRange, SampleUniform};
 use rand::rngs::ThreadRng;
+use rand::seq::IndexedRandom as _;
 use rand_chacha::ChaCha20Rng;
 use random_data::{DataGenerator, DataType};
 
@@ -15,6 +18,14 @@ pub enum RandomDataGenerator {
 }
 
 impl RandomDataGenerator {
+    /// Chooses an element from a slice with the random generator
+    pub fn choose<'values, T>(&mut self, values: &'values [T]) -> Option<&'values T> {
+        match self {
+            Self::NonDeterministic(data_generator) => values.choose(data_generator.rng()),
+            Self::Seeded(data_generator) => values.choose(data_generator.rng()),
+        }
+    }
+
     /// Creates a new [`RandomDataGenerator`] with a seed or not.
     pub fn new(seed: Option<u64>) -> Self {
         seed.map_or_else(
@@ -23,6 +34,26 @@ impl RandomDataGenerator {
         )
     }
 
+    /// Chooses a boolean with the given weight with the random generator
+    pub fn random_bool(&mut self, weight: f64) -> bool {
+        match self {
+            Self::NonDeterministic(generator) => generator.rng().random_bool(weight),
+            Self::Seeded(generator) => generator.rng().random_bool(weight),
+        }
+    }
+
+    /// Chooses an element from a range with the random generator
+    pub fn random_range<T, R>(&mut self, range: R) -> T
+    where
+        T: SampleUniform,
+        R: SampleRange<T>,
+    {
+        match self {
+            Self::NonDeterministic(generator) => generator.rng().random_range(range),
+            Self::Seeded(generator) => generator.rng().random_range(range),
+        }
+    }
+
     /// Generates a value randomly from the given [`DataType`]
     pub fn random_value(&mut self, data_type: DataType) -> String {
         match self {

src/generator.rs

@@ -4,9 +4,7 @@ use core::hash::{Hash, Hasher};
 use core::mem::discriminant;
 use std::collections::{HashMap, HashSet};
 
-use rand::rngs::ThreadRng;
-use rand::seq::IndexedRandom as _;
-use rand::{Rng as _, rng};
+use rand::distr::uniform::{SampleRange, SampleUniform};
 use random_data::DataType;
 use serde_json::{Number, Value};
 
@@ -30,15 +28,13 @@ pub trait NullableGenerator<T>: Sized {
 /// Contains the list of data types and the random generator to apply
 /// generators.
 pub struct Data {
-    /// Radnom data generator
-    random_data_generator: RandomDataGenerator,
     /// Pseudo-random refs
     ///
     /// This represents data that is randomly generated once, then used in
     /// multiple place.
     refs: HashMap<String, OutputData>,
-    /// Random generator
-    rng: ThreadRng,
+    /// Radnom data generator
+    rng: RandomDataGenerator,
     /// Data types that were required to be unique.
     uniq_types: HashMap<String, HashSet<OutputData>>,
     /// User-defined data types
@@ -65,20 +61,20 @@ impl Data {
 
         let value = if let Some(values) = self.user_defined.get(data_type) {
             OutputData::String(
-                values
-                    .choose(&mut self.rng)
+                self.rng
+                    .choose(values)
                     .ok_or(Error::FakerDefEmpty)?
                     .to_owned(),
             )
         } else if data_type == "Bool" {
             OutputData::Bool(self.rng.random_bool(0.5))
         } else if data_type == "Int" {
-            OutputData::Int(self.rng.random_range(0..=u64::MAX))
+            OutputData::Int(self.random_range(0..=u64::MAX))
         } else if data_type == "Float" {
-            OutputData::Float(self.rng.random_range(0.0f64..=f64::MAX))
+            OutputData::Float(self.random_range(0.0f64..=f64::MAX))
         } else {
             OutputData::String(
-                self.random_data_generator.random_value(
+                self.rng.random_value(
                     DataType::try_from(data_type)
                         .map_err(|()| Error::InvalidDataType(data_type.to_owned()))?,
                 ),
@@ -94,8 +90,8 @@ impl Data {
             .split('|')
             .filter(|x| !x.is_empty())
             .collect::<Vec<_>>();
-        values
-            .choose(self.rng())
+        self.rng
+            .choose(&values)
             .ok_or(Error::MissingValueBeforePipe)
             .map(|data| OutputData::String((*data).to_owned()))
     }
@@ -128,7 +124,7 @@ impl Data {
                 u64::MAX
             };
 
-            return Ok(OutputData::Int(self.rng().random_range(min..max)));
+            return Ok(OutputData::Int(self.random_range(min..max)));
         }
         match min_str.parse() {
             Ok(min) => {
@@ -139,7 +135,7 @@ impl Data {
                 } else {
                     f64::MAX
                 };
-                Ok(OutputData::Float(self.rng().random_range(min..max)))
+                Ok(OutputData::Float(self.random_range(min..max)))
             }
             Err(error) => Err(Error::invalid_bounds(|| min_str.to_owned())(error)),
         }
@@ -214,9 +210,8 @@ impl Data {
         }
 
         Ok(Self {
-            random_data_generator: RandomDataGenerator::new(seed),
+            rng: RandomDataGenerator::new(seed),
             user_defined,
-            rng: rng(),
             refs: HashMap::new(),
             uniq_types: HashMap::new(),
         })
@@ -246,9 +241,13 @@ impl Data {
         self.rng.random_bool(0.3)
     }
 
-    /// Borrows the random generator as mutable.
-    pub const fn rng(&mut self) -> &mut ThreadRng {
-        &mut self.rng
+    /// Chooses an element from a range with the random generator
+    pub fn random_range<T, R>(&mut self, range: R) -> T
+    where
+        T: SampleUniform,
+        R: SampleRange<T>,
+    {
+        self.rng.random_range(range)
     }
 
     /// List the possible values of a data-type

src/json/generator.rs

@@ -2,7 +2,6 @@
 
 use core::iter::repeat_with;
 
-use rand::Rng as _;
 use serde_json::{Map, Value};
 
 use crate::errors::{Error, Res};
@@ -51,10 +50,9 @@ impl Generator<Value> for Vec<Value> {
         let array_item_type = iter.next().ok_or(Error::ArrayMissingDataType)?;
 
         let len = match (iter.next(), iter.next()) {
-            (None, _) => data.rng().random_range(1..10),
-            (Some(Value::Number(inf)), Some(Value::Number(sup))) => data
-                .rng()
-                .random_range(number_to_int(inf)?..number_to_int(sup)?),
+            (None, _) => data.random_range(1..10),
+            (Some(Value::Number(inf)), Some(Value::Number(sup))) =>
+                data.random_range(number_to_int(inf)?..number_to_int(sup)?),
             (Some(Value::Number(inf)), None) => number_to_int(inf)?,
             (Some(Value::Number(_)), Some(value)) | (Some(value), _) =>
                 return Err(Error::ExpectedInteger(value.to_owned())),