feat: Add flag to read from file/stdin (#405)

* from standard

* improve

* happy clippy

* explicit arg option

* fix problem

src/cli.rs

@@ -286,4 +286,12 @@ pub fn build_cli() -> Command {
             .value_parser(value_parser!(String))
             .help("just like -mtime, but based on file change time")
         )
+        .arg(
+            Arg::new("files0_from")
+                .long("files0-from")
+                .value_hint(clap::ValueHint::AnyPath)
+                .value_parser(value_parser!(String))
+                .num_args(1)
+                .help("run dust on NUL-terminated file names specified in file; if argument is -, then read names from standard input"),
+        )
 }

src/config.rs

@@ -36,9 +36,17 @@ pub struct Config {
     pub threads: Option<usize>,
     pub output_json: Option<bool>,
     pub print_errors: Option<bool>,
+    pub files0_from: Option<String>,
 }
 
 impl Config {
+    pub fn get_files_from(&self, options: &ArgMatches) -> Option<String> {
+        let from_file = options.get_one::<String>("files0_from");
+        match from_file {
+            None => self.files0_from.as_ref().map(|x| x.to_string()),
+            Some(x) => Some(x.to_string()),
+        }
+    }
     pub fn get_no_colors(&self, options: &ArgMatches) -> bool {
         Some(true) == self.no_colors || options.get_flag("no_colors")
     }

src/main.rs

@@ -21,8 +21,11 @@ use regex::Error;
 use std::collections::HashSet;
 use std::env;
 use std::fs::read_to_string;
+use std::io;
 use std::panic;
 use std::process;
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::sync::Mutex;
 use sysinfo::{System, SystemExt};
@@ -119,17 +122,49 @@ fn main() {
     let error_listen_for_ctrlc = Arc::new(Mutex::new(errors));
     let errors_for_rayon = error_listen_for_ctrlc.clone();
     let errors_final = error_listen_for_ctrlc.clone();
+    let is_in_listing = Arc::new(AtomicBool::new(false));
+    let cloned_is_in_listing = Arc::clone(&is_in_listing);
 
     ctrlc::set_handler(move || {
         error_listen_for_ctrlc.lock().unwrap().abort = true;
         println!("\nAborting");
+        if cloned_is_in_listing.load(Ordering::Relaxed) {
+            process::exit(1);
+        }
     })
     .expect("Error setting Ctrl-C handler");
 
-    let target_dirs = match options.get_many::<String>("params") {
-        Some(values) => values.map(|v| v.as_str()).collect::<Vec<&str>>(),
-        None => vec!["."],
+    is_in_listing.store(true, Ordering::Relaxed);
+    let target_dirs = match config.get_files_from(&options) {
+        Some(path) => {
+            if path == "-" {
+                let mut targets_to_add = io::stdin()
+                    .lines()
+                    .map_while(Result::ok)
+                    .collect::<Vec<String>>();
+
+                if targets_to_add.is_empty() {
+                    eprintln!("No input provided, defaulting to current directory");
+                    targets_to_add.push(".".to_owned());
+                }
+                targets_to_add
+            } else {
+                // read file
+                match read_to_string(path) {
+                    Ok(file_content) => file_content.lines().map(|x| x.to_string()).collect(),
+                    Err(e) => {
+                        eprintln!("Error reading file: {e}");
+                        vec![".".to_owned()]
+                    }
+                }
+            }
+        }
+        None => match options.get_many::<String>("params") {
+            Some(values) => values.cloned().collect(),
+            None => vec![".".to_owned()],
+        },
     };
+    is_in_listing.store(false, Ordering::Relaxed);
 
     let summarize_file_types = options.get_flag("types");