Feature: Add min-size parameter

Add often requested feature. '--min-size 50000' will only include files
above a size of 50kB

src/cli.rs

@@ -64,6 +64,14 @@ pub fn build_cli() -> Command<'static> {
                 .long("no-percent-bars")
                 .help("No percent bars or percentages will be displayed"),
         )
+        .arg(
+            Arg::new("min_size")
+                .short('z')
+                .long("min-size")
+                .takes_value(true)
+                .number_of_values(1)
+                .help("Minimum size file to include in output"),
+        )
         .arg(
             Arg::new("skip_total")
                 .long("skip-total")

src/config.rs

@@ -4,6 +4,8 @@ use serde::Deserialize;
 use std::path::Path;
 use std::path::PathBuf;
 
+use crate::display::UNITS;
+
 #[derive(Deserialize, Default)]
 #[serde(rename_all = "kebab-case")]
 #[serde(deny_unknown_fields)]
@@ -16,6 +18,7 @@ pub struct Config {
     pub skip_total: Option<bool>,
     pub ignore_hidden: Option<bool>,
     pub iso: Option<bool>,
+    pub min_size: Option<String>,
 }
 
 impl Config {
@@ -43,6 +46,46 @@ impl Config {
     pub fn get_skip_total(&self, options: &ArgMatches) -> bool {
         Some(true) == self.skip_total || options.is_present("skip_total")
     }
+    pub fn get_min_size(&self, options: &ArgMatches, iso: bool) -> Option<usize> {
+        let size_from_param = options.value_of("min_size");
+        self._get_min_size(size_from_param, iso)
+    }
+    fn _get_min_size(&self, min_size: Option<&str>, iso: bool) -> Option<usize> {
+        let size_from_param = min_size.and_then(|a| convert_min_size(a, iso));
+
+        if size_from_param.is_none() {
+            self.min_size
+                .as_ref()
+                .and_then(|a| convert_min_size(a.as_ref(), iso))
+        } else {
+            size_from_param
+        }
+    }
+}
+
+fn convert_min_size(input: &str, iso: bool) -> Option<usize> {
+    let chars_as_vec: Vec<char> = input.chars().collect();
+    match chars_as_vec.split_last() {
+        Some((last, start)) => {
+            let mut starts: String = start.iter().collect::<String>();
+
+            for (i, u) in UNITS.iter().enumerate() {
+                if Some(*u) == last.to_uppercase().next() {
+                    return match starts.parse::<usize>() {
+                        Ok(pure) => {
+                            let num: usize = if iso { 1000 } else { 1024 };
+                            let marker = pure * num.pow((UNITS.len() - i) as u32);
+                            Some(marker)
+                        }
+                        Err(_) => None,
+                    };
+                }
+            }
+            starts.push(*last);
+            starts.parse().ok()
+        }
+        None => None,
+    }
 }
 
 fn get_config_locations(base: &Path) -> Vec<PathBuf> {
@@ -66,3 +109,33 @@ pub fn get_config() -> Config {
         ..Default::default()
     }
 }
+
+mod tests {
+    #[allow(unused_imports)]
+    use super::*;
+
+    #[test]
+    fn test_conversion() {
+        assert_eq!(convert_min_size("55", false), Some(55));
+        assert_eq!(convert_min_size("12344321", false), Some(12344321));
+        assert_eq!(convert_min_size("95RUBBISH", false), None);
+        assert_eq!(convert_min_size("10K", false), Some(10 * 1024));
+        assert_eq!(convert_min_size("10M", false), Some(10 * 1024usize.pow(2)));
+        assert_eq!(convert_min_size("10M", true), Some(10 * 1000usize.pow(2)));
+        assert_eq!(convert_min_size("2G", false), Some(2 * 1024usize.pow(3)));
+    }
+
+    #[test]
+    fn test_config_min_size() {
+        let c = Config {
+            min_size: Some("1K".to_owned()),
+            ..Default::default()
+        };
+        assert_eq!(c._get_min_size(None, false), Some(1024));
+        assert_eq!(c._get_min_size(Some("100"), false), Some(100));
+        assert_eq!(c._get_min_size(Some("2K"), false), Some(2048));
+
+        assert_eq!(c._get_min_size(None, true), Some(1000));
+        assert_eq!(c._get_min_size(Some("2K"), true), Some(2000));
+    }
+}

src/display.rs

@@ -14,7 +14,7 @@ use std::iter::repeat;
 use std::path::Path;
 use thousands::Separable;
 
-static UNITS: [char; 4] = ['T', 'G', 'M', 'K'];
+pub static UNITS: [char; 4] = ['T', 'G', 'M', 'K'];
 static BLOCKS: [char; 5] = ['█', '▓', '▒', '░', ' '];
 
 pub struct DisplayData {

src/filter.rs

@@ -7,6 +7,7 @@ use std::path::PathBuf;
 
 pub fn get_biggest(
     top_level_nodes: Vec<Node>,
+    min_size: Option<usize>,
     n: usize,
     depth: usize,
     using_a_filter: bool,
@@ -22,14 +23,14 @@ pub fn get_biggest(
     let mut allowed_nodes = HashSet::new();
 
     allowed_nodes.insert(root.name.as_path());
-    heap = add_children(using_a_filter, &root, depth, heap);
+    heap = add_children(using_a_filter, min_size, &root, depth, heap);
 
     for _ in number_top_level_nodes..n {
         let line = heap.pop();
         match line {
             Some(line) => {
                 allowed_nodes.insert(line.name.as_path());
-                heap = add_children(using_a_filter, line, depth, heap);
+                heap = add_children(using_a_filter, min_size, line, depth, heap);
             }
             None => break,
         }
@@ -39,17 +40,16 @@ pub fn get_biggest(
 
 fn add_children<'a>(
     using_a_filter: bool,
+    min_size: Option<usize>,
     file_or_folder: &'a Node,
     depth: usize,
     mut heap: BinaryHeap<&'a Node>,
 ) -> BinaryHeap<&'a Node> {
     if depth > file_or_folder.depth {
-        heap.extend(
-            file_or_folder
-                .children
-                .iter()
-                .filter(|c| !using_a_filter || c.name.is_file() || c.size > 0),
-        )
+        heap.extend(file_or_folder.children.iter().filter(|c| match min_size {
+            Some(ms) => c.size > ms as u64,
+            None => !using_a_filter || c.name.is_file() || c.size > 0,
+        }))
     }
     heap
 }

src/main.rs

@@ -91,7 +91,6 @@ fn get_regex_value(maybe_value: Option<Values>) -> Vec<Regex> {
 
 fn main() {
     let options = build_cli().get_matches();
-
     let config = get_config();
 
     let target_dirs = options
@@ -161,12 +160,14 @@ fn main() {
         .build_global()
         .unwrap();
 
+    let iso = config.get_iso(&options);
     let (top_level_nodes, has_errors) = walk_it(simplified_dirs, walk_data);
 
     let tree = match summarize_file_types {
         true => get_all_file_types(&top_level_nodes, number_of_lines),
         false => get_biggest(
             top_level_nodes,
+            config.get_min_size(&options, iso),
             number_of_lines,
             depth,
             options.values_of("filter").is_some() || options.value_of("invert_filter").is_some(),
@@ -185,7 +186,7 @@ fn main() {
             terminal_width,
             by_filecount,
             &root_node,
-            config.get_iso(&options),
+            iso,
             config.get_skip_total(&options),
         )
     }