style(memorable-pass): clippy fix

crates/memorable-pass/src/lib.rs

@@ -21,11 +21,11 @@
 #![feature(async_fn_in_trait)]
 
 use crate::config::asset::WORDS;
-use rand::Rng;
-use tracing::{instrument, trace};
 use crate::processor::processor::Processor;
 use crate::rules::rule::Rule;
-use crate::rules::rules::Rules;
+use crate::rules::Rules;
+use rand::Rng;
+use tracing::{instrument, trace};
 
 pub mod config;
 pub mod processor;

crates/memorable-pass/src/processor/mod.rs

@@ -14,5 +14,6 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+#[allow(clippy::module_inception)]
 pub mod processor;
 pub mod word;

crates/memorable-pass/src/processor/processor.rs

@@ -48,14 +48,6 @@ impl<'a> Processor<'a> {
                     Action::Addition(_, position, addition, condition) => {
                         match condition.should_use(index, position, &start_end) {
                             false => debug!("Skipping rule as condition failed"),
-                            // ActionCondition::HasNoInput if start_end.0 != 0 || position.is_end() => {
-                            //     debug!("Skipping rule as it has no input and is not at the start of the word");
-                            //     continue
-                            // },
-                            // ActionCondition::HasInput if start_end.0 == 0 && position.is_start() => {
-                            //     debug!("Skipping rule as it has input and is at the start of the word");
-                            //     continue
-                            // },
                             _ => match position {
                                 Position::Start => {
                                     mut_word.insert_str(start_end.0, addition);

crates/memorable-pass/src/rules/action.rs

@@ -29,13 +29,13 @@ pub enum ActionCondition {
 }
 
 #[derive(Derivative)]
-#[derivative(Debug, Ord = "feature_allow_slow_enum", Eq, PartialEq)]
+#[derivative(Debug, Eq)]
 pub enum Action {
     Addition(Priority, Position, String, ActionCondition),
     Transformation(
         Priority,
         ActionCondition,
-        #[derivative(Debug = "ignore", Ord = "ignore", PartialEq = "ignore")] TransformationFn,
+        #[derivative(Debug = "ignore")] TransformationFn,
     ),
 }
 
@@ -56,16 +56,28 @@ impl ActionCondition {
     }
 }
 
+impl PartialEq<Self> for Action {
+    fn eq(&self, other: &Self) -> bool {
+        self.cmp(other) == Ordering::Equal
+    }
+}
+
 impl PartialOrd for Action {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for Action {
+    fn cmp(&self, other: &Self) -> Ordering {
         match (self, other) {
             (Self::Addition(pri1, pos1, ..), Self::Addition(pri2, pos2, ..)) => match pos1 == pos2 {
-                true => pri1.partial_cmp(pri2),
-                false => pos1.partial_cmp(pos2),
+                true => pri1.cmp(pri2),
+                false => pos1.cmp(pos2),
             },
-            (Self::Transformation(pri1, ..), Self::Transformation(pri2, ..)) => pri1.partial_cmp(pri2),
-            (Self::Addition(..), Self::Transformation(..)) => Some(Ordering::Less),
-            (Self::Transformation(..), Self::Addition(..)) => Some(Ordering::Greater),
+            (Self::Transformation(pri1, ..), Self::Transformation(pri2, ..)) => pri1.cmp(pri2),
+            (Self::Addition(..), Self::Transformation(..)) => Ordering::Less,
+            (Self::Transformation(..), Self::Addition(..)) => Ordering::Greater,
         }
     }
 }

crates/memorable-pass/src/rules/addition/separator.rs

@@ -108,13 +108,6 @@ mod tests {
     use regex::Regex;
     use std::assert_matches::assert_matches;
 
-    fn get_string(action: &Action) -> String {
-        match action {
-            Action::Addition(_, _, string, ..) => string.clone(),
-            _ => String::new(),
-        }
-    }
-
     #[test_log::test(test)]
     fn separator_none() {
         let mut processor = Processor::new(vec!["hello", "world"]);

crates/memorable-pass/src/rules/mod.rs

@@ -19,5 +19,60 @@ pub mod addition;
 pub mod position;
 pub mod priority;
 pub mod rule;
-pub mod rules;
 pub mod transformation;
+
+use crate::rules::addition::digits::DigitAddition;
+use crate::rules::addition::separator::SeparatorAddition;
+use crate::rules::transformation::case::CaseTransformation;
+use clap::Parser;
+use serde::{Deserialize, Serialize};
+use std::fmt::Debug;
+
+/// The rules which are used to generate passwords.
+#[derive(Debug, Parser, Serialize, Deserialize)]
+#[serde(default)]
+pub struct Rules {
+    /// How many words are used.
+    ///
+    /// This is the number of words which each password will contain.
+    /// These words are the base of the password with the rules being applied to them.
+    ///
+    /// The maximum number of words is 10 with the minimum being 1.
+    #[arg(short = 'w', long = "words", default_value_t = 2, value_parser = clap::value_parser!(u8).range(1..10))]
+    pub word_count: u8,
+
+    /// The minimum length of each word.
+    #[arg(short = 'm', long = "min-length", default_value_t = 5, value_parser = clap::value_parser!(u8).range(3..=9))]
+    pub word_length_min: u8,
+
+    /// The maximum length of each word.
+    #[arg(short = 'M', long = "max-length", default_value_t = 7, value_parser = clap::value_parser!(u8).range(3..=9))]
+    pub word_length_max: u8,
+
+    #[command(flatten)]
+    pub addition_digits: DigitAddition,
+
+    #[command(flatten)]
+    pub addition_separator: SeparatorAddition,
+
+    #[arg(long, default_value_t = CaseTransformation::default(), value_enum)]
+    pub transformation_case: CaseTransformation,
+
+    /// The number of passwords to generate.
+    #[arg(short, long, default_value_t = 3)]
+    pub amount: usize,
+}
+
+impl Default for Rules {
+    fn default() -> Self {
+        Rules {
+            word_count: 2,
+            word_length_min: 5,
+            word_length_max: 7,
+            addition_digits: DigitAddition::default(),
+            addition_separator: SeparatorAddition::default(),
+            transformation_case: CaseTransformation::default(),
+            amount: 3,
+        }
+    }
+}

crates/memorable-pass/src/rules/priority.rs

@@ -43,7 +43,7 @@ impl Ord for Priority {
 
 impl PartialOrd for Priority {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        self.u8().partial_cmp(&other.u8())
+        Some(self.cmp(other))
     }
 }
 

crates/memorable-pass/src/rules/rules.rs

@@ -14,89 +14,3 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-use crate::rules::addition::digits::DigitAddition;
-use crate::rules::addition::separator::SeparatorAddition;
-use crate::rules::transformation::case::CaseTransformation;
-use clap::Parser;
-use serde::{Deserialize, Serialize};
-use std::fmt::Debug;
-
-/// The rules which are used to generate passwords.
-#[derive(Debug, Parser, Serialize, Deserialize)]
-#[serde(default)]
-pub struct Rules {
-    /// How many words are used.
-    ///
-    /// This is the number of words which each password will contain.
-    /// These words are the base of the password with the rules being applied to them.
-    ///
-    /// The maximum number of words is 10 with the minimum being 1.
-    #[arg(short = 'w', long = "words", default_value_t = 2, value_parser = clap::value_parser!(u8).range(1..10))]
-    pub word_count: u8,
-
-    /// The minimum length of each word.
-    #[arg(short = 'm', long = "min-length", default_value_t = 5, value_parser = clap::value_parser!(u8).range(3..=9))]
-    pub word_length_min: u8,
-
-    /// The maximum length of each word.
-    #[arg(short = 'M', long = "max-length", default_value_t = 7, value_parser = clap::value_parser!(u8).range(3..=9))]
-    pub word_length_max: u8,
-
-    #[command(flatten)]
-    pub addition_digits: DigitAddition,
-
-    #[command(flatten)]
-    pub addition_separator: SeparatorAddition,
-
-    #[arg(long, default_value_t = CaseTransformation::default(), value_enum)]
-    pub transformation_case: CaseTransformation,
-
-    /// The number of digits to add before the password.
-    // #[arg(short, long, default_value_t, value_parser = clap::value_parser!(u8).range(0..8))]
-    // pub digits_before: u8,
-    //
-    // /// The number of digits to add after the password.
-    // #[arg(short = 'D', long, default_value_t, value_parser = clap::value_parser!(u8).range(0..8))]
-    // pub digits_after: u8,
-    //
-    // /// The transformation to apply to each word.
-    // #[arg(short, long, default_value_t = Rules::default().transform, value_enum)]
-    // pub transform: Transformation,
-    //
-    // /// The separator mode or singular character to use.
-    // #[serde(alias = "separator_char")]
-    // #[arg(short = 's', long, default_value_t = Rules::default().separator_mode, value_enum)]
-    // pub separator_mode: SeparatorMode,
-    //
-    // /// The list of characters which can be used for the separator.
-    // #[arg(short = 'S', long, default_value_t)]
-    // pub separator_alphabet: Vec<char>,
-
-    // /// If all separator characters in the password should be the same.
-    // #[serde(alias = "match_random_char")]
-    // #[arg(
-    //     short = 'r',
-    //     long = "match-random-char",
-    //     long = "separator_matching",
-    //     default_value_t
-    // )]
-    // pub separator_matching: bool,
-
-    /// The number of passwords to generate.
-    #[arg(short, long, default_value_t = 3)]
-    pub amount: usize,
-}
-
-impl Default for Rules {
-    fn default() -> Self {
-        Rules {
-            word_count: 2,
-            word_length_min: 5,
-            word_length_max: 7,
-            addition_digits: DigitAddition::default(),
-            addition_separator: SeparatorAddition::default(),
-            transformation_case: CaseTransformation::default(),
-            amount: 3,
-        }
-    }
-}

crates/memorable-pass/src/ui/cli/action.rs

@@ -14,13 +14,13 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-use crate::rules::rules::Rules;
+use crate::rules::Rules;
 use clap::Subcommand;
 
 #[derive(Debug, Subcommand)]
 pub enum Action {
     Generate {
         #[command(flatten)]
         rules: Rules,
-    }
+    },
 }

crates/memorable-pass/src/ui/cli/ui.rs

@@ -15,7 +15,7 @@
  */
 
 use crate::config;
-use crate::rules::rules::Rules;
+use crate::rules::Rules;
 use crate::ui::cli::action::Action;
 use lib::cli::Flags as CommonFlags;
 use lib::ui::cli::cli::{AsyncCliUI, CliResult, CliUI};
@@ -41,10 +41,10 @@ impl CliUI for MemorablePassCli {
             let _preload = &config::asset::WORDS;
         });
 
-        return Ok(Self {
+        Ok(Self {
             _guard: None,
             rules: None,
-        });
+        })
     }
 }
 
@@ -60,10 +60,7 @@ impl AsyncCliUI for MemorablePassCli {
                 let passwords = crate::generate(&rules).await;
                 self.rules.replace(rules);
 
-                info!(
-                    "Generated passwords:\n{passwords}",
-                    passwords = passwords.join("\n")
-                );
+                info!("Generated passwords:\n{passwords}", passwords = passwords.join("\n"));
             }
         }