v3, added report system and cleaning the code

Author: ArcadeCode

Cargo.lock

@@ -1,5 +1,5 @@
 [package]
-name = "yet-another-disk-mapper"
+name = "yadm"
 version = "0.1.0"
 edition = "2021"
 

Cargo.toml

@@ -1,2 +1,78 @@
 # Yet Another Disk Mapper (YADM)
-YADM is a little Disk Mapper for some future projects.
+
+**YADM** is a lightweight disk mapping tool designed for small-scale projects.  
+It allows you to serialize the structure of a file system directory into compact and optimized formats for fast storage and access.
+
+---
+
+## 🚀 Features
+
+- Generates lightweight and ultra-optimized mapping files.
+- Provides serializers for Rust to handle `.msgpack.tar.gz` files.
+
+---
+
+## ⚙️ How It Works
+
+Running a command like `./yadm.exe serialize "C://"` will perform the following steps:
+
+1. Traverse the specified directory and collect all file and folder metadata.
+2. Convert the resulting data structure into a [MessagePack](https://msgpack.org/) object.
+3. Compress the MessagePack file using `tar.gz`.
+4. Output the final mapping as `map.msgpack.tar.gz`.
+
+In my personal configuration :
+- SSD NVMe
+- 471,45 Go on 500,00 Go used
+- Output result :
+    ```
+    1. Scanning folders at: C://
+    Scan Time: 195.4473487s
+    Elements found: 2065488
+    2. Parsing to hashmap...
+    3. Encoding + writing MessagePack...
+
+    --- Résultats ---
+    Compression Time: 5.5725601s
+    Average compression time per file: 2697 ns
+    Compressed file size: 358444787 octets
+    Compressed file size: 350043.74 Ko
+    Compressed file size: 341.84 Mo
+    Average compressed size per file: 173 octets
+    ```
+---
+
+## 🧰 Commands
+
+There are two main commands:
+
+- `yadm serialize "path" --use-tar-gz=true`  
+  → Maps a directory and outputs a compressed `.msgpack.tar.gz` file.
+
+- `yadm serialize "path" --use-tar-gz=false`  
+  → Outputs a raw `.msgpack` file (uncompressed).
+
+- `yadm parse "map.msgpack.tar.gz"`  
+  → Parses the mapping and loads it into memory as a `Vec<HashMap<String, String>>`.
+
+---
+
+## 🦀 Usage in Rust
+
+You can integrate YADM directly in your Rust project like this:
+
+```rust
+use yadm::{serialize, parse};
+use std::collections::HashMap;
+
+fn main() {
+    // Serialize a directory
+    serialize("C://", true);
+
+    // Parse the resulting file
+    let map: Vec<HashMap<String, String>> = parse("map.msgpack.tar.gz");
+
+    // You can now use `map` in your application
+}
+```
+> ⚠️ Make sure to handle Result and error types appropriately in real applications.

readme.md

@@ -2,20 +2,13 @@ use std::env;
 use std::fs::File;
 use std::io::Write;
 use std::path::{Path, PathBuf};
-use std::time::Instant;
+use std::time::{Duration, Instant};
 use std::collections::HashMap;
 use rmp_serde::encode;
 use walkdir::WalkDir;
 
-fn format_file_size(size: u64, unit: &str) -> String {
-    match unit {
-        "o" => format!("{} octets", size),
-        "Ko" => format!("{:.2} Ko", size as f64 / 1024.0),
-        "Mo" => format!("{:.2} Mo", size as f64 / (1024.0 * 1024.0)),
-        "Go" => format!("{:.2} Go", size as f64 / (1024.0 * 1024.0 * 1024.0)),
-        _ => format!("{} octets", size),
-    }
-}
+mod yadm;
+use yadm::report::report::Report;
 
 fn scan_dir(path: &Path) -> Vec<PathBuf> {
     WalkDir::new(path)
@@ -27,8 +20,8 @@ fn scan_dir(path: &Path) -> Vec<PathBuf> {
 }
 
 fn parsing_to_hashmap(entries: &[PathBuf]) -> Vec<HashMap<String, String>> {
-    entries.iter().map(|entry| {
-        let mut hashmap = HashMap::new();
+    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());
@@ -44,34 +37,56 @@ fn main() {
         std::process::exit(1);
     }
 
-    let target_dir = &args[1];
+    let target_dir: &String = &args[1];
+
     println!("1. Scanning folders at: {}", target_dir);
+    let scan_start: Instant = Instant::now();
+    let paths: Vec<PathBuf> = scan_dir(Path::new(target_dir));
+    let scan_duration: Duration = scan_start.elapsed();
 
-    let start_time = Instant::now();
-    let paths = scan_dir(Path::new(target_dir));
-    let end_time = start_time.elapsed();
+    let total_files: u64 =
+    if paths.is_empty() {
+        eprintln!("No files found. Exiting.");
+        return;
+    } else {
+        let count = paths.len() as u64;
+        println!("Found {} files", count);
+        count
+    };
 
-    println!("Time taken: {:?}", end_time);
-    println!("Elements found: {:?}", paths.len());
 
-    if !paths.is_empty() {
-        let medium_time_per_element = end_time.as_nanos() / paths.len() as u128;
-        println!("Medium time by element: {:?} ns", medium_time_per_element);
-    } else {
-        println!("No elements found, cannot calculate medium time by element.");
-    }
+    println!("2. Parsing to hashmap...");
+    let hashmap_parsing_start: Instant = Instant::now();
+    let hashmap: Vec<HashMap<String, String>> = parsing_to_hashmap(&paths);
+    let hashmap_parsing_duration: Duration = hashmap_parsing_start.elapsed();
+
 
-    let hashmap = parsing_to_hashmap(&paths);
-    let encoded = encode::to_vec(&hashmap).unwrap();
+    println!("3. Encoding + writing MessagePack...");
+    let msgpack_parsing_start = Instant::now();
 
-    let mut file = File::create("output.msgpack").expect("Impossible de créer le fichier");
+    let encoded: Vec<u8> = encode::to_vec(&hashmap).unwrap();
+    let mut file: File = File::create("output.msgpack").expect("Impossible de créer le fichier");
     file.write_all(&encoded).expect("Impossible d'écrire dans le fichier");
 
-    let metadata = file.metadata().expect("Impossible d'obtenir les métadonnées du fichier");
-    let file_size = metadata.len();
+    let msgpack_parsing_duration: Duration = msgpack_parsing_start.elapsed();
 
-    println!("Taille du fichier : {}", format_file_size(file_size, "o"));
-    println!("Taille du fichier : {}", format_file_size(file_size, "Ko"));
-    println!("Taille du fichier : {}", format_file_size(file_size, "Mo"));
-    println!("Taille du fichier : {}", format_file_size(file_size, "Go"));
-}
+    let metadata: std::fs::Metadata = file.metadata().expect("Impossible d'obtenir les métadonnées du fichier");
+    let file_size: u64 = metadata.len();
+
+    let report: Report = Report {
+        target: args[0].clone(),
+        scan_start_at: scan_start,
+        scan_duration: scan_duration,
+        elements_found: file_size,
+        hashmap_parsing_start_at: hashmap_parsing_start,
+        hashmap_parsing_duration: hashmap_parsing_duration,
+        msgpack_parsing_start_at: msgpack_parsing_start,
+        msgpack_parsing_duration: msgpack_parsing_duration,
+        output_file_size: file_size,
+        full_duration: scan_duration+hashmap_parsing_duration+msgpack_parsing_duration,
+        average_duration_by_file: file_size.checked_div(scan_duration.as_secs()+hashmap_parsing_duration.as_secs()+msgpack_parsing_duration.as_secs()).unwrap_or(0),
+        average_size_by_file: file_size.checked_div(total_files).unwrap_or(0),
+    };
+
+    println!("{}", report)
+}

src/main.rs

@@ -0,0 +1 @@
+pub mod report;

src/yadm/mod.rs

@@ -0,0 +1,66 @@
+use std::fmt;
+use std::time::{Duration, Instant};
+
+pub mod report {
+    use super::*;
+
+    pub struct Report {
+        pub target: String,
+        pub scan_start_at: Instant,
+        pub scan_duration: Duration,
+        pub elements_found: u64,
+
+        pub hashmap_parsing_start_at: Instant,
+        pub hashmap_parsing_duration: Duration,
+
+        pub msgpack_parsing_start_at: Instant,
+        pub msgpack_parsing_duration: Duration,
+
+        pub output_file_size: u64,
+        pub full_duration: Duration,
+        pub average_duration_by_file: u64,
+        pub average_size_by_file: u64,
+    }
+
+    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, "
+=== YADM report ===
+Target : {}
+Scan duration : {:.2}s
+Elements found : {}
+Hashmap parsing duration : {:.2}s
+MsgPack parsing duration : {:.2}s
+-----
+Full duration : {:.2}s
+Average duration by file : {:.2}s
+Average size by file : {} o
+Output file size : {} o
+Output file size : {:.2} Ko
+Output file size : {:.2} Mo
+Output file size : {:.2} Go
+===================
+",
+                self.target,
+                self.scan_duration.as_secs_f64(),
+                self.elements_found,
+                self.hashmap_parsing_duration.as_secs_f64(),
+                self.msgpack_parsing_duration.as_secs_f64(),
+                self.full_duration.as_secs_f64(),
+                self.average_duration_by_file,
+                self.average_size_by_file,
+                self.output_file_size,
+                self.output_file_size as f64 / 1024.0,
+                self.output_file_size as f64 / (1024.0 * 1024.0),
+                self.output_file_size as f64 / (1024.0 * 1024.0 * 1024.0),
+            )
+        }
+    }
+}