chore: clippy pedantic

Author: LoricAndre

bench.py

@@ -4,8 +4,8 @@
 This measures how fast skim can ingest items and display matched results.
 
 Usage: bench.py [BINARY_PATH ...] [-n|--num-items NUM] [-q|--query QUERY]
-                [-r|--runs RUNS] [-f|--file FILE] [-g|--generate-file FILE]
-                [-j|--json] [-- EXTRA_ARGS...]
+                [-r|--runs RUNS] [-w|--warmup N] [-f|--file FILE]
+                [-g|--generate-file FILE] [-j|--json] [-- EXTRA_ARGS...]
 
 Arguments:
   BINARY_PATH ...          One or more paths to binaries (default: ./target/release/sk)
@@ -14,6 +14,7 @@
   -n, --num-items NUM      Number of items to generate (default: 1000000)
   -q, --query QUERY        Query string to search (default: "test")
   -r, --runs RUNS          Number of benchmark runs per binary (default: 1)
+  -w, --warmup N           Number of warmup runs per binary (default: 1)
   -f, --file FILE          Use existing file as input instead of generating
   -g, --generate-file FILE Generate test data to file and exit
   -j, --json               Output results as JSON
@@ -44,6 +45,7 @@
 DEFAULT_NUM_ITEMS = 1_000_000
 DEFAULT_QUERY = "test"
 DEFAULT_RUNS = 1
+DEFAULT_WARMUP = 1
 
 # Stability / timeout tuning (mirrors bench.sh values)
 REQUIRED_STABLE_S = 5.0  # seconds the matched count must be unchanged
@@ -129,6 +131,7 @@ def parse_args(argv):
     parser.add_argument("-n", "--num-items", type=int, default=DEFAULT_NUM_ITEMS)
     parser.add_argument("-q", "--query", default=DEFAULT_QUERY)
     parser.add_argument("-r", "--runs", type=int, default=DEFAULT_RUNS)
+    parser.add_argument("-w", "--warmup", type=int, default=DEFAULT_WARMUP)
     parser.add_argument("-f", "--file", default="")
     parser.add_argument("-g", "--generate-file", default="")
     parser.add_argument("-j", "--json", action="store_true")
@@ -423,12 +426,13 @@ def _max(values):
 
 
 def aggregate(results: list) -> dict:
-    times = [r["elapsed_s"] for r in results]
-    rates = [r["rate"] for r in results]
-    matched = [r["matched"] for r in results]
-    mems = [r["peak_mem_kb"] for r in results]
-    cpus = [r["peak_cpu"] for r in results]
-    completed = sum(1 for r in results if r["completed"])
+    completed_results = [r for r in results if r["completed"]]
+    times = [r["elapsed_s"] for r in completed_results]
+    rates = [r["rate"] for r in completed_results]
+    matched = [r["matched"] for r in completed_results]
+    mems = [r["peak_mem_kb"] for r in completed_results]
+    cpus = [r["peak_cpu"] for r in completed_results]
+    completed = len(completed_results)
 
     return {
         "completed": completed,
@@ -611,6 +615,7 @@ def main():
     num_items = opts.num_items
     query = opts.query
     runs = opts.runs
+    warmup = opts.warmup
     input_file = opts.file
     generate_file = opts.generate_file
     as_json = opts.json
@@ -645,14 +650,33 @@ def main():
         print(f"=== Skim Ingestion + Matching Benchmark ===", file=sys.stderr)
         print(
             f"Binaries: {binary_list} | Items: {num_items} | "
-            f"Query: '{query}' | Runs: {runs} (per binary)",
+            f"Query: '{query}' | Warmup: {warmup} | Runs: {runs} (per binary)",
             file=sys.stderr,
         )
         if input_file:
             print(f"Input file: {input_file}", file=sys.stderr)
         if extra_args:
             print(f"Extra args: {' '.join(extra_args)}", file=sys.stderr)
 
+        # ---- warmup (results discarded) -------------------------------------
+        if warmup > 0:
+            print(f"\n=== Warmup ({warmup} run(s) per binary) ===", file=sys.stderr)
+            for bi, binary in enumerate(binaries):
+                for wu in range(1, warmup + 1):
+                    print(
+                        f"  Warmup {wu}/{warmup} — {binary} ...",
+                        file=sys.stderr,
+                    )
+                    run_once(
+                        binary_path=binary,
+                        query=query,
+                        tmp_file=tmp_file,
+                        num_items=num_items,
+                        extra_args=extra_args,
+                        run_index=wu,
+                        session_suffix=f"warmup_b{bi}",
+                    )
+
         # ---- run benchmark in round-robin -----------------------------------
         # all_results[i] = list of per-run dicts for binaries[i]
         all_results = [[] for _ in binaries]

flake.nix

@@ -16,6 +16,7 @@
           cargo-insta
           cargo-llvm-cov
           cargo-edit
+          cargo-public-api
           git-cliff
           libclang
           binutils

src/bin/main.rs

@@ -182,8 +182,8 @@ fn sk_main(mut opts: SkimOptions) -> Result<i32> {
                 output_format,
                 &bin_options.delimiter,
                 &bin_options.replstr,
-                result.selected_items.iter(),
-                result.current,
+                &result.selected_items.iter(),
+                &result.current,
                 &result.query,
                 &result.cmd,
                 true

src/binds.rs

@@ -44,7 +44,7 @@ impl Default for KeyMap {
 }
 
 impl KeyMap {
-    /// Adds keymaps from the source, parsing them using parse_keymap
+    /// Adds keymaps from the source, parsing them using `parse_keymap`
     pub fn add_keymaps<'a, T>(&mut self, source: T)
     where
         T: Iterator<Item = &'a str>,
@@ -70,6 +70,7 @@ impl KeyMap {
 
 /// Returns the default key bindings for skim
 #[rustfmt::skip]
+#[must_use]
 pub fn get_default_key_map() -> KeyMap {
     let mut ret = HashMap::new();
 
@@ -132,7 +133,11 @@ pub fn get_default_key_map() -> KeyMap {
     KeyMap(ret)
 }
 
-/// Parses a key str into a crossterm KeyEvent
+/// Parses a key str into a crossterm `KeyEvent`
+///
+/// # Errors
+/// Returns an error if the key string is empty, contains an unknown modifier,
+/// or does not correspond to a recognised key name.
 pub fn parse_key(key: &str) -> Result<KeyEvent> {
     if key.is_empty() {
         return Err(eyre!("Cannot parse empty key"));
@@ -155,15 +160,15 @@ pub fn parse_key(key: &str) -> Result<KeyEvent> {
 
     let keycode: KeyCode;
     if key.len() == 1 {
-        let char = key.chars().next().unwrap();
+        let char = key.chars().next().unwrap_or_default();
         if char.is_uppercase() {
             mods |= KeyModifiers::SHIFT;
-            keycode = KeyCode::Char(char.to_lowercase().next().unwrap());
+            keycode = KeyCode::Char(char.to_ascii_lowercase());
         } else {
             keycode = KeyCode::Char(char);
         }
-    } else if key.starts_with("f") {
-        let f_index = key.strip_prefix("f").unwrap().parse::<u8>()?;
+    } else if let Some(f) = key.strip_prefix('f') {
+        let f_index = f.parse::<u8>()?;
         keycode = KeyCode::F(f_index);
     } else {
         keycode = match key.as_str() {
@@ -191,7 +196,7 @@ pub fn parse_key(key: &str) -> Result<KeyEvent> {
     Ok(KeyEvent::new(keycode, mods))
 }
 
-/// Parse an iterator of keymaps into a KeyMap
+/// Parse an iterator of keymaps into a `KeyMap`
 pub fn parse_keymaps<'a, T>(maps: T) -> KeyMap
 where
     T: Iterator<Item = &'a str>,
@@ -202,12 +207,15 @@ where
 }
 
 /// Parses an action chain, separated by '+'s into the corresponding actions
+///
+/// # Errors
+/// Returns an error if the action chain is empty or contains only unknown actions.
 pub fn parse_action_chain(action_chain: &str) -> Result<Vec<Action>> {
     let mut actions: Vec<Action> = vec![];
-    let mut split = action_chain.split("+");
+    let mut split = action_chain.split('+');
 
     while let Some(mut s) = split.next().map(String::from) {
-        if (s.starts_with("if-") || s.ends_with("{"))
+        if (s.starts_with("if-") || s.ends_with('{'))
             && let Some(otherwise) = split.next()
         {
             s += &(String::from("+") + otherwise);
@@ -224,15 +232,19 @@ pub fn parse_action_chain(action_chain: &str) -> Result<Vec<Action>> {
 }
 
 /// Parse a single keymap and return the key and action(s)
+///
+/// # Errors
+/// Returns an error if the string is empty, missing a colon separator, or the
+/// action chain cannot be parsed.
 pub fn parse_keymap(key_action: &str) -> Result<(&str, Vec<Action>)> {
     if key_action.is_empty() {
         return Err(eyre!("Got an empty keybind, skipping"));
     }
-    debug!("got key_action: {:?}", key_action);
+    debug!("got key_action: {key_action:?}");
     let (key, action_chain) = key_action
         .split_once(':')
         .ok_or(eyre!("Failed to parse {} as key and action", key_action))?;
-    debug!("parsed key_action: {:?}: {:?}", key, action_chain);
+    debug!("parsed key_action: {key:?}: {action_chain:?}");
     Ok((key, parse_action_chain(action_chain)?))
 }
 

src/engine/andor.rs

@@ -70,7 +70,7 @@ impl AndEngine {
         self
     }
 
-    fn merge_matched_items(&self, items: Vec<MatchResult>, text: &str) -> MatchResult {
+    fn merge_matched_items(items: Vec<MatchResult>, text: &str) -> MatchResult {
         let mut ranges = MatchIndices::new();
         let mut rank = crate::Rank {
             score: 0,
@@ -92,7 +92,7 @@ impl AndEngine {
             rank.end = rank.end.max(item.rank.end);
         }
 
-        ranges.sort();
+        ranges.sort_unstable();
         ranges.dedup();
         MatchResult {
             rank,
@@ -113,7 +113,7 @@ impl MatchEngine for AndEngine {
         if results.is_empty() {
             None
         } else {
-            Some(self.merge_matched_items(results, &item.text()))
+            Some(Self::merge_matched_items(results, &item.text()))
         }
     }
 }

src/engine/exact.rs

@@ -87,10 +87,10 @@ impl MatchEngine for ExactEngine {
             }
 
             matched_result =
-                regex_match(&item_text[start..end], &self.query_regex).map(|(s, e)| (s + start, e + start));
+                regex_match(&item_text[start..end], self.query_regex.as_ref()).map(|(s, e)| (s + start, e + start));
 
             if self.inverse {
-                matched_result = matched_result.xor(Some((0, 0)))
+                matched_result = matched_result.xor(Some((0, 0)));
             }
 
             if matched_result.is_some() {
@@ -99,7 +99,7 @@ impl MatchEngine for ExactEngine {
         }
 
         let (begin, end) = matched_result?;
-        let score = (end - begin) as i32;
+        let score = i32::try_from(end - begin).unwrap_or(i32::MAX);
         Some(MatchResult {
             rank: self.rank_builder.build_rank(score, begin, end, &item_text),
             matched_range: MatchRange::ByteRange(begin, end),
@@ -113,7 +113,7 @@ impl Display for ExactEngine {
             f,
             "(Exact|{}{})",
             if self.inverse { "!" } else { "" },
-            self.query_regex.as_ref().map(|x| x.as_str()).unwrap_or("")
+            self.query_regex.as_ref().map_or("", regex::Regex::as_str)
         )
     }
 }

src/engine/factory.rs

@@ -25,6 +25,7 @@ pub struct ExactOrFuzzyEngineFactory {
 
 impl ExactOrFuzzyEngineFactory {
     /// Creates a new builder with default settings
+    #[must_use]
     pub fn builder() -> Self {
         Self {
             exact_mode: false,
@@ -37,18 +38,21 @@ impl ExactOrFuzzyEngineFactory {
     }
 
     /// Sets whether to use exact matching mode
+    #[must_use]
     pub fn exact_mode(mut self, exact_mode: bool) -> Self {
         self.exact_mode = exact_mode;
         self
     }
 
     /// Sets the fuzzy matching algorithm to use
+    #[must_use]
     pub fn fuzzy_algorithm(mut self, fuzzy_algorithm: FuzzyAlgorithm) -> Self {
         self.fuzzy_algorithm = fuzzy_algorithm;
         self
     }
 
     /// Sets the rank builder for scoring matches
+    #[must_use]
     pub fn rank_builder(mut self, rank_builder: Arc<RankBuilder>) -> Self {
         self.rank_builder = rank_builder;
         self
@@ -57,26 +61,30 @@ impl ExactOrFuzzyEngineFactory {
     /// Sets the typo tolerance configuration
     ///
     /// - `Typos::Disabled`: no typo tolerance
-    /// - `Typos::Smart`: adaptive typo tolerance (pattern_length / 4)
+    /// - `Typos::Smart`: adaptive typo tolerance (`pattern_length` / 4)
     /// - `Typos::Fixed(n)`: exactly n typos allowed
+    #[must_use]
     pub fn typos(mut self, typos: Typos) -> Self {
         self.typos = typos;
         self
     }
 
     /// Sets filter mode (skips per-character match indices for faster matching)
+    #[must_use]
     pub fn filter_mode(mut self, filter_mode: bool) -> Self {
         self.filter_mode = filter_mode;
         self
     }
 
     /// When true, prefer the last (rightmost) occurrence on tied scores
+    #[must_use]
     pub fn last_match(mut self, last_match: bool) -> Self {
         self.last_match = last_match;
         self
     }
 
     /// Builds the factory (currently a no-op, returns self)
+    #[must_use]
     pub fn build(self) -> Self {
         self
     }
@@ -170,7 +178,7 @@ impl AndOrEngineFactory {
             return self.inner.create_engine_with_case(query, case);
         }
         let and_engines = RE_OR_WITH_SPACES
-            .replace_all(&self.mask_escape_space(query), "|")
+            .replace_all(&Self::mask_escape_space(query), "|")
             .split(' ')
             .filter_map(|and_term| {
                 if and_term.is_empty() {
@@ -185,7 +193,7 @@ impl AndOrEngineFactory {
                         debug!("Creating Or engine for {term}");
                         Some(
                             self.inner
-                                .create_engine_with_case(&self.unmask_escape_space(term), case),
+                                .create_engine_with_case(&Self::unmask_escape_space(term), case),
                         )
                     })
                     .collect::<Vec<_>>();
@@ -200,11 +208,11 @@ impl AndOrEngineFactory {
         Box::new(AndEngine::builder().engines(and_engines).build())
     }
 
-    fn mask_escape_space(&self, string: &str) -> String {
+    fn mask_escape_space(string: &str) -> String {
         string.replace("\\ ", "\0")
     }
 
-    fn unmask_escape_space(&self, string: &str) -> String {
+    fn unmask_escape_space(string: &str) -> String {
         string.replace('\0', " ")
     }
 }
@@ -223,19 +231,22 @@ pub struct RegexEngineFactory {
 
 impl RegexEngineFactory {
     /// Creates a new builder with default settings
+    #[must_use]
     pub fn builder() -> Self {
         Self {
             rank_builder: Default::default(),
         }
     }
 
     /// Sets the rank builder for scoring matches
+    #[must_use]
     pub fn rank_builder(mut self, rank_builder: Arc<RankBuilder>) -> Self {
         self.rank_builder = rank_builder;
         self
     }
 
     /// Builds the factory (currently a no-op, returns self)
+    #[must_use]
     pub fn build(self) -> Self {
         self
     }