Merge pull request #178 from replydev/fix_clippy_1.67

replydev · web-flow · commit 0917471d30d9 · 2023-01-27T22:08:33.000+01:00
Fix clippy 1.67 warnings
diff --git a/src/argument_functions.rs b/src/argument_functions.rs
@@ -38,7 +38,7 @@ pub fn import(matches: &ArgMatches, database: &mut OTPDatabase) -> Result<String
     let elements = match result {
         Ok(result) => result,
         Err(e) => {
-            return Err(format!("An error occurred: {}", e));
+            return Err(format!("An error occurred: {e}"));
         }
     };
 
@@ -132,7 +132,7 @@ pub fn edit(matches: &ArgMatches, database: &mut OTPDatabase) -> Result<String,
             }
             database.edit_element(index, element);
         }
-        None => return Err(format!("No element found at index {}", index)),
+        None => return Err(format!("No element found at index {index}")),
     }
 
     secret.zeroize();
@@ -145,15 +145,15 @@ pub fn export(matches: &ArgMatches, database: &mut OTPDatabase) -> Result<String
             "Database was successfully exported at {}",
             export_result.to_str().unwrap_or("**Invalid path**")
         )),
-        Err(e) => Err(format!("An error occurred while exporting database: {}", e)),
+        Err(e) => Err(format!("An error occurred while exporting database: {e}")),
     }
 }
 
 pub fn change_password(database: &mut OTPDatabase) -> Result<String, String> {
     let mut new_password = utils::verified_password("New password: ", 8);
     let r = match database.save_with_pw(&new_password) {
         Ok(()) => Ok(String::from("Password changed")),
-        Err(e) => Err(format!("An error has occurred: {}", e)),
+        Err(e) => Err(format!("An error has occurred: {e}")),
     };
     new_password.zeroize();
     r
diff --git a/src/crypto/cryptography.rs b/src/crypto/cryptography.rs
@@ -32,8 +32,7 @@ pub fn argon_derive_key(password_bytes: &[u8], salt: &[u8]) -> Result<Vec<u8>, S
 pub fn gen_salt() -> Result<[u8; ARGON2ID_SALT_LENGTH], String> {
     let mut salt: [u8; ARGON2ID_SALT_LENGTH] = [0; ARGON2ID_SALT_LENGTH];
     if let Err(e) = getrandom::getrandom(&mut salt) {
-        //return Err(format!("Error during salt generation: {}", e));
-        return Err(format!("Error during salt generation: {}", e));
+        return Err(format!("Error during salt generation: {e}"));
     }
     Ok(salt)
 }
@@ -49,7 +48,7 @@ pub fn encrypt_string_with_key(
     let mut nonce_bytes: [u8; XCHACHA20_POLY1305_NONCE_LENGTH] =
         [0; XCHACHA20_POLY1305_NONCE_LENGTH];
     if let Err(e) = getrandom::getrandom(&mut nonce_bytes) {
-        return Err(format!("Error during nonce generation: {}", e));
+        return Err(format!("Error during nonce generation: {e}"));
     }
     let nonce = XNonce::from_slice(&nonce_bytes);
     let cipher_text = aead
@@ -72,8 +71,7 @@ pub fn decrypt_string(
         Ok(result) => result,
         Err(e) => {
             return Err(format!(
-                "Error during encrypted database deserialization: {}",
-                e
+                "Error during encrypted database deserialization: {e}"
             ))
         }
     };
@@ -100,7 +98,7 @@ pub fn decrypt_string(
     };
     match String::from_utf8(decrypted) {
         Ok(result) => Ok((result, key, salt)),
-        Err(e) => Err(format!("Error during UTF-8 string conversion: {}", e)),
+        Err(e) => Err(format!("Error during UTF-8 string conversion: {e}")),
     }
 }
 
diff --git a/src/importers/aegis.rs b/src/importers/aegis.rs
@@ -47,7 +47,7 @@ struct AegisInfo {
 pub fn import(filepath: &str) -> Result<Vec<OTPElement>, String> {
     let file_to_import_contents = match read_to_string(filepath) {
         Ok(result) => result,
-        Err(e) => return Err(format!("Error during file reading: {:?}", e)),
+        Err(e) => return Err(format!("Error during file reading: {e:?}")),
     };
     import_from_string(file_to_import_contents.as_str())
 }
@@ -58,7 +58,7 @@ pub fn import_from_string(file_to_import_contents: &str) -> Result<Vec<OTPElemen
         Err(_) => {
             let aegis_db: AegisDb = match serde_json::from_str(file_to_import_contents) {
                 Ok(element) => element,
-                Err(e) => return Err(format!("{:?}", e)),
+                Err(e) => return Err(format!("{e:?}")),
             };
             // maybe we are importing from an encrypted aegis database, so we don
             Ok(map_entries(aegis_db.entries))
diff --git a/src/importers/aegis_encrypted.rs b/src/importers/aegis_encrypted.rs
@@ -49,12 +49,12 @@ struct AegisEncryptedSlot {
 pub fn import(filepath: &str, password: &str) -> Result<Vec<OTPElement>, String> {
     let file_to_import_contents = match read_to_string(filepath) {
         Ok(result) => result,
-        Err(e) => return Err(format!("Error during file reading: {:?}", e)),
+        Err(e) => return Err(format!("Error during file reading: {e:?}")),
     };
     let aegis_encrypted: AegisEncryptedDatabase =
         match serde_json::from_str(&file_to_import_contents) {
             Ok(result) => result,
-            Err(e) => return Err(format!("Error during deserialization: {:?}", e)),
+            Err(e) => return Err(format!("Error during deserialization: {e:?}")),
         };
 
     let mut master_key: Option<Vec<u8>> = None;
@@ -70,15 +70,15 @@ pub fn import(filepath: &str, password: &str) -> Result<Vec<OTPElement>, String>
                 master_key = Some(value);
                 break;
             }
-            Err(e) => println!("{}", e),
+            Err(e) => println!("{e}"),
         }
     }
 
     match master_key {
         Some(mut master_key) => {
             let content = match BASE64.decode(aegis_encrypted.db.as_bytes()) {
                 Ok(result) => result,
-                Err(e) => return Err(format!("Error during base64 decoding: {:?}", e)),
+                Err(e) => return Err(format!("Error during base64 decoding: {e:?}")),
             };
 
             let key = GenericArray::clone_from_slice(master_key.as_slice());
@@ -100,12 +100,12 @@ pub fn import(filepath: &str, password: &str) -> Result<Vec<OTPElement>, String>
                 .as_slice(),
             ) {
                 Ok(result) => result,
-                Err(e) => return Err(format!("Failed to derive master key: {:?}", e)),
+                Err(e) => return Err(format!("Failed to derive master key: {e:?}")),
             };
 
             let json = match String::from_utf8(decrypted_db) {
                 Ok(result) => result,
-                Err(e) => return Err(format!("Failed to decode from utf-8 bytes: {:?}", e)),
+                Err(e) => return Err(format!("Failed to decode from utf-8 bytes: {e:?}")),
             };
 
             aegis::import_from_string(json.as_str())
@@ -121,7 +121,7 @@ fn get_params(slot: &AegisEncryptedSlot) -> Result<Params, String> {
 
     match Params::new((n as f32).log2() as u8, r, p) {
         Ok(result) => Ok(result),
-        Err(e) => Err(format!("Error during scrypt params creation: {:?}", e)),
+        Err(e) => Err(format!("Error during scrypt params creation: {e:?}")),
     }
 }
 
@@ -139,7 +139,7 @@ fn get_master_key(slot: &AegisEncryptedSlot, password: &str) -> Result<Vec<u8>,
         &params,
         output.as_mut_slice(),
     ) {
-        return Err(format!("Error during scrypt key derivation: {:?}", e));
+        return Err(format!("Error during scrypt key derivation: {e:?}"));
     }
     let key = GenericArray::clone_from_slice(output.as_slice());
     output.zeroize();
@@ -160,6 +160,6 @@ fn get_master_key(slot: &AegisEncryptedSlot, password: &str) -> Result<Vec<u8>,
         cipher_text.as_slice(),
     ) {
         Ok(result) => Ok(result),
-        Err(e) => Err(format!("Failed to derive master key: {:?}", e)),
+        Err(e) => Err(format!("Failed to derive master key: {e:?}")),
     }
 }
diff --git a/src/importers/and_otp.rs b/src/importers/and_otp.rs
@@ -6,11 +6,11 @@ use crate::otp::otp_element::OTPElement;
 pub fn import(filepath: &str) -> Result<Vec<OTPElement>, String> {
     let file_to_import_contents = match read_to_string(filepath) {
         Ok(result) => result,
-        Err(e) => return Err(format!("Error during file reading: {:?}", e)),
+        Err(e) => return Err(format!("Error during file reading: {e:?}")),
     };
 
     match serde_json::from_str::<Vec<OTPElement>>(&file_to_import_contents) {
         Ok(elements) => Ok(elements),
-        Err(e) => Err(format!("Failed to serialize file: {}", e)),
+        Err(e) => Err(format!("Failed to serialize file: {e}")),
     }
 }
diff --git a/src/importers/authy_remote_debug.rs b/src/importers/authy_remote_debug.rs
@@ -67,11 +67,11 @@ impl AuthyExportedJsonElement {
 pub fn import(file_path: &str) -> Result<Vec<OTPElement>, String> {
     let json = match read_to_string(file_path) {
         Ok(r) => r,
-        Err(e) => return Err(format!("{:?}", e)),
+        Err(e) => return Err(format!("{e:?}")),
     };
     let elements: Vec<AuthyExportedJsonElement> = match serde_json::from_str(json.as_str()) {
         Ok(r) => r,
-        Err(e) => return Err(format!("Error during deserializing: {:?}", e)),
+        Err(e) => return Err(format!("Error during deserializing: {e:?}")),
     };
 
     Ok(elements
diff --git a/src/importers/converted.rs b/src/importers/converted.rs
@@ -20,13 +20,13 @@ struct ConvertedJson {
 pub fn import(filepath: &str) -> Result<Vec<OTPElement>, String> {
     let file_to_import_contents = match read_to_string(filepath) {
         Ok(result) => result,
-        Err(e) => return Err(format!("Error during file reading: {:?}", e)),
+        Err(e) => return Err(format!("Error during file reading: {e:?}")),
     };
     let result: Result<Vec<ConvertedJson>, serde_json::Error> =
         serde_json::from_str(&file_to_import_contents);
     let vector: Vec<ConvertedJson> = match result {
         Ok(r) => r,
-        Err(e) => return Err(format!("{}", e)),
+        Err(e) => return Err(format!("{e}")),
     };
 
     Ok(vector
diff --git a/src/importers/cotp.rs b/src/importers/cotp.rs
@@ -5,14 +5,14 @@ use crate::otp::otp_element::{OTPDatabase, OTPElement};
 pub fn import(filepath: &str) -> Result<Vec<OTPElement>, String> {
     let file_to_import_contents = match read_to_string(filepath) {
         Ok(result) => result,
-        Err(e) => return Err(format!("Error during file reading: {:?}", e)),
+        Err(e) => return Err(format!("Error during file reading: {e:?}")),
     };
 
     match serde_json::from_str::<OTPDatabase>(&file_to_import_contents) {
         Ok(database) => Ok(database.elements),
         Err(_e) => match serde_json::from_str::<Vec<OTPElement>>(&file_to_import_contents) {
             Ok(elements) => Ok(elements),
-            Err(e) => Err(format!("Failed to serialize file: {}", e)),
+            Err(e) => Err(format!("Failed to serialize file: {e}")),
         },
     }
 }
diff --git a/src/importers/freeotp_plus.rs b/src/importers/freeotp_plus.rs
@@ -31,12 +31,12 @@ struct FreeOTPElement {
 pub fn import(file_path: &str) -> Result<Vec<OTPElement>, String> {
     let json = match read_to_string(file_path) {
         Ok(r) => r,
-        Err(e) => return Err(format!("{:?}", e)),
+        Err(e) => return Err(format!("{e:?}")),
     };
 
     let freeotp: FreeOTPPlusJson = match serde_json::from_str(json.as_str()) {
         Ok(r) => r,
-        Err(e) => return Err(format!("Error during deserializing: {:?}", e)),
+        Err(e) => return Err(format!("Error during deserializing: {e:?}")),
     };
 
     Ok(freeotp
diff --git a/src/interface/handler.rs b/src/interface/handler.rs
@@ -227,7 +227,7 @@ fn copy_selected_code_to_clipboard(app: &mut App) -> String {
                 }
                 None => "Cannot get OTP Code column".to_string(),
             },
-            None => format!("Cannot fetch element from index: {}", selected),
+            None => format!("Cannot fetch element from index: {selected}"),
         },
         None => "No code selected".to_string(),
     }
diff --git a/src/interface/table.rs b/src/interface/table.rs
@@ -60,7 +60,7 @@ pub fn fill_table(table: &mut StatefulTable, elements: &[OTPElement]) {
         let label = match element.type_ {
             OTPType::Hotp => match element.counter {
                 Some(result) => {
-                    element.label.to_owned() + (format!(" ({} counter)", result).as_str())
+                    element.label.to_owned() + (format!(" ({result} counter)").as_str())
                 }
                 None => element.label.to_owned(),
             },
diff --git a/src/main.rs b/src/main.rs
@@ -51,7 +51,7 @@ fn main() -> AppResult<()> {
     let mut result = match init() {
         Ok(v) => v,
         Err(e) => {
-            println!("{}", e);
+            println!("{e}");
             std::process::exit(-1);
         }
     };
@@ -78,7 +78,7 @@ fn main() -> AppResult<()> {
                 std::process::exit(0)
             }
             Err(e) => {
-                eprintln!("{}", e);
+                eprintln!("{e}");
                 std::process::exit(-2);
             }
         },
diff --git a/src/otp/algorithms/hotp_maker.rs b/src/otp/algorithms/hotp_maker.rs
@@ -37,7 +37,7 @@ where
     // decode the base32 secret
     let secret_decoded = match BASE32_NOPAD.decode(secret.as_bytes()) {
         Ok(result) => result,
-        Err(e) => return Err(format!("{:?}", e)),
+        Err(e) => return Err(format!("{e:?}")),
     };
 
     let hash = hotp_hash::<D>(&secret_decoded, counter);
diff --git a/src/otp/algorithms/motp_maker.rs b/src/otp/algorithms/motp_maker.rs
@@ -21,7 +21,7 @@ fn get_motp_code(
     // TODO MOTP Secrets are hex encoded, so do not use BASE32 at all
     let hex_secret = secret;
     let counter = seconds / period;
-    let data = format!("{}{}{}", counter, hex_secret, pin);
+    let data = format!("{counter}{hex_secret}{pin}");
 
     let mut md5_hasher = Md5::new();
     md5_hasher.update(data.as_bytes());
diff --git a/src/otp/otp_algorithm.rs b/src/otp/otp_algorithm.rs
@@ -13,7 +13,7 @@ pub enum OTPAlgorithm {
 
 impl fmt::Display for OTPAlgorithm {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}", self)
+        write!(f, "{self:?}")
     }
 }
 
diff --git a/src/otp/otp_element.rs b/src/otp/otp_element.rs
@@ -52,7 +52,7 @@ impl OTPDatabase {
         migrate(self)?;
         match self.overwrite_database_key(key, salt) {
             Ok(()) => Ok(()),
-            Err(e) => Err(format!("{:?}", e)),
+            Err(e) => Err(format!("{e:?}")),
         }
     }
 
@@ -99,7 +99,7 @@ impl OTPDatabase {
                 contents.zeroize();
                 Ok(exported_path)
             }
-            Err(e) => Err(format!("{:?}", e)),
+            Err(e) => Err(format!("{e:?}")),
         }
     }
 
diff --git a/src/otp/otp_type.rs b/src/otp/otp_type.rs
@@ -24,7 +24,7 @@ pub enum OTPType {
 
 impl fmt::Display for OTPType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}", self)
+        write!(f, "{self:?}")
     }
 }
 
diff --git a/src/reading.rs b/src/reading.rs
@@ -11,7 +11,7 @@ pub fn get_elements() -> Result<ReadResult, String> {
     let mut pw = utils::password("Password: ", 8);
     let (elements, key, salt) = match read_from_file(&pw) {
         Ok((result, key, salt)) => (result, key, salt),
-        Err(e) => return Err(format!("Cannot decrypt existing database: {}", e)),
+        Err(e) => return Err(format!("Cannot decrypt existing database: {e}")),
     };
     pw.zeroize();
     Ok((elements, key, salt))
@@ -22,7 +22,7 @@ pub fn read_decrypted_text(password: &str) -> Result<(String, Vec<u8>, Vec<u8>),
         Ok(result) => result,
         Err(e) => {
             // no need to zeroize since contents are encrypted
-            return Err(format!("Error during file reading: {:?}", e));
+            return Err(format!("Error during file reading: {e:?}"));
         }
     };
     if encrypted_contents.is_empty() {
@@ -49,7 +49,7 @@ pub fn read_from_file(password: &str) -> Result<ReadResult, String> {
                         Ok(r) => r,
                         Err(e) => {
                             contents.zeroize();
-                            return Err(format!("Failed to deserialize database: {:?}", e));
+                            return Err(format!("Failed to deserialize database: {e:?}"));
                         }
                     };
                     OTPDatabase {
diff --git a/src/utils.rs b/src/utils.rs
@@ -35,7 +35,7 @@ pub fn get_default_db_path() -> PathBuf {
         None => {
             let current_dir = PathBuf::from(".");
             if let Some(str_dir) = current_dir.to_str() {
-                eprintln!("Cannot get home folder, using: {}", str_dir);
+                eprintln!("Cannot get home folder, using: {str_dir}");
             } else {
                 eprintln!("Cannot get home folder, using");
             }
@@ -76,10 +76,7 @@ pub fn password(message: &str, minimum_length: usize) -> String {
     loop {
         let password = rpassword::prompt_password(message).unwrap();
         if password.chars().count() < minimum_length {
-            println!(
-                "Please insert a password with at least {} digits.",
-                minimum_length
-            );
+            println!("Please insert a password with at least {minimum_length} digits.");
             continue;
         }
         return password;

Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ pub fn import(matches: &ArgMatches, database: &mut OTPDatabase) -> Result<String`
`38`	`38`	`let elements = match result {`
`39`	`39`	`Ok(result) => result,`
`40`	`40`	`Err(e) => {`
`41`		`- return Err(format!("An error occurred: {}", e));`
	`41`	`+ return Err(format!("An error occurred: {e}"));`
`42`	`42`	`}`
`43`	`43`	`};`
`44`	`44`
`@@ -132,7 +132,7 @@ pub fn edit(matches: &ArgMatches, database: &mut OTPDatabase) -> Result<String,`
`132`	`132`	`}`
`133`	`133`	`database.edit_element(index, element);`
`134`	`134`	`}`
`135`		`- None => return Err(format!("No element found at index {}", index)),`
	`135`	`+ None => return Err(format!("No element found at index {index}")),`
`136`	`136`	`}`
`137`	`137`
`138`	`138`	`secret.zeroize();`
`@@ -145,15 +145,15 @@ pub fn export(matches: &ArgMatches, database: &mut OTPDatabase) -> Result<String`
`145`	`145`	`"Database was successfully exported at {}",`
`146`	`146`	`export_result.to_str().unwrap_or("Invalid path")`
`147`	`147`	`)),`
`148`		`- Err(e) => Err(format!("An error occurred while exporting database: {}", e)),`
	`148`	`+ Err(e) => Err(format!("An error occurred while exporting database: {e}")),`
`149`	`149`	`}`
`150`	`150`	`}`
`151`	`151`
`152`	`152`	`pub fn change_password(database: &mut OTPDatabase) -> Result<String, String> {`
`153`	`153`	`let mut new_password = utils::verified_password("New password: ", 8);`
`154`	`154`	`let r = match database.save_with_pw(&new_password) {`
`155`	`155`	`Ok(()) => Ok(String::from("Password changed")),`
`156`		`- Err(e) => Err(format!("An error has occurred: {}", e)),`
	`156`	`+ Err(e) => Err(format!("An error has occurred: {e}")),`
`157`	`157`	`};`
`158`	`158`	`new_password.zeroize();`
`159`	`159`	`r`
Original file line number	Diff line number	Diff line change
`@@ -32,8 +32,7 @@ pub fn argon_derive_key(password_bytes: &[u8], salt: &[u8]) -> Result<Vec<u8>, S`
`32`	`32`	`pub fn gen_salt() -> Result<[u8; ARGON2ID_SALT_LENGTH], String> {`
`33`	`33`	`let mut salt: [u8; ARGON2ID_SALT_LENGTH] = [0; ARGON2ID_SALT_LENGTH];`
`34`	`34`	`if let Err(e) = getrandom::getrandom(&mut salt) {`
`35`		`- //return Err(format!("Error during salt generation: {}", e));`
`36`		`- return Err(format!("Error during salt generation: {}", e));`
	`35`	`+ return Err(format!("Error during salt generation: {e}"));`
`37`	`36`	`}`
`38`	`37`	`Ok(salt)`
`39`	`38`	`}`
`@@ -49,7 +48,7 @@ pub fn encrypt_string_with_key(`
`49`	`48`	`let mut nonce_bytes: [u8; XCHACHA20_POLY1305_NONCE_LENGTH] =`
`50`	`49`	`[0; XCHACHA20_POLY1305_NONCE_LENGTH];`
`51`	`50`	`if let Err(e) = getrandom::getrandom(&mut nonce_bytes) {`
`52`		`- return Err(format!("Error during nonce generation: {}", e));`
	`51`	`+ return Err(format!("Error during nonce generation: {e}"));`
`53`	`52`	`}`
`54`	`53`	`let nonce = XNonce::from_slice(&nonce_bytes);`
`55`	`54`	`let cipher_text = aead`
`@@ -72,8 +71,7 @@ pub fn decrypt_string(`
`72`	`71`	`Ok(result) => result,`
`73`	`72`	`Err(e) => {`
`74`	`73`	`return Err(format!(`
`75`		`- "Error during encrypted database deserialization: {}",`
`76`		`- e`
	`74`	`+ "Error during encrypted database deserialization: {e}"`
`77`	`75`	`))`
`78`	`76`	`}`
`79`	`77`	`};`
`@@ -100,7 +98,7 @@ pub fn decrypt_string(`
`100`	`98`	`};`
`101`	`99`	`match String::from_utf8(decrypted) {`
`102`	`100`	`Ok(result) => Ok((result, key, salt)),`
`103`		`- Err(e) => Err(format!("Error during UTF-8 string conversion: {}", e)),`
	`101`	`+ Err(e) => Err(format!("Error during UTF-8 string conversion: {e}")),`
`104`	`102`	`}`
`105`	`103`	`}`
`106`	`104`
Original file line number	Diff line number	Diff line change
`@@ -6,11 +6,11 @@ use crate::otp::otp_element::OTPElement;`
`6`	`6`	`pub fn import(filepath: &str) -> Result<Vec<OTPElement>, String> {`
`7`	`7`	`let file_to_import_contents = match read_to_string(filepath) {`
`8`	`8`	`Ok(result) => result,`
`9`		`- Err(e) => return Err(format!("Error during file reading: {:?}", e)),`
	`9`	`+ Err(e) => return Err(format!("Error during file reading: {e:?}")),`
`10`	`10`	`};`
`11`	`11`
`12`	`12`	`match serde_json::from_str::<Vec<OTPElement>>(&file_to_import_contents) {`
`13`	`13`	`Ok(elements) => Ok(elements),`
`14`		`- Err(e) => Err(format!("Failed to serialize file: {}", e)),`
	`14`	`+ Err(e) => Err(format!("Failed to serialize file: {e}")),`
`15`	`15`	`}`
`16`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -227,7 +227,7 @@ fn copy_selected_code_to_clipboard(app: &mut App) -> String {`
`227`	`227`	`}`
`228`	`228`	`None => "Cannot get OTP Code column".to_string(),`
`229`	`229`	`},`
`230`		`- None => format!("Cannot fetch element from index: {}", selected),`
	`230`	`+ None => format!("Cannot fetch element from index: {selected}"),`
`231`	`231`	`},`
`232`	`232`	`None => "No code selected".to_string(),`
`233`	`233`	`}`