Add performance improvements and standardize error handling

Cargo.toml

@@ -31,3 +31,4 @@ sha3 = { default-features = false, version = ">= 0.10.8" }
 whirlpool = { default-features = false, version = ">= 0.10.4" }
 blake2 = { default-features = false, version = ">= 0.10.6" }
 crc32fast = { default-features = false, version = ">= 1.4.2" }
+indicatif = ">= 0.17.9"

src/hasher.rs

@@ -8,6 +8,10 @@ use digest::{Digest, Output};
 
 use crate::classes::{BasicHash, OutputEncoding};
 
+/// Buffer size for reading large files in chunks. 32KB provides optimal performance
+/// by balancing memory usage with I/O efficiency. Larger buffers reduce syscall overhead
+/// but increase memory pressure, while smaller buffers result in more frequent I/O operations.
+/// Files ≤32KB are read entirely into memory for maximum performance.
 const BUFFER_SIZE: usize = 4096 * 8;
 
 /// Hash a file using the given hasher as a Digest implementation, eg `Sha1`, `Sha256`, `Sha3_256`

src/main.rs

@@ -9,6 +9,9 @@ use std::io::BufRead;
 use std::str::FromStr;
 
 use anyhow::{Result, anyhow};
+use indicatif::{ProgressBar, ProgressStyle};
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
 
 //use crate::hasher::hash_file_crc32;
 use blake2::{Blake2b512, Blake2s256};
@@ -258,7 +261,7 @@ where
     }
 
     for pathstr in paths {
-        let file_hash = call_hasher(config.algorithm, config.encoding, pathstr);
+        let file_hash = hash_with_progress(config, pathstr);
 
         match file_hash {
             Ok(basic_hash) => {
@@ -268,7 +271,7 @@ where
                     println!("{basic_hash} {pathstr}");
                 }
             }
-            Err(e) => eprintln!("'{pathstr}' file err {e:?}"),
+            Err(e) => eprintln!("File error for '{}': {}", pathstr, e),
         }
     }
 }
@@ -285,7 +288,16 @@ where
 
     // process the paths in parallel
     paths.par_iter().for_each(|pathstr| {
+        // For multithreaded operations, we don't show individual progress spinners
+        // to avoid UI conflicts, but we still time operations for debug output
+        let start_time = Instant::now();
         let file_hash = call_hasher(config.algorithm, config.encoding, pathstr);
+        let elapsed = start_time.elapsed();
+
+        // If the operation took more than 1 second, mention it in debug mode
+        if config.debug_mode && elapsed >= Duration::from_secs(1) {
+            eprintln!("File '{}' took {:.2}s to hash", pathstr, elapsed.as_secs_f64());
+        }
 
         match file_hash {
             Ok(basic_hash) => {
@@ -297,11 +309,71 @@ where
             }
 
             // failed to calculate the hash
-            Err(e) => eprintln!("'{pathstr}' file err {e:?}"),
+            Err(e) => eprintln!("File error for '{}': {}", pathstr, e),
         }
     });
 }
 
+/// Hash a file with progress indication for operations taking >1 second
+fn hash_with_progress<S>(config: &ConfigSettings, pathstr: S) -> Result<BasicHash>
+where
+    S: AsRef<str> + Display + Clone,
+{
+    let start_time = Instant::now();
+    let done = Arc::new(Mutex::new(false));
+    let done_clone = Arc::clone(&done);
+    let pathstr_clone = pathstr.clone();
+
+    // Spawn a thread to show progress if operation takes >1 second
+    let progress_handle = if !config.debug_mode {
+        Some(std::thread::spawn(move || {
+            std::thread::sleep(Duration::from_secs(1));
+
+            // Check if operation is still running
+            if let Ok(is_done) = done_clone.lock() {
+                if !*is_done {
+                    let pb = ProgressBar::new_spinner();
+                    pb.set_style(
+                        ProgressStyle::default_spinner()
+                            .template("{spinner:.green} Hashing {msg}...")
+                            .expect("Spinner template should be valid")
+                    );
+                    pb.set_message(pathstr_clone.to_string());
+                    pb.enable_steady_tick(Duration::from_millis(120));
+
+                    // Keep spinning until done
+                    loop {
+                        std::thread::sleep(Duration::from_millis(100));
+                        if let Ok(is_done) = done_clone.lock() {
+                            if *is_done {
+                                pb.finish_and_clear();
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }))
+    } else {
+        None
+    };
+
+    // Perform the actual hashing
+    let result = call_hasher(config.algorithm, config.encoding, pathstr);
+
+    // Mark as done
+    if let Ok(mut is_done) = done.lock() {
+        *is_done = true;
+    }
+
+    // Wait for progress thread to finish
+    if let Some(handle) = progress_handle {
+        let _ = handle.join();
+    }
+
+    result
+}
+
 /// calculate the hash of a file using given algorithm
 fn call_hasher(
     algo: HashAlgorithm,
@@ -312,7 +384,9 @@ fn call_hasher(
     if (algo == HashAlgorithm::CRC32 && encoding != OutputEncoding::U32)
         || (algo != HashAlgorithm::CRC32 && encoding == OutputEncoding::U32)
     {
-        return Err(anyhow!("CRC32 can only be output as U32"));
+        return Err(anyhow!(
+            "CRC32 must use U32 encoding, and U32 encoding can only be used with CRC32"
+        ));
     }
 
     match algo {