Fmt

Author: dani-garcia

crates/bitwarden-crypto/src/lib.rs

@@ -83,7 +83,7 @@ pub use wordlist::EFF_LONG_WORD_LIST;
 mod store;
 pub use store::{KeyStore, KeyStoreContext};
 mod traits;
-pub use traits::{Decryptable, Encryptable, KeyId, KeyIds, IdentifyKey};
+pub use traits::{Decryptable, Encryptable, IdentifyKey, KeyId, KeyIds};
 pub use zeroizing_alloc::ZeroAlloc as ZeroizingAllocator;
 
 #[cfg(feature = "uniffi")]

crates/bitwarden-crypto/src/store/mod.rs

@@ -163,10 +163,10 @@ impl<Ids: KeyIds> KeyStore<Ids> {
         data.encrypt(&mut self.context(), key)
     }
 
-    /// Decrypt a list of items using this key store. The keys returned by `data[i].key_identifier()` must
-    /// already be present in the store, otherwise this will return an error.
-    /// This method will try to parallelize the decryption of the items, for better performance on
-    /// large lists.
+    /// Decrypt a list of items using this key store. The keys returned by
+    /// `data[i].key_identifier()` must already be present in the store, otherwise this will
+    /// return an error. This method will try to parallelize the decryption of the items, for
+    /// better performance on large lists.
     pub fn decrypt_list<
         Key: KeyId,
         Data: Decryptable<Ids, Key, Output> + IdentifyKey<Key> + Send + Sync,
@@ -196,10 +196,11 @@ impl<Ids: KeyIds> KeyStore<Ids> {
         res
     }
 
-    /// Encrypt a list of items using this key store. The keys returned by `data[i].key_identifier()` must
-    /// already be present in the store, otherwise this will return an error.
-    /// This method will try to parallelize the encryption of the items, for better performance on
-    /// large lists. This method is not parallelized, and is meant for single item encryption.
+    /// Encrypt a list of items using this key store. The keys returned by
+    /// `data[i].key_identifier()` must already be present in the store, otherwise this will
+    /// return an error. This method will try to parallelize the encryption of the items, for
+    /// better performance on large lists. This method is not parallelized, and is meant for
+    /// single item encryption.
     pub fn encrypt_list<
         Key: KeyId,
         Data: Encryptable<Ids, Key, Output> + IdentifyKey<Key> + Send + Sync,

crates/bitwarden-crypto/src/traits/decryptable.rs

@@ -140,7 +140,8 @@ mod tests {
         let string_decrypted: Option<String> = none_data.decrypt(&mut ctx, key).unwrap();
         assert_eq!(string_decrypted, None);
 
-        // The None implementation will not do any decrypt operations, so it won't fail even if the key doesn't exist
+        // The None implementation will not do any decrypt operations, so it won't fail even if the
+        // key doesn't exist
         let bad_key = TestSymmKey::B((0, 1));
         let string_decrypted_bad: Option<String> = none_data.decrypt(&mut ctx, bad_key).unwrap();
         assert_eq!(string_decrypted_bad, None);

crates/bitwarden-crypto/src/traits/encryptable.rs

@@ -241,7 +241,8 @@ mod tests {
         let string_encrypted = none_data.encrypt(&mut ctx, key).unwrap();
         assert_eq!(string_encrypted, None);
 
-        // The None implementation will not do any decrypt operations, so it won't fail even if the key doesn't exist
+        // The None implementation will not do any decrypt operations, so it won't fail even if the
+        // key doesn't exist
         let bad_key = TestSymmKey::B((0, 1));
         let string_encrypted_bad = none_data.encrypt(&mut ctx, bad_key).unwrap();
         assert_eq!(string_encrypted_bad, None);