refactor: Fixed clippy warnings

Saphereye · Feb 16, 2024 · b6bf605 · b6bf605
1 parent 18c79e3
commit b6bf605
Show file tree

Hide file tree

Showing 6 changed files with 21 additions and 51 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git 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 <adarshdas950@gmail.com>"]
 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
@@ -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
@@ -5,37 +5,15 @@ 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<u32>,
     accept: HashSet<u32>,
     /// The transition function is a map from a pair of a state and a character to a set of states.
     transition_function: HashMap<(u32, char), HashSet<u32>>,
 }
 
-impl Default for NFA {
-    fn default() -> Self {
-        NFA {
-            states: HashSet::new(),
-            accept: HashSet::new(),
-            transition_function: HashMap::new(),
-        }
-    }
-}
-
 impl NFA {
-    fn new(
-        states: HashSet<u32>,
-        accept: HashSet<u32>,
-        transition_function: HashMap<(u32, char), HashSet<u32>>,
-    ) -> 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
@@ -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
@@ -15,17 +15,17 @@ pub enum Node {
 pub fn nullability_set(regex_tree: &Node) -> HashSet<SetTerminal> {
     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<SetTerminal> {
         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<SetTerminal> {
         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<SetTerminal> {
 pub fn factors_set(regex_tree: &Node) -> HashSet<SetTerminal> {
     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 {