RegexSolver v1

.gitignore

@@ -18,4 +18,7 @@ Cargo.lock
 #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
+#.idea/
+
+# cargo mutants output
+mutants.out*/

Cargo.toml

@@ -1,20 +1,18 @@
 [package]
 name = "regexsolver"
-version = "0.3.1"
-edition = "2021"
+version = "1.0.0"
+edition = "2024"
 authors = ["Alexandre van Beurden"]
 repository = "https://github.com/RegexSolver/regexsolver"
 license = "MIT"
 keywords = ["automaton", "intersection", "union", "difference", "regex"]
-description = "Manipulate regex and automaton as if they were sets."
+description = "High-performance Rust library for building, combining, and analyzing regular expressions and finite automata"
 readme = "README.md"
 
 [dependencies]
 serde = { version = "1.0", features = ["derive"], optional = true }
 ciborium = { version = "0.2.2", optional = true }
 z85 = { version = "3.0.5", optional = true }
-aes-gcm-siv = { version = "0.11.1", optional = true }
-sha2 = { version = "0.10.8", optional = true }
 flate2 = { version = "1.0.30", features = [
     "zlib-ng",
 ], default-features = false, optional = true }
@@ -26,6 +24,8 @@ lazy_static = "1.4.0"
 regex = "1.10.3"
 regex-syntax = "0.8.5"
 regex-charclass = { version = "1.0.3" }
+rayon = "1.10.0"
+bit-set = "0.8.0"
 
 [dev-dependencies]
 criterion = { version = "0.5", features = ["html_reports"] }
@@ -34,17 +34,15 @@ serde_json = "1.0.114"
 
 
 [features]
-default = ["serde"]
-serde = [
+default = []
+serializable = [
     "regex-charclass/serde",
     "dep:serde",
     "dep:ciborium",
     "dep:z85",
-    "dep:aes-gcm-siv",
-    "dep:sha2",
     "dep:flate2",
 ]
 
 [[bench]]
 name = "my_benchmark"
-harness = false
+harness = false

benches/my_benchmark.rs

@@ -1,4 +1,3 @@
-use ahash::AHashSet;
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use regexsolver::{fast_automaton::FastAutomaton, regex::RegularExpression};
 
@@ -7,18 +6,18 @@ fn parse_regex(regex: &str) -> RegularExpression {
 }
 
 fn to_regex(automaton: &FastAutomaton) -> RegularExpression {
-    automaton.to_regex().unwrap()
+    automaton.to_regex()
 }
 
 fn determinize(automaton: &FastAutomaton) -> FastAutomaton {
-    automaton.determinize().unwrap()
+    automaton.determinize().unwrap().into_owned()
 }
 
 fn intersection(automaton_1: &FastAutomaton, automaton_2: &FastAutomaton) -> FastAutomaton {
     automaton_1.intersection(automaton_2).unwrap()
 }
 
-fn generate_strings(automaton: &FastAutomaton) -> AHashSet<String> {
+fn generate_strings(automaton: &FastAutomaton) -> Vec<String> {
     automaton.generate_strings(2000).unwrap()
 }
 

src/cardinality/mod.rs

@@ -1,10 +1,10 @@
-#[cfg(feature = "serde")]
+#[cfg(feature = "serializable")]
 use serde::{Deserialize, Serialize};
 
 /// Represent a number.
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serializable", derive(Serialize, Deserialize))]
 #[derive(PartialEq, Eq, Debug, Clone)]
-#[cfg_attr(feature = "serde", serde(tag = "type", content = "value"))]
+#[cfg_attr(feature = "serializable", serde(tag = "type", content = "value", rename_all = "camelCase"))]
 pub enum Cardinality<U> {
     /// An infinite number.
     Infinite,

src/error/mod.rs

@@ -1,6 +1,7 @@
 use std::fmt::{self};
 
-use crate::tokenizer::token::TokenError;
+#[cfg(feature = "serializable")]
+use crate::fast_automaton::serializer::tokenizer::token::TokenError;
 
 /// An error thrown by the engine.
 #[derive(Debug, PartialEq, Eq)]
@@ -9,18 +10,13 @@ pub enum EngineError {
     InvalidCharacterInRegex,
     /// The operation took too much time.
     OperationTimeOutError,
-    /// The given automaton should be deterministic.
-    AutomatonShouldBeDeterministic,
     /// The automaton has too many states.
     AutomatonHasTooManyStates,
     /// The regular expression can not be parsed.
     RegexSyntaxError(String),
-    /// Too many terms are used in the operation.
-    TooMuchTerms(usize, usize),
     /// The provided range can not be built from the spanning set.
     ConditionInvalidRange,
-    /// The provided index is out of bound of the condition.
-    ConditionIndexOutOfBound,
+    #[cfg(feature = "serializable")]
     /// There is an error with one of the token.
     TokenError(TokenError),
 }
@@ -30,33 +26,18 @@ impl fmt::Display for EngineError {
         match self {
             EngineError::InvalidCharacterInRegex => write!(f, "Invalid character used in regex."),
             EngineError::OperationTimeOutError => write!(f, "The operation took too much time."),
-            EngineError::AutomatonShouldBeDeterministic => write!(f, "The given automaton should be deterministic."),
-            EngineError::AutomatonHasTooManyStates => write!(f, "The automaton has too many states."),
+            EngineError::AutomatonHasTooManyStates => {
+                write!(f, "The automaton has too many states.")
+            }
             EngineError::RegexSyntaxError(err) => write!(f, "{err}."),
-            EngineError::TooMuchTerms(max, got) => write!(f, "Too many terms are used in this operation, the maximum allowed for your plan is {max} and you used {got}."),
-            EngineError::TokenError(err) =>  write!(f, "{err}."),
-            EngineError::ConditionInvalidRange => write!(f, "The provided range can not be built from the spanning set."),
-            EngineError::ConditionIndexOutOfBound => write!(f, "The provided index is out of bound of the condition."),
+            #[cfg(feature = "serializable")]
+            EngineError::TokenError(err) => write!(f, "{err}."),
+            EngineError::ConditionInvalidRange => write!(
+                f,
+                "The provided range can not be built from the spanning set."
+            ),
         }
     }
 }
 
 impl std::error::Error for EngineError {}
-
-impl EngineError {
-    /// Determine if the error is a server error.
-    /// A server error should not be shown to the end user.
-    pub fn is_server_error(&self) -> bool {
-        match self {
-            EngineError::InvalidCharacterInRegex => false,
-            EngineError::OperationTimeOutError => false,
-            EngineError::AutomatonShouldBeDeterministic => true,
-            EngineError::AutomatonHasTooManyStates => false,
-            EngineError::RegexSyntaxError(_) => false,
-            EngineError::TooMuchTerms(_, _) => false,
-            EngineError::TokenError(_) => false,
-            EngineError::ConditionInvalidRange => true,
-            EngineError::ConditionIndexOutOfBound => true,
-        }
-    }
-}