v2

Author: ArcadeCode

.gitignore

@@ -1,2 +1,4 @@
 /target
-.vscode/
+.vscode/
+output.msgpack
+**.msgpack

Cargo.lock

@@ -6,9 +6,10 @@ edition = "2021"
 [dependencies]
 rmp-serde = "1.3.0"
 serde = "1.0.219"
+walkdir = "2.5.0"
 
 [profile.custom-opt]
 inherits = "release"
 opt-level = 3
 lto = true
-codegen-units = 1
+codegen-units = 1

Cargo.toml

@@ -1,12 +1,11 @@
-use std::fs;
-use std::time::{Duration, Instant};
-use std::path::{PathBuf};
-use std::ffi::OsStr;
-
-use rmp_serde::{encode};
-use std::collections::HashMap;
+use std::env;
 use std::fs::File;
 use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::time::Instant;
+use std::collections::HashMap;
+use rmp_serde::encode;
+use walkdir::WalkDir;
 
 fn format_file_size(size: u64, unit: &str) -> String {
     match unit {
@@ -18,103 +17,61 @@ fn format_file_size(size: u64, unit: &str) -> String {
     }
 }
 
-fn scan_dir(path: &str) -> Vec<PathBuf> {
-    let mut result = Vec::new();
-    if let Ok(entries) = fs::read_dir(path) {
-        for entry in entries {
-            if let Ok(entry) = entry {
-                let path = entry.path();
-                if path.is_dir() {
-                    // Récursivement scanner les sous-répertoires
-                    let mut sub_dir_results = scan_dir(path.to_str().unwrap());
-                    result.append(&mut sub_dir_results);
-                } else {
-                    // Ajouter le fichier à la liste des résultats
-                    result.push(path);
-                }
-            }
-        }
-    }
-    result
-}
-
-fn scan_dirs(path: &str) -> Vec<PathBuf> {
-    let result = scan_dir(path);
-    result
+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()
 }
 
-fn parsing_to_hashmap(entries: &Vec<PathBuf>) -> Vec<HashMap<String, String>> {
-    let mut dictionaries: Vec<HashMap<String, String>> = Vec::new();
-
-    for entry in entries {
+fn parsing_to_hashmap(entries: &[PathBuf]) -> Vec<HashMap<String, String>> {
+    entries.iter().map(|entry| {
         let mut hashmap = HashMap::new();
-
-        // Convertir Option<&OsStr> en String pour "name"
-        if let Some(name) = entry.file_name().and_then(OsStr::to_str) {
-            hashmap.insert(String::from("name"), name.to_string());
-        } else {
-            hashmap.insert(String::from("name"), String::from(""));
-        }
-
-        // Convertir Option<&OsStr> en String pour "ext"
-        if let Some(ext) = entry.extension().and_then(OsStr::to_str) {
-            hashmap.insert(String::from("ext"), ext.to_string());
-        } else {
-            hashmap.insert(String::from("ext"), String::from(""));
-        }
-
-        // Convertir Option<&str> en String pour "path"
-        if let Some(path) = entry.to_str() {
-            hashmap.insert(String::from("path"), path.to_string());
-        } else {
-            hashmap.insert(String::from("path"), String::from(""));
-        }
-
-        dictionaries.push(hashmap);
-    }
-
-    dictionaries
+        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()
 }
 
-
 fn main() {
-    println!("1. Scanning folders...");
-    let start_time: Instant = Instant::now();
+    let args: Vec<String> = env::args().collect();
 
-    let paths: Vec<PathBuf> = scan_dirs("C:/Users/ederv/");
+    if args.len() < 2 {
+        eprintln!("Usage: {} <directory_path>", args[0]);
+        std::process::exit(1);
+    }
 
-    let end_time: Duration = start_time.elapsed();
+    let target_dir = &args[1];
+    println!("1. Scanning folders at: {}", target_dir);
+
+    let start_time = Instant::now();
+    let paths = scan_dir(Path::new(target_dir));
+    let end_time = start_time.elapsed();
 
     println!("Time taken: {:?}", end_time);
     println!("Elements found: {:?}", paths.len());
 
-    if paths.len() > 0 {
+    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 a list of dicts...");
     let hashmap = parsing_to_hashmap(&paths);
-
-    // Sérialiser le HashMap en MessagePack
     let encoded = encode::to_vec(&hashmap).unwrap();
 
-    // Écrire le MessagePack dans un fichier
     let mut file = File::create("output.msgpack").expect("Impossible de créer le fichier");
     file.write_all(&encoded).expect("Impossible d'écrire dans le fichier");
 
-    // Obtenir la taille du fichier
     let metadata = file.metadata().expect("Impossible d'obtenir les métadonnées du fichier");
     let file_size = metadata.len();
 
-    //println!("MessagePack sauvegardé dans output.msgpack");
-    
-    // Afficher la taille du fichier dans différentes unités
     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"));
-
-}
+}