dependency: upgrade to clap 4

src/main.rs

@@ -11,6 +11,7 @@ mod progress;
 mod utils;
 
 use crate::cli::build_cli;
+use clap::parser::ValuesRef;
 use dir_walker::WalkData;
 use display::InitialDisplayData;
 use filter::AggregateData;
@@ -22,7 +23,6 @@ use std::process;
 use sysinfo::{System, SystemExt};
 
 use self::display::draw_it;
-use clap::Values;
 use config::get_config;
 use dir_walker::walk_it;
 use filter::get_biggest;
@@ -86,7 +86,7 @@ fn get_width_of_terminal() -> usize {
         .unwrap_or(DEFAULT_TERMINAL_WIDTH)
 }
 
-fn get_regex_value(maybe_value: Option<Values>) -> Vec<Regex> {
+fn get_regex_value(maybe_value: Option<ValuesRef<String>>) -> Vec<Regex> {
     maybe_value
         .unwrap_or_default()
         .map(|reg| {
@@ -102,49 +102,50 @@ fn main() {
     let options = build_cli().get_matches();
     let config = get_config();
 
-    let target_dirs = match options.values_of("inputs") {
-        Some(values) => values.collect(),
+    let target_dirs = match options.get_many::<String>("params") {
+        Some(values) => values.map(|v| v.as_str()).collect::<Vec<&str>>(),
         None => vec!["."],
     };
 
-    let summarize_file_types = options.is_present("types");
+    let summarize_file_types = options.get_flag("types");
 
-    let filter_regexs = get_regex_value(options.values_of("filter"));
-    let invert_filter_regexs = get_regex_value(options.values_of("invert_filter"));
+    let filter_regexs = get_regex_value(options.get_many("filter"));
+    let invert_filter_regexs = get_regex_value(options.get_many("invert_filter"));
 
-    let terminal_width = options
-        .value_of_t("width")
-        .unwrap_or_else(|_| get_width_of_terminal());
+    let terminal_width: usize = match options.get_one::<usize>("width") {
+        Some(&val) => val,
+        None => get_width_of_terminal(),
+    };
 
     let depth = config.get_depth(&options);
 
     // If depth is set, then we set the default number_of_lines to be max
     // instead of screen height
-    let default_height = if depth != usize::MAX {
-        usize::MAX
-    } else {
-        get_height_of_terminal()
-    };
 
-    let number_of_lines = options
-        .value_of("number_of_lines")
-        .and_then(|v| {
-            v.parse()
-                .map_err(|_| eprintln!("Ignoring bad value for number_of_lines"))
-                .ok()
-        })
-        .unwrap_or(default_height);
+    let number_of_lines = match options.get_one::<usize>("number_of_lines") {
+        Some(&val) => val,
+        None => {
+            if depth != usize::MAX {
+                usize::MAX
+            } else {
+                get_height_of_terminal()
+            }
+        }
+    };
 
     let no_colors = init_color(config.get_no_colors(&options));
 
-    let ignore_directories = options
-        .values_of("ignore_directory")
-        .unwrap_or_default()
-        .map(PathBuf::from);
+    let ignore_directories = match options.get_many::<String>("ignore_directory") {
+        Some(values) => values
+            .map(|v| v.as_str())
+            .map(PathBuf::from)
+            .collect::<Vec<PathBuf>>(),
+        None => vec![],
+    };
 
-    let by_filecount = options.is_present("by_filecount");
-    let limit_filesystem = options.is_present("limit_filesystem");
-    let follow_links = options.is_present("dereference_links");
+    let by_filecount = options.get_flag("by_filecount");
+    let limit_filesystem = options.get_flag("limit_filesystem");
+    let follow_links = options.get_flag("dereference_links");
 
     let simplified_dirs = simplify_dir_names(target_dirs);
     let allowed_filesystems = limit_filesystem
@@ -152,6 +153,7 @@ fn main() {
         .unwrap_or_default();
 
     let ignored_full_path: HashSet<PathBuf> = ignore_directories
+        .into_iter()
         .flat_map(|x| simplified_dirs.iter().map(move |d| d.join(&x)))
         .collect();
 
@@ -192,8 +194,7 @@ fn main() {
                 only_file: config.get_only_file(&options),
                 number_of_lines,
                 depth,
-                using_a_filter: options.values_of("filter").is_some()
-                    || options.value_of("invert_filter").is_some(),
+                using_a_filter: !filter_regexs.is_empty() || !invert_filter_regexs.is_empty(),
             };
             get_biggest(top_level_nodes, agg_data)
         }