feat: handling piped stdin

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "grip-grab"
-version = "0.2.27"
+version = "0.2.28"
 edition = "2021"
 authors = ["Alexandre Pasmantier <[email protected]>"]
 license = "Apache-2.0"

src/main.rs

@@ -1,3 +1,5 @@
+use std::io::IsTerminal;
+use std::path::PathBuf;
 use std::sync::Arc;
 
 use clap::Parser;
@@ -6,7 +8,7 @@ use crossbeam::queue::SegQueue;
 use grep::regex::RegexMatcher;
 use ignore::DirEntry;
 use printer::PrinterConfig;
-use search::build_searcher;
+use search::{build_searcher, search_reader};
 
 use crate::cli::{process_cli_args, Cli};
 use crate::fs::walk_builder;
@@ -21,56 +23,84 @@ mod utils;
 
 pub fn main() -> anyhow::Result<()> {
     let cli_args = process_cli_args(Cli::parse())?;
-    let queue: Arc<SegQueue<FileResults>> = Arc::new(SegQueue::new());
 
-    let haystack_builder = walk_builder(
-        cli_args.paths.iter().map(|p| p.as_path()).collect(),
-        &cli_args.ignored_paths,
-        cli_args.n_threads,
-        !cli_args.disregard_gitignore,
-        cli_args.filter_filetypes,
-    );
-    let matcher: Arc<RegexMatcher> = Arc::new(build_matcher(&cli_args.patterns)?);
-    haystack_builder.build_parallel().run(|| {
-        let matcher = Arc::clone(&matcher);
+    let stdin = std::io::stdin();
+    if !stdin.is_terminal() {
+        let matcher = build_matcher(&cli_args.patterns)?;
         let mut searcher = build_searcher(cli_args.multiline);
-        let queue = Arc::clone(&queue);
-        Box::new(move |entry: Result<DirEntry, ignore::Error>| match entry {
-            Ok(entry) => {
-                let file_type = entry.file_type().unwrap();
-                if !file_type.is_dir() {
-                    let path = entry.path().to_path_buf();
-                    match search_file(path, &matcher, &mut searcher) {
-                        Ok(file_results) => {
-                            if !file_results.is_empty() {
-                                queue.push(file_results);
-                            }
-                        }
-                        Err(_err) => (),
-                    }
-                }
-                ignore::WalkState::Continue
+        match search_reader(stdin.lock(), &matcher, &mut searcher) {
+            Ok(search_results) => {
+                let printer_config = PrinterConfig {
+                    mode: cli_args.print_mode,
+                    absolute_paths: cli_args.absolute_paths,
+                    colored_output: cli_args.colored_output,
+                    disable_hyperlinks: cli_args.disable_hyperlinks,
+                    ..Default::default()
+                };
+                let mut printer = Printer::new(printer_config);
+                printer.write(FileResults {
+                    path: PathBuf::from("stdin"),
+                    results: search_results,
+                })?;
+                printer.print()?;
             }
             Err(err) => {
                 eprintln!("Error: {}", err);
-                ignore::WalkState::Continue
             }
-        })
-    });
+        }
+        Ok(())
+    } else {
+        let queue: Arc<SegQueue<FileResults>> = Arc::new(SegQueue::new());
+
+        let haystack_builder = walk_builder(
+            cli_args.paths.iter().map(|p| p.as_path()).collect(),
+            &cli_args.ignored_paths,
+            cli_args.n_threads,
+            !cli_args.disregard_gitignore,
+            cli_args.filter_filetypes,
+        );
+        let matcher: Arc<RegexMatcher> = Arc::new(build_matcher(&cli_args.patterns)?);
+        haystack_builder.build_parallel().run(|| {
+            let matcher = Arc::clone(&matcher);
+            let mut searcher = build_searcher(cli_args.multiline);
+            let queue = Arc::clone(&queue);
+            Box::new(move |entry: Result<DirEntry, ignore::Error>| match entry {
+                Ok(entry) => {
+                    let file_type = entry.file_type().unwrap();
+                    if !file_type.is_dir() {
+                        let path = entry.path().to_path_buf();
+                        match search_file(path, &matcher, &mut searcher) {
+                            Ok(file_results) => {
+                                if !file_results.is_empty() {
+                                    queue.push(file_results);
+                                }
+                            }
+                            Err(_err) => (),
+                        }
+                    }
+                    ignore::WalkState::Continue
+                }
+                Err(err) => {
+                    eprintln!("Error: {}", err);
+                    ignore::WalkState::Continue
+                }
+            })
+        });
 
-    let printer_config = PrinterConfig {
-        mode: cli_args.print_mode,
-        absolute_paths: cli_args.absolute_paths,
-        colored_output: cli_args.colored_output,
-        disable_hyperlinks: cli_args.disable_hyperlinks,
-        ..Default::default()
-    };
-    let mut printer = Printer::new(printer_config);
-    let printer_queue = Arc::into_inner(queue).unwrap();
-    printer_queue
-        .into_iter()
-        .for_each(|file_results| printer.write(file_results).unwrap());
+        let printer_config = PrinterConfig {
+            mode: cli_args.print_mode,
+            absolute_paths: cli_args.absolute_paths,
+            colored_output: cli_args.colored_output,
+            disable_hyperlinks: cli_args.disable_hyperlinks,
+            ..Default::default()
+        };
+        let mut printer = Printer::new(printer_config);
+        let printer_queue = Arc::into_inner(queue).unwrap();
+        printer_queue
+            .into_iter()
+            .for_each(|file_results| printer.write(file_results).unwrap());
 
-    printer.print()?;
-    Ok(())
+        printer.print()?;
+        Ok(())
+    }
 }

src/search.rs

@@ -236,6 +236,36 @@ pub fn search_file<'a>(
     Ok(FileResults { path, results })
 }
 
+pub fn search_reader(
+    reader: impl std::io::BufRead,
+    matcher: &RegexMatcher,
+    searcher: &mut Searcher,
+) -> anyhow::Result<Vec<SearchResult>> {
+    let mut results = Vec::new();
+    let mut line_number = 0;
+    searcher.search_reader(
+        matcher,
+        reader,
+        UTF8(|lnum, line| {
+            line_number = lnum;
+            let mut matches = Vec::new();
+            matcher.find_iter(line.as_bytes(), |m| {
+                matches.push(MatchRange::from_match(m));
+                true
+            })?;
+            results.push(SearchResult {
+                line_number: lnum,
+                line: line.to_string(),
+                line_start: lnum,
+                line_end: lnum,
+                matches,
+            });
+            Ok(true)
+        }),
+    )?;
+    Ok(results)
+}
+
 pub fn build_matcher(patterns: &Vec<String>) -> anyhow::Result<RegexMatcher> {
     let builder = RegexMatcherBuilder::new();
     Ok(builder.build_many(patterns)?)