refactor code

Cargo.toml

@@ -7,13 +7,12 @@ license = "MIT"
 readme = "README.md"
 version = "1.2.0"
 authors = ["Joern Bernhardt <[email protected]>"]
+edition = "2021"
 
 # See https://crates.io/category_slugs
 categories = ["command-line-utilities"]
 
-exclude = [
-  "docs/*"
-]
+exclude = ["docs/*"]
 
 [dependencies]
 base64 = "0.21.5"

src/diff/entry.rs

@@ -1,43 +1,29 @@
-use base64::{engine::general_purpose, Engine as _};
-use keepass::db::Value;
 use std::collections::HashMap;
 
-use crate::diff::field::{Field, ValueType};
+use crate::diff::field::Field;
 use crate::diff::{Diff, DiffResult, DiffResultFormat};
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Entry {
-    pub fields: HashMap<String, Field>,
+    fields: HashMap<String, Field>,
     use_verbose: bool,
     mask_passwords: bool,
 }
 
 impl Entry {
-    pub fn from_keepass(e: &keepass::db::Entry, use_verbose: bool, mask_passwords: bool) -> Self {
+    pub fn from_keepass(
+        entry: &keepass::db::Entry,
+        use_verbose: bool,
+        mask_passwords: bool,
+    ) -> Self {
         // username, password, etc. are just fields
-        let fields = e
+        let fields = entry
             .fields
             .iter()
-            .map(|(k, v)| {
+            .map(|(key, value)| {
                 (
-                    k.to_owned(),
-                    Field {
-                        name: k.to_owned(),
-                        value: match v {
-                            Value::Bytes(b) => general_purpose::STANDARD_NO_PAD.encode(b),
-                            Value::Unprotected(v) => v.to_owned(),
-                            Value::Protected(p) => String::from_utf8(p.unsecure().to_owned())
-                                .unwrap()
-                                .to_owned(),
-                        },
-                        kind: match v {
-                            Value::Bytes(_) => ValueType::Binary,
-                            Value::Unprotected(_) => ValueType::Unprotected,
-                            Value::Protected(_) => ValueType::Protected,
-                        },
-                        use_verbose,
-                        mask_passwords,
-                    },
+                    key.to_owned(),
+                    Field::from_keepass(key.to_owned(), value, use_verbose, mask_passwords),
                 )
             })
             .collect();
@@ -56,11 +42,10 @@ impl Diff for Entry {
             crate::diff::diff_entry(&self.fields, &other.fields);
 
         if has_differences {
-            let mut inner_differences: Vec<Box<dyn DiffResultFormat>> = Vec::new();
-
-            for dr in field_differences {
-                inner_differences.push(Box::new(dr))
-            }
+            let inner_differences = field_differences
+                .into_iter()
+                .map(|dr| Box::new(dr) as Box<dyn DiffResultFormat>)
+                .collect();
 
             DiffResult::InnerDifferences {
                 left: self,
@@ -78,18 +63,7 @@ impl Diff for Entry {
 
 impl std::fmt::Display for Entry {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        let name = self
-            .fields
-            .get("Title")
-            .unwrap_or(&Field {
-                name: "Title".to_string(),
-                value: "".to_string(),
-                kind: ValueType::Unprotected,
-                use_verbose: self.use_verbose,
-                mask_passwords: self.mask_passwords,
-            })
-            .value
-            .clone();
+        let name = self.fields.get("Title").map(|f| f.value()).unwrap_or("");
         if self.use_verbose {
             write!(f, "Entry '{}'", name)
         } else {

src/diff/field.rs

@@ -1,3 +1,6 @@
+use base64::{engine::general_purpose, Engine};
+use keepass::db::Value;
+
 use crate::diff::{Diff, DiffResult};
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -9,11 +12,42 @@ pub enum ValueType {
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Field {
-    pub name: String,
-    pub value: String,
-    pub kind: ValueType,
-    pub use_verbose: bool,
-    pub mask_passwords: bool,
+    name: String,
+    value: String,
+    kind: ValueType,
+    use_verbose: bool,
+    mask_passwords: bool,
+}
+
+impl Field {
+    pub fn from_keepass(
+        name: String,
+        value: &Value,
+        use_verbose: bool,
+        mask_passwords: bool,
+    ) -> Self {
+        Field {
+            name,
+            value: match value {
+                Value::Bytes(b) => general_purpose::STANDARD_NO_PAD.encode(b),
+                Value::Unprotected(v) => v.to_owned(),
+                Value::Protected(p) => String::from_utf8(p.unsecure().to_owned())
+                    .unwrap()
+                    .to_owned(),
+            },
+            kind: match value {
+                Value::Bytes(_) => ValueType::Binary,
+                Value::Unprotected(_) => ValueType::Unprotected,
+                Value::Protected(_) => ValueType::Protected,
+            },
+            use_verbose,
+            mask_passwords,
+        }
+    }
+
+    pub fn value(&self) -> &str {
+        self.value.as_str()
+    }
 }
 
 impl Diff for Field {
@@ -34,26 +68,14 @@ impl Diff for Field {
 
 impl std::fmt::Display for Field {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let password_str = match (self.mask_passwords, self.kind) {
+            (true, ValueType::Protected) => "***",
+            _ => self.value.as_str(),
+        };
         if self.use_verbose {
-            write!(
-                f,
-                "Field '{}' = '{}'",
-                self.name,
-                match (self.mask_passwords, self.kind) {
-                    (true, ValueType::Protected) => "***".to_owned(),
-                    _ => self.value.to_owned(),
-                }
-            )
+            write!(f, "Field '{}' = '{}'", self.name, password_str)
         } else {
-            write!(
-                f,
-                "{} = {}",
-                self.name,
-                match (self.mask_passwords, self.kind) {
-                    (true, ValueType::Protected) => "***".to_owned(),
-                    _ => self.value.to_owned(),
-                }
-            )
+            write!(f, "{} = {}", self.name, password_str)
         }
     }
 }