Used rustfmt and adding the tool to the github workflow

Author: ArcadeCode

.github/workflows/check_format.yaml

@@ -0,0 +1,25 @@
+name: Rustfmt Check
+
+on:
+  push:
+    branches:
+      - '**'  # Toutes les branches
+
+jobs:
+  rustfmt:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    - name: Install Rust toolchain
+      run: |
+        curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+        source $HOME/.cargo/env
+        rustup component add rustfmt
+
+    - name: Run rustfmt check
+      run: |
+        source $HOME/.cargo/env
+        cargo fmt -- --check

src/main.rs

@@ -1,7 +1,6 @@
 use std::path::Path;
 mod yadm;
 
-
 fn main() {
-   yadm::serialize(Path::new("."))
-}
+    yadm::serialize(Path::new("."))
+}

src/yadm.rs

@@ -2,4 +2,4 @@ pub mod report;
 pub use report::report::Report;
 
 pub mod serialize;
-pub use serialize::serialize;
+pub use serialize::serialize;

src/yadm/report.rs

@@ -24,14 +24,15 @@ pub mod report {
 
     impl fmt::Display for Report {
         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-            write!(f, "Scan of {} found {} elements in {:?}",
-                self.target,
-                self.elements_found,
-                self.full_duration
+            write!(
+                f,
+                "Scan of {} found {} elements in {:?}",
+                self.target, self.elements_found, self.full_duration
             )?;
 
             write!(
-                f, "
+                f,
+                "
 === YADM report ===
 Target : {}
 Scan duration : {:.2}s

src/yadm/serialize.rs

@@ -1,39 +1,57 @@
-use std::path::{Path, PathBuf};
-use walkdir::WalkDir;
 use std::collections::HashMap;
 use std::fs::File;
 use std::io::Write;
+use std::path::{Path, PathBuf};
+use walkdir::WalkDir;
 use zstd;
 
 /// TODO: Faire la doc
 pub fn serialize(path: &Path) {
-
     // Step 1 : Getting all entities into the Path
     fn scan_dir(path: &Path) -> Vec<PathBuf> {
-    WalkDir::new(path)
-        .into_iter()
-        .filter_map(|e| e.ok())
-        .filter(|e| e.file_type().is_file())
-        .map(|e| e.path().to_owned())
-        .collect()
+        WalkDir::new(path)
+            .into_iter()
+            .filter_map(|e| e.ok())
+            .filter(|e| e.file_type().is_file())
+            .map(|e| e.path().to_owned())
+            .collect()
     }
 
     // Step 2 : Creating a list of dictionary with all related and useful informations.
     fn parsing_to_hashmap(entries: &[PathBuf]) -> Vec<HashMap<String, String>> {
-        entries.iter().map(|entry: &PathBuf| {
-            let mut hashmap: HashMap<String, String> = HashMap::new();
-            hashmap.insert("name".to_string(), entry.file_name().unwrap_or_default().to_string_lossy().into_owned());
-            hashmap.insert("ext".to_string(), entry.extension().unwrap_or_default().to_string_lossy().into_owned());
-            hashmap.insert("path".to_string(), entry.to_string_lossy().into_owned());
-            hashmap
-        }).collect()
+        entries
+            .iter()
+            .map(|entry: &PathBuf| {
+                let mut hashmap: HashMap<String, String> = HashMap::new();
+                hashmap.insert(
+                    "name".to_string(),
+                    entry
+                        .file_name()
+                        .unwrap_or_default()
+                        .to_string_lossy()
+                        .into_owned(),
+                );
+                hashmap.insert(
+                    "ext".to_string(),
+                    entry
+                        .extension()
+                        .unwrap_or_default()
+                        .to_string_lossy()
+                        .into_owned(),
+                );
+                hashmap.insert("path".to_string(), entry.to_string_lossy().into_owned());
+                hashmap
+            })
+            .collect()
     }
 
     // Step 3 : We serializing the Vector to a message pack.
     fn serialize_to_msgpack(hashmap: &Vec<HashMap<String, String>>) -> File {
         let encoded: Vec<u8> = rmp_serde::encode::to_vec(&hashmap).unwrap();
-        let mut file: File = File::create("output.msgpack.temp").expect("Creation of the file impossible");
-        file.write_all(&encoded).expect("Writing of the file impossible");
+        let mut file: File =
+            File::create("output.msgpack.temp").expect("Creation of the file impossible");
+        file.write_all(&encoded)
+            .expect("Writing of the file impossible");
         // We will rewriting the file using the file content but this technique isn't good for production
         // In the futur commit, TODO: replacing this with a stream flux and output into a file AFTER.
         return file;
@@ -50,18 +68,18 @@ pub fn serialize(path: &Path) {
     serialize_to_msgpack(&hashmap);
 
     // Ouvrir le fichier sérialisé en lecture
-    let mut uncompressed_file = File::open("output.msgpack.temp").expect("Failed to open serialized file");
+    let mut uncompressed_file =
+        File::open("output.msgpack.temp").expect("Failed to open serialized file");
 
     // Ouvrir un fichier de sortie pour recevoir la version compressée
-    let output_file = File::create("output.msgpack.zst").expect("Failed to create output compressed file");
+    let output_file =
+        File::create("output.msgpack.zst").expect("Failed to create output compressed file");
 
     // Compresser du fichier sérialisé vers le fichier compressé avec un niveau de compression à 22 (max)
-    zstd::stream::copy_encode(&mut uncompressed_file, output_file, 22)
-        .expect("Compression failed");
+    zstd::stream::copy_encode(&mut uncompressed_file, output_file, 22).expect("Compression failed");
 
     match std::fs::remove_file(Path::new("output.msgpack.temp")) {
         Ok(_) => println!("Fichier supprimé avec succès !"),
         Err(e) => eprintln!("Erreur lors de la suppression du fichier : {}", e),
     }
-
-    }
+}