code quality

src/lib.rs

@@ -266,8 +266,8 @@ where
             // rule parsing
             if parsing && line.is_empty() {
                 parsing = false;
-                if current_rule.is_some() {
-                    match current_rule.as_ref().unwrap() {
+                if let Some(current_rule) = &current_rule {
+                    match current_rule {
                         RuleKind::Order => {
                             orders.push(current_order.to_owned());
                             current_order.clear();
@@ -288,11 +288,13 @@ where
             }
 
             // finish rule parsing
-            if parsing && current_rule.is_some() {
-                match current_rule.as_ref().unwrap() {
-                    RuleKind::Order => current_order.push(line),
-                    RuleKind::Note => todo!(),
-                    RuleKind::Conflict => todo!(),
+            if parsing {
+                if let Some(current_rule) = &current_rule {
+                    match current_rule {
+                        RuleKind::Order => current_order.push(line),
+                        RuleKind::Note => todo!(),
+                        RuleKind::Conflict => todo!(),
+                    }
                 }
             }
         }

tests/unit_expression_tests.rs

@@ -4,7 +4,7 @@ mod unit_expressions_tests {
 
     #[test]
     fn evaluate_all() {
-        let mods: Vec<String> = vec!["a", "b", "c", "d", "e", "f", "g"]
+        let mods: Vec<String> = ["a", "b", "c", "d", "e", "f", "g"]
             .iter()
             .map(|e| (*e).into())
             .collect();
@@ -24,7 +24,7 @@ mod unit_expressions_tests {
 
     #[test]
     fn evaluate_any() {
-        let mods: Vec<String> = vec!["a", "b", "c", "d", "e", "f", "g"]
+        let mods: Vec<String> = ["a", "b", "c", "d", "e", "f", "g"]
             .iter()
             .map(|e| (*e).into())
             .collect();
@@ -44,7 +44,7 @@ mod unit_expressions_tests {
 
     #[test]
     fn evaluate_not() {
-        let mods: Vec<String> = vec!["a", "b", "c", "d", "e", "f", "g"]
+        let mods: Vec<String> = ["a", "b", "c", "d", "e", "f", "g"]
             .iter()
             .map(|e| (*e).into())
             .collect();

tests/unit_rules_tests.rs

@@ -4,12 +4,12 @@ mod unit_rules_tests {
 
     #[test]
     fn test_notes() {
-        let mods: Vec<String> = vec!["a", "b", "c", "d", "e", "f", "g"]
+        let mods: Vec<String> = ["a", "b", "c", "d", "e", "f", "g"]
             .iter()
             .map(|e| (*e).into())
             .collect();
 
-        let rules: Vec<_> = vec![("a", "some a"), ("c", "some b"), ("x", "some x!")]
+        let rules: Vec<_> = [("a", "some a"), ("c", "some b"), ("x", "some x!")]
             .iter()
             .map(|e| Note {
                 comment: e.1.into(),
@@ -29,7 +29,7 @@ mod unit_rules_tests {
 
     #[test]
     fn test_conflicts() {
-        let mods: Vec<String> = vec!["a", "b", "c", "d", "e", "f", "g"]
+        let mods: Vec<String> = ["a", "b", "c", "d", "e", "f", "g"]
             .iter()
             .map(|e| (*e).into())
             .collect();

tests/unit_tests.rs

@@ -5,13 +5,13 @@ mod unit_tests {
     #[test]
     fn test_cycle() {
         let rules = Rules {
-            order: vec![("a", "b"), ("b", "c"), ("d", "e"), ("b", "a")]
+            order: [("a", "b"), ("b", "c"), ("d", "e"), ("b", "a")]
                 .iter()
                 .map(|e| (e.0.to_owned(), e.1.to_owned()))
                 .collect(),
         };
 
-        let mods: Vec<String> = vec!["a", "b", "c", "d", "e", "f", "g"]
+        let mods: Vec<String> = ["a", "b", "c", "d", "e", "f", "g"]
             .iter()
             .map(|e| (*e).into())
             .collect();
@@ -25,7 +25,7 @@ mod unit_tests {
     #[test]
     fn test_ordering() {
         let rules = Rules {
-            order: vec![
+            order: [
                 ("a", "b"),
                 ("b", "c"),
                 ("d", "e"),
@@ -37,7 +37,7 @@ mod unit_tests {
             .collect(),
         };
 
-        let mods = vec!["a", "b", "c", "d", "e", "f", "g"]
+        let mods = ["a", "b", "c", "d", "e", "f", "g"]
             .iter()
             .map(|e| (*e).into())
             .collect();
@@ -70,12 +70,12 @@ mod unit_tests {
 
     #[test]
     fn test_notes() {
-        let mods: Vec<String> = vec!["a", "b", "c", "d", "e", "f", "g"]
+        let mods: Vec<String> = ["a", "b", "c", "d", "e", "f", "g"]
             .iter()
             .map(|e| (*e).into())
             .collect();
 
-        let rules: Vec<_> = vec![("a", "some a"), ("c", "some b"), ("x", "some x!")]
+        let rules: Vec<_> = [("a", "some a"), ("c", "some b"), ("x", "some x!")]
             .iter()
             .map(|e| Note {
                 comment: e.1.into(),
@@ -95,7 +95,7 @@ mod unit_tests {
 
     #[test]
     fn test_conflicts() {
-        let mods: Vec<String> = vec!["a", "b", "c", "d", "e", "f", "g"]
+        let mods: Vec<String> = ["a", "b", "c", "d", "e", "f", "g"]
             .iter()
             .map(|e| (*e).into())
             .collect();