fixing clippy issues

Signed-off-by: Till Wegmueller <toasterson@gmail.com>

libips/Cargo.toml

@@ -25,3 +25,4 @@ sha2 = "0.9.3"
 sha3 = "0.9.1"
 pest = "2.1.3"
 pest_derive = "2.1.0"
+strum = { version = "0.24.1", features = ["derive"] }

libips/src/digest/mod.rs

@@ -3,47 +3,54 @@
 //  MPL was not distributed with this file, You can
 //  obtain one at https://mozilla.org/MPL/2.0/.
 
-use thiserror::Error;
+use sha2::Digest as Sha2Digest;
-use std::result::Result as StdResult;
-use std::str::FromStr;
-use sha2::{Digest as Sha2Digest};
 #[allow(unused_imports)]
-use sha3::{Digest as Sha3Digest};
+use sha3::Digest as Sha3Digest;
+use std::str::FromStr;
+use std::{convert::TryInto, result::Result as StdResult};
+use strum::{Display as StrumDisplay, EnumString};
+use thiserror::Error;
 
 type Result<T> = StdResult<T, DigestError>;
 
 #[allow(dead_code)]
 static DEFAULT_ALGORITHM: DigestAlgorithm = DigestAlgorithm::SHA512;
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq, Clone, StrumDisplay, EnumString, Default)]
 pub enum DigestAlgorithm {
+    #[strum(serialize = "sha1")]
     SHA1, //Default, sadly
+    #[strum(serialize = "sha256t")]
     SHA256, //sha256t
+    #[default]
+    #[strum(serialize = "sha512t")]
     SHA512, //sha512t
+    #[strum(serialize = "sha512t_256")]
     SHA512Half, //sha512t_256
+    #[strum(serialize = "sha3256t")]
     SHA3256, // Sha3 version of sha256t
+    #[strum(serialize = "sha3512t_256")]
     SHA3512Half, // Sha3 version of sha512t_256
+    #[strum(serialize = "sha3512t")]
     SHA3512, // Sha3 version of sha512t
 }
 
-impl Default for DigestAlgorithm {
+#[derive(Debug, PartialEq, Clone, StrumDisplay, EnumString, Default)]
-    fn default() -> Self { DigestAlgorithm::SHA1 }
-}
-
-#[derive(Debug, PartialEq, Clone)]
 pub enum DigestSource {
+    #[strum(serialize = "gzip")]
     GzipCompressed,
+    #[strum(serialize = "gelf")]
     GNUElf,
+    #[strum(serialize = "gelf.unsigned")]
     GNUElfUnsigned,
+    #[strum(serialize = "file")]
     UncompressedFile,
+    #[strum(serialize = "unknown")]
     Unknown,
+    #[default]
     PrimaryPayloadHash,
 }
 
-impl Default for DigestSource {
-    fn default() -> Self { DigestSource::PrimaryPayloadHash }
-}
-
 #[derive(Debug, Default, PartialEq, Clone)]
 pub struct Digest {
     pub hash: String,
@@ -73,23 +80,12 @@ impl FromStr for Digest {
         }
 
         Ok(Digest {
-            source: match parts[0] {
+            source: parts[0].try_into().unwrap_or(DigestSource::Unknown),
-                "file" => DigestSource::UncompressedFile,
+            algorithm: parts[1]
-                "gzip" => DigestSource::GzipCompressed,
+                .try_into()
-                "gelf" => DigestSource::GNUElf,
+                .map_err(|_e| DigestError::UnknownAlgorithm {
-                "gelf.unsigned" => DigestSource::GNUElfUnsigned,
+                    algorithm: String::from(parts[1]),
-                _ => DigestSource::Unknown,
+                })?,
-            },
-            algorithm: match parts[1] {
-                "sha1" => DigestAlgorithm::SHA1,
-                "sha256t" => DigestAlgorithm::SHA256,
-                "sha512t_256" => DigestAlgorithm::SHA512Half,
-                "sha512t" => DigestAlgorithm::SHA512,
-                "sha3256t" => DigestAlgorithm::SHA3256,
-                "sha3512t_256" => DigestAlgorithm::SHA3512Half,
-                "sha3512t" => DigestAlgorithm::SHA3512,
-                _ => return Err(DigestError::UnknownAlgorithm {algorithm: String::from(parts[1])}),
-            },
             hash: String::from(parts[2]),
         })
     }
@@ -115,7 +111,6 @@ impl Digest {
             }
         };
 
-
         Ok(Digest {
             source: src,
             algorithm: algo,
@@ -124,13 +119,16 @@ impl Digest {
     }
 
     pub fn to_string(&self) -> String {
-        format!("{}:{}:{}", match self.source {
+        format!(
+            "{}:{}:{}",
+            match self.source {
                 DigestSource::UncompressedFile => "file",
                 DigestSource::GzipCompressed => "gzip",
                 DigestSource::GNUElf => "gelf",
                 DigestSource::GNUElfUnsigned => "gelf.unsigned",
                 DigestSource::Unknown | _ => "unknown",
-        }, match self.algorithm {
+            },
+            match self.algorithm {
                 DigestAlgorithm::SHA1 => "sha1",
                 DigestAlgorithm::SHA256 => "sha256t",
                 DigestAlgorithm::SHA512Half => "sha512t_256",
@@ -138,19 +136,16 @@ impl Digest {
                 DigestAlgorithm::SHA3256 => "sha3256t",
                 DigestAlgorithm::SHA3512Half => "sha3512t_256",
                 DigestAlgorithm::SHA3512 => "sha3512t",
-        }, self.hash)
+            },
+            self.hash
+        )
     }
 }
 
 #[derive(Debug, Error)]
 pub enum DigestError {
     #[error("hashing algorithm {algorithm:?} is not known by this library")]
-    UnknownAlgorithm {
+    UnknownAlgorithm { algorithm: String },
-        algorithm: String,
-    },
     #[error("digest {digest:?} is not formatted properly: {details:?}")]
-    InvalidDigestFormat{
+    InvalidDigestFormat { digest: String, details: String },
-        digest: String,
-        details: String,
-    },
 }