[ci skip] fix: cargo clippy (#507)

# clippy fixes

I think these fixes improves code quality.

> [!NOTE]
> `unreadable_literal` might also be usable, but I've excluded it for
now.


command used:

```sh
cargo clippy -- \
    -W clippy::pedantic \
    -A clippy::cast_sign_loss \
    -A clippy::cast_possible_wrap \
    -A clippy::similar_names \
    -A clippy::must_use_candidate \
    -A clippy::return_self_not_must_use \
    -A clippy::cast_possible_truncation \
    -A clippy::default_trait_access \
    -A clippy::struct_excessive_bools \
    -A clippy::cast_lossless \
    -A clippy::wildcard_imports \
    -A clippy::cast_precision_loss \
    -A clippy::module_name_repetitions \
    -A clippy::unreadable_literal
```

Author: replydev

build.rs

@@ -1,21 +1,17 @@
-use std::env;
-use std::process::Command;
+use std::{env, process::Command};
 
 fn main() {
     let version = env!("CARGO_PKG_VERSION");
 
     if Ok("release".to_owned()) == env::var("PROFILE") {
-        println!("cargo:rustc-env=COTP_VERSION={}", version);
+        println!("cargo:rustc-env=COTP_VERSION={version}");
     } else {
         // Suffix with -DEBUG
         // If we can get the last commit hash, let's append that also
         if let Some(last_commit) = get_last_commit() {
-            println!(
-                "cargo:rustc-env=COTP_VERSION={}-DEBUG-{}",
-                version, last_commit
-            );
+            println!("cargo:rustc-env=COTP_VERSION={version}-DEBUG-{last_commit}");
         } else {
-            println!("cargo:rustc-env=COTP_VERSION={}-DEBUG", version);
+            println!("cargo:rustc-env=COTP_VERSION={version}-DEBUG");
         }
     }
 }
@@ -27,5 +23,5 @@ fn get_last_commit() -> Option<String> {
         .ok()
         .filter(|e| e.status.success())
         .map(|e| String::from_utf8(e.stdout))
-        .and_then(|e| e.ok())
+        .and_then(Result::ok)
 }

src/arguments/export.rs

@@ -37,7 +37,7 @@ pub struct ExportFormat {
     #[arg(short, long = "otp-uri")]
     pub otp_uri: bool,
 
-    /// Export into the FreeOTP+ database format
+    /// Export into the `FreeOTP`+ database format
     #[arg(short, long = "freeotp-plus")]
     pub freeotp_plus: bool,
 }

src/arguments/extract.rs

@@ -30,12 +30,12 @@ impl SubcommandExecutor for ExtractArgs {
             .elements
             .iter()
             .enumerate()
-            .find(|(index, code)| filter_extract(&self, index, code))
+            .find(|(index, code)| filter_extract(&self, *index, code))
             .map(|(_, code)| code);
 
         if let Some(otp) = first_with_filters {
             let code = otp.get_otp_code()?;
-            println!("{}", code);
+            println!("{code}");
             if self.copy_to_clipboard {
                 let _ = clipboard::copy_string_to_clipboard(code.as_str())?;
                 println!("Copied to clipboard");
@@ -47,8 +47,8 @@ impl SubcommandExecutor for ExtractArgs {
     }
 }
 
-fn filter_extract(args: &ExtractArgs, index: &usize, code: &OTPElement) -> bool {
-    let match_by_index = args.index.map_or(true, |i| i == *index);
+fn filter_extract(args: &ExtractArgs, index: usize, code: &OTPElement) -> bool {
+    let match_by_index = args.index.map_or(true, |i| i == index);
 
     let match_by_issuer = args.issuer.as_ref().map_or(true, |issuer| {
         code.issuer.to_lowercase() == issuer.to_lowercase()

src/arguments/import.rs

@@ -44,11 +44,11 @@ pub struct BackupType {
     #[arg(short = 'k', long = "aegis-encrypted")]
     pub aegis_encrypted: bool,
 
-    /// Import from FreeOTP+ backup
+    /// Import from `FreeOTP`+ backup
     #[arg(short, long = "freeotp-plus")]
     pub freeotp_plus: bool,
 
-    /// Import from FreeOTP backup
+    /// Import from `FreeOTP` backup
     #[arg(short = 'r', long)]
     pub freeotp: bool,
 
@@ -60,7 +60,7 @@ pub struct BackupType {
     #[arg(short = 't', long)]
     pub authy: bool,
 
-    /// Import from Authy Database exported following this guide https://gist.github.com/gboudreau/94bb0c11a6209c82418d01a59d958c93
+    /// Import from Authy Database exported following this guide <https://gist.github.com/gboudreau/94bb0c11a6209c82418d01a59d958c93>
     #[arg(short = 'u', long = "authy-exported")]
     pub authy_exported: bool,
 

src/arguments/list.rs

@@ -64,7 +64,7 @@ impl SubcommandExecutor for ListArgs {
             let json_elements = otp_database
                 .elements
                 .iter()
-                .map(|element| element.try_into())
+                .map(TryInto::try_into)
                 .collect::<Result<Vec<JsonOtpList>>>()?;
 
             let stringified = serde_json::to_string_pretty(&json_elements)
@@ -104,13 +104,13 @@ impl SubcommandExecutor for ListArgs {
                                     .repeat(issuer_width - NO_ISSUER_TEXT.chars().count())
                                     .as_str()
                         } else {
-                            e.issuer.to_owned()
+                            e.issuer.clone()
                                 + " ".repeat(issuer_width - e.issuer.chars().count()).as_str()
                         },
-                        e.label.to_owned()
+                        e.label.clone()
                             + " ".repeat(label_width - e.label.chars().count()).as_str(),
                         e.get_otp_code().unwrap_or("ERROR".to_string())
-                    )
+                    );
                 });
         }
 

src/arguments/mod.rs

@@ -72,5 +72,5 @@ pub fn args_parser(matches: CotpArgs, read_result: OTPDatabase) -> color_eyre::R
 #[test]
 fn verify_cli() {
     use clap::CommandFactory;
-    CotpArgs::command().debug_assert()
+    CotpArgs::command().debug_assert();
 }

src/crypto/cryptography.rs

@@ -31,7 +31,7 @@ pub fn gen_salt() -> color_eyre::Result<[u8; ARGON2ID_SALT_LENGTH]> {
 }
 
 pub fn encrypt_string_with_key(
-    plain_text: String,
+    plain_text: &str,
     key: &Vec<u8>,
     salt: &[u8],
 ) -> color_eyre::Result<EncryptedDatabase> {
@@ -93,8 +93,7 @@ mod tests {
     fn test_encryption() {
         let salt = gen_salt().unwrap();
         let key = argon_derive_key(b"pa$$w0rd", salt.as_ref()).unwrap();
-        let encrypted =
-            encrypt_string_with_key(String::from("Secret data@#[]ò"), &key, salt.as_ref()).unwrap();
+        let encrypted = encrypt_string_with_key("Secret data@#[]ò", &key, salt.as_ref()).unwrap();
         let (decrypted, _key, _salt) =
             decrypt_string(&serde_json::to_string(&encrypted).unwrap(), "pa$$w0rd").unwrap();
         assert_eq!(String::from("Secret data@#[]ò"), decrypted);

src/exporters/freeotp_plus.rs

@@ -12,7 +12,7 @@ impl TryFrom<&OTPDatabase> for FreeOTPPlusJson {
         otp_database
             .elements
             .iter()
-            .map(|e| e.try_into())
+            .map(TryInto::try_into)
             .collect::<Result<Vec<FreeOTPElement>, ErrReport>>()
             .map(FreeOTPPlusJson::new)
     }
@@ -22,19 +22,19 @@ impl TryFrom<&OTPElement> for FreeOTPElement {
     type Error = ErrReport;
     fn try_from(otp_element: &OTPElement) -> Result<Self, Self::Error> {
         Ok(FreeOTPElement {
-            secret: decode_secret(otp_element.secret.clone())?,
+            secret: decode_secret(&otp_element.secret)?,
             algo: otp_element.algorithm.to_string(),
             counter: otp_element.counter.unwrap_or(0),
             digits: otp_element.digits,
             issuer_ext: otp_element.issuer.clone(),
-            _label: otp_element.label.clone(),
+            label: otp_element.label.clone(),
             period: otp_element.period,
-            _type: otp_element.type_.to_string(),
+            r#type: otp_element.type_.to_string(),
         })
     }
 }
 
-fn decode_secret(secret: String) -> Result<Vec<i8>> {
+fn decode_secret(secret: &str) -> Result<Vec<i8>> {
     BASE32_NOPAD
         .decode(secret.as_bytes())
         .map(|v| v.into_iter().map(|n| n as i8).collect::<Vec<i8>>())

src/exporters/otp_uri.rs

@@ -8,7 +8,11 @@ pub struct OtpUriList {
 
 impl<'a> From<&'a OTPDatabase> for OtpUriList {
     fn from(value: &'a OTPDatabase) -> Self {
-        let items: Vec<String> = value.elements.iter().map(|e| e.get_otpauth_uri()).collect();
+        let items: Vec<String> = value
+            .elements
+            .iter()
+            .map(super::super::otp::otp_element::OTPElement::get_otpauth_uri)
+            .collect();
 
         OtpUriList { items }
     }

src/importers/aegis.rs

@@ -23,8 +23,7 @@ pub(crate) struct AegisDb {
 
 #[derive(Serialize, Deserialize)]
 struct AegisElement {
-    #[serde(rename = "type")]
-    _type: String,
+    r#type: String,
     //uuid: String,
     name: String,
     issuer: String,
@@ -39,7 +38,7 @@ impl From<AegisElement> for OTPElement {
             issuer: value.issuer,
             label: value.name,
             digits: value.info.digits,
-            type_: OTPType::from(value._type.as_str()),
+            type_: OTPType::from(value.r#type.as_str()),
             algorithm: OTPAlgorithm::from(value.info.algo.as_str()),
             period: value.info.period.unwrap_or(30),
             counter: value.info.counter,
@@ -52,7 +51,7 @@ impl TryFrom<AegisDb> for Vec<OTPElement> {
     type Error = String;
 
     fn try_from(aegis_db: AegisDb) -> Result<Self, Self::Error> {
-        Ok(aegis_db.entries.into_iter().map(|e| e.into()).collect())
+        Ok(aegis_db.entries.into_iter().map(Into::into).collect())
     }
 }