From 03eac2be4aa0fe7b8bc4872a91111585b8be5734 Mon Sep 17 00:00:00 2001
From: Parth Jadhav <jadhavparth99@gmail.com>
Date: Mon, 2 Mar 2026 01:58:48 +0530
Subject: [PATCH 1/9] perf: add fast extension-only matcher and improve
 benchmark harness
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Skip regex entirely when only file extension is specified (no search
  input, not strict, not ignore_case) — uses direct OsStr comparison
- Replace path.display().to_string() with to_string_lossy().into_owned()
  for cheaper path conversion
- Improve benchmark harness with warmup iterations, median timing, and
  an "all" mode for running all benchmarks together
- Add dirs as dev-dependency for benchmarks
---
 Cargo.toml              |   9 ++-
 benches/bench_search.rs | 131 ++++++++++++++++++++++++++++++++++++++++
 src/search.rs           |  63 ++++++++++++++-----
 3 files changed, 187 insertions(+), 16 deletions(-)
 create mode 100644 benches/bench_search.rs

diff --git a/Cargo.toml b/Cargo.toml
index 023d3b8..34abc09 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -17,4 +17,11 @@ regex = "1"
 ignore = "0.4"
 num_cpus = "1.0"
 dirs = "4.0.0"
-strsim = "0.10.0"
\ No newline at end of file
+strsim = "0.10.0"
+
+[dev-dependencies]
+dirs = "4.0.0"
+
+[[bench]]
+name = "bench_search"
+harness = false
\ No newline at end of file
diff --git a/benches/bench_search.rs b/benches/bench_search.rs
new file mode 100644
index 0000000..1f78b9f
--- /dev/null
+++ b/benches/bench_search.rs
@@ -0,0 +1,131 @@
+use rust_search::{similarity_sort, SearchBuilder};
+use std::time::{Duration, Instant};
+
+const WARMUP_ITERS: usize = 1;
+const BENCH_ITERS: usize = 5;
+
+fn median(times: &mut [Duration]) -> Duration {
+    times.sort();
+    times[times.len() / 2]
+}
+
+fn bench_search() -> (usize, Duration) {
+    let home = dirs::home_dir().unwrap();
+
+    // Warmup
+    for _ in 0..WARMUP_ITERS {
+        let _: Vec<String> = SearchBuilder::default()
+            .location(&home)
+            .ext("rs")
+            .build()
+            .collect();
+    }
+
+    let mut times = Vec::with_capacity(BENCH_ITERS);
+    let mut count = 0;
+    for _ in 0..BENCH_ITERS {
+        let start = Instant::now();
+        let results: Vec<String> = SearchBuilder::default()
+            .location(&home)
+            .ext("rs")
+            .build()
+            .collect();
+        times.push(start.elapsed());
+        count = results.len();
+    }
+
+    (count, median(&mut times))
+}
+
+fn bench_search_with_limit() -> (usize, Duration) {
+    let home = dirs::home_dir().unwrap();
+
+    // Warmup
+    for _ in 0..WARMUP_ITERS {
+        let _: Vec<String> = SearchBuilder::default()
+            .location(&home)
+            .ext("rs")
+            .limit(100)
+            .build()
+            .collect();
+    }
+
+    let mut times = Vec::with_capacity(BENCH_ITERS);
+    let mut count = 0;
+    for _ in 0..BENCH_ITERS {
+        let start = Instant::now();
+        let results: Vec<String> = SearchBuilder::default()
+            .location(&home)
+            .ext("rs")
+            .limit(100)
+            .build()
+            .collect();
+        times.push(start.elapsed());
+        count = results.len();
+    }
+
+    (count, median(&mut times))
+}
+
+fn bench_similarity_sort() -> (usize, Duration) {
+    let home = dirs::home_dir().unwrap();
+
+    // Collect results once
+    let base_results: Vec<String> = SearchBuilder::default()
+        .location(&home)
+        .ext("rs")
+        .build()
+        .collect();
+    let count = base_results.len();
+
+    // Warmup
+    for _ in 0..WARMUP_ITERS {
+        let mut results = base_results.clone();
+        similarity_sort(&mut results, "main");
+    }
+
+    let mut times = Vec::with_capacity(BENCH_ITERS);
+    for _ in 0..BENCH_ITERS {
+        let mut results = base_results.clone();
+        let start = Instant::now();
+        similarity_sort(&mut results, "main");
+        times.push(start.elapsed());
+    }
+
+    (count, median(&mut times))
+}
+
+fn main() {
+    let arg = std::env::args().nth(1).unwrap_or_default();
+    match arg.as_str() {
+        "search" => {
+            let (count, median) = bench_search();
+            eprintln!("search: {} results, median {:?} ({} iters)", count, median, BENCH_ITERS);
+        }
+        "limit" => {
+            let (count, median) = bench_search_with_limit();
+            eprintln!("limit: {} results, median {:?} ({} iters)", count, median, BENCH_ITERS);
+        }
+        "sort" => {
+            let (count, median) = bench_similarity_sort();
+            eprintln!("sort: {} items, median {:?} ({} iters)", count, median, BENCH_ITERS);
+        }
+        "all" => {
+            eprintln!("=== Running all benchmarks ===\n");
+
+            let (count, median) = bench_search();
+            eprintln!("search: {} results, median {:?}", count, median);
+
+            let (count, median) = bench_search_with_limit();
+            eprintln!("limit:  {} results, median {:?}", count, median);
+
+            let (count, median) = bench_similarity_sort();
+            eprintln!("sort:   {} items, median {:?}", count, median);
+
+            eprintln!("\n=== Done ===");
+        }
+        _ => {
+            eprintln!("Usage: bench_search [search|limit|sort|all]");
+        }
+    }
+}
diff --git a/src/search.rs b/src/search.rs
index 91d6ade..9d9b39e 100644
--- a/src/search.rs
+++ b/src/search.rs
@@ -1,5 +1,6 @@
 use std::{
     cmp,
+    ffi::OsStr,
     path::Path,
     sync::{
         atomic::{AtomicUsize, Ordering},
@@ -11,6 +12,12 @@ use std::{
 use crate::{filter::FilterType, utils, SearchBuilder};
 use ignore::{WalkBuilder, WalkState};
 
+/// Matcher strategy: either a fast extension-only check or a full regex.
+enum Matcher {
+    ExtOnly(String),
+    Regex(regex::Regex),
+}
+
 /// A struct that holds the receiver for the search results
 ///
 /// Can be iterated on to get the next element in the search results
@@ -82,8 +89,27 @@ impl Search {
         with_hidden: bool,
         filters: Vec<FilterType>,
     ) -> Self {
-        let regex_search_input =
-            utils::build_regex_search_input(search_input, file_ext, strict, ignore_case);
+        // Fast path: when only an extension is specified (no search_input, not strict,
+        // not ignore_case), skip regex entirely and use a simple extension check.
+        let matcher = if search_input.is_none() && !strict && !ignore_case {
+            if let Some(ext) = file_ext {
+                Matcher::ExtOnly(ext.to_owned())
+            } else {
+                Matcher::Regex(utils::build_regex_search_input(
+                    search_input,
+                    file_ext,
+                    strict,
+                    ignore_case,
+                ))
+            }
+        } else {
+            Matcher::Regex(utils::build_regex_search_input(
+                search_input,
+                file_ext,
+                strict,
+                ignore_case,
+            ))
+        };
 
         let mut walker = WalkBuilder::new(search_location);
 
@@ -104,30 +130,37 @@ impl Search {
         }
 
         let (tx, rx) = mpsc::channel::<String>();
-        let reg_exp = Arc::new(regex_search_input);
+        let matcher = Arc::new(matcher);
         let counter = Arc::new(AtomicUsize::new(0));
 
         walker.build_parallel().run(|| {
             let tx: Sender<String> = tx.clone();
-            let reg_exp = Arc::clone(&reg_exp);
+            let matcher = Arc::clone(&matcher);
             let counter = Arc::clone(&counter);
 
             Box::new(move |path_entry| {
                 if let Ok(entry) = path_entry {
                     let path = entry.path();
-                    if let Some(file_name) = path.file_name() {
-                        // Lossy means that if the file name is not valid UTF-8
-                        // it will be replaced with �.
-                        // Will return the file name with extension.
-                        let file_name = file_name.to_string_lossy();
-                        if reg_exp.is_match(&file_name) {
-                            if limit.is_none_or(|l| counter.fetch_add(1, Ordering::Relaxed) < l)
-                                && tx.send(path.display().to_string()).is_ok()
-                            {
-                                return WalkState::Continue;
+                    let matched = match matcher.as_ref() {
+                        Matcher::ExtOnly(ext) => {
+                            path.extension() == Some(OsStr::new(ext.as_str()))
+                        }
+                        Matcher::Regex(reg_exp) => {
+                            if let Some(file_name) = path.file_name() {
+                                let file_name = file_name.to_string_lossy();
+                                reg_exp.is_match(&file_name)
+                            } else {
+                                false
                             }
-                            return WalkState::Quit;
                         }
+                    };
+                    if matched {
+                        if limit.is_none_or(|l| counter.fetch_add(1, Ordering::Relaxed) < l)
+                            && tx.send(path.to_string_lossy().into_owned()).is_ok()
+                        {
+                            return WalkState::Continue;
+                        }
+                        return WalkState::Quit;
                     }
                 }
                 WalkState::Continue

From 249f4aa20b2971b8e4bc9525fea13e3044354759 Mon Sep 17 00:00:00 2001
From: Parth Jadhav <jadhavparth99@gmail.com>
Date: Mon, 2 Mar 2026 02:03:31 +0530
Subject: [PATCH 2/9] perf: use crossbeam-channel, type pre-filter, and 2x
 thread count

- Replace std::sync::mpsc with crossbeam-channel for faster multi-producer
  single-consumer communication
- Pre-filter files by extension using ignore crate's TypesBuilder, reducing
  callback invocations for non-matching files
- Increase thread count to 2x CPU cores for better I/O overlap during
  directory traversal
- Skip filter_entry closure when no filters are configured
- Add controlled benchmark suite with 10,000-file test directory for
  reliable matching-path measurement
---
 Cargo.toml              |   3 +-
 benches/bench_search.rs | 127 +++++++++++++++++++++++++++++++++++++++-
 src/search.rs           |  36 +++++++++---
 3 files changed, 154 insertions(+), 12 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 34abc09..f215a09 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,10 +18,11 @@ ignore = "0.4"
 num_cpus = "1.0"
 dirs = "4.0.0"
 strsim = "0.10.0"
+crossbeam-channel = "0.5.15"
 
 [dev-dependencies]
 dirs = "4.0.0"
 
 [[bench]]
 name = "bench_search"
-harness = false
\ No newline at end of file
+harness = false
diff --git a/benches/bench_search.rs b/benches/bench_search.rs
index 1f78b9f..16a68bc 100644
--- a/benches/bench_search.rs
+++ b/benches/bench_search.rs
@@ -1,4 +1,7 @@
 use rust_search::{similarity_sort, SearchBuilder};
+use std::fs;
+use std::io::Write;
+use std::path::{Path, PathBuf};
 use std::time::{Duration, Instant};
 
 const WARMUP_ITERS: usize = 1;
@@ -9,6 +12,30 @@ fn median(times: &mut [Duration]) -> Duration {
     times[times.len() / 2]
 }
 
+/// Create a controlled test directory with many files for benchmarking.
+/// Returns the path to the temp dir (caller should clean up).
+fn create_test_dir(num_dirs: usize, files_per_dir: usize) -> PathBuf {
+    let dir = std::env::temp_dir().join("rust_search_bench");
+    let _ = fs::remove_dir_all(&dir);
+    fs::create_dir_all(&dir).unwrap();
+
+    let extensions = ["rs", "txt", "md", "json", "toml", "yaml", "py", "js", "ts", "css"];
+
+    for d in 0..num_dirs {
+        let subdir = dir.join(format!("dir_{d:04}"));
+        fs::create_dir_all(&subdir).unwrap();
+        for f in 0..files_per_dir {
+            let ext = extensions[f % extensions.len()];
+            let filename = format!("file_{f:04}.{ext}");
+            let path = subdir.join(&filename);
+            let mut file = fs::File::create(&path).unwrap();
+            let _ = file.write_all(b"content");
+        }
+    }
+
+    dir
+}
+
 fn bench_search() -> (usize, Duration) {
     let home = dirs::home_dir().unwrap();
 
@@ -95,6 +122,85 @@ fn bench_similarity_sort() -> (usize, Duration) {
     (count, median(&mut times))
 }
 
+fn bench_controlled_search(dir: &Path) -> (usize, Duration) {
+    // Warmup
+    for _ in 0..WARMUP_ITERS {
+        let _: Vec<String> = SearchBuilder::default()
+            .location(dir)
+            .ext("rs")
+            .build()
+            .collect();
+    }
+
+    let mut times = Vec::with_capacity(BENCH_ITERS);
+    let mut count = 0;
+    for _ in 0..BENCH_ITERS {
+        let start = Instant::now();
+        let results: Vec<String> = SearchBuilder::default()
+            .location(dir)
+            .ext("rs")
+            .build()
+            .collect();
+        times.push(start.elapsed());
+        count = results.len();
+    }
+
+    (count, median(&mut times))
+}
+
+fn bench_controlled_search_with_input(dir: &Path) -> (usize, Duration) {
+    // Warmup
+    for _ in 0..WARMUP_ITERS {
+        let _: Vec<String> = SearchBuilder::default()
+            .location(dir)
+            .search_input("file_00")
+            .ext("rs")
+            .build()
+            .collect();
+    }
+
+    let mut times = Vec::with_capacity(BENCH_ITERS);
+    let mut count = 0;
+    for _ in 0..BENCH_ITERS {
+        let start = Instant::now();
+        let results: Vec<String> = SearchBuilder::default()
+            .location(dir)
+            .search_input("file_00")
+            .ext("rs")
+            .build()
+            .collect();
+        times.push(start.elapsed());
+        count = results.len();
+    }
+
+    (count, median(&mut times))
+}
+
+fn bench_controlled_similarity_sort(dir: &Path) -> (usize, Duration) {
+    let base_results: Vec<String> = SearchBuilder::default()
+        .location(dir)
+        .ext("rs")
+        .build()
+        .collect();
+    let count = base_results.len();
+
+    // Warmup
+    for _ in 0..WARMUP_ITERS {
+        let mut results = base_results.clone();
+        similarity_sort(&mut results, "file_0042");
+    }
+
+    let mut times = Vec::with_capacity(BENCH_ITERS);
+    for _ in 0..BENCH_ITERS {
+        let mut results = base_results.clone();
+        let start = Instant::now();
+        similarity_sort(&mut results, "file_0042");
+        times.push(start.elapsed());
+    }
+
+    (count, median(&mut times))
+}
+
 fn main() {
     let arg = std::env::args().nth(1).unwrap_or_default();
     match arg.as_str() {
@@ -114,13 +220,28 @@ fn main() {
             eprintln!("=== Running all benchmarks ===\n");
 
             let (count, median) = bench_search();
-            eprintln!("search: {} results, median {:?}", count, median);
+            eprintln!("search:       {} results, median {:?}", count, median);
 
             let (count, median) = bench_search_with_limit();
-            eprintln!("limit:  {} results, median {:?}", count, median);
+            eprintln!("limit:        {} results, median {:?}", count, median);
 
             let (count, median) = bench_similarity_sort();
-            eprintln!("sort:   {} items, median {:?}", count, median);
+            eprintln!("sort:         {} items, median {:?}", count, median);
+
+            // Controlled benchmarks (50 dirs x 200 files = 10,000 files)
+            eprintln!("\n--- Controlled (10,000 files) ---");
+            let dir = create_test_dir(50, 200);
+
+            let (count, median) = bench_controlled_search(&dir);
+            eprintln!("ctrl_search:  {} results, median {:?}", count, median);
+
+            let (count, median) = bench_controlled_search_with_input(&dir);
+            eprintln!("ctrl_input:   {} results, median {:?}", count, median);
+
+            let (count, median) = bench_controlled_similarity_sort(&dir);
+            eprintln!("ctrl_sort:    {} items, median {:?}", count, median);
+
+            let _ = fs::remove_dir_all(&dir);
 
             eprintln!("\n=== Done ===");
         }
diff --git a/src/search.rs b/src/search.rs
index 9d9b39e..c5bd1c2 100644
--- a/src/search.rs
+++ b/src/search.rs
@@ -4,12 +4,13 @@ use std::{
     path::Path,
     sync::{
         atomic::{AtomicUsize, Ordering},
-        mpsc::{self, Sender},
         Arc,
     },
 };
 
 use crate::{filter::FilterType, utils, SearchBuilder};
+use crossbeam_channel::Sender;
+use ignore::types::TypesBuilder;
 use ignore::{WalkBuilder, WalkState};
 
 /// Matcher strategy: either a fast extension-only check or a full regex.
@@ -113,15 +114,33 @@ impl Search {
 
         let mut walker = WalkBuilder::new(search_location);
 
+        // Use more threads than CPUs for I/O-bound work: while one thread
+        // waits for I/O, others can make progress.
+        let thread_count = cmp::max(8, num_cpus::get() * 2);
+
         walker
             .hidden(!with_hidden)
             .git_ignore(true)
             .max_depth(depth)
-            .threads(cmp::min(12, num_cpus::get()));
+            .threads(thread_count);
 
-        // filters getting applied to walker
-        // only if all filters are true then the walker will return the file
-        walker.filter_entry(move |dir| filters.iter().all(|f| f.apply(dir)));
+        // Pre-filter by extension using ignore's type system when possible.
+        // This avoids calling our callback for non-matching files.
+        if let Some(ext) = file_ext {
+            let mut types = TypesBuilder::new();
+            types.add_defaults();
+            if types.add("custom", &format!("*.{ext}")).is_ok() {
+                types.select("custom");
+                if let Ok(built) = types.build() {
+                    walker.types(built);
+                }
+            }
+        }
+
+        // Only apply filter_entry if there are filters to check
+        if !filters.is_empty() {
+            walker.filter_entry(move |dir| filters.iter().all(|f| f.apply(dir)));
+        }
 
         if let Some(locations) = more_locations {
             for location in locations {
@@ -129,7 +148,7 @@ impl Search {
             }
         }
 
-        let (tx, rx) = mpsc::channel::<String>();
+        let (tx, rx) = crossbeam_channel::unbounded::<String>();
         let matcher = Arc::new(matcher);
         let counter = Arc::new(AtomicUsize::new(0));
 
@@ -167,9 +186,10 @@ impl Search {
             })
         });
 
+        // Drop the sender so the receiver knows when all results have been sent
+        drop(tx);
+
         if let Some(limit) = limit {
-            // This will take the first `limit` elements from the iterator
-            // will return all if there are less than `limit` elements
             Self {
                 rx: Box::new(rx.into_iter().take(limit)),
             }

From c037ff2340b7fc1a980f3592f8060a0aa4535cec Mon Sep 17 00:00:00 2001
From: Parth Jadhav <jadhavparth99@gmail.com>
Date: Mon, 2 Mar 2026 02:04:30 +0530
Subject: [PATCH 3/9] perf: optimize similarity_sort with Schwartzian transform
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Use a precomputed-scores approach instead of recomputing file name
extraction, lowercasing, and Jaro-Winkler similarity on every comparison.

Before: O(n log n) comparisons each computing 2 scores = redundant work
After: O(n) score computations + O(n log n) float comparisons

Also:
- Return &str instead of String from file_name_from_path to avoid alloc
- Use sort_unstable_by for better cache locality on float comparisons
- Apply in-place permutation to reorder results without extra allocation

Benchmark results (1000 items): 1.313ms -> 155µs (8.4x faster)
---
 src/utils.rs | 37 ++++++++++++++++++++++++++++---------
 1 file changed, 28 insertions(+), 9 deletions(-)

diff --git a/src/utils.rs b/src/utils.rs
index 7a5fd20..f9d0892 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -44,12 +44,11 @@ pub fn replace_tilde_with_home_dir(path: impl AsRef<Path>) -> PathBuf {
     path.to_path_buf()
 }
 
-fn file_name_from_path(path: &str) -> String {
+fn file_name_from_path(path: &str) -> &str {
     Path::new(path)
         .file_name()
         .and_then(|f| f.to_str())
         .unwrap_or(path)
-        .to_string()
 }
 
 /// This function can be used to sort the given vector on basis of similarity between the input & the vector
@@ -82,13 +81,33 @@ fn file_name_from_path(path: &str) -> String {
 /// `["fly.txt", "flyer.txt", "afly.txt", "bfly.txt",]`
 pub fn similarity_sort(vector: &mut [String], input: &str) {
     let input = input.to_lowercase();
-    vector.sort_by(|a, b| {
-        let a = file_name_from_path(a).to_lowercase();
-        let b = file_name_from_path(b).to_lowercase();
-        let a = jaro_winkler(a.as_str(), input.as_str());
-        let b = jaro_winkler(b.as_str(), input.as_str());
-        b.partial_cmp(&a).unwrap_or(Ordering::Equal)
-    });
+    // Schwartzian transform: precompute all scores once, then sort by score.
+    // This avoids recomputing file_name extraction, lowercasing, and jaro_winkler
+    // on every comparison (O(n log n) comparisons become O(n) score computations).
+    let mut scored: Vec<(usize, f64)> = vector
+        .iter()
+        .enumerate()
+        .map(|(i, path)| {
+            let name = file_name_from_path(path).to_lowercase();
+            (i, jaro_winkler(&name, &input))
+        })
+        .collect();
+    scored.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(Ordering::Equal));
+
+    // Reorder vector in-place according to the sorted indices.
+    // Use a permutation cycle approach to avoid extra allocations.
+    let order: Vec<usize> = scored.into_iter().map(|(i, _)| i).collect();
+    apply_permutation(vector, order);
+}
+
+fn apply_permutation<T>(v: &mut [T], mut order: Vec<usize>) {
+    for i in 0..v.len() {
+        while order[i] != i {
+            let j = order[i];
+            v.swap(i, j);
+            order.swap(i, j);
+        }
+    }
 }
 
 #[cfg(test)]

From 356caee818f1f828e948bdcbed6d6337731eda7b Mon Sep 17 00:00:00 2001
From: Parth Jadhav <jadhavparth99@gmail.com>
Date: Mon, 2 Mar 2026 02:05:26 +0530
Subject: [PATCH 4/9] perf: replace num_cpus with
 std::thread::available_parallelism

Remove the num_cpus dependency in favor of the standard library's
available_parallelism() (stable since Rust 1.59). This reduces the
dependency count and uses the platform-native CPU detection.
---
 Cargo.toml    | 1 -
 src/search.rs | 5 +++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index f215a09..75fd837 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,7 +15,6 @@ categories = ["filesystem", "algorithms"]
 [dependencies]
 regex = "1"
 ignore = "0.4"
-num_cpus = "1.0"
 dirs = "4.0.0"
 strsim = "0.10.0"
 crossbeam-channel = "0.5.15"
diff --git a/src/search.rs b/src/search.rs
index c5bd1c2..de43675 100644
--- a/src/search.rs
+++ b/src/search.rs
@@ -1,5 +1,4 @@
 use std::{
-    cmp,
     ffi::OsStr,
     path::Path,
     sync::{
@@ -116,7 +115,9 @@ impl Search {
 
         // Use more threads than CPUs for I/O-bound work: while one thread
         // waits for I/O, others can make progress.
-        let thread_count = cmp::max(8, num_cpus::get() * 2);
+        let cpus = std::thread::available_parallelism()
+            .map_or(8, std::num::NonZero::get);
+        let thread_count = cpus * 2;
 
         walker
             .hidden(!with_hidden)

From 396aba6dea9df2fdd178d36591978bf60c3c2bc6 Mon Sep 17 00:00:00 2001
From: Parth Jadhav <jadhavparth99@gmail.com>
Date: Mon, 2 Mar 2026 02:08:12 +0530
Subject: [PATCH 5/9] perf: add parallel similarity scoring with rayon for
 large datasets

Use rayon's par_iter for computing Jaro-Winkler scores in parallel when
the dataset exceeds 5,000 items. Below the threshold, use sequential
iteration to avoid rayon thread pool overhead.

Also scale up controlled benchmark to 100,000 files for better stress
testing of matching and sorting paths.
---
 Cargo.toml              |  1 +
 benches/bench_search.rs |  6 +++---
 src/utils.rs            | 35 +++++++++++++++++++++++------------
 3 files changed, 27 insertions(+), 15 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 75fd837..e6353e0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,6 +18,7 @@ ignore = "0.4"
 dirs = "4.0.0"
 strsim = "0.10.0"
 crossbeam-channel = "0.5.15"
+rayon = "1.11.0"
 
 [dev-dependencies]
 dirs = "4.0.0"
diff --git a/benches/bench_search.rs b/benches/bench_search.rs
index 16a68bc..1231f22 100644
--- a/benches/bench_search.rs
+++ b/benches/bench_search.rs
@@ -228,9 +228,9 @@ fn main() {
             let (count, median) = bench_similarity_sort();
             eprintln!("sort:         {} items, median {:?}", count, median);
 
-            // Controlled benchmarks (50 dirs x 200 files = 10,000 files)
-            eprintln!("\n--- Controlled (10,000 files) ---");
-            let dir = create_test_dir(50, 200);
+            // Controlled benchmarks (500 dirs x 200 files = 100,000 files)
+            eprintln!("\n--- Controlled (100,000 files) ---");
+            let dir = create_test_dir(500, 200);
 
             let (count, median) = bench_controlled_search(&dir);
             eprintln!("ctrl_search:  {} results, median {:?}", count, median);
diff --git a/src/utils.rs b/src/utils.rs
index f9d0892..58e31b6 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -1,3 +1,4 @@
+use rayon::prelude::*;
 use regex::Regex;
 use std::cmp::Ordering;
 use std::path::{Path, PathBuf};
@@ -80,22 +81,32 @@ fn file_name_from_path(path: &str) -> &str {
 /// search **with** similarity sort
 /// `["fly.txt", "flyer.txt", "afly.txt", "bfly.txt",]`
 pub fn similarity_sort(vector: &mut [String], input: &str) {
+    const PARALLEL_SORT_THRESHOLD: usize = 5000;
     let input = input.to_lowercase();
-    // Schwartzian transform: precompute all scores once, then sort by score.
-    // This avoids recomputing file_name extraction, lowercasing, and jaro_winkler
-    // on every comparison (O(n log n) comparisons become O(n) score computations).
-    let mut scored: Vec<(usize, f64)> = vector
-        .iter()
-        .enumerate()
-        .map(|(i, path)| {
-            let name = file_name_from_path(path).to_lowercase();
-            (i, jaro_winkler(&name, &input))
-        })
-        .collect();
+    // Schwartzian transform: precompute all scores, then sort by score.
+    // Use parallel scoring only for large datasets where rayon overhead is worthwhile.
+    let mut scored: Vec<(usize, f64)> = if vector.len() >= PARALLEL_SORT_THRESHOLD {
+        vector
+            .par_iter()
+            .enumerate()
+            .map(|(i, path)| {
+                let name = file_name_from_path(path).to_lowercase();
+                (i, jaro_winkler(&name, &input))
+            })
+            .collect()
+    } else {
+        vector
+            .iter()
+            .enumerate()
+            .map(|(i, path)| {
+                let name = file_name_from_path(path).to_lowercase();
+                (i, jaro_winkler(&name, &input))
+            })
+            .collect()
+    };
     scored.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(Ordering::Equal));
 
     // Reorder vector in-place according to the sorted indices.
-    // Use a permutation cycle approach to avoid extra allocations.
     let order: Vec<usize> = scored.into_iter().map(|(i, _)| i).collect();
     apply_permutation(vector, order);
 }

From 8261bbdca72c1266675523d1f3bb7d3cea2fe22d Mon Sep 17 00:00:00 2001
From: Parth Jadhav <jadhavparth99@gmail.com>
Date: Mon, 2 Mar 2026 02:10:40 +0530
Subject: [PATCH 6/9] perf: zero-copy path conversion and AcceptAll matcher for
 ext-only search

- Add AcceptAll matcher variant: when the types pre-filter handles
  extension matching, skip redundant per-entry extension checks
- Use entry.into_path().into_os_string().into_string() for zero-copy
  String conversion when paths are valid UTF-8 (99.9% of cases)
- Remove add_defaults() from TypesBuilder to avoid loading hundreds of
  predefined type definitions on every search
---
 src/search.rs | 75 ++++++++++++++++++++++++++++++---------------------
 1 file changed, 44 insertions(+), 31 deletions(-)

diff --git a/src/search.rs b/src/search.rs
index de43675..e63a9b3 100644
--- a/src/search.rs
+++ b/src/search.rs
@@ -12,9 +12,13 @@ use crossbeam_channel::Sender;
 use ignore::types::TypesBuilder;
 use ignore::{WalkBuilder, WalkState};
 
-/// Matcher strategy: either a fast extension-only check or a full regex.
+/// Matcher strategy for the walk callback.
 enum Matcher {
+    /// The types pre-filter already handles extension matching; accept all entries.
+    AcceptAll,
+    /// Simple extension-only check (fallback when types filter setup failed).
     ExtOnly(String),
+    /// Full regex matching on file names.
     Regex(regex::Regex),
 }
 
@@ -89,28 +93,6 @@ impl Search {
         with_hidden: bool,
         filters: Vec<FilterType>,
     ) -> Self {
-        // Fast path: when only an extension is specified (no search_input, not strict,
-        // not ignore_case), skip regex entirely and use a simple extension check.
-        let matcher = if search_input.is_none() && !strict && !ignore_case {
-            if let Some(ext) = file_ext {
-                Matcher::ExtOnly(ext.to_owned())
-            } else {
-                Matcher::Regex(utils::build_regex_search_input(
-                    search_input,
-                    file_ext,
-                    strict,
-                    ignore_case,
-                ))
-            }
-        } else {
-            Matcher::Regex(utils::build_regex_search_input(
-                search_input,
-                file_ext,
-                strict,
-                ignore_case,
-            ))
-        };
-
         let mut walker = WalkBuilder::new(search_location);
 
         // Use more threads than CPUs for I/O-bound work: while one thread
@@ -127,17 +109,37 @@ impl Search {
 
         // Pre-filter by extension using ignore's type system when possible.
         // This avoids calling our callback for non-matching files.
+        let mut types_filter_active = false;
         if let Some(ext) = file_ext {
             let mut types = TypesBuilder::new();
-            types.add_defaults();
             if types.add("custom", &format!("*.{ext}")).is_ok() {
                 types.select("custom");
                 if let Ok(built) = types.build() {
                     walker.types(built);
+                    types_filter_active = true;
                 }
             }
         }
 
+        // Determine the matcher strategy based on search parameters.
+        let matcher = if search_input.is_none() && !strict && !ignore_case {
+            if file_ext.is_some() && types_filter_active {
+                // Types pre-filter handles extension matching; no additional check needed.
+                Matcher::AcceptAll
+            } else if let Some(ext) = file_ext {
+                // Fallback: simple extension comparison.
+                Matcher::ExtOnly(ext.to_owned())
+            } else {
+                Matcher::Regex(utils::build_regex_search_input(
+                    search_input, file_ext, strict, ignore_case,
+                ))
+            }
+        } else {
+            Matcher::Regex(utils::build_regex_search_input(
+                search_input, file_ext, strict, ignore_case,
+            ))
+        };
+
         // Only apply filter_entry if there are filters to check
         if !filters.is_empty() {
             walker.filter_entry(move |dir| filters.iter().all(|f| f.apply(dir)));
@@ -160,13 +162,17 @@ impl Search {
 
             Box::new(move |path_entry| {
                 if let Ok(entry) = path_entry {
-                    let path = entry.path();
+                    // Check match using borrowed path first, then convert to owned
+                    // only if matched (avoids allocation for non-matching entries).
                     let matched = match matcher.as_ref() {
+                        Matcher::AcceptAll => {
+                            entry.file_type().is_some_and(|ft| !ft.is_dir())
+                        }
                         Matcher::ExtOnly(ext) => {
-                            path.extension() == Some(OsStr::new(ext.as_str()))
+                            entry.path().extension() == Some(OsStr::new(ext.as_str()))
                         }
                         Matcher::Regex(reg_exp) => {
-                            if let Some(file_name) = path.file_name() {
+                            if let Some(file_name) = entry.path().file_name() {
                                 let file_name = file_name.to_string_lossy();
                                 reg_exp.is_match(&file_name)
                             } else {
@@ -175,10 +181,17 @@ impl Search {
                         }
                     };
                     if matched {
-                        if limit.is_none_or(|l| counter.fetch_add(1, Ordering::Relaxed) < l)
-                            && tx.send(path.to_string_lossy().into_owned()).is_ok()
-                        {
-                            return WalkState::Continue;
+                        if limit.is_none_or(|l| counter.fetch_add(1, Ordering::Relaxed) < l) {
+                            // Use into_path() for zero-copy PathBuf, then try zero-copy
+                            // String conversion (succeeds for valid UTF-8 paths).
+                            let path_string = entry
+                                .into_path()
+                                .into_os_string()
+                                .into_string()
+                                .unwrap_or_else(|os| os.to_string_lossy().into_owned());
+                            if tx.send(path_string).is_ok() {
+                                return WalkState::Continue;
+                            }
                         }
                         return WalkState::Quit;
                     }

From 2516f7587afa8f81340ae82fe62cf6aba2edc1cd Mon Sep 17 00:00:00 2001
From: Parth Jadhav <jadhavparth99@gmail.com>
Date: Mon, 2 Mar 2026 02:12:35 +0530
Subject: [PATCH 7/9] docs: add learnings.md documenting performance
 optimization results

Document all optimization checkpoints, what worked (Schwartzian transform
9x sort speedup, crossbeam-channel, zero-copy paths), what didn't work
(rayon overhead for small datasets), and benchmark results for each
iteration.
---
 learnings.md | 154 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 154 insertions(+)
 create mode 100644 learnings.md

diff --git a/learnings.md b/learnings.md
new file mode 100644
index 0000000..e468b4f
--- /dev/null
+++ b/learnings.md
@@ -0,0 +1,154 @@
+# Performance Optimization Learnings
+
+## Summary
+
+Achieved significant performance improvements across all benchmarks through 6 iterative
+optimization checkpoints. The biggest win was in `similarity_sort` (9x faster for small
+datasets, estimated 20-35x faster for large datasets), with meaningful improvements in
+search throughput as well.
+
+## Baseline (Original Code)
+
+| Benchmark | Result |
+|---|---|
+| search (home dir, .rs files) | 28 results, **1.290s** |
+| search with limit=100 | 28 results, **1.309s** |
+| similarity_sort (28 items) | **34.7µs** |
+
+## Final Results (After All Optimizations)
+
+| Benchmark | Result |
+|---|---|
+| search (home dir, .rs files) | 28 results, **1.137s** |
+| search with limit=100 | 28 results, **1.148s** |
+| similarity_sort (28 items) | **3.79µs** |
+| ctrl_search (100K files, ext-only) | 10,000 results, **41.5ms** |
+| ctrl_search (100K files, regex) | 5,000 results, **42.4ms** |
+| ctrl_sort (10K items) | **506-856µs** |
+
+## Improvement Summary
+
+| Benchmark | Before | After | Speedup |
+|---|---|---|---|
+| search (home dir) | 1.290s | 1.137s | **12% faster** |
+| search with limit | 1.309s | 1.148s | **12% faster** |
+| similarity_sort (28 items) | 34.7µs | 3.79µs | **9.1x faster** |
+| similarity_sort (1K items) | 1.313ms | ~155µs | **8.5x faster** |
+| similarity_sort (10K items, est.) | ~17.5ms | ~500µs | **~35x faster** |
+
+---
+
+## What Worked
+
+### 1. Schwartzian Transform for similarity_sort (Checkpoint 3) — **8.5-9x speedup**
+**The single biggest win.** The original code recomputed file name extraction, lowercasing,
+and Jaro-Winkler similarity scores during every comparison in the sort. With n=1000,
+`sort_by` makes ~10,000 comparisons, each computing 2 scores = 20,000 redundant JW calls.
+
+The Schwartzian transform precomputes all scores once (O(n)), then sorts by precomputed
+float values (O(n log n)). Combined with `sort_unstable_by` for better cache locality,
+this produced an immediate 8.5x speedup.
+
+Also changed `file_name_from_path` to return `&str` instead of `String` to avoid
+per-call allocation.
+
+### 2. AcceptAll matcher with types pre-filter (Checkpoint 6) — measurable
+When only a file extension is specified (the most common use case), we set up the
+`ignore` crate's TypesBuilder to pre-filter by extension at the walker level. Then our
+callback uses `Matcher::AcceptAll` — it doesn't need to check the extension again since
+the walker already filtered. This avoids redundant `path.extension()` comparisons on
+every entry that reaches our callback.
+
+### 3. Zero-copy path conversion (Checkpoint 6) — measurable
+Replaced `path.to_string_lossy().into_owned()` (always allocates) with
+`entry.into_path().into_os_string().into_string()`. For valid UTF-8 paths (99.9% of
+cases), this is a zero-copy conversion — the `OsString`'s internal buffer becomes the
+`String` directly.
+
+### 4. crossbeam-channel (Checkpoint 2) — small improvement
+Replaced `std::sync::mpsc` with `crossbeam-channel`. The crossbeam implementation has
+lower overhead for multi-producer scenarios and better cache behavior.
+
+### 5. Increased thread count (Checkpoint 2) — small improvement
+Changed from `min(12, num_cpus)` to `num_cpus * 2`. For I/O-bound directory traversal,
+having more threads than CPUs allows threads to make progress while others wait for I/O.
+
+### 6. Conditional rayon parallelism (Checkpoint 5) — helps large datasets
+Added rayon `par_iter` for computing Jaro-Winkler scores in parallel, but only when
+the dataset exceeds 5,000 items. Below that threshold, sequential iteration is faster
+due to rayon's thread pool overhead.
+
+### 7. Removed num_cpus dependency (Checkpoint 4)
+Replaced `num_cpus::get()` with `std::thread::available_parallelism()` (stable since
+Rust 1.59). Reduces dependency count without changing behavior.
+
+---
+
+## What Did NOT Work (or Had Minimal Impact)
+
+### 1. Extension-only fast path without types pre-filter (Checkpoint 1) — negligible
+Adding a `Matcher::ExtOnly` variant that uses `path.extension() == Some(OsStr::new(ext))`
+instead of regex showed no measurable improvement in the home directory benchmark. The
+reason: with only 28 matching files across thousands of directories, the bottleneck is
+filesystem I/O (directory traversal), not regex matching overhead. The regex is fast and
+compiled once.
+
+### 2. `same_file_system(true)` — removed (behavioral change)
+This would prevent traversal into mounted filesystems (network drives, Time Machine),
+which could speed up searches on macOS significantly. However, it changes the library's
+behavior for users who intentionally search across mount points, so it was reverted.
+
+### 3. Rayon for small datasets (< 5K items) — **7x SLOWER**
+Naive use of `par_iter` for small datasets (28 items) made similarity_sort 7x slower
+(3.9µs → 29.5µs) due to rayon's thread pool initialization overhead. Fixed with a
+threshold: only use parallel scoring above 5,000 items.
+
+### 4. Skip empty filter_entry closure — negligible
+Skipping `walker.filter_entry()` when no filters exist showed no measurable improvement.
+The closure `|dir| [].iter().all(...)` is essentially free.
+
+---
+
+## Benchmark Results by Checkpoint
+
+| Checkpoint | search (28) | limit (28) | sort (28) | Notes |
+|---|---|---|---|---|
+| **Baseline** | 1.290s | 1.309s | 34.7µs | Original code |
+| **CP1**: Fast ext matcher | 1.308s | 1.278s | 36.5µs | Negligible change |
+| **CP2**: crossbeam + types + 2x threads | 1.153s | 1.145s | 35.5µs | ~11% search improvement |
+| **CP3**: Schwartzian transform | 1.155s | 1.161s | **3.96µs** | **8.8x sort improvement** |
+| **CP4**: Replace num_cpus | 1.155s | 1.146s | 3.88µs | Same perf, fewer deps |
+| **CP5**: Conditional rayon | 1.155s | 1.138s | 3.88µs | Helps large datasets |
+| **CP6**: AcceptAll + zero-copy | 1.137s | 1.148s | 3.79µs | Final polish |
+
+---
+
+## Key Insights
+
+1. **Profile before optimizing.** The home directory benchmark is 99%+ I/O-bound.
+   No amount of CPU optimization in the matching path can significantly improve it.
+   Creating a controlled benchmark with 100K files revealed the actual matching path
+   performance.
+
+2. **Algorithmic improvements beat micro-optimizations.** The Schwartzian transform
+   (changing the algorithm) gave 8.5x. All the micro-optimizations combined
+   (crossbeam, zero-copy, etc.) gave ~12%.
+
+3. **Parallelism has overhead.** Rayon made small sorts 7x slower. Always use
+   thresholds for parallel algorithms.
+
+4. **Pre-filtering at the walker level is effective.** Using `ignore`'s TypesBuilder
+   to filter by extension before our callback reduces the number of entries we process.
+
+5. **Zero-copy conversions matter in hot paths.** `OsString::into_string()` vs
+   `to_string_lossy().into_owned()` avoids allocation for valid UTF-8 paths.
+
+---
+
+## Dependencies Changed
+
+| Dependency | Action | Reason |
+|---|---|---|
+| `num_cpus` | **Removed** | Replaced with `std::thread::available_parallelism()` |
+| `crossbeam-channel` | **Added** | Faster MPSC channel implementation |
+| `rayon` | **Added** | Parallel scoring for large similarity_sort datasets |

From 7f6df2da081d6498d72f50b12a42fe4eb63082cf Mon Sep 17 00:00:00 2001
From: Parth Jadhav <jadhavparth99@gmail.com>
Date: Mon, 2 Mar 2026 18:09:07 +0530
Subject: [PATCH 8/9] bench: add full system benchmark mode searching from /

Add "system" mode that benchmarks searching from the root filesystem,
covering ext-only, regex, limit, no-filter, hidden, strict, and
case-insensitive search patterns across ~3.9M real files. Refactor
benchmark helpers to reduce duplication.
---
 benches/bench_search.rs | 284 ++++++++++++++++------------------------
 1 file changed, 114 insertions(+), 170 deletions(-)

diff --git a/benches/bench_search.rs b/benches/bench_search.rs
index 1231f22..b3a2d8c 100644
--- a/benches/bench_search.rs
+++ b/benches/bench_search.rs
@@ -5,7 +5,7 @@ use std::path::{Path, PathBuf};
 use std::time::{Duration, Instant};
 
 const WARMUP_ITERS: usize = 1;
-const BENCH_ITERS: usize = 5;
+const BENCH_ITERS: usize = 3;
 
 fn median(times: &mut [Duration]) -> Duration {
     times.sort();
@@ -13,7 +13,6 @@ fn median(times: &mut [Duration]) -> Duration {
 }
 
 /// Create a controlled test directory with many files for benchmarking.
-/// Returns the path to the temp dir (caller should clean up).
 fn create_test_dir(num_dirs: usize, files_per_dir: usize) -> PathBuf {
     let dir = std::env::temp_dir().join("rust_search_bench");
     let _ = fs::remove_dir_all(&dir);
@@ -36,217 +35,162 @@ fn create_test_dir(num_dirs: usize, files_per_dir: usize) -> PathBuf {
     dir
 }
 
-fn bench_search() -> (usize, Duration) {
-    let home = dirs::home_dir().unwrap();
-
-    // Warmup
-    for _ in 0..WARMUP_ITERS {
-        let _: Vec<String> = SearchBuilder::default()
-            .location(&home)
-            .ext("rs")
-            .build()
-            .collect();
-    }
-
-    let mut times = Vec::with_capacity(BENCH_ITERS);
-    let mut count = 0;
-    for _ in 0..BENCH_ITERS {
-        let start = Instant::now();
-        let results: Vec<String> = SearchBuilder::default()
-            .location(&home)
-            .ext("rs")
-            .build()
-            .collect();
-        times.push(start.elapsed());
-        count = results.len();
-    }
-
-    (count, median(&mut times))
-}
-
-fn bench_search_with_limit() -> (usize, Duration) {
-    let home = dirs::home_dir().unwrap();
-
-    // Warmup
-    for _ in 0..WARMUP_ITERS {
-        let _: Vec<String> = SearchBuilder::default()
-            .location(&home)
-            .ext("rs")
-            .limit(100)
-            .build()
-            .collect();
-    }
-
-    let mut times = Vec::with_capacity(BENCH_ITERS);
-    let mut count = 0;
-    for _ in 0..BENCH_ITERS {
-        let start = Instant::now();
-        let results: Vec<String> = SearchBuilder::default()
-            .location(&home)
-            .ext("rs")
-            .limit(100)
-            .build()
-            .collect();
-        times.push(start.elapsed());
-        count = results.len();
-    }
-
-    (count, median(&mut times))
-}
-
-fn bench_similarity_sort() -> (usize, Duration) {
-    let home = dirs::home_dir().unwrap();
-
-    // Collect results once
-    let base_results: Vec<String> = SearchBuilder::default()
-        .location(&home)
-        .ext("rs")
-        .build()
-        .collect();
-    let count = base_results.len();
-
-    // Warmup
-    for _ in 0..WARMUP_ITERS {
-        let mut results = base_results.clone();
-        similarity_sort(&mut results, "main");
-    }
-
-    let mut times = Vec::with_capacity(BENCH_ITERS);
-    for _ in 0..BENCH_ITERS {
-        let mut results = base_results.clone();
-        let start = Instant::now();
-        similarity_sort(&mut results, "main");
-        times.push(start.elapsed());
-    }
-
-    (count, median(&mut times))
-}
-
-fn bench_controlled_search(dir: &Path) -> (usize, Duration) {
-    // Warmup
-    for _ in 0..WARMUP_ITERS {
-        let _: Vec<String> = SearchBuilder::default()
-            .location(dir)
-            .ext("rs")
-            .build()
-            .collect();
+fn run_bench<F: Fn() -> Vec<String>>(label: &str, warmup: usize, iters: usize, f: F) -> (usize, Duration) {
+    for _ in 0..warmup {
+        let _ = f();
     }
 
-    let mut times = Vec::with_capacity(BENCH_ITERS);
+    let mut times = Vec::with_capacity(iters);
     let mut count = 0;
-    for _ in 0..BENCH_ITERS {
+    for _ in 0..iters {
         let start = Instant::now();
-        let results: Vec<String> = SearchBuilder::default()
-            .location(dir)
-            .ext("rs")
-            .build()
-            .collect();
+        let results = f();
         times.push(start.elapsed());
         count = results.len();
     }
 
-    (count, median(&mut times))
+    let med = median(&mut times);
+    eprintln!("{label:<28} {count:>8} results, median {med:>12.3?}");
+    (count, med)
 }
 
-fn bench_controlled_search_with_input(dir: &Path) -> (usize, Duration) {
-    // Warmup
-    for _ in 0..WARMUP_ITERS {
-        let _: Vec<String> = SearchBuilder::default()
-            .location(dir)
-            .search_input("file_00")
-            .ext("rs")
-            .build()
-            .collect();
-    }
-
-    let mut times = Vec::with_capacity(BENCH_ITERS);
-    let mut count = 0;
-    for _ in 0..BENCH_ITERS {
-        let start = Instant::now();
-        let results: Vec<String> = SearchBuilder::default()
-            .location(dir)
-            .search_input("file_00")
-            .ext("rs")
-            .build()
-            .collect();
-        times.push(start.elapsed());
-        count = results.len();
-    }
-
-    (count, median(&mut times))
-}
-
-fn bench_controlled_similarity_sort(dir: &Path) -> (usize, Duration) {
-    let base_results: Vec<String> = SearchBuilder::default()
-        .location(dir)
-        .ext("rs")
-        .build()
-        .collect();
+fn run_sort_bench(label: &str, base_results: &[String], input: &str, warmup: usize, iters: usize) -> (usize, Duration) {
     let count = base_results.len();
 
-    // Warmup
-    for _ in 0..WARMUP_ITERS {
-        let mut results = base_results.clone();
-        similarity_sort(&mut results, "file_0042");
+    for _ in 0..warmup {
+        let mut results = base_results.to_vec();
+        similarity_sort(&mut results, input);
     }
 
-    let mut times = Vec::with_capacity(BENCH_ITERS);
-    for _ in 0..BENCH_ITERS {
-        let mut results = base_results.clone();
+    let mut times = Vec::with_capacity(iters);
+    for _ in 0..iters {
+        let mut results = base_results.to_vec();
         let start = Instant::now();
-        similarity_sort(&mut results, "file_0042");
+        similarity_sort(&mut results, input);
         times.push(start.elapsed());
     }
 
-    (count, median(&mut times))
+    let med = median(&mut times);
+    eprintln!("{label:<28} {count:>8} items,   median {med:>12.3?}");
+    (count, med)
 }
 
 fn main() {
     let arg = std::env::args().nth(1).unwrap_or_default();
     match arg.as_str() {
         "search" => {
-            let (count, median) = bench_search();
-            eprintln!("search: {} results, median {:?} ({} iters)", count, median, BENCH_ITERS);
+            let home = dirs::home_dir().unwrap();
+            run_bench("search", WARMUP_ITERS, BENCH_ITERS, || {
+                SearchBuilder::default().location(&home).ext("rs").build().collect()
+            });
         }
         "limit" => {
-            let (count, median) = bench_search_with_limit();
-            eprintln!("limit: {} results, median {:?} ({} iters)", count, median, BENCH_ITERS);
+            let home = dirs::home_dir().unwrap();
+            run_bench("limit", WARMUP_ITERS, BENCH_ITERS, || {
+                SearchBuilder::default().location(&home).ext("rs").limit(100).build().collect()
+            });
         }
         "sort" => {
-            let (count, median) = bench_similarity_sort();
-            eprintln!("sort: {} items, median {:?} ({} iters)", count, median, BENCH_ITERS);
+            let home = dirs::home_dir().unwrap();
+            let base: Vec<String> = SearchBuilder::default().location(&home).ext("rs").build().collect();
+            run_sort_bench("sort", &base, "main", WARMUP_ITERS, BENCH_ITERS);
         }
         "all" => {
-            eprintln!("=== Running all benchmarks ===\n");
+            let home = dirs::home_dir().unwrap();
 
-            let (count, median) = bench_search();
-            eprintln!("search:       {} results, median {:?}", count, median);
+            eprintln!("=== Home directory benchmarks ===\n");
 
-            let (count, median) = bench_search_with_limit();
-            eprintln!("limit:        {} results, median {:?}", count, median);
+            run_bench("home/ext_only (.rs)", WARMUP_ITERS, BENCH_ITERS, || {
+                SearchBuilder::default().location(&home).ext("rs").build().collect()
+            });
+            run_bench("home/ext+limit (.rs, 100)", WARMUP_ITERS, BENCH_ITERS, || {
+                SearchBuilder::default().location(&home).ext("rs").limit(100).build().collect()
+            });
 
-            let (count, median) = bench_similarity_sort();
-            eprintln!("sort:         {} items, median {:?}", count, median);
+            let base: Vec<String> = SearchBuilder::default().location(&home).ext("rs").build().collect();
+            run_sort_bench("home/sort", &base, "main", WARMUP_ITERS, BENCH_ITERS);
 
-            // Controlled benchmarks (500 dirs x 200 files = 100,000 files)
-            eprintln!("\n--- Controlled (100,000 files) ---");
+            // Controlled benchmarks
+            eprintln!("\n=== Controlled (100,000 files) ===\n");
             let dir = create_test_dir(500, 200);
 
-            let (count, median) = bench_controlled_search(&dir);
-            eprintln!("ctrl_search:  {} results, median {:?}", count, median);
-
-            let (count, median) = bench_controlled_search_with_input(&dir);
-            eprintln!("ctrl_input:   {} results, median {:?}", count, median);
+            run_bench("ctrl/ext_only (.rs)", WARMUP_ITERS, BENCH_ITERS, || {
+                SearchBuilder::default().location(&dir).ext("rs").build().collect()
+            });
+            run_bench("ctrl/ext+input (file_00.rs)", WARMUP_ITERS, BENCH_ITERS, || {
+                SearchBuilder::default().location(&dir).search_input("file_00").ext("rs").build().collect()
+            });
 
-            let (count, median) = bench_controlled_similarity_sort(&dir);
-            eprintln!("ctrl_sort:    {} items, median {:?}", count, median);
+            let ctrl_base: Vec<String> = SearchBuilder::default().location(&dir).ext("rs").build().collect();
+            run_sort_bench("ctrl/sort", &ctrl_base, "file_0042", WARMUP_ITERS, BENCH_ITERS);
 
             let _ = fs::remove_dir_all(&dir);
 
             eprintln!("\n=== Done ===");
         }
+        "system" => {
+            eprintln!("=== Full system benchmarks (searching from /) ===");
+            eprintln!("=== {} iters, {} warmup ===\n", BENCH_ITERS, WARMUP_ITERS);
+
+            // 1. Search for .rs files across the entire system
+            let (rs_count, _) = run_bench("system/ext_only (.rs)", WARMUP_ITERS, BENCH_ITERS, || {
+                SearchBuilder::default().location("/").ext("rs").build().collect()
+            });
+
+            // 2. Search for .txt files (typically many more)
+            run_bench("system/ext_only (.txt)", WARMUP_ITERS, BENCH_ITERS, || {
+                SearchBuilder::default().location("/").ext("txt").build().collect()
+            });
+
+            // 3. Search for .py files
+            run_bench("system/ext_only (.py)", WARMUP_ITERS, BENCH_ITERS, || {
+                SearchBuilder::default().location("/").ext("py").build().collect()
+            });
+
+            // 4. Search with regex pattern + extension
+            run_bench("system/regex+ext (main*.rs)", WARMUP_ITERS, BENCH_ITERS, || {
+                SearchBuilder::default().location("/").search_input("main").ext("rs").build().collect()
+            });
+
+            // 5. Search with limit
+            run_bench("system/ext+limit (.rs, 1000)", WARMUP_ITERS, BENCH_ITERS, || {
+                SearchBuilder::default().location("/").ext("rs").limit(1000).build().collect()
+            });
+
+            // 6. Search for all files (no filter)
+            run_bench("system/no_filter (all)", WARMUP_ITERS, BENCH_ITERS, || {
+                SearchBuilder::default().location("/").build().collect()
+            });
+
+            // 7. Similarity sort on the .rs results
+            if rs_count > 0 {
+                let rs_results: Vec<String> = SearchBuilder::default()
+                    .location("/")
+                    .ext("rs")
+                    .build()
+                    .collect();
+                run_sort_bench("system/sort (.rs results)", &rs_results, "main", WARMUP_ITERS, BENCH_ITERS);
+            }
+
+            // 8. Search hidden files
+            run_bench("system/hidden (.conf)", WARMUP_ITERS, BENCH_ITERS, || {
+                SearchBuilder::default().location("/").ext("conf").hidden().build().collect()
+            });
+
+            // 9. Strict match
+            run_bench("system/strict (Cargo.toml)", WARMUP_ITERS, BENCH_ITERS, || {
+                SearchBuilder::default().location("/").search_input("Cargo").ext("toml").strict().build().collect()
+            });
+
+            // 10. Case-insensitive search
+            run_bench("system/icase (readme.md)", WARMUP_ITERS, BENCH_ITERS, || {
+                SearchBuilder::default().location("/").search_input("readme").ext("md").ignore_case().build().collect()
+            });
+
+            eprintln!("\n=== Done ===");
+        }
         _ => {
-            eprintln!("Usage: bench_search [search|limit|sort|all]");
+            eprintln!("Usage: bench_search [search|limit|sort|all|system]");
         }
     }
 }

From 5639adc8af1490ffeaeed7eb3f858a91bdd1c81b Mon Sep 17 00:00:00 2001
From: Parth Jadhav <jadhavparth99@gmail.com>
Date: Mon, 2 Mar 2026 18:15:40 +0530
Subject: [PATCH 9/9] fix: resolve clippy warnings and formatting issues

- Rename `matched` to `is_match` to avoid similar_names lint
- Use `is_some_and` instead of `map_or(false, ...)` for Option check
- Remove needless borrows in test files
- Remove unused `Path` import in bench
---
 benches/bench_search.rs | 212 ++++++++++++++++++++++++++++++++--------
 src/search.rs           |  27 ++---
 tests/filter_tests.rs   |  10 +-
 tests/search_tests.rs   |  24 ++---
 4 files changed, 204 insertions(+), 69 deletions(-)

diff --git a/benches/bench_search.rs b/benches/bench_search.rs
index b3a2d8c..b4b8af0 100644
--- a/benches/bench_search.rs
+++ b/benches/bench_search.rs
@@ -1,7 +1,7 @@
 use rust_search::{similarity_sort, SearchBuilder};
 use std::fs;
 use std::io::Write;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 use std::time::{Duration, Instant};
 
 const WARMUP_ITERS: usize = 1;
@@ -18,7 +18,9 @@ fn create_test_dir(num_dirs: usize, files_per_dir: usize) -> PathBuf {
     let _ = fs::remove_dir_all(&dir);
     fs::create_dir_all(&dir).unwrap();
 
-    let extensions = ["rs", "txt", "md", "json", "toml", "yaml", "py", "js", "ts", "css"];
+    let extensions = [
+        "rs", "txt", "md", "json", "toml", "yaml", "py", "js", "ts", "css",
+    ];
 
     for d in 0..num_dirs {
         let subdir = dir.join(format!("dir_{d:04}"));
@@ -35,7 +37,12 @@ fn create_test_dir(num_dirs: usize, files_per_dir: usize) -> PathBuf {
     dir
 }
 
-fn run_bench<F: Fn() -> Vec<String>>(label: &str, warmup: usize, iters: usize, f: F) -> (usize, Duration) {
+fn run_bench<F: Fn() -> Vec<String>>(
+    label: &str,
+    warmup: usize,
+    iters: usize,
+    f: F,
+) -> (usize, Duration) {
     for _ in 0..warmup {
         let _ = f();
     }
@@ -54,7 +61,13 @@ fn run_bench<F: Fn() -> Vec<String>>(label: &str, warmup: usize, iters: usize, f
     (count, med)
 }
 
-fn run_sort_bench(label: &str, base_results: &[String], input: &str, warmup: usize, iters: usize) -> (usize, Duration) {
+fn run_sort_bench(
+    label: &str,
+    base_results: &[String],
+    input: &str,
+    warmup: usize,
+    iters: usize,
+) -> (usize, Duration) {
     let count = base_results.len();
 
     for _ in 0..warmup {
@@ -81,18 +94,31 @@ fn main() {
         "search" => {
             let home = dirs::home_dir().unwrap();
             run_bench("search", WARMUP_ITERS, BENCH_ITERS, || {
-                SearchBuilder::default().location(&home).ext("rs").build().collect()
+                SearchBuilder::default()
+                    .location(&home)
+                    .ext("rs")
+                    .build()
+                    .collect()
             });
         }
         "limit" => {
             let home = dirs::home_dir().unwrap();
             run_bench("limit", WARMUP_ITERS, BENCH_ITERS, || {
-                SearchBuilder::default().location(&home).ext("rs").limit(100).build().collect()
+                SearchBuilder::default()
+                    .location(&home)
+                    .ext("rs")
+                    .limit(100)
+                    .build()
+                    .collect()
             });
         }
         "sort" => {
             let home = dirs::home_dir().unwrap();
-            let base: Vec<String> = SearchBuilder::default().location(&home).ext("rs").build().collect();
+            let base: Vec<String> = SearchBuilder::default()
+                .location(&home)
+                .ext("rs")
+                .build()
+                .collect();
             run_sort_bench("sort", &base, "main", WARMUP_ITERS, BENCH_ITERS);
         }
         "all" => {
@@ -101,13 +127,31 @@ fn main() {
             eprintln!("=== Home directory benchmarks ===\n");
 
             run_bench("home/ext_only (.rs)", WARMUP_ITERS, BENCH_ITERS, || {
-                SearchBuilder::default().location(&home).ext("rs").build().collect()
-            });
-            run_bench("home/ext+limit (.rs, 100)", WARMUP_ITERS, BENCH_ITERS, || {
-                SearchBuilder::default().location(&home).ext("rs").limit(100).build().collect()
+                SearchBuilder::default()
+                    .location(&home)
+                    .ext("rs")
+                    .build()
+                    .collect()
             });
-
-            let base: Vec<String> = SearchBuilder::default().location(&home).ext("rs").build().collect();
+            run_bench(
+                "home/ext+limit (.rs, 100)",
+                WARMUP_ITERS,
+                BENCH_ITERS,
+                || {
+                    SearchBuilder::default()
+                        .location(&home)
+                        .ext("rs")
+                        .limit(100)
+                        .build()
+                        .collect()
+                },
+            );
+
+            let base: Vec<String> = SearchBuilder::default()
+                .location(&home)
+                .ext("rs")
+                .build()
+                .collect();
             run_sort_bench("home/sort", &base, "main", WARMUP_ITERS, BENCH_ITERS);
 
             // Controlled benchmarks
@@ -115,14 +159,38 @@ fn main() {
             let dir = create_test_dir(500, 200);
 
             run_bench("ctrl/ext_only (.rs)", WARMUP_ITERS, BENCH_ITERS, || {
-                SearchBuilder::default().location(&dir).ext("rs").build().collect()
-            });
-            run_bench("ctrl/ext+input (file_00.rs)", WARMUP_ITERS, BENCH_ITERS, || {
-                SearchBuilder::default().location(&dir).search_input("file_00").ext("rs").build().collect()
+                SearchBuilder::default()
+                    .location(&dir)
+                    .ext("rs")
+                    .build()
+                    .collect()
             });
-
-            let ctrl_base: Vec<String> = SearchBuilder::default().location(&dir).ext("rs").build().collect();
-            run_sort_bench("ctrl/sort", &ctrl_base, "file_0042", WARMUP_ITERS, BENCH_ITERS);
+            run_bench(
+                "ctrl/ext+input (file_00.rs)",
+                WARMUP_ITERS,
+                BENCH_ITERS,
+                || {
+                    SearchBuilder::default()
+                        .location(&dir)
+                        .search_input("file_00")
+                        .ext("rs")
+                        .build()
+                        .collect()
+                },
+            );
+
+            let ctrl_base: Vec<String> = SearchBuilder::default()
+                .location(&dir)
+                .ext("rs")
+                .build()
+                .collect();
+            run_sort_bench(
+                "ctrl/sort",
+                &ctrl_base,
+                "file_0042",
+                WARMUP_ITERS,
+                BENCH_ITERS,
+            );
 
             let _ = fs::remove_dir_all(&dir);
 
@@ -133,29 +201,62 @@ fn main() {
             eprintln!("=== {} iters, {} warmup ===\n", BENCH_ITERS, WARMUP_ITERS);
 
             // 1. Search for .rs files across the entire system
-            let (rs_count, _) = run_bench("system/ext_only (.rs)", WARMUP_ITERS, BENCH_ITERS, || {
-                SearchBuilder::default().location("/").ext("rs").build().collect()
-            });
+            let (rs_count, _) =
+                run_bench("system/ext_only (.rs)", WARMUP_ITERS, BENCH_ITERS, || {
+                    SearchBuilder::default()
+                        .location("/")
+                        .ext("rs")
+                        .build()
+                        .collect()
+                });
 
             // 2. Search for .txt files (typically many more)
             run_bench("system/ext_only (.txt)", WARMUP_ITERS, BENCH_ITERS, || {
-                SearchBuilder::default().location("/").ext("txt").build().collect()
+                SearchBuilder::default()
+                    .location("/")
+                    .ext("txt")
+                    .build()
+                    .collect()
             });
 
             // 3. Search for .py files
             run_bench("system/ext_only (.py)", WARMUP_ITERS, BENCH_ITERS, || {
-                SearchBuilder::default().location("/").ext("py").build().collect()
+                SearchBuilder::default()
+                    .location("/")
+                    .ext("py")
+                    .build()
+                    .collect()
             });
 
             // 4. Search with regex pattern + extension
-            run_bench("system/regex+ext (main*.rs)", WARMUP_ITERS, BENCH_ITERS, || {
-                SearchBuilder::default().location("/").search_input("main").ext("rs").build().collect()
-            });
+            run_bench(
+                "system/regex+ext (main*.rs)",
+                WARMUP_ITERS,
+                BENCH_ITERS,
+                || {
+                    SearchBuilder::default()
+                        .location("/")
+                        .search_input("main")
+                        .ext("rs")
+                        .build()
+                        .collect()
+                },
+            );
 
             // 5. Search with limit
-            run_bench("system/ext+limit (.rs, 1000)", WARMUP_ITERS, BENCH_ITERS, || {
-                SearchBuilder::default().location("/").ext("rs").limit(1000).build().collect()
-            });
+            run_bench(
+                "system/ext+limit (.rs, 1000)",
+                WARMUP_ITERS,
+                BENCH_ITERS,
+                || {
+                    SearchBuilder::default()
+                        .location("/")
+                        .ext("rs")
+                        .limit(1000)
+                        .build()
+                        .collect()
+                },
+            );
 
             // 6. Search for all files (no filter)
             run_bench("system/no_filter (all)", WARMUP_ITERS, BENCH_ITERS, || {
@@ -169,23 +270,56 @@ fn main() {
                     .ext("rs")
                     .build()
                     .collect();
-                run_sort_bench("system/sort (.rs results)", &rs_results, "main", WARMUP_ITERS, BENCH_ITERS);
+                run_sort_bench(
+                    "system/sort (.rs results)",
+                    &rs_results,
+                    "main",
+                    WARMUP_ITERS,
+                    BENCH_ITERS,
+                );
             }
 
             // 8. Search hidden files
             run_bench("system/hidden (.conf)", WARMUP_ITERS, BENCH_ITERS, || {
-                SearchBuilder::default().location("/").ext("conf").hidden().build().collect()
+                SearchBuilder::default()
+                    .location("/")
+                    .ext("conf")
+                    .hidden()
+                    .build()
+                    .collect()
             });
 
             // 9. Strict match
-            run_bench("system/strict (Cargo.toml)", WARMUP_ITERS, BENCH_ITERS, || {
-                SearchBuilder::default().location("/").search_input("Cargo").ext("toml").strict().build().collect()
-            });
+            run_bench(
+                "system/strict (Cargo.toml)",
+                WARMUP_ITERS,
+                BENCH_ITERS,
+                || {
+                    SearchBuilder::default()
+                        .location("/")
+                        .search_input("Cargo")
+                        .ext("toml")
+                        .strict()
+                        .build()
+                        .collect()
+                },
+            );
 
             // 10. Case-insensitive search
-            run_bench("system/icase (readme.md)", WARMUP_ITERS, BENCH_ITERS, || {
-                SearchBuilder::default().location("/").search_input("readme").ext("md").ignore_case().build().collect()
-            });
+            run_bench(
+                "system/icase (readme.md)",
+                WARMUP_ITERS,
+                BENCH_ITERS,
+                || {
+                    SearchBuilder::default()
+                        .location("/")
+                        .search_input("readme")
+                        .ext("md")
+                        .ignore_case()
+                        .build()
+                        .collect()
+                },
+            );
 
             eprintln!("\n=== Done ===");
         }
diff --git a/src/search.rs b/src/search.rs
index e63a9b3..2dcd8b4 100644
--- a/src/search.rs
+++ b/src/search.rs
@@ -97,8 +97,7 @@ impl Search {
 
         // Use more threads than CPUs for I/O-bound work: while one thread
         // waits for I/O, others can make progress.
-        let cpus = std::thread::available_parallelism()
-            .map_or(8, std::num::NonZero::get);
+        let cpus = std::thread::available_parallelism().map_or(8, std::num::NonZero::get);
         let thread_count = cpus * 2;
 
         walker
@@ -131,12 +130,18 @@ impl Search {
                 Matcher::ExtOnly(ext.to_owned())
             } else {
                 Matcher::Regex(utils::build_regex_search_input(
-                    search_input, file_ext, strict, ignore_case,
+                    search_input,
+                    file_ext,
+                    strict,
+                    ignore_case,
                 ))
             }
         } else {
             Matcher::Regex(utils::build_regex_search_input(
-                search_input, file_ext, strict, ignore_case,
+                search_input,
+                file_ext,
+                strict,
+                ignore_case,
             ))
         };
 
@@ -164,23 +169,19 @@ impl Search {
                 if let Ok(entry) = path_entry {
                     // Check match using borrowed path first, then convert to owned
                     // only if matched (avoids allocation for non-matching entries).
-                    let matched = match matcher.as_ref() {
-                        Matcher::AcceptAll => {
-                            entry.file_type().is_some_and(|ft| !ft.is_dir())
-                        }
+                    let is_match = match matcher.as_ref() {
+                        Matcher::AcceptAll => entry.file_type().is_some_and(|ft| !ft.is_dir()),
                         Matcher::ExtOnly(ext) => {
                             entry.path().extension() == Some(OsStr::new(ext.as_str()))
                         }
                         Matcher::Regex(reg_exp) => {
-                            if let Some(file_name) = entry.path().file_name() {
+                            entry.path().file_name().is_some_and(|file_name| {
                                 let file_name = file_name.to_string_lossy();
                                 reg_exp.is_match(&file_name)
-                            } else {
-                                false
-                            }
+                            })
                         }
                     };
-                    if matched {
+                    if is_match {
                         if limit.is_none_or(|l| counter.fetch_add(1, Ordering::Relaxed) < l) {
                             // Use into_path() for zero-copy PathBuf, then try zero-copy
                             // String conversion (succeeds for valid UTF-8 paths).
diff --git a/tests/filter_tests.rs b/tests/filter_tests.rs
index bffbed9..88520ad 100644
--- a/tests/filter_tests.rs
+++ b/tests/filter_tests.rs
@@ -45,7 +45,7 @@ fn file_size_greater_filter() {
     // Note: the root directory entry bypasses filter_entry in the ignore crate,
     // so we only check that no actual file passes the filter.
     let results: Vec<String> = SearchBuilder::default()
-        .location(&fixtures_path())
+        .location(fixtures_path())
         .file_size_greater(FileSize::Kilobyte(10.0))
         .build()
         .collect();
@@ -64,7 +64,7 @@ fn file_size_greater_filter() {
 fn file_size_smaller_filter() {
     // All fixture files are tiny, so size < 10KB should return all files
     let results: Vec<String> = SearchBuilder::default()
-        .location(&fixtures_path())
+        .location(fixtures_path())
         .file_size_smaller(FileSize::Kilobyte(10.0))
         .build()
         .collect();
@@ -75,7 +75,7 @@ fn file_size_smaller_filter() {
 fn custom_filter_works() {
     // Filter to only include files (not directories)
     let results: Vec<String> = SearchBuilder::default()
-        .location(&fixtures_path())
+        .location(fixtures_path())
         .custom_filter(|dir| dir.metadata().map(|m| m.is_file()).unwrap_or(false))
         .build()
         .collect();
@@ -87,7 +87,7 @@ fn created_after_epoch_finds_files() {
     // All files were created after UNIX epoch
     let epoch = SystemTime::UNIX_EPOCH;
     let results: Vec<String> = SearchBuilder::default()
-        .location(&fixtures_path())
+        .location(fixtures_path())
         .created_after(epoch)
         .build()
         .collect();
@@ -102,7 +102,7 @@ fn modified_before_future_finds_files() {
     // All files were modified before far future
     let future = SystemTime::now() + Duration::from_secs(3600 * 24 * 365 * 10);
     let results: Vec<String> = SearchBuilder::default()
-        .location(&fixtures_path())
+        .location(fixtures_path())
         .modified_before(future)
         .build()
         .collect();
diff --git a/tests/search_tests.rs b/tests/search_tests.rs
index 853ecf1..1cf4119 100644
--- a/tests/search_tests.rs
+++ b/tests/search_tests.rs
@@ -12,7 +12,7 @@ fn fixtures_path() -> String {
 #[test]
 fn basic_search_finds_files() {
     let results: Vec<String> = SearchBuilder::default()
-        .location(&fixtures_path())
+        .location(fixtures_path())
         .build()
         .collect();
     // Should find at least the known fixture files
@@ -27,7 +27,7 @@ fn basic_search_finds_files() {
 #[test]
 fn search_ext_filters_by_extension() {
     let results: Vec<String> = SearchBuilder::default()
-        .location(&fixtures_path())
+        .location(fixtures_path())
         .ext("rs")
         .build()
         .collect();
@@ -40,7 +40,7 @@ fn search_ext_filters_by_extension() {
 #[test]
 fn search_input_matches_filename() {
     let results: Vec<String> = SearchBuilder::default()
-        .location(&fixtures_path())
+        .location(fixtures_path())
         .search_input("hello")
         .build()
         .collect();
@@ -56,14 +56,14 @@ fn search_input_matches_filename() {
 fn search_depth_limits_traversal() {
     // depth(1) means only the fixtures dir itself, not subdir/deep/
     let shallow: Vec<String> = SearchBuilder::default()
-        .location(&fixtures_path())
+        .location(fixtures_path())
         .ext("rs")
         .depth(1)
         .build()
         .collect();
 
     let deep: Vec<String> = SearchBuilder::default()
-        .location(&fixtures_path())
+        .location(fixtures_path())
         .ext("rs")
         .build()
         .collect();
@@ -88,7 +88,7 @@ fn search_depth_limits_traversal() {
 #[test]
 fn search_limit_caps_results() {
     let results: Vec<String> = SearchBuilder::default()
-        .location(&fixtures_path())
+        .location(fixtures_path())
         .limit(2)
         .build()
         .collect();
@@ -102,7 +102,7 @@ fn search_limit_caps_results() {
 #[test]
 fn search_strict_matches_exact() {
     let results: Vec<String> = SearchBuilder::default()
-        .location(&fixtures_path())
+        .location(fixtures_path())
         .search_input("hello")
         .ext("rs")
         .strict()
@@ -122,7 +122,7 @@ fn search_strict_matches_exact() {
 #[test]
 fn search_ignore_case() {
     let results: Vec<String> = SearchBuilder::default()
-        .location(&fixtures_path())
+        .location(fixtures_path())
         .search_input("HELLO")
         .ext("rs")
         .ignore_case()
@@ -134,12 +134,12 @@ fn search_ignore_case() {
 #[test]
 fn search_hidden_includes_hidden_files() {
     let without_hidden: Vec<String> = SearchBuilder::default()
-        .location(&fixtures_path())
+        .location(fixtures_path())
         .build()
         .collect();
 
     let with_hidden: Vec<String> = SearchBuilder::default()
-        .location(&fixtures_path())
+        .location(fixtures_path())
         .hidden()
         .build()
         .collect();
@@ -158,7 +158,7 @@ fn search_hidden_includes_hidden_files() {
 fn search_more_locations() {
     let subdir = fixtures_dir().join("subdir").display().to_string();
     let results: Vec<String> = SearchBuilder::default()
-        .location(&fixtures_path())
+        .location(fixtures_path())
         .more_locations(vec![&subdir])
         .ext("rs")
         .depth(1)
@@ -175,7 +175,7 @@ fn search_more_locations() {
 #[test]
 fn search_chained_options() {
     let results: Vec<String> = SearchBuilder::default()
-        .location(&fixtures_path())
+        .location(fixtures_path())
         .search_input("nested")
         .ext("rs")
         .strict()