Merge remote-tracking branch 'allilo/add_compression_algo_arg' into oldpr452

# Conflicts:
#	Cargo.toml
#	examples/write_dir.rs

Cargo.toml

@@ -55,6 +55,8 @@ getrandom = { version = "0.2.14", features = ["js"] }
 walkdir = "2.5.0"
 time = { workspace = true, features = ["formatting", "macros"] }
 anyhow = "1"
+clap = { version = "=4.4.18", features = ["derive"] }
+
 [features]
 aes-crypto = ["aes", "constant_time_eq", "hmac", "pbkdf2", "sha1"]
 chrono = ["chrono/default"]

examples/write_dir.rs

@@ -1,11 +1,34 @@
 use anyhow::Context;
+use clap::{Parser, ValueEnum};
 use std::io::prelude::*;
 use zip::{result::ZipError, write::SimpleFileOptions};
 
 use std::fs::File;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use walkdir::{DirEntry, WalkDir};
 
+#[derive(Parser)]
+#[command(about, long_about = None)]
+struct Args {
+    // Source directory
+    source: PathBuf,
+    // Destination zipfile
+    destination: PathBuf,
+    // Compression method
+    #[arg(value_enum)]
+    compression_method: CompressionMethod,
+}
+
+#[derive(Clone, ValueEnum)]
+enum CompressionMethod {
+    Stored,
+    Deflated,
+    DeflatedMiniz,
+    DeflatedZlib,
+    Bzip2,
+    Zstd,
+}
+
 fn main() {
     std::process::exit(real_main());
 }
@@ -28,25 +51,60 @@ const METHOD_ZSTD: Option<zip::CompressionMethod> = Some(zip::CompressionMethod:
 const METHOD_ZSTD: Option<zip::CompressionMethod> = None;
 
 fn real_main() -> i32 {
-    let args: Vec<_> = std::env::args().collect();
+    let args = Args::parse();
-    if args.len() < 3 {
+    let src_dir = &args.source;
-        println!(
+    let dst_file = &args.destination;
-            "Usage: {} <source_directory> <destination_zipfile>",
+    let method = match args.compression_method {
-            args[0]
+        CompressionMethod::Stored => zip::CompressionMethod::Stored,
-        );
+        CompressionMethod::Deflated => {
-        return 1;
+            #[cfg(not(feature = "deflate"))]
-    }
+            {
-
+                println!("The `deflate` feature is not enabled");
-    let src_dir = &*args[1];
+                return 1;
-    let dst_file = &*args[2];
+            }
-    for &method in [METHOD_STORED, METHOD_DEFLATED, METHOD_BZIP2, METHOD_ZSTD].iter() {
+            #[cfg(feature = "deflate")]
-        if method.is_none() {
+            zip::CompressionMethod::Deflated
-            continue;
+        },
-        }
+        CompressionMethod::DeflatedMiniz => {
-        match doit(src_dir, dst_file, method.unwrap()) {
+            #[cfg(not(feature = "deflate-miniz"))]
-            Ok(_) => println!("done: {src_dir} written to {dst_file}"),
+            {
-            Err(e) => eprintln!("Error: {e:?}"),
+                println!("The `deflate-miniz` feature is not enabled");
+                return 1;
+            }
+            #[cfg(feature = "deflate-miniz")]
+            zip::CompressionMethod::Deflated
+        },
+        CompressionMethod::DeflatedZlib => {
+            #[cfg(not(feature = "deflate-zlib"))]
+            {
+                println!("The `deflate-zlib` feature is not enabled");
+                return 1;
+            }
+            #[cfg(feature = "deflate-zlib")]
+            zip::CompressionMethod::Deflated
+        },
+        CompressionMethod::Bzip2 => {
+            #[cfg(not(feature = "bzip2"))]
+            {
+                println!("The `bzip2` feature is not enabled");
+                return 1;
+            }
+            #[cfg(feature = "bzip2")]
+            zip::CompressionMethod::Bzip2
+        },
+        CompressionMethod::Zstd => {
+            #[cfg(not(feature = "zstd"))]
+            {
+                println!("The `zstd` feature is not enabled");
+                return 1;
+            }
+            #[cfg(feature = "zstd")]
+            zip::CompressionMethod::Zstd
         }
+    };
+    match doit(src_dir, dst_file, method) {
+        Ok(_) => println!("done: {:?} written to {:?}", src_dir, dst_file),
+        Err(e) => eprintln!("Error: {e:?}"),
     }
 
     0
@@ -54,7 +112,7 @@ fn real_main() -> i32 {
 
 fn zip_dir<T>(
     it: &mut dyn Iterator<Item = DirEntry>,
-    prefix: &str,
+    prefix: &Path,
     writer: T,
     method: zip::CompressionMethod,
 ) -> anyhow::Result<()>
@@ -97,7 +155,7 @@ where
     Ok(())
 }
 
-fn doit(src_dir: &str, dst_file: &str, method: zip::CompressionMethod) -> anyhow::Result<()> {
+fn doit(src_dir: &Path, dst_file: &Path, method: zip::CompressionMethod) -> anyhow::Result<()> {
     if !Path::new(src_dir).is_dir() {
         return Err(ZipError::FileNotFound.into());
     }