enabled pedantic clippy lints

Author: alexanderkjall

Cargo.toml

@@ -36,6 +36,9 @@ flate2 = "1"
 tar = "0.4"
 criterion = "0.8"
 
+[lints.clippy]
+pedantic = "warn"
+
 [workspace]
 
 members = [

cursive/src/main.rs

@@ -55,6 +55,7 @@ use crate::helpers::{
 use lazy_static::lazy_static;
 use ripasso::crypto::Fingerprint;
 use zeroize::Zeroize;
+use ripasso::password_generator::PasswordGenerationCategory;
 
 /// The 'pointer' to the current PasswordStore is of this convoluted type.
 type PasswordStoreType = Arc<Mutex<Arc<Mutex<PasswordStore>>>>;
@@ -444,7 +445,7 @@ fn open(ui: &mut Cursive, store: PasswordStoreType) -> Result<()> {
 
         })
         .button(CATALOG.gettext("Generate Password"), move |s| {
-            let mut new_password = password_generator(20, 0);
+            let mut new_password = password_generator(20, PasswordGenerationCategory::AsciiOnly);
             s.call_on_name("editbox", |e: &mut TextArea| {
                 e.set_content(&new_password);
             });
@@ -456,7 +457,7 @@ fn open(ui: &mut Cursive, store: PasswordStoreType) -> Result<()> {
             let mut new_password = match passphrase_generator(6) {
                 Ok(words) => words.join(" "),
                 Err(err) => {
-                    helpers::errorbox(s, &ripasso::pass::Error::from(err));
+                    helpers::errorbox(s, &err);
                     return;
                 }
             };
@@ -791,8 +792,13 @@ fn create(ui: &mut Cursive, store: PasswordStoreType) {
             move |s| {
                 let category = *category_value.lock().unwrap();
                 let length = *password_length.lock().unwrap();
+                let category = if category == 0 {
+                    PasswordGenerationCategory::AsciiOnly
+                } else {
+                    PasswordGenerationCategory::AsciiExtended
+                };
                 let new_password =
-                    ripasso::password_generator::password_generator(length, category);
+                    password_generator(length, category);
 
                 s.call_on_name("new_password_input", |e: &mut EditView| {
                     e.set_content(new_password);
@@ -803,7 +809,7 @@ fn create(ui: &mut Cursive, store: PasswordStoreType) {
             let new_password = match ripasso::passphrase_generator::passphrase_generator(6) {
                 Ok(words) => words.join(" "),
                 Err(err) => {
-                    helpers::errorbox(s, &ripasso::pass::Error::from(err));
+                    helpers::errorbox(s, &err);
                     return;
                 }
             };
@@ -1592,7 +1598,7 @@ fn save_edit_config(
 
     let e_k = if e_k_bool {
         let mut recipients: Vec<Recipient> = vec![];
-        for (i, r) in all_recipients_from_stores(stores.clone())?
+        for (i, r) in all_recipients_from_stores(&stores)?
             .iter()
             .enumerate()
         {
@@ -1648,7 +1654,7 @@ fn save_edit_config(
         }
     }
 
-    let save_res = pass::save_config(stores, config_file_location);
+    let save_res = pass::save_config(&stores, config_file_location);
     if let Err(err) = save_res {
         helpers::errorbox(ui, &err);
     }
@@ -1692,7 +1698,7 @@ fn save_new_config(
         stores_borrowed.push(Arc::new(Mutex::new(new_store)));
     }
 
-    pass::save_config(stores, config_file_location)?;
+    pass::save_config(&stores, config_file_location)?;
 
     let mut l = ui.find_name::<SelectView<String>>("stores").unwrap();
 
@@ -1711,7 +1717,7 @@ fn edit_store_in_config(
     config_file_location: &Path,
     home: &Option<PathBuf>,
 ) -> Result<()> {
-    let all_recipients = all_recipients_from_stores(stores.clone())?;
+    let all_recipients = all_recipients_from_stores(&stores)?;
 
     let l = ui.find_name::<SelectView<String>>("stores").unwrap();
 
@@ -1881,7 +1887,7 @@ fn delete_store_from_config(
         stores_borrowed.retain(|store| store.lock().unwrap().get_name() != name);
     }
 
-    let save_res = pass::save_config(stores, config_file_location);
+    let save_res = pass::save_config(&stores, config_file_location);
     if let Err(err) = save_res {
         helpers::errorbox(ui, &err);
         return Ok(());
@@ -1903,7 +1909,7 @@ fn add_store_to_config(
     config_file_location: &Path,
     home: &Option<PathBuf>,
 ) -> Result<()> {
-    let all_recipients = all_recipients_from_stores(stores.clone())?;
+    let all_recipients = all_recipients_from_stores(&stores)?;
 
     let mut fields = LinearLayout::vertical();
     let mut name_fields = LinearLayout::horizontal();
@@ -2153,10 +2159,10 @@ fn main() -> Result<()> {
         };
 
         pass::read_config(
-            &password_store_dir,
-            &password_store_signing_key,
-            &home,
-            &xdg_config_home,
+            password_store_dir.as_deref(),
+            password_store_signing_key.as_deref(),
+            home.as_ref(),
+            xdg_config_home.as_ref(),
         )
     };
     if let Err(err) = config_res {
@@ -2189,7 +2195,7 @@ fn main() -> Result<()> {
             eprintln!("Error {err}");
             process::exit(1);
         }
-        if let Err(err) = pass::save_config(stores.clone(), &config_file_location) {
+        if let Err(err) = pass::save_config(&stores, &config_file_location) {
             eprintln!("Error {err}");
             process::exit(1);
         }

gtk/src/window/imp.rs

@@ -76,7 +76,7 @@ impl ObjectImpl for Window {
         // Setup
         let obj = self.obj();
         obj.setup_collections();
-        obj.restore_data(home_dir, user_config_dir);
+        obj.restore_data(home_dir.as_ref(), user_config_dir.as_ref());
         obj.setup_callbacks();
         obj.setup_actions();
     }

gtk/src/window/mod.rs

@@ -101,15 +101,15 @@ impl Window {
         )
     }
 
-    fn restore_data(&self, home_dir: Option<PathBuf>, user_config_dir: Option<PathBuf>) {
-        let (config, home) = ripasso::pass::read_config(&None, &None, &home_dir, &user_config_dir)
+    fn restore_data(&self, home_dir: Option<&PathBuf>, user_config_dir: Option<&PathBuf>) {
+        let (config, home) = ripasso::pass::read_config(None, None, home_dir, user_config_dir)
             .expect("No config file present");
 
         let stores = get_stores(&config, &Some(home)).expect("Problem constructing stores");
         // Convert `Vec<CollectionData>` to `Vec<CollectionObject>`
         let collections: Vec<CollectionObject> = stores
             .into_iter()
-            .map(|s| CollectionObject::from_store_data(s, &user_config_dir.clone().unwrap()))
+            .map(|s| CollectionObject::from_store_data(s, user_config_dir.unwrap()))
             .collect();
 
         // Insert restored objects into model

src/crypto.rs

@@ -182,13 +182,16 @@ impl AsRef<[u8]> for Fingerprint {
 
 /// Models the interactions that can be done on a pgp key
 pub trait Key {
-    /// returns a list of names associated with the key
+    /// Returns a list of names associated with the key.
     fn user_id_names(&self) -> Vec<String>;
 
-    /// returns the keys fingerprint
+    /// Returns the keys fingerprint.
+    ///
+    /// # Errors
+    /// If a gpg context can't be created, and the gpg backend is chosen.
     fn fingerprint(&self) -> Result<Fingerprint>;
 
-    /// returns if the key isn't usable
+    /// Returns if the key isn't usable.
     fn is_not_usable(&self) -> bool;
 }
 
@@ -228,6 +231,7 @@ pub trait Crypto {
     /// Will return `Err` if decryption fails, for example if the current user isn't the
     /// recipient of the message.
     fn decrypt_string(&self, ciphertext: &[u8]) -> Result<String>;
+
     /// Encrypts a string
     /// # Errors
     /// Will return `Err` if encryption fails, for example if the current users key
@@ -256,6 +260,9 @@ pub trait Crypto {
     ) -> std::result::Result<SignatureStatus, VerificationError>;
 
     /// Returns true if a recipient is in the user's keyring.
+    ///
+    /// # Errors
+    /// If a gpg context can't be created, and the gpg backend is chosen.
     fn is_key_in_keyring(&self, recipient: &Recipient) -> Result<bool>;
 
     /// Pull keys from the keyserver for those recipients.
@@ -273,7 +280,7 @@ pub trait Crypto {
     /// Will return `Err` if `key_id` didn't correspond to a key.
     fn get_key(&self, key_id: &str) -> Result<Box<dyn Key>>;
 
-    /// Returns a map from key fingerprints to OwnerTrustLevel's
+    /// Returns a map from key fingerprints to `OwnerTrustLevel`'s
     /// # Errors
     /// Will return `Err` on failure to obtain trust levels.
     fn get_all_trust_items(&self) -> Result<HashMap<Fingerprint, OwnerTrustLevel>>;
@@ -294,7 +301,7 @@ impl Crypto for GpgMe {
         let mut ctx = gpgme::Context::from_protocol(gpgme::Protocol::OpenPgp)?;
         let mut output = Vec::new();
         ctx.decrypt(ciphertext, &mut output)?;
-        let result = String::from_utf8(output.to_vec())?;
+        let result = String::from_utf8(output.clone())?;
         output.zeroize();
         Ok(result)
     }
@@ -514,7 +521,7 @@ struct Helper<'a> {
     key_ring: &'a HashMap<Fingerprint, Arc<Cert>>,
     /// This is all the certificates that are allowed to sign something
     public_keys: Vec<Arc<Cert>>,
-    /// context if talking to gpg_agent for example
+    /// context if talking to `gpg_agent` for example
     ctx: Option<sequoia_gpg_agent::gnupg::Context>,
     /// to do verification or not
     do_signature_verification: bool,
@@ -555,7 +562,7 @@ impl VerificationHelper for Helper<'_> {
 
 fn find(
     key_ring: &HashMap<Fingerprint, Arc<Cert>>,
-    recipient: &Option<KeyHandle>,
+    recipient: Option<&KeyHandle>,
 ) -> Result<Arc<Cert>> {
     let recipient = recipient.as_ref().ok_or(Error::Generic("No recipient"))?;
 
@@ -576,7 +583,7 @@ fn find(
                     return Err(Error::Generic("unknown fingerprint version"));
                 }
                 _ => {}
-            };
+            }
         }
         KeyHandle::KeyID(key_id) => match key_id {
             KeyID::Long(bytes) => {
@@ -608,7 +615,7 @@ impl DecryptionHelper for Helper<'_> {
             // we don't know which key is the users own key, so lets try them all
             let mut selected_fingerprint: Option<Arc<Cert>> = None;
             for pkesk in pkesks {
-                if let Ok(cert) = find(self.key_ring, &pkesk.recipient()) {
+                if let Ok(cert) = find(self.key_ring, pkesk.recipient().as_ref()) {
                     let key = cert.primary_key().key();
                     let mut pair = sequoia_gpg_agent::KeyPair::new_for_gnupg_context(
                         self.ctx
@@ -648,8 +655,7 @@ impl DecryptionHelper for Helper<'_> {
         for pkesk in pkesks {
             if pkesk
                 .decrypt(&mut pair, sym_algo)
-                .map(|(algo, sk)| decrypt(algo, &sk))
-                .unwrap_or(false)
+                .is_some_and(|(algo, sk)| decrypt(algo, &sk))
             {
                 return Ok(Some(
                     (*self
@@ -688,10 +694,7 @@ impl Key for SequoiaKey {
     fn is_not_usable(&self) -> bool {
         let p = sequoia_openpgp::policy::StandardPolicy::new();
 
-        let policy = match self.cert.with_policy(&p, None) {
-            Err(_) => return true,
-            Ok(p) => p,
-        };
+        let Ok(policy) = self.cert.with_policy(&p, None) else { return true };
 
         self.cert.revocation_status(&p, None) != RevocationStatus::NotAsFarAsWeKnow
             || policy.alive().is_err()
@@ -737,6 +740,7 @@ impl Sequoia {
         })
     }
 
+    #[must_use]
     pub fn from_values(
         user_key_id: Fingerprint,
         key_ring: HashMap<Fingerprint, Arc<Cert>>,
@@ -756,26 +760,25 @@ impl Sequoia {
         let mut result = vec![];
 
         for recipient in input {
-            match &recipient.fingerprint {
-                Some(fp) => match self.key_ring.get(fp) {
+            if let Some(fp) = &recipient.fingerprint {
+                match self.key_ring.get(fp) {
                     Some(cert) => result.push(cert.clone()),
                     None => {
                         return Err(Error::GenericDyn(format!(
                             "Recipient with key id {} not found",
                             recipient.key_id
                         )));
                     }
-                },
-                None => {
-                    let kh: KeyHandle = recipient.key_id.parse()?;
-
-                    for cert in self.key_ring.values() {
-                        if cert.key_handle().aliases(&kh) {
-                            result.push(cert.clone());
-                        }
+                }
+            } else {
+                let kh: KeyHandle = recipient.key_id.parse()?;
+
+                for cert in self.key_ring.values() {
+                    if cert.key_handle().aliases(&kh) {
+                        result.push(cert.clone());
                     }
                 }
-            };
+            }
         }
 
         Ok(result)

src/error.rs

@@ -190,28 +190,31 @@ impl std::fmt::Display for Error {
             Self::Gpg(err) => write!(f, "{err}"),
             Self::Utf8(err) => write!(f, "{err}"),
             Self::Generic(err) => write!(f, "{err}"),
-            Self::GenericDyn(err) => write!(f, "{err}"),
+            Self::GenericDyn(err) | Self::RecipientNotInKeyRing(err) => write!(f, "{err}"),
             Self::PathError(err) => write!(f, "{err}"),
             Self::PatternError(err) => write!(f, "{err}"),
             Self::GlobError(err) => write!(f, "{err}"),
             Self::Utf8Error(err) => write!(f, "{err}"),
-            Self::RecipientNotInKeyRing(err) => write!(f, "{err}"),
             Self::ConfigError(err) => write!(f, "{err}"),
             Self::SerError(err) => write!(f, "{err}"),
             Self::ReqwestError(err) => write!(f, "{err}"),
             Self::AnyhowError(err) => write!(f, "{err}"),
-            Self::NoneError => write!(f, "NoneError"),
             Self::HexError(err) => write!(f, "{err}"),
             Self::FmtError(err) => write!(f, "{err}"),
-            Self::TotpUrlError(_err) => write!(f, "TOTP url error"),
             Self::SystemTimeError(err) => write!(f, "{err}"),
+            Self::NoneError => write!(f, "NoneError"),
+            Self::TotpUrlError(_err) => write!(f, "TOTP url error"),
         }
     }
 }
 
 /// Convenience type for Results
 pub type Result<T> = std::result::Result<T, Error>;
 
+/// Converts a `LocalResult` to a normal `Result`.
+///
+/// # Errors
+/// If the supplied `LocalResult` have no timezone or more than one timezone.
 pub fn to_result<T: chrono::TimeZone>(
     res: chrono::LocalResult<chrono::DateTime<T>>,
 ) -> Result<chrono::DateTime<T>> {