added minsize filter

src/filters.rs

@@ -0,0 +1,12 @@
+use crate::file_manager::File;
+use crate::params::Params;
+
+pub fn is_file_gt_minsize(app_opts: &Params, file: &File) -> bool {
+    match app_opts.get_minsize() {
+        Some(msize) => match file.size {
+            Some(fsize) => fsize >= msize,
+            None => true,
+        },
+        None => true,
+    }
+}

src/main.rs

@@ -3,6 +3,7 @@ mod file_manager;
 mod output;
 mod params;
 mod scanner;
+mod filters;
 
 use anyhow::Result;
 use app::App;

src/output.rs

@@ -5,7 +5,6 @@ use chrono::offset::Utc;
 use chrono::DateTime;
 use colored::Colorize;
 use dashmap::DashMap;
-use humansize::{format_size, DECIMAL};
 use itertools::Itertools;
 use prettytable::{format, row, Table};
 use std::io::Write;
@@ -30,10 +29,8 @@ fn format_path(path: &str, opts: &Params) -> Result<String> {
     Ok(format!("...{:<32}", display_range))
 }
 
-fn file_size(path: &String) -> Result<String> {
-    let mdata = fs::metadata(path)?;
-    let formatted_size = format!("{:>12}", format_size(mdata.len(), DECIMAL));
-    Ok(formatted_size)
+fn file_size(file: &File) -> Result<String> {
+    Ok(format!("{:>12}", bytesize::ByteSize::b(file.size.unwrap())))
 }
 
 fn modified_time(path: &String) -> Result<String> {
@@ -131,7 +128,7 @@ pub fn interactive(duplicates: DashMap<String, Vec<File>>, opts: &Params) {
                 itable.add_row(row![
                     index,
                     format_path(&file.path, opts).unwrap_or_default().blue(),
-                    file_size(&file.path).unwrap_or_default().red(),
+                    file_size(&file).unwrap_or_default().red(),
                     modified_time(&file.path).unwrap_or_default().yellow()
                 ]);
             });
@@ -151,7 +148,7 @@ pub fn print(duplicates: DashMap<String, Vec<File>>, opts: &Params) {
         group.iter().for_each(|file| {
             inner_table.add_row(row![
                 format_path(&file.path, opts).unwrap_or_default().blue(),
-                file_size(&file.path).unwrap_or_default().red(),
+                file_size(&file).unwrap_or_default().red(),
                 modified_time(&file.path).unwrap_or_default().yellow()
             ]);
         });

src/params.rs

@@ -14,9 +14,24 @@ pub struct Params {
     /// Delete files interactively
     #[arg(long, short)]
     pub interactive: bool,
+    /// Minimum filesize of duplicates to scan (e.g., 100B/1K/2M/3G/4T). [default = 0]
+    #[arg(long, short)]
+    pub minsize: Option<String>,
 }
 
 impl Params {
+    pub fn get_minsize(&self) -> Option<u64> {
+        match &self.minsize {
+            Some(msize) => {
+                match msize.parse::<bytesize::ByteSize>() {
+                    Ok(units) => Some(units.0),
+                    Err(_) => None
+                }
+            },
+            None => None
+        }
+    }
+
     pub fn get_directory(&self) -> Result<String> {
         let dir_pathbuf: PathBuf = self
             .dir

src/scanner.rs

@@ -1,3 +1,4 @@
+use crate::{file_manager::File, filters, params::Params};
 use anyhow::Result;
 use dashmap::DashMap;
 use fxhash::hash64 as hasher;
@@ -8,8 +9,6 @@ use rayon::prelude::*;
 use std::hash::Hasher;
 use std::{fs, path::PathBuf};
 
-use crate::{file_manager::File, params::Params};
-
 #[derive(Clone, Copy)]
 enum IndexCritera {
     Size,
@@ -58,17 +57,22 @@ fn scan(app_opts: &Params) -> Result<Vec<File>> {
                 })
                 .collect::<Vec<String>>()
         })
-        .map(|file_path| File { path: file_path.clone(), hash: None, size: Some(fs::metadata(file_path).unwrap().len()) })
+        .map(|file_path| File {
+            path: file_path.clone(),
+            hash: None,
+            size: Some(fs::metadata(file_path).unwrap().len()),
+        })
+        .filter(|file| filters::is_file_gt_minsize(app_opts, file))
         .collect();
 
     Ok(files)
 }
 
-fn process_file_hash_index(fpath: String) -> Result<File> {
+fn process_file_hash_index(file: &File) -> Result<File> {
     Ok(File {
-        path: fpath.clone(),
-        size: None,
-        hash: Some(hash_file(&fpath).unwrap_or_default()),
+        path: file.path.clone(),
+        size: file.size,
+        hash: Some(hash_file(&file.path).unwrap_or_default()),
     })
 }
 
@@ -85,7 +89,7 @@ fn process_file_index(
                 .or_insert_with(|| vec![file]);
         }
         IndexCritera::Hash => {
-            let processed_file = process_file_hash_index(file.path).unwrap();
+            let processed_file = process_file_hash_index(&file).unwrap();
             let indexhash = processed_file.clone().hash.unwrap_or_default();
 
             store