Added cli implementation

Author: ArcadeCode

Cargo.lock

@@ -2,8 +2,10 @@
 name = "yadm"
 version = "0.1.0"
 edition = "2021"
+authors = ["Dervaux Esteban <[email protected]>"]
 
 [dependencies]
+clap = { version = "4.5.40", features = ["derive"] }
 rmp-serde = "1.3.0"
 serde = "1.0.219"
 walkdir = "2.5.0"

Cargo.toml

@@ -0,0 +1,47 @@
+use clap::{Parser, Subcommand, Args, ArgAction};
+
+#[derive(Parser)]
+#[command(
+    name = env!("CARGO_PKG_NAME"),
+    version = env!("CARGO_PKG_VERSION"),
+    author = env!("CARGO_PKG_AUTHORS"),
+    about = "YADM is a lightweight 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."
+)]
+pub struct Cli {
+    /// Active le mode verbeux
+    #[arg(short, long, global = true)]
+    pub verbose: bool,
+
+    #[command(subcommand)]
+    pub command: Commands,
+}
+
+#[derive(Subcommand)]
+pub enum Commands {
+    /// Show the current version of YADM
+    Version,
+
+    /// Serialize a directory or just one file
+    Serialize(SerializeArgs),
+
+    /// Parse a serialize file
+    Parse(ParseArgs),
+}
+
+#[derive(Args)]
+pub struct SerializeArgs {
+    /// Path to the element to serialize
+    #[arg(value_name = "PATH")]
+    pub path: String,
+
+    /// Enable or disable compression using zstd, (set to true by default)
+    #[arg(long, action = ArgAction::Set, default_value_t = true)]
+    pub use_zstd: bool,
+}
+
+#[derive(Args)]
+pub struct ParseArgs {
+    /// Path to the file to parse.
+    #[arg(value_name = "PATH")]
+    pub path: String,
+}

src/cli.rs

@@ -1,6 +1,32 @@
-use std::path::Path;
+mod cli;
 mod yadm;
 
+use std::path::Path;
+
+use clap::Parser;
+use cli::{Cli, Commands};
+
 fn main() {
-    yadm::serialize(Path::new("../"))
+    let cli = Cli::parse();
+
+    match &cli.command {
+        Commands::Version => {
+            println!("{} v{}", env!("CARGO_PKG_NAME"), env!("CARGO_PKG_VERSION"));
+        }
+
+        Commands::Serialize(args) => {
+            let path = &args.path;
+            let use_zstd = args.use_zstd;
+            let verbose = cli.verbose;
+
+            yadm::serialize(Path::new(path), use_zstd, verbose);
+        }
+
+        Commands::Parse(args) => {
+            let path = &args.path;
+            let verbose = cli.verbose;
+
+            yadm::parse(Path::new(path), verbose);
+        }
+    }
 }

src/main.rs

@@ -1,3 +1,5 @@
 pub mod report;
 pub mod serialize;
 pub use serialize::serialize;
+pub mod parse;
+pub use parse::parse;

src/yadm.rs

@@ -0,0 +1,5 @@
+use std::path::Path;
+
+pub fn parse(_path: &Path, _verbose: bool) {
+    eprintln!("Not implemented")
+}

src/yadm/parse.rs

@@ -8,7 +8,7 @@ use zstd;
 use super::report::Report;
 
 /// TODO: Faire la doc
-pub fn serialize(path: &Path) {
+pub fn serialize(path: &Path, use_zstd: bool, verbose: bool) {
     // Step 1 : Getting all entities into the Path
     fn scan_dir(path: &Path) -> Vec<PathBuf> {
         WalkDir::new(path)
@@ -19,7 +19,7 @@ pub fn serialize(path: &Path) {
             .collect()
     }
 
-    // Step 2 : Creating a list of dictionary with all related and useful informations.
+    // Step 2 : Creating a list of dictionary with all related and useful information.
     fn parsing_to_hashmap(entries: &[PathBuf]) -> Vec<HashMap<String, String>> {
         entries
             .iter()
@@ -51,15 +51,15 @@ pub fn serialize(path: &Path) {
     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::create("map.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;
     }
 
-    // Report give some informations to know how good or bad this version of YADM was.
+    // Report give some information to know how good or bad this version of YADM was.
     let mut report: Report = Report::new(path.to_path_buf());
 
     // We check if the path go to only one File to skip the WalkDir call if not needed.
@@ -85,24 +85,35 @@ pub fn serialize(path: &Path) {
     serialize_to_msgpack(&hashmap);
     report.time_msgpack_parsing();
 
-    // Ouvrir le fichier sérialisé en lecture
-    let mut uncompressed_file =
-        File::open("output.msgpack.temp").expect("Failed to open serialized file");
+    if use_zstd {
+        // Ouvrir le fichier sérialisé en lecture
+        let mut uncompressed_file =
+            File::open("map.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");
+        // Ouvrir un fichier de sortie pour recevoir la version compressée
+        let output_file =
+            File::create("map.msgpack.zst").expect("Failed to create output compressed file");
 
-    report.time_zstd_compression();
-    // 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");
-    report.time_zstd_compression();
+        report.time_zstd_compression();
+        // 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");
+        report.time_zstd_compression();
 
-    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),
+        match std::fs::remove_file(Path::new("map.msgpack.temp")) {
+            Ok(_) => println!("Fichier supprimé avec succès !"),
+            Err(e) => eprintln!("Erreur lors de la suppression du fichier : {}", e),
+        }
+    } else {
+        match std::fs::rename(Path::new("map.msgpack.temp"), Path::new("map.msgpack")) {
+            Ok(_) => println!("Fichier supprimé avec succès !"),
+            Err(e) => eprintln!("Erreur lors de la suppression du fichier : {}", e),
+        }
     }
+    
 
     report.close_report();
-    println!("{}", report);
+    if verbose {
+        // FIXME: In the futur, we need to implement a dummy report struct to skip all timers when "verbose" is set to false
+        println!("{}", report);
+    }
 }