From b6bf605eb9b752e449f487d6bfd5d3915d30615f Mon Sep 17 00:00:00 2001 From: Saphereye Date: Fri, 16 Feb 2024 20:30:59 +0530 Subject: [PATCH] refactor: Fixed clippy warnings --- Cargo.lock | 2 +- Cargo.toml | 4 ++-- src/lib.rs | 12 ++++-------- src/nfa.rs | 26 ++------------------------ src/translation/linearize.rs | 4 ---- src/translation/node.rs | 24 ++++++++++++------------ 6 files changed, 21 insertions(+), 51 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index c5b28dd..92a3276 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4,4 +4,4 @@ version = 3 [[package]] name = "gregex" -version = "0.4.3" +version = "0.4.4" diff --git a/Cargo.toml b/Cargo.toml index 3df413d..dd1f14e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "gregex" -version = "0.4.3" +version = "0.4.4" edition = "2021" authors = ["Saphereye "] license = "MIT" @@ -9,7 +9,7 @@ keywords = ["regex", "nfa", "automata"] categories = ["text-processing"] documentation = "https://docs.rs/gregex" exclude = [ - ".github/workflows/rust.yml", + ".github/", ".gitignore", "LICENSE", "README.md", diff --git a/src/lib.rs b/src/lib.rs index e2390c4..1aaab6d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -4,10 +4,8 @@ //! ```rust //! use::gregex::regex; //! -//! fn main() { -//! let regex = regex("(a.b)*"); -//! assert!(regex.simulate("abab")); -//! } +//! let regex = regex("(a.b)*"); +//! assert!(regex.simulate("abab")); //! ``` //! //! The regex function uses the regular expression string to create a NFA that can be used to simulate the regular expression. @@ -38,10 +36,8 @@ type Regex = NFA; /// ```rust /// use::gregex::regex; /// -/// fn main() { -/// let regex = regex("(a.b)*"); -/// assert!(regex.simulate("abab")); -/// } +/// let regex = regex("(a.b)*"); +/// assert!(regex.simulate("abab")); /// ``` pub fn regex(regex_string: &str) -> Regex { let regex_tree = linearize(regex_string); diff --git a/src/nfa.rs b/src/nfa.rs index 8293c0d..cdcfe68 100644 --- a/src/nfa.rs +++ b/src/nfa.rs @@ -5,7 +5,7 @@ use core::panic; use std::collections::{HashMap, HashSet}; /// The `NFA` struct represents a non-deterministic finite automaton. -#[derive(Debug)] +#[derive(Debug, Default)] pub struct NFA { states: HashSet, accept: HashSet, @@ -13,29 +13,7 @@ pub struct NFA { transition_function: HashMap<(u32, char), HashSet>, } -impl Default for NFA { - fn default() -> Self { - NFA { - states: HashSet::new(), - accept: HashSet::new(), - transition_function: HashMap::new(), - } - } -} - impl NFA { - fn new( - states: HashSet, - accept: HashSet, - transition_function: HashMap<(u32, char), HashSet>, - ) -> NFA { - NFA { - states, - accept, - transition_function, - } - } - pub fn simulate(&self, input: &str) -> bool { let mut current_states = HashSet::new(); current_states.insert(0); @@ -90,7 +68,7 @@ impl NFA { SetTerminal::DoubleElement(_, index1, symbol2, index2) => { nfa.states.insert(index1); nfa.states.insert(index2); - nfa.transition_function.entry((index1, symbol2)).or_insert_with(|| HashSet::new()).insert(index2); + nfa.transition_function.entry((index1, symbol2)).or_insert_with(HashSet::new).insert(index2); } SetTerminal::SingleElement(_, _) => { panic!("SingleElement not supported") diff --git a/src/translation/linearize.rs b/src/translation/linearize.rs index ce8e373..9066718 100644 --- a/src/translation/linearize.rs +++ b/src/translation/linearize.rs @@ -1,8 +1,4 @@ //! Converts input regex to its linear form. Then it converts it into a Node tree. - -use std::collections::HashMap; -use std::process::Child; - use crate::translation::node::Node; use crate::translation::operator::Operator; diff --git a/src/translation/node.rs b/src/translation/node.rs index 2eb89d9..ecd5d6e 100644 --- a/src/translation/node.rs +++ b/src/translation/node.rs @@ -15,17 +15,17 @@ pub enum Node { pub fn nullability_set(regex_tree: &Node) -> HashSet { let mut set = HashSet::new(); match regex_tree { - Node::Terminal(symbol, code) => { + Node::Terminal(_, _) => { set.insert(SetTerminal::Empty); } Node::Operation(op, left, right) => match op { Operator::Or => { set.extend(nullability_set(left)); - set.extend(nullability_set(&*right.as_ref().unwrap())); + set.extend(nullability_set(right.as_ref().unwrap())); } Operator::Concat => { set.extend(nullability_set(left)); - let right_set = nullability_set(&*right.as_ref().unwrap()); + let right_set = nullability_set(right.as_ref().unwrap()); set.extend(right_set); } Operator::Production => { @@ -47,14 +47,14 @@ pub fn prefix_set(regex_tree: &Node) -> HashSet { Node::Operation(op, left, right) => match op { Operator::Or => { let left_set = prefix_set(left); - let right_set = prefix_set(&*right.as_ref().unwrap()); + let right_set = prefix_set(right.as_ref().unwrap()); set.extend(left_set); set.extend(right_set); } Operator::Concat => { let left_set = prefix_set(left); set.extend(left_set); - let right_set = prefix_set(&*right.as_ref().unwrap()); + let right_set = prefix_set(right.as_ref().unwrap()); let nullable_set = nullability_set(left); // If the left expression is nullable, include the first set of the right expression @@ -82,15 +82,15 @@ pub fn suffix_set(regex_tree: &Node) -> HashSet { Node::Operation(op, left, right) => match op { Operator::Or => { let left_set = suffix_set(left); - let right_set = suffix_set(&*right.as_ref().unwrap()); + let right_set = suffix_set(right.as_ref().unwrap()); set.extend(left_set); set.extend(right_set); } Operator::Concat => { - let left_set = suffix_set(&*right.as_ref().unwrap()); + let left_set = suffix_set(right.as_ref().unwrap()); set.extend(left_set); let right_set = suffix_set(left); - let nullable_set = nullability_set(&*right.as_ref().unwrap()); + let nullable_set = nullability_set(right.as_ref().unwrap()); // If the left expression is nullable, include the first set of the right expression if nullable_set.contains(&SetTerminal::Epsilon) { @@ -111,21 +111,21 @@ pub fn suffix_set(regex_tree: &Node) -> HashSet { pub fn factors_set(regex_tree: &Node) -> HashSet { let mut set = HashSet::new(); match regex_tree { - Node::Terminal(symbol, code) => { + Node::Terminal(_, _) => { set.insert(SetTerminal::Empty); } Node::Operation(op, left, right) => match op { Operator::Or => { let left_set = factors_set(left); - let right_set = factors_set(&*right.as_ref().unwrap()); + let right_set = factors_set(right.as_ref().unwrap()); set.extend(left_set); set.extend(right_set); } Operator::Concat => { let left_set = factors_set(left); - let right_set = factors_set(&*right.as_ref().unwrap()); + let right_set = factors_set(right.as_ref().unwrap()); let suffix_set = suffix_set(left); - let prefix_set = prefix_set(&*right.as_ref().unwrap()); + let prefix_set = prefix_set(right.as_ref().unwrap()); set.extend(left_set); set.extend(right_set); for i in suffix_set {