.

src/comparemode.rs

@@ -1,7 +1,6 @@
-use Fasching::{compare_snapshots, create_snapshot, import_snapshot};
-use Fasching::hasher::HashType::BLAKE3;
-use Fasching::snapshot::{Snapshot, SnapshotChangeType, SnapshotCompareResult};
 use crate::syscompare::Comparer;
+use Fasching::snapshot::{Snapshot, SnapshotChangeType, SnapshotCompareResult};
+use Fasching::{compare_snapshots, import_snapshot};
 
 pub struct CompareMode {
     left: Snapshot,
@@ -13,7 +12,6 @@ pub struct CompareMode {
 
 impl CompareMode {
     pub fn new(args: Vec<String>, left: String, right: String) -> CompareMode {
-
         let left = import_snapshot(left);
         let right = import_snapshot(right);
 
@@ -34,8 +32,8 @@ impl CompareMode {
 impl Comparer for CompareMode {
     fn run(&mut self) {
         let selector = match self.args.get(4) {
-            None => {"none"}
-            Some(r) => { r }
+            None => "none",
+            Some(r) => r,
         };
 
         let results = match compare_snapshots(self.left.clone(), self.right.clone()) {
@@ -45,16 +43,15 @@ impl Comparer for CompareMode {
         self.results = results.1;
         self.result_type = results.0;
 
-
         match selector {
             "created" => {
                 self.results.created.iter().for_each(|e| println!("{e}"));
                 println!("Created: {:?}", self.results.created.len());
-            },
+            }
             "deleted" => {
                 self.results.deleted.iter().for_each(|e| println!("{e}"));
                 println!("Deleted: {:?}", self.results.deleted.len());
-            },
+            }
             "changed" => {
                 self.results.changed.iter().for_each(|e| println!("{e}"));
                 println!("Changed: {:?}", self.results.changed.len());
@@ -63,7 +60,7 @@ impl Comparer for CompareMode {
                 println!("Created: {:?}", self.results.created.len());
                 println!("Deleted: {:?}", self.results.deleted.len());
                 println!("Changed: {:?}", self.results.changed.len());
-            },
+            }
             _ => {
                 // println!("Created: {:?}", self.results.created.len());
                 // println!("Deleted: {:?}", self.results.deleted.len());
@@ -75,11 +72,11 @@ impl Comparer for CompareMode {
 
 #[cfg(test)]
 mod tests {
-    use std::env;
-    use std::fmt::format;
     use crate::comparemode::CompareMode;
     use crate::createmode::CreateMode;
     use crate::syscompare::Comparer;
+    use std::env;
+    use std::fmt::format;
 
     #[test]
     fn compare_mode() {

src/createmode.rs

@@ -1,16 +1,17 @@
+use crate::print_help;
+use crate::syscompare::Comparer;
 use std::process::exit;
-use Fasching::{create_snapshot, export_snapshot};
 use Fasching::hasher::HashType;
 use Fasching::hasher::HashType::BLAKE3;
 use Fasching::snapshot::Snapshot;
-use crate::print_help;
-use crate::syscompare::Comparer;
+use Fasching::{create_snapshot, export_snapshot};
 
 pub struct CreateMode {
     snapshot_path: String,
     root_path: String,
+    #[allow(unused)]
     args: Vec<String>,
-    snapshot: Snapshot
+    snapshot: Snapshot,
 }
 
 impl CreateMode {
@@ -22,7 +23,12 @@ impl CreateMode {
         }
         let bind = root_path.clone();
         let rp = bind.as_str();
-        CreateMode { args, snapshot_path, root_path, snapshot: create_snapshot(rp, HashType::MD5, vec![]) }
+        CreateMode {
+            args,
+            snapshot_path,
+            root_path,
+            snapshot: create_snapshot(rp, HashType::MD5, vec![]),
+        }
     }
 }
 
@@ -33,6 +39,6 @@ impl Comparer for CreateMode {
         if let Ok(e) = snapshot.file_hashes.lock() {
             println!("Total FileHash Entries {}", e.len());
         }
-        let _ = export_snapshot(self.snapshot.clone(), self.snapshot_path.clone(), true);
+        export_snapshot(self.snapshot.clone(), self.snapshot_path.clone(), true);
     }
 }

src/main.rs

@@ -1,11 +1,11 @@
-pub mod syscompare;
-pub mod createmode;
 pub mod comparemode;
+pub mod createmode;
+pub mod syscompare;
 
+use crate::syscompare::SysCompareApp;
+use crate::syscompare::SysCompareMode::{Compare, Create};
 use std::env::args;
 use std::process::exit;
-use crate::syscompare::{SysCompareApp};
-use crate::syscompare::SysCompareMode::{Compare, Create};
 
 fn main() {
     let args: Vec<String> = args().collect();
@@ -20,8 +20,8 @@ fn main() {
             // app mode
             let m = mode.as_str();
             let app_mode = match m {
-                "create" => { Create },
-                "compare" => { Compare },
+                "create" => Create,
+                "compare" => Compare,
                 _ => {
                     println!("Invalid MODE argument");
                     print_help();

src/syscompare.rs

@@ -1,27 +1,30 @@
-use std::collections::HashMap;
-use std::env::args;
-use std::process::exit;
-use std::sync::{Arc, Mutex};
-use Fasching::snapshot::Snapshot;
 use crate::comparemode::CompareMode;
 use crate::createmode::CreateMode;
 use crate::print_help;
+use std::collections::HashMap;
+use std::process::exit;
+use std::sync::{Arc, Mutex};
+use Fasching::snapshot::Snapshot;
 
 pub enum SysCompareMode {
     Create,
-    Compare
+    Compare,
 }
 
 pub struct SysCompareApp {
     mode: SysCompareMode,
     args: Vec<String>,
-    comparatives: Arc<Mutex<HashMap<String, Snapshot>>>
+    #[allow(unused)]
+    comparatives: Arc<Mutex<HashMap<String, Snapshot>>>,
 }
 
-
 impl SysCompareApp {
     pub fn new(mode: SysCompareMode, args: Vec<String>) -> SysCompareApp {
-        SysCompareApp { mode, args, comparatives: Arc::new(Mutex::new(HashMap::new())) }
+        SysCompareApp {
+            mode,
+            args,
+            comparatives: Arc::new(Mutex::new(HashMap::new())),
+        }
     }
     pub fn run(&self) {
         println!("running");
@@ -33,7 +36,7 @@ impl SysCompareApp {
                         print_help();
                         exit(0);
                     }
-                    Some(r) => {not_empty(r)}
+                    Some(r) => not_empty(r),
                 };
                 let root_dir = match self.args.get(3) {
                     None => {
@@ -41,9 +44,10 @@ impl SysCompareApp {
                         print_help();
                         exit(0);
                     }
-                    Some(r) => {not_empty(r)}
+                    Some(r) => not_empty(r),
                 };
-                let mut create = CreateMode::new(self.args.clone(), snapshot_path.clone(), root_dir.clone());
+                let mut create =
+                    CreateMode::new(self.args.clone(), snapshot_path.clone(), root_dir.clone());
                 create.run()
             }
             SysCompareMode::Compare => {
@@ -53,7 +57,7 @@ impl SysCompareApp {
                         print_help();
                         exit(0);
                     }
-                    Some(r) => {not_empty(r)}
+                    Some(r) => not_empty(r),
                 };
                 let right = match self.args.get(3) {
                     None => {
@@ -61,7 +65,7 @@ impl SysCompareApp {
                         print_help();
                         exit(0);
                     }
-                    Some(r) => {not_empty(r)}
+                    Some(r) => not_empty(r),
                 };
 
                 let mut compare = CompareMode::new(self.args.clone(), left, right);
@@ -83,7 +87,11 @@ fn not_empty(r: &String) -> String {
 
 impl Default for SysCompareApp {
     fn default() -> Self {
-        SysCompareApp { mode: SysCompareMode::Create, args: vec![], comparatives: Arc::new(Mutex::new(HashMap::new())) }
+        SysCompareApp {
+            mode: SysCompareMode::Create,
+            args: vec![],
+            comparatives: Arc::new(Mutex::new(HashMap::new())),
+        }
     }
 }