Make the dependencies optional.

Author: oo13

.github/workflows/test.yml

@@ -2,11 +2,13 @@ name: unit_test
 on:
   push:
     paths:
+      - '.github/workflows/*'
       - 'Cargo.toml'
       - 'src/**.rs'
       - 'test/**.rs'
   pull_request:
     paths:
+      - '.github/workflows/*'
       - 'Cargo.toml'
       - 'src/**.rs'
       - 'test/**.rs'
@@ -18,11 +20,14 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
+        features: [default, fastrand, regex, ""]
         BUILD_TARGET: [dev, release]
+    env:
+      FEATURE_OPTION: ${{ matrix.features == "" && "" || "-F" }}
     steps:
       - name: Checkout
         uses: actions/checkout@v4
       - name: Build
-        run: cargo build --profile ${{ matrix.BUILD_TARGET }}
+        run: cargo build --profile ${{ matrix.BUILD_TARGET }} --no-default-features ${{ env.FEATURE_OPTION }} ${{ matrix.features }}
       - name: Test
         run: cargo test --profile ${{ matrix.BUILD_TARGET }}

Cargo.toml

@@ -7,6 +7,9 @@ license = "MIT OR Apache-2.0"
 repository = "https://github.com/oo13/tphrase-rs.git"
 categories = ["internationalization", "text-processing"]
 
+[features]
+default = [ "fastrand", "regex" ]
+
 [dependencies]
-regex = "1.11.1"
-fastrand = "2.3.0"
+fastrand = { version = "2.3.0", optional = true }
+regex = { version = "1.11.1", optional = true }

src/generator.rs

@@ -88,8 +88,10 @@ pub type SyntaxId = usize;
 /// [`from_str()`]: #method.from_str
 #[derive(Clone, Debug)]
 pub struct Generator<
-    R: RandomNumberGenerator = crate::DefaultRng,
-    S: Substitutor = crate::DefaultSubst,
+    #[cfg(all(feature = "fastrand", feature = "regex"))] R: RandomNumberGenerator = crate::DefaultRng,
+    #[cfg(not(all(feature = "fastrand", feature = "regex")))] R: RandomNumberGenerator,
+    #[cfg(feature = "regex")] S: Substitutor = crate::DefaultSubst,
+    #[cfg(not(feature = "regex"))] S: Substitutor,
 > {
     /// The syntaxes in the instance.
     syntaxes: Vec<Syntax<S>>,

src/lib.rs

@@ -304,6 +304,17 @@
 //! gsub_limit = "g" | { ? [0-9] ? } ;
 //! ```
 //!
+//! # Features
+//! TPhrase has two features:
+//! - "fastrand": define [`FastrandRng`] and [`DefaultRng`]
+//! - "regex": define [`RegexGsub`] and [`DefaultSubst`]
+//!
+//! They are enalbed by default.
+//!
+//! Disabling the features, the default generic types of [`Generator`] is removed. 1st default generic type needs "fastrand" and "regex", 2nd needs "regex".
+//!
+//! The tests and examples support only the default features.
+//!
 //! # License
 //! TPhrase for Rust is licensed under either of [MIT](http://opensource.org/licenses/MIT) or [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0) at your option.
 //!
@@ -330,15 +341,18 @@
 //! Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
 
 mod compile_error;
+#[cfg(feature = "fastrand")]
 mod fastrand_rng;
 mod generator;
 mod parser;
 mod random_number_generator;
+#[cfg(feature = "regex")]
 mod regex_substitutor;
 mod substitutor;
 mod utils;
 
 pub use compile_error::CompileError;
+#[cfg(feature = "fastrand")]
 pub use fastrand_rng::FastrandRng;
 pub use generator::Generator;
 pub use generator::SyntaxId;
@@ -347,15 +361,18 @@ pub use parser::data::Syntax;
 pub use parser::parse;
 pub use parser::parse_str;
 pub use random_number_generator::RandomNumberGenerator;
+#[cfg(feature = "regex")]
 pub use regex_substitutor::RegexGsub;
 pub use substitutor::Substitutor;
 pub use substitutor::SubstitutorAddError;
 pub(crate) use utils::{select_and_generate_text, TextGenerator};
 pub use utils::{trunc_syntax, trunc_syntax_str};
 
 /// The default random number generator of [`Generator`].
+#[cfg(feature = "fastrand")]
 pub type DefaultRng = FastrandRng;
 /// The default substitutor of [`Generator`].
+#[cfg(feature = "regex")]
 pub type DefaultSubst = RegexGsub;
 /// The type of the external context.
 pub type ExtContext = std::collections::HashMap<String, String>;

src/parser/data.rs

@@ -582,7 +582,10 @@ impl<S: Substitutor> ProductionRule<S> {
 /// [`parse()`]: ../../fn.parse.html
 /// [`parse_str()`]: ../../fn.parse_str.html
 #[derive(Debug)]
-pub struct Syntax<S: Substitutor = crate::DefaultSubst> {
+pub struct Syntax<
+    #[cfg(feature = "regex")] S: Substitutor = crate::DefaultSubst,
+    #[cfg(not(feature = "regex"))] S: Substitutor,
+> {
     /// The assignments in the syntax.
     assignments: Assignments<S>,
     /// The reference to the start condition.

tests/test_parse.rs

@@ -400,14 +400,14 @@ fn test_parse_gsub_with_too_big_number() {
 
 #[test]
 fn test_parse_gsub_with_error_and_report() {
-    let ph: Result<Generator, _> = r#"
-        main = 1 | 2 | 3 ~ /[1/2/
+    let ph: Result<Generator<ZeroNG, PlainSubst>, _> = r#"
+        main = 1 | 2 | 3 ~ /1/2/3
     "#
     .parse();
     assert!(ph.is_err());
     let err = ph.err().unwrap();
     assert_eq!(err.error_messages().len(), 1);
-    assert!(err.error_messages()[0].contains("Gsub error:"));
+    assert!(err.error_messages()[0].contains("Gsub error: limit must be 0 or g."));
 }
 
 #[test]

tests/test_struct_generator.rs

@@ -456,3 +456,47 @@ fn test_struct_generator_clear() {
     assert_eq!(ph.weight(), 5.0);
     assert_eq!(ph.number_of_syntax(), 1);
 }
+
+#[test]
+fn test_struct_generator_alternaitve_rng_and_subst() {
+    let mut ph: Generator<PosixRng, PlainSubst> = r#"
+        main = {= X | Y | Z } | {A} | {B}
+
+        A = A[1] | A[2] | A[3] ~ /[1]/[0]/g
+
+        B = B1 | B2 | B3
+    "#
+    .parse()
+    .unwrap();
+    let syntax: Syntax<PlainSubst> = r#"
+        main = {= V | W } | {C} ~ /C/D/g
+
+        C = C1 | C2 | C3
+    "#
+    .parse()
+    .unwrap();
+    ph.add(syntax).unwrap();
+
+    let dist = TextDistribution::from([
+        ("X".to_string(), 1.0 / 14.0),
+        ("Y".to_string(), 1.0 / 14.0),
+        ("Z".to_string(), 1.0 / 14.0),
+        ("A[0]".to_string(), 1.0 / 14.0),
+        ("A[2]".to_string(), 1.0 / 14.0),
+        ("A[3]".to_string(), 1.0 / 14.0),
+        ("B1".to_string(), 1.0 / 14.0),
+        ("B2".to_string(), 1.0 / 14.0),
+        ("B3".to_string(), 1.0 / 14.0),
+        ("V".to_string(), 1.0 / 14.0),
+        ("W".to_string(), 1.0 / 14.0),
+        ("D1".to_string(), 1.0 / 14.0),
+        ("D2".to_string(), 1.0 / 14.0),
+        ("D3".to_string(), 1.0 / 14.0),
+    ]);
+
+    assert!(check_distribution(&mut ph, 100000, &dist, 0.01));
+
+    assert_eq!(ph.combination_number(), 14);
+    assert_eq!(ph.weight(), 14.0);
+    assert_eq!(ph.number_of_syntax(), 2);
+}

tests/utils/mod.rs

@@ -20,6 +20,8 @@
 
 use tphrase::*;
 
+// Random number generators to test a phrase generation.
+
 #[derive(Clone, Debug)]
 pub struct ZeroNG {}
 impl RandomNumberGenerator for ZeroNG {
@@ -97,12 +99,14 @@ pub type LinearNG3 = LinearNG<LinearNGParam3>;
 #[allow(dead_code)]
 pub type LinearNG6 = LinearNG<LinearNGParam6>;
 
+// function to check a distribution.
+
 #[allow(dead_code)]
 pub type TextDistribution = std::collections::HashMap<String, f64>;
 
 #[allow(dead_code)]
-pub fn check_distribution(
-    ph: &mut Generator,
+pub fn check_distribution<R: RandomNumberGenerator, S: Substitutor>(
+    ph: &mut Generator<R, S>,
     num: usize,
     dist: &TextDistribution,
     allowance: f64,
@@ -135,3 +139,52 @@ pub fn check_distribution(
     }
     return is_match;
 }
+
+// Alternative RNG
+pub struct PosixRng {
+    n: u64,
+}
+impl RandomNumberGenerator for PosixRng {
+    fn new() -> Self {
+        Self { n: 1 }
+    }
+    fn next(self: &mut Self) -> f64 {
+        self.n = self.n * 1103515245 + 12345;
+        self.n &= 0xFFFF_FFFF;
+        return ((self.n / 65536 % 32768) as f64) / 32768.0;
+    }
+}
+
+// Alternative Substitutor
+pub struct PlainSubst {
+    replaces: Vec<(String, String)>,
+}
+impl Substitutor for PlainSubst {
+    fn new() -> Self {
+        Self {
+            replaces: Vec::new(),
+        }
+    }
+    fn gsub<'a>(self: &Self, s: &'a str) -> std::borrow::Cow<'a, str> {
+        let mut r = std::borrow::Cow::Borrowed(s);
+        for repl in self.replaces.iter() {
+            r = r.replace(&repl.0, &repl.1).into();
+        }
+        return r;
+    }
+    fn add(
+        self: &mut Self,
+        pattern: &str,
+        repl: String,
+        limit: usize,
+    ) -> Result<(), SubstitutorAddError> {
+        if limit == 0 {
+            self.replaces.push((pattern.to_string(), repl));
+            Ok(())
+        } else {
+            Err(SubstitutorAddError::new(
+                "limit must be 0 or g.".to_string(),
+            ))
+        }
+    }
+}