is a command line search tool ("rg") that tries to combine the usability of "ag" (an "ack" clone) with the raw speed of GNU "grep" (written in "Rust").
| main.rs (ripgrep-12.1.1) | : | main.rs (ripgrep-13.0.0) |
|---|
| | |
| skipping to change at line 86 | | skipping to change at line 86 |
|---|
| /// The top-level entry point for single-threaded search. This recursively | | /// The top-level entry point for single-threaded search. This recursively |
| /// steps through the file list (current directory by default) and searches | | /// steps through the file list (current directory by default) and searches |
| /// each file sequentially. | | /// each file sequentially. |
| fn search(args: &Args) -> Result<bool> { | | fn search(args: &Args) -> Result<bool> { |
| let started_at = Instant::now(); | | let started_at = Instant::now(); |
| let quit_after_match = args.quit_after_match()?; | | let quit_after_match = args.quit_after_match()?; |
| let subject_builder = args.subject_builder(); | | let subject_builder = args.subject_builder(); |
| let mut stats = args.stats()?; | | let mut stats = args.stats()?; |
| let mut searcher = args.search_worker(args.stdout())?; | | let mut searcher = args.search_worker(args.stdout())?; |
| let mut matched = false; | | let mut matched = false; |
|
| | let mut searched = false; |
| | |
| for result in args.walker()? { | | for result in args.walker()? { |
| let subject = match subject_builder.build_from_result(result) { | | let subject = match subject_builder.build_from_result(result) { |
| Some(subject) => subject, | | Some(subject) => subject, |
| None => continue, | | None => continue, |
| }; | | }; |
|
| | searched = true; |
| let search_result = match searcher.search(&subject) { | | let search_result = match searcher.search(&subject) { |
| Ok(search_result) => search_result, | | Ok(search_result) => search_result, |
| Err(err) => { | | Err(err) => { |
| // A broken pipe means graceful termination. | | // A broken pipe means graceful termination. |
| if err.kind() == io::ErrorKind::BrokenPipe { | | if err.kind() == io::ErrorKind::BrokenPipe { |
| break; | | break; |
| } | | } |
| err_message!("{}: {}", subject.path().display(), err); | | err_message!("{}: {}", subject.path().display(), err); |
| continue; | | continue; |
| } | | } |
| }; | | }; |
| matched = matched || search_result.has_match(); | | matched = matched || search_result.has_match(); |
| if let Some(ref mut stats) = stats { | | if let Some(ref mut stats) = stats { |
| *stats += search_result.stats().unwrap(); | | *stats += search_result.stats().unwrap(); |
| } | | } |
| if matched && quit_after_match { | | if matched && quit_after_match { |
| break; | | break; |
| } | | } |
| } | | } |
|
| | if args.using_default_path() && !searched { |
| | eprint_nothing_searched(); |
| | } |
| if let Some(ref stats) = stats { | | if let Some(ref stats) = stats { |
| let elapsed = Instant::now().duration_since(started_at); | | let elapsed = Instant::now().duration_since(started_at); |
| // We don't care if we couldn't print this successfully. | | // We don't care if we couldn't print this successfully. |
| let _ = searcher.print_stats(elapsed, stats); | | let _ = searcher.print_stats(elapsed, stats); |
| } | | } |
| Ok(matched) | | Ok(matched) |
| } | | } |
| | |
| /// The top-level entry point for multi-threaded search. The parallelism is | | /// The top-level entry point for multi-threaded search. The parallelism is |
| /// itself achieved by the recursive directory traversal. All we need to do is | | /// itself achieved by the recursive directory traversal. All we need to do is |
| | |
| skipping to change at line 132 | | skipping to change at line 137 |
|---|
| fn search_parallel(args: &Args) -> Result<bool> { | | fn search_parallel(args: &Args) -> Result<bool> { |
| use std::sync::atomic::AtomicBool; | | use std::sync::atomic::AtomicBool; |
| use std::sync::atomic::Ordering::SeqCst; | | use std::sync::atomic::Ordering::SeqCst; |
| | |
| let quit_after_match = args.quit_after_match()?; | | let quit_after_match = args.quit_after_match()?; |
| let started_at = Instant::now(); | | let started_at = Instant::now(); |
| let subject_builder = args.subject_builder(); | | let subject_builder = args.subject_builder(); |
| let bufwtr = args.buffer_writer()?; | | let bufwtr = args.buffer_writer()?; |
| let stats = args.stats()?.map(Mutex::new); | | let stats = args.stats()?.map(Mutex::new); |
| let matched = AtomicBool::new(false); | | let matched = AtomicBool::new(false); |
|
| | let searched = AtomicBool::new(false); |
| let mut searcher_err = None; | | let mut searcher_err = None; |
| args.walker_parallel()?.run(|| { | | args.walker_parallel()?.run(|| { |
| let bufwtr = &bufwtr; | | let bufwtr = &bufwtr; |
| let stats = &stats; | | let stats = &stats; |
| let matched = &matched; | | let matched = &matched; |
|
| | let searched = &searched; |
| let subject_builder = &subject_builder; | | let subject_builder = &subject_builder; |
| let mut searcher = match args.search_worker(bufwtr.buffer()) { | | let mut searcher = match args.search_worker(bufwtr.buffer()) { |
| Ok(searcher) => searcher, | | Ok(searcher) => searcher, |
| Err(err) => { | | Err(err) => { |
| searcher_err = Some(err); | | searcher_err = Some(err); |
| return Box::new(move |_| WalkState::Quit); | | return Box::new(move |_| WalkState::Quit); |
| } | | } |
| }; | | }; |
| | |
| Box::new(move |result| { | | Box::new(move |result| { |
| let subject = match subject_builder.build_from_result(result) { | | let subject = match subject_builder.build_from_result(result) { |
| Some(subject) => subject, | | Some(subject) => subject, |
| None => return WalkState::Continue, | | None => return WalkState::Continue, |
| }; | | }; |
|
| | searched.store(true, SeqCst); |
| searcher.printer().get_mut().clear(); | | searcher.printer().get_mut().clear(); |
| let search_result = match searcher.search(&subject) { | | let search_result = match searcher.search(&subject) { |
| Ok(search_result) => search_result, | | Ok(search_result) => search_result, |
| Err(err) => { | | Err(err) => { |
| err_message!("{}: {}", subject.path().display(), err); | | err_message!("{}: {}", subject.path().display(), err); |
| return WalkState::Continue; | | return WalkState::Continue; |
| } | | } |
| }; | | }; |
| if search_result.has_match() { | | if search_result.has_match() { |
| matched.store(true, SeqCst); | | matched.store(true, SeqCst); |
| | |
| skipping to change at line 184 | | skipping to change at line 192 |
|---|
| if matched.load(SeqCst) && quit_after_match { | | if matched.load(SeqCst) && quit_after_match { |
| WalkState::Quit | | WalkState::Quit |
| } else { | | } else { |
| WalkState::Continue | | WalkState::Continue |
| } | | } |
| }) | | }) |
| }); | | }); |
| if let Some(err) = searcher_err.take() { | | if let Some(err) = searcher_err.take() { |
| return Err(err); | | return Err(err); |
| } | | } |
|
| | if args.using_default_path() && !searched.load(SeqCst) { |
| | eprint_nothing_searched(); |
| | } |
| if let Some(ref locked_stats) = stats { | | if let Some(ref locked_stats) = stats { |
| let elapsed = Instant::now().duration_since(started_at); | | let elapsed = Instant::now().duration_since(started_at); |
| let stats = locked_stats.lock().unwrap(); | | let stats = locked_stats.lock().unwrap(); |
| let mut searcher = args.search_worker(args.stdout())?; | | let mut searcher = args.search_worker(args.stdout())?; |
| // We don't care if we couldn't print this successfully. | | // We don't care if we couldn't print this successfully. |
| let _ = searcher.print_stats(elapsed, &stats); | | let _ = searcher.print_stats(elapsed, &stats); |
| } | | } |
| Ok(matched.load(SeqCst)) | | Ok(matched.load(SeqCst)) |
| } | | } |
| | |
|
| | fn eprint_nothing_searched() { |
| | err_message!( |
| | "No files were searched, which means ripgrep probably \ |
| | applied a filter you didn't expect.\n\ |
| | Running with --debug will show why files are being skipped." |
| | ); |
| | } |
| | |
| /// The top-level entry point for listing files without searching them. This | | /// The top-level entry point for listing files without searching them. This |
| /// recursively steps through the file list (current directory by default) and | | /// recursively steps through the file list (current directory by default) and |
| /// prints each path sequentially using a single thread. | | /// prints each path sequentially using a single thread. |
| fn files(args: &Args) -> Result<bool> { | | fn files(args: &Args) -> Result<bool> { |
| let quit_after_match = args.quit_after_match()?; | | let quit_after_match = args.quit_after_match()?; |
| let subject_builder = args.subject_builder(); | | let subject_builder = args.subject_builder(); |
| let mut matched = false; | | let mut matched = false; |
| let mut path_printer = args.path_printer(args.stdout())?; | | let mut path_printer = args.path_printer(args.stdout())?; |
| for result in args.walker()? { | | for result in args.walker()? { |
| let subject = match subject_builder.build_from_result(result) { | | let subject = match subject_builder.build_from_result(result) { |
| | | |
| End of changes. 8 change blocks. |
|---|
| 0 lines changed or deleted | | 19 lines changed or added |
|---|
"Fossies" - the Fresh Open Source Software Archive 