clippy fixes

Signed-off-by: Dave Huseby <dwh@linuxprogrammer.org>

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "multikey"
-version = "1.0.6"
+version = "1.0.7"
 edition = "2021"
 authors = ["Dave Grantham <dwg@linuxprogrammer.org>"]
 description = "Multikey self-describing cryptographic key data"

src/attrid.rs

@@ -38,7 +38,7 @@ pub enum AttrId {
 impl AttrId {
     /// Get the code for the attribute id
     pub fn code(&self) -> u8 {
-        self.clone().into()
+        (*self).into()
     }
 
     /// Convert the attribute id to &str
@@ -60,9 +60,9 @@ impl AttrId {
     }
 }
 
-impl Into<u8> for AttrId {
-    fn into(self) -> u8 {
-        self as u8
+impl From<AttrId> for u8 {
+    fn from(val: AttrId) -> Self {
+        val as u8
     }
 }
 
@@ -88,9 +88,9 @@ impl TryFrom<u8> for AttrId {
     }
 }
 
-impl Into<Vec<u8>> for AttrId {
-    fn into(self) -> Vec<u8> {
-        let v: u8 = self.into();
+impl From<AttrId> for Vec<u8> {
+    fn from(val: AttrId) -> Self {
+        let v: u8 = val.into();
         v.encode_into()
     }
 }

src/kdf.rs

@@ -25,7 +25,7 @@ impl Builder {
     /// initialize from a multikey with kdf attributes in it
     pub fn try_from_multikey(mut self, mk: &Multikey) -> Result<Self, Error> {
         // try to look up the kdf codec in the multikey attributes
-        if let Some(v) = mk.attributes.get(&(AttrId::KdfCodec.into())) {
+        if let Some(v) = mk.attributes.get(&AttrId::KdfCodec) {
             if let Ok(codec) = Codec::try_from(v.as_slice()) {
                 self.codec = codec;
             }

src/lib.rs

@@ -1,5 +1,5 @@
 // SPDX-License-Idnetifier: Apache-2.0
-//!
+//! multikey
 #![warn(missing_docs)]
 #![deny(
     trivial_casts,

src/mk.rs

@@ -404,15 +404,15 @@ impl Builder {
         let key_bytes = match codec {
             Codec::Ed25519Priv => Ed25519Keypair::random(rng).private.to_bytes().to_vec(),
             Codec::P256Priv => EcdsaKeypair::random(rng, EcdsaCurve::NistP256)
-                .map_err(|e| ConversionsError::SshKey(e))?
+                .map_err(ConversionsError::SshKey)?
                 .private_key_bytes()
                 .to_vec(),
             Codec::P384Priv => EcdsaKeypair::random(rng, EcdsaCurve::NistP384)
-                .map_err(|e| ConversionsError::SshKey(e))?
+                .map_err(ConversionsError::SshKey)?
                 .private_key_bytes()
                 .to_vec(),
             Codec::P521Priv => EcdsaKeypair::random(rng, EcdsaCurve::NistP521)
-                .map_err(|e| ConversionsError::SshKey(e))?
+                .map_err(ConversionsError::SshKey)?
                 .private_key_bytes()
                 .to_vec(),
             Codec::Secp256K1Priv => k256::SecretKey::random(rng).to_bytes().to_vec(),
@@ -592,7 +592,7 @@ impl Builder {
                         ..Default::default()
                     })
                 }
-                s => return Err(ConversionsError::UnsupportedAlgorithm(s.to_string()).into()),
+                s => Err(ConversionsError::UnsupportedAlgorithm(s.to_string()).into()),
             },
             Ed25519 => {
                 let key_bytes = match sshkey.key_data() {
@@ -780,7 +780,7 @@ impl Builder {
                         ..Default::default()
                     })
                 }
-                s => return Err(ConversionsError::UnsupportedAlgorithm(s.to_string()).into()),
+                s => Err(ConversionsError::UnsupportedAlgorithm(s.to_string()).into()),
             },
             Ed25519 => {
                 let key_bytes = match sshkey.key_data() {
@@ -819,7 +819,7 @@ impl Builder {
 
     fn with_attribute(mut self, attr: AttrId, data: &Vec<u8>) -> Self {
         let mut attributes = self.attributes.unwrap_or_default();
-        attributes.insert(attr, data.clone().into());
+        attributes.insert(attr, data.to_owned().into());
         self.attributes = Some(attributes);
         self
     }
@@ -831,7 +831,8 @@ impl Builder {
 
     /// add in the threshold value
     pub fn with_threshold(self, threshold: usize) -> Self {
-        self.with_attribute(AttrId::Threshold, &Varuint(threshold).into())
+        let v: Vec<u8> = Varuint(threshold).into();
+        self.with_attribute(AttrId::Threshold, &v)
     }
 
     /// add in the limit value
@@ -861,7 +862,7 @@ impl Builder {
     pub fn try_build_encoded(self) -> Result<EncodedMultikey, Error> {
         Ok(BaseEncoded::new(
             self.base_encoding
-                .unwrap_or_else(|| Multikey::preferred_encoding()),
+                .unwrap_or_else(Multikey::preferred_encoding),
             self.try_build()?,
         ))
     }

src/nonce.rs

@@ -25,6 +25,11 @@ impl Nonce {
     pub fn len(&self) -> usize {
         self.nonce.len()
     }
+
+    /// return if the nonce is empty
+    pub fn is_empty(&self) -> bool {
+        self.nonce.is_empty()
+    }
 }
 
 impl CodecInfo for Nonce {
@@ -121,8 +126,7 @@ pub struct Builder {
 impl Builder {
     /// build from random source
     pub fn new_from_random_bytes(size: usize, rng: &mut (impl RngCore + CryptoRng)) -> Self {
-        let mut bytes = Vec::with_capacity(size);
-        bytes.resize(size, 0u8);
+        let mut bytes = vec![0; size];
         rng.fill_bytes(bytes.as_mut());
         Self {
             bytes,
@@ -148,7 +152,7 @@ impl Builder {
     pub fn try_build_encoded(&self) -> Result<EncodedNonce, Error> {
         Ok(EncodedNonce::new(
             self.base_encoding
-                .unwrap_or_else(|| Nonce::preferred_encoding()),
+                .unwrap_or_else(Nonce::preferred_encoding),
             self.try_build()?,
         ))
     }

src/serde/de.rs

@@ -18,7 +18,7 @@ impl<'de> Deserialize<'de> for Nonce {
     where
         D: Deserializer<'de>,
     {
-        const FIELDS: &'static [&'static str] = &["nonce"];
+        const FIELDS: &[&str] = &["nonce"];
 
         #[derive(Deserialize)]
         #[serde(field_identifier, rename_all = "lowercase")]
@@ -84,28 +84,28 @@ impl<'de> Deserialize<'de> for AttrId {
             where
                 E: Error,
             {
-                Ok(AttrId::try_from(c).map_err(|e| Error::custom(e.to_string()))?)
+                AttrId::try_from(c).map_err(|e| Error::custom(e.to_string()))
             }
 
             fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
             where
                 E: Error,
             {
-                Ok(AttrId::try_from(s).map_err(|e| Error::custom(e.to_string()))?)
+                AttrId::try_from(s).map_err(|e| Error::custom(e.to_string()))
             }
 
             fn visit_borrowed_str<E>(self, s: &'de str) -> Result<Self::Value, E>
             where
                 E: Error,
             {
-                Ok(AttrId::try_from(s).map_err(|e| Error::custom(e.to_string()))?)
+                AttrId::try_from(s).map_err(|e| Error::custom(e.to_string()))
             }
 
             fn visit_string<E>(self, s: String) -> Result<Self::Value, E>
             where
                 E: Error,
             {
-                Ok(AttrId::try_from(s.as_str()).map_err(|e| Error::custom(e.to_string()))?)
+                AttrId::try_from(s.as_str()).map_err(|e| Error::custom(e.to_string()))
             }
         }
 
@@ -119,7 +119,7 @@ impl<'de> Deserialize<'de> for Multikey {
     where
         D: Deserializer<'de>,
     {
-        const FIELDS: &'static [&'static str] = &["codec", "comment", "attributes"];
+        const FIELDS: &[&str] = &["codec", "comment", "attributes"];
 
         #[derive(Deserialize)]
         #[serde(field_identifier, rename_all = "lowercase")]

src/views/bcrypt.rs

@@ -31,7 +31,7 @@ impl<'a> KdfView for View<'a> {
     /// generates a new Multikey by copying the viewed Multikey (self) and
     /// storing the derived key and attributes in the new Multikey
     fn derive_key(&self, passphrase: &[u8]) -> Result<Multikey, Error> {
-        let kdf = self.kdf.ok_or_else(|| KdfError::MissingCodec)?;
+        let kdf = self.kdf.ok_or(KdfError::MissingCodec)?;
 
         // get the salt data and rounds attribute
         let (salt, rounds) = {
@@ -42,21 +42,21 @@ impl<'a> KdfView for View<'a> {
         // get the key length from the viewed Multikey
         let key_length = {
             let cattr = self.mk.cipher_attr_view()?;
-            let key_length = cattr.key_length()?;
-            key_length
+
+            cattr.key_length()?
         };
 
         // heap allocate a buffer to receive the derived key
         let mut key: Zeroizing<Vec<u8>> = vec![0; key_length].into();
 
         // derive the key
         bcrypt_pbkdf::bcrypt_pbkdf(
-            passphrase.as_ref(),
+            passphrase,
             &salt,
             rounds as u32,
             key.as_mut_slice(),
         )
-        .map_err(|e| KdfError::Bcrypt(e))?;
+        .map_err(KdfError::Bcrypt)?;
 
         // prepare the attributes
         let kdf_codec: Vec<u8> = kdf.codec.into();
@@ -85,7 +85,7 @@ impl<'a> KdfAttrView for View<'a> {
             .mk
             .attributes
             .get(&AttrId::KdfSalt)
-            .ok_or_else(|| KdfError::MissingSalt)?;
+            .ok_or(KdfError::MissingSalt)?;
         if salt.len() != SALT_LENGTH {
             Err(KdfError::InvalidSaltLen.into())
         } else {