Merge pull request #32 from lookbusy1344/claude/issue-31-20250912-1026

Refactor project into logical modules

Author: lookbusy1344

src/cli/args.rs

@@ -0,0 +1,93 @@
+use std::ffi::OsString;
+use std::str::FromStr;
+
+use anyhow::{Result, anyhow};
+use pico_args::Arguments;
+
+use crate::cli::config::{ConfigSettings, HELP};
+use crate::core::types::{DEFAULT_HASH, GIT_VERSION_SHORT, HashAlgorithm, OutputEncoding, VERSION};
+
+pub fn process_command_line(mut pargs: Arguments) -> Result<ConfigSettings> {
+    let algo_str: Option<String> = pargs.opt_value_from_str(["-a", "--algorithm"])?;
+    let algo = parse_hash_algorithm(algo_str.as_deref()).map_err(|_| {
+        anyhow!(
+        "Algorithm can be: CRC32, MD5, SHA1, SHA2 / SHA2-256 / SHA-256, SHA2-224, SHA2-384, SHA2-512, SHA3 / SHA3-256, SHA3-384, SHA3-512, WHIRLPOOL, BLAKE2S-256, BLAKE2B-512. Default is {DEFAULT_HASH:?}",
+    )
+    })?;
+
+    let encoding_str: Option<String> = pargs.opt_value_from_str(["-e", "--encoding"])?;
+    let encoding = parse_hash_encoding(encoding_str.as_deref())
+        .map_err(|_| anyhow!("Encoding can be: Hex, Base64, Base32. Default is Hex",))?;
+
+    let encoding = match encoding {
+        OutputEncoding::Unspecified if algo == HashAlgorithm::CRC32 => OutputEncoding::U32,
+        OutputEncoding::Unspecified => OutputEncoding::Hex,
+        other => other,
+    };
+
+    if algo == HashAlgorithm::CRC32 && encoding != OutputEncoding::U32 {
+        return Err(anyhow!(
+            "CRC32 must use U32 encoding, and U32 encoding can only be used with CRC32"
+        ));
+    }
+
+    let mut config = ConfigSettings::new(
+        pargs.contains(["-d", "--debug"]),
+        pargs.contains(["-x", "--exclude-filenames"]),
+        pargs.contains(["-s", "--single-thread"]),
+        pargs.contains(["-c", "--case-sensitive"]),
+        pargs.contains(["-n", "--no-progress"]),
+        algo,
+        encoding,
+        pargs.opt_value_from_str(["-l", "--limit"])?,
+    );
+
+    let remaining_args = args_finished(pargs)?;
+
+    let supplied_paths = remaining_args
+        .into_iter()
+        .map(|arg| arg.to_string_lossy().to_string())
+        .collect();
+
+    config.set_supplied_paths(supplied_paths);
+
+    Ok(config)
+}
+
+pub fn parse_hash_algorithm(algorithm: Option<&str>) -> Result<HashAlgorithm, strum::ParseError> {
+    match algorithm {
+        Some(algo_str) if !algo_str.is_empty() => HashAlgorithm::from_str(algo_str),
+        _ => Ok(DEFAULT_HASH),
+    }
+}
+
+pub fn parse_hash_encoding(encoding: Option<&str>) -> Result<OutputEncoding, strum::ParseError> {
+    match encoding {
+        Some(enc_str) if !enc_str.is_empty() => OutputEncoding::from_str(enc_str),
+        _ => Ok(OutputEncoding::Unspecified),
+    }
+}
+
+pub fn show_help(longform: bool) {
+    println!(
+        "File hasher for various algorithms. Version {} ({})",
+        VERSION.unwrap_or("?"),
+        GIT_VERSION_SHORT
+    );
+    if longform {
+        println!("{HELP}");
+    }
+    println!("Default algorithm is {DEFAULT_HASH:?}");
+}
+
+fn args_finished(args: Arguments) -> Result<Vec<OsString>> {
+    let unused = args.finish();
+
+    for arg in &unused {
+        if arg.to_string_lossy().starts_with('-') {
+            return Err(anyhow!("Unknown argument: {}", arg.to_string_lossy()));
+        }
+    }
+
+    Ok(unused)
+}

src/cli/config.rs

@@ -0,0 +1,67 @@
+use crate::core::types::{HashAlgorithm, OutputEncoding};
+
+#[allow(clippy::struct_excessive_bools)]
+#[readonly::make]
+#[derive(Debug)]
+pub struct ConfigSettings {
+    pub debug_mode: bool,
+    pub exclude_fn: bool,
+    pub single_thread: bool,
+    pub case_sensitive: bool,
+    pub no_progress: bool,
+    pub algorithm: HashAlgorithm,
+    pub encoding: OutputEncoding,
+    pub limit_num: Option<usize>,
+    pub supplied_paths: Vec<String>,
+}
+
+impl ConfigSettings {
+    #[allow(clippy::fn_params_excessive_bools)]
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        debug_mode: bool,
+        exclude_fn: bool,
+        single_thread: bool,
+        case_sensitive: bool,
+        no_progress: bool,
+        algorithm: HashAlgorithm,
+        encoding: OutputEncoding,
+        limit_num: Option<usize>,
+    ) -> Self {
+        Self {
+            debug_mode,
+            exclude_fn,
+            single_thread,
+            case_sensitive,
+            no_progress,
+            algorithm,
+            encoding,
+            limit_num,
+            supplied_paths: Vec::new(),
+        }
+    }
+
+    pub fn set_supplied_paths(&mut self, paths: Vec<String>) {
+        self.supplied_paths = paths;
+    }
+}
+
+pub const HELP: &str = "\
+USAGE:
+    hash_rust.exe [flags] [options] file glob
+FLAGS:
+    -h, --help                   Prints help information
+    -d, --debug                  Debug messages
+    -c, --case-sensitive         Case-sensitive glob matching
+    -x, --exclude-filenames      Exclude filenames from output
+    -s, --single-thread          Single-threaded (not multi-threaded)
+    -n, --no-progress            Suppress progress display (for scripts)
+OPTIONS:
+    -a, --algorithm [algorithm]  Hash algorithm to use
+    -e, --encoding [encoding]    Output encoding (Hex, Base64, Base32. Default is Hex)
+    -l, --limit [num]            Limit number of files processed
+    
+Algorithm can be:
+    CRC32, MD5, SHA1, WHIRLPOOL, BLAKE2S-256, BLAKE2B-512,
+    SHA2 / SHA2-256 / SHA-256, SHA2-224, SHA2-384, SHA2-512,
+    SHA3 / SHA3-256 (default), SHA3-384, SHA3-512";

src/cli/mod.rs

@@ -0,0 +1,4 @@
+pub mod args;
+pub mod config;
+
+pub use args::{process_command_line, show_help};

src/core/mod.rs

@@ -0,0 +1,4 @@
+pub mod types;
+pub mod worker;
+
+pub use worker::worker_func;

src/core/types.rs

@@ -0,0 +1,64 @@
+use std::fmt;
+
+use git_version::git_version;
+use strum::EnumString;
+
+pub const DEFAULT_HASH: HashAlgorithm = HashAlgorithm::SHA3_256;
+pub const VERSION: Option<&str> = option_env!("CARGO_PKG_VERSION");
+pub const GIT_VERSION_SHORT: &str = git_version!(args = ["--abbrev=14", "--always", "--dirty=+"]);
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, EnumString)]
+#[strum(ascii_case_insensitive)]
+pub enum HashAlgorithm {
+    #[strum(serialize = "CRC32", serialize = "CRC-32")]
+    CRC32,
+    #[strum(serialize = "MD5", serialize = "MD-5")]
+    MD5,
+    #[strum(serialize = "SHA1", serialize = "SHA-1")]
+    SHA1,
+    #[strum(
+        serialize = "SHA2",
+        serialize = "SHA2-256",
+        serialize = "SHA2_256",
+        serialize = "SHA_256",
+        serialize = "SHA-256"
+    )]
+    SHA2_256,
+    #[strum(serialize = "SHA2-224", serialize = "SHA2_224")]
+    SHA2_224,
+    #[strum(serialize = "SHA2-384", serialize = "SHA2_384")]
+    SHA2_384,
+    #[strum(serialize = "SHA3", serialize = "SHA3-256", serialize = "SHA3_256")]
+    SHA3_256,
+    #[strum(serialize = "SHA2-512", serialize = "SHA2_512")]
+    SHA2_512,
+    #[strum(serialize = "SHA3-384", serialize = "SHA3_384")]
+    SHA3_384,
+    #[strum(serialize = "SHA3-512", serialize = "SHA3_512")]
+    SHA3_512,
+    #[strum(serialize = "WHIRLPOOL")]
+    Whirlpool,
+    #[strum(serialize = "BLAKE2B-512", serialize = "BLAKE2B_512")]
+    Blake2B512,
+    #[strum(serialize = "BLAKE2S-256", serialize = "BLAKE2S_256")]
+    Blake2S256,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, EnumString)]
+#[strum(ascii_case_insensitive)]
+pub enum OutputEncoding {
+    Hex,
+    Base64,
+    Base32,
+    U32,
+    Unspecified,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct BasicHash(pub String);
+
+impl fmt::Display for BasicHash {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}

src/core/worker.rs

@@ -0,0 +1,148 @@
+use std::fmt::Display;
+use std::time::{Duration, Instant};
+
+use anyhow::Result;
+use rayon::prelude::*;
+
+use crate::cli::config::ConfigSettings;
+use crate::core::types::BasicHash;
+use crate::hash::algorithms::call_hasher;
+use crate::io::files::get_required_filenames;
+use crate::progress::ProgressManager;
+
+pub fn worker_func(config: &ConfigSettings) -> Result<()> {
+    if config.debug_mode {
+        show_initial_info(config);
+    }
+
+    let paths = get_required_filenames(config)?;
+
+    if paths.is_empty() {
+        if config.debug_mode {
+            eprintln!("No files found");
+        }
+        return Ok(());
+    }
+
+    if config.debug_mode {
+        eprintln!("Files to hash: {paths:?}");
+    }
+
+    if config.single_thread || paths.len() == 1 {
+        file_hashes_st(config, &paths);
+    } else {
+        file_hashes_mt(config, &paths);
+    }
+
+    Ok(())
+}
+
+fn show_initial_info(config: &ConfigSettings) {
+    crate::cli::args::show_help(false);
+    eprintln!();
+    eprintln!("Config: {config:?}");
+    if config.supplied_paths.is_empty() {
+        eprintln!("No path specified, reading from stdin");
+    } else {
+        eprintln!(
+            "Paths: {} file path(s) supplied",
+            config.supplied_paths.len()
+        );
+    }
+}
+
+fn file_hashes_st<S>(config: &ConfigSettings, paths: &[S])
+where
+    S: AsRef<str> + Display + Send + Sync,
+{
+    if config.debug_mode {
+        eprintln!("Single-threaded mode");
+        eprintln!("Algorithm: {:?}", config.algorithm);
+    }
+
+    for pathstr in paths {
+        let file_hash = hash_with_progress(config, pathstr.as_ref().to_string());
+
+        match file_hash {
+            Ok(basic_hash) => {
+                if config.exclude_fn {
+                    println!("{basic_hash}");
+                } else {
+                    println!("{basic_hash} {pathstr}");
+                }
+            }
+            Err(e) => eprintln!("File error for '{pathstr}': {e}"),
+        }
+    }
+}
+
+fn file_hashes_mt<S>(config: &ConfigSettings, paths: &[S])
+where
+    S: AsRef<str> + Sync + Display,
+{
+    if config.debug_mode {
+        eprintln!("Multi-threaded mode");
+        eprintln!("Algorithm: {:?}", config.algorithm);
+    }
+
+    let overall_progress = if config.no_progress {
+        None
+    } else {
+        ProgressManager::create_overall_progress(paths.len(), config.debug_mode)
+    };
+
+    paths.par_iter().for_each(|pathstr| {
+        let file_hash = hash_with_progress(config, pathstr.as_ref().to_string());
+
+        if let Some(ref pb) = overall_progress {
+            pb.inc(1);
+        }
+
+        match file_hash {
+            Ok(basic_hash) => {
+                if config.exclude_fn {
+                    println!("{basic_hash}");
+                } else {
+                    println!("{basic_hash} {pathstr}");
+                }
+            }
+
+            Err(e) => eprintln!("File error for '{pathstr}': {e}"),
+        }
+    });
+
+    if let Some(pb) = overall_progress {
+        pb.finish_with_message("Complete!");
+    }
+}
+
+fn hash_with_progress<S>(config: &ConfigSettings, pathstr: S) -> Result<BasicHash>
+where
+    S: AsRef<str> + Display + Clone + Send + 'static,
+{
+    let pathstr_clone = pathstr.clone();
+
+    let progress_handle = if config.no_progress {
+        None
+    } else {
+        ProgressManager::create_file_progress(pathstr_clone.clone(), config.debug_mode)
+    };
+
+    let start_time = Instant::now();
+    let result = call_hasher(config.algorithm, config.encoding, pathstr);
+    let elapsed = start_time.elapsed();
+
+    if let Some(handle) = progress_handle {
+        handle.finish(config.debug_mode);
+    }
+
+    if config.debug_mode && elapsed >= Duration::from_millis(ProgressManager::threshold_millis()) {
+        eprintln!(
+            "File '{}' took {:.2}s to hash",
+            pathstr_clone,
+            elapsed.as_secs_f64()
+        );
+    }
+
+    result
+}