feat(search): add smart case search support

Author: Squirreljetpack

src/core/commands.rs

@@ -66,6 +66,8 @@ pub enum Command {
     SetRunNoOverflow(bool),
     #[cfg(feature = "search")]
     IncrementalSearchCondition(Box<dyn Fn(&SearchOpts) -> bool + Send + Sync + 'static>),
+    #[cfg(feature = "search")]
+    SetSmartCase(bool),
 
     Io(IoCommand),
 }
@@ -92,6 +94,8 @@ impl PartialEq for Command {
             (Self::RemoveHook(h1, id1), Self::RemoveHook(h2, id2)) => h1 == h2 && id1 == id2,
             #[cfg(feature = "search")]
             (Self::IncrementalSearchCondition(_), Self::IncrementalSearchCondition(_)) => true,
+            #[cfg(feature = "search")]
+            (Self::SetSmartCase(s1), Self::SetSmartCase(s2)) => s1 == s2,
             (Self::Io(a), Self::Io(b)) => a == b,
             _ => false,
         }
@@ -114,6 +118,8 @@ impl Debug for Command {
             Self::ShowPrompt(show) => write!(f, "ShowPrompt({show:?})"),
             #[cfg(feature = "search")]
             Self::IncrementalSearchCondition(_) => write!(f, "IncrementalSearchCondition"),
+            #[cfg(feature = "search")]
+            Self::SetSmartCase(sc) => write!(f, "SetSmartCase({sc:?})"),
             Self::AddExitCallback(_) => write!(f, "AddExitCallback"),
             Self::AddHook(h, id, _) => write!(f, "AddHook({h:?}, {id})"),
             Self::RemoveHook(h, id) => write!(f, "RemoveHook({h:?}, {id})"),

src/core/ev_handler.rs

@@ -196,6 +196,18 @@ pub fn handle_event(
             command_queue.push_back(Command::Io(IoCommand::FetchSearchQuery));
         }
         #[cfg(feature = "search")]
+        Command::UserInput(InputEvent::ToggleSmartCase) => {
+            p.search_state.smart_case = !p.search_state.smart_case;
+            if let Some(ref term) = p.search_state.search_term {
+                let pat = term.as_str();
+                p.search_state.search_term = search::compile_regex(pat, p.search_state.smart_case);
+                p.reformat_display();
+                command_queue.push_back(Command::Io(IoCommand::RedrawDisplay));
+            }
+            p.format_prompt();
+            command_queue.push_back(Command::Io(IoCommand::RedrawPrompt));
+        }
+        #[cfg(feature = "search")]
         Command::UserInput(InputEvent::NextMatch | InputEvent::MoveToNextMatch(1))
             if p.search_state.search_term.is_some() =>
         {
@@ -378,6 +390,8 @@ pub fn handle_event(
         Command::SetRunNoOverflow(val) => p.run_no_overflow = val,
         #[cfg(feature = "search")]
         Command::IncrementalSearchCondition(cb) => p.search_state.incremental_search_condition = cb,
+        #[cfg(feature = "search")]
+        Command::SetSmartCase(sc) => p.search_state.smart_case = sc,
         Command::SetInputClassifier(clf) => p.input_classifier = clf,
         #[cfg(feature = "clipboard")]
         Command::SetClipboardHandler(handler) => p.clipboard_handler = Some(handler),
@@ -469,12 +483,14 @@ pub fn handle_io_command(
             drop(active);
             cvar.notify_one();
 
+            p.search_state.smart_case = search_result.smart_case;
             // If we only have compiled regex cached, use that otherwise compile the original
             // string query if its not empty
             p.search_state.search_term = if search_result.compiled_regex.is_some() {
                 search_result.compiled_regex
             } else if !search_result.string.is_empty() {
-                let compiled_regex = regex::Regex::new(&search_result.string).ok();
+                let compiled_regex =
+                    search::compile_regex(&search_result.string, p.search_state.smart_case);
                 if compiled_regex.is_none() {
                     command_queue.push_back(Command::SendMessage(
                         "Invalid regular expression. Press Enter".to_string(),
@@ -636,7 +652,7 @@ mod tests {
             &is_exited,
         );
         assert!(ps.help_state.is_none());
-        assert_eq!(is_exited.load(std::sync::atomic::Ordering::SeqCst), false);
+        assert!(!is_exited.load(std::sync::atomic::Ordering::SeqCst));
         assert_eq!(ps.screen.orig_text, "original text\n");
     }
 
@@ -841,6 +857,7 @@ mod tests {
 
     #[test]
     #[cfg(feature = "search")]
+    #[allow(clippy::trivial_regex)]
     fn search_navigation_with_no_matches_does_not_panic() {
         let mut ps = PagerState::new().unwrap();
         ps.search_state.search_term = Some(regex::Regex::new("nonexistent").unwrap());
@@ -849,15 +866,15 @@ mod tests {
 
         // NextMatch with empty search_idx should not panic
         handle_event(
-            Command::UserInput(InputEvent::NextMatch),
+            Command::UserInput(InputEvent::MoveToNextMatch(1)),
             &mut ps,
             &mut command_queue,
             &Arc::new(AtomicBool::new(false)),
         );
 
         // PrevMatch with empty search_idx should not panic
         handle_event(
-            Command::UserInput(InputEvent::PrevMatch),
+            Command::UserInput(InputEvent::MoveToPrevMatch(1)),
             &mut ps,
             &mut command_queue,
             &Arc::new(AtomicBool::new(false)),
@@ -879,4 +896,39 @@ mod tests {
             &Arc::new(AtomicBool::new(false)),
         );
     }
+
+    #[test]
+    #[cfg(feature = "search")]
+    fn test_toggle_and_set_smart_case() {
+        let mut ps = PagerState::new().unwrap();
+        assert!(!ps.search_state.smart_case);
+        let mut command_queue = CommandQueue::new_zero();
+
+        // Toggle via UserInput
+        handle_event(
+            Command::UserInput(InputEvent::ToggleSmartCase),
+            &mut ps,
+            &mut command_queue,
+            &Arc::new(AtomicBool::new(false)),
+        );
+        assert!(ps.search_state.smart_case);
+
+        // Toggle again
+        handle_event(
+            Command::UserInput(InputEvent::ToggleSmartCase),
+            &mut ps,
+            &mut command_queue,
+            &Arc::new(AtomicBool::new(false)),
+        );
+        assert!(!ps.search_state.smart_case);
+
+        // Explicit set
+        handle_event(
+            Command::SetSmartCase(true),
+            &mut ps,
+            &mut command_queue,
+            &Arc::new(AtomicBool::new(false)),
+        );
+        assert!(ps.search_state.smart_case);
+    }
 }

src/core/mod.rs

@@ -36,8 +36,8 @@ impl CommandQueue {
     ///
     /// This is useful when we have to pass this type to [`handle_event`](ev_handler::handle_event)
     /// but it is sure that this won't be used.
-    pub fn new_zero() -> Self {
-        Self(VecDeque::with_capacity(0))
+    pub const fn new_zero() -> Self {
+        Self(VecDeque::new())
     }
     /// Returns true if the queue is empty.
     pub fn is_empty(&self) -> bool {

src/help.rs

@@ -1,8 +1,10 @@
 //! Help text and related definitions for the pager.
 
 use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
+use std::fmt::Write as _;
 
 /// Format a [`KeyEvent`] into a human-readable representation (e.g. `"Ctrl-c"`, `"Alt-h"`).
+#[must_use]
 pub fn format_key(ke: &KeyEvent) -> String {
     let mut s = String::new();
     if ke.modifiers.contains(KeyModifiers::CONTROL) {
@@ -38,7 +40,9 @@ pub fn format_key(ke: &KeyEvent) -> String {
         KeyCode::End => s.push_str("End"),
         KeyCode::Delete => s.push_str("Delete"),
         KeyCode::Insert => s.push_str("Insert"),
-        KeyCode::F(n) => s.push_str(&format!("F{n}")),
+        KeyCode::F(n) => {
+            let _ = write!(s, "F{n}");
+        }
         KeyCode::Null => s.push_str("Null"),
         _ => s.push_str("Unknown"),
     }
@@ -48,6 +52,7 @@ pub fn format_key(ke: &KeyEvent) -> String {
 /// Format dynamic help table from key event entries and their descriptions.
 ///
 /// Empty descriptions are omitted.
+#[must_use]
 pub fn format_help_table_from_entries<'a, I>(entries: I) -> String
 where
     I: IntoIterator<Item = (&'a KeyEvent, &'a str)>,
@@ -79,10 +84,9 @@ where
 
     for (desc, keys) in groups {
         let keys_str = keys.join(", ");
-        out.push_str(&format!("  {:<30} {}\n", keys_str, desc));
+        let _ = writeln!(out, "  {keys_str:<30} {desc}");
     }
 
-    out.push_str("\n  -- Press q, Enter, or Alt-h to return to pager --\n");
     out
 }
 

src/input/hashed_event_register.rs

@@ -126,11 +126,7 @@ where
 
     fn format_help(&self) -> Option<String> {
         let h = self.format_help();
-        if h.is_empty() {
-            None
-        } else {
-            Some(h)
-        }
+        if h.is_empty() { None } else { Some(h) }
     }
 }
 
@@ -142,7 +138,7 @@ where
     S: BuildHasher,
 {
     /// Create a new `HashedEventRegister` with the Hasher `s`
-    pub fn new(s: S) -> Self {
+    pub const fn new(s: S) -> Self {
         Self(HashMap::with_hasher(s))
     }
 
@@ -305,6 +301,9 @@ where
     }
 
     /// Add all elements of `keys` as key bindings with a description that minus should respond to with the callback `cb`, with conflict checking.
+    ///
+    /// # Panics
+    /// Panics if a key already exists and `remap` is `false`.
     pub fn add_described_key_events_checked(
         &mut self,
         keys: &[&str],

src/input/mod.rs

@@ -265,6 +265,9 @@ pub enum InputEvent {
     /// This is similar to [`Pager::follow_output`](crate::pager::Pager::follow_output) except that
     /// this is used to control it from the user's side.
     FollowOutput(bool),
+    #[cfg(feature = "search")]
+    /// Toggle smart case searching mode.
+    ToggleSmartCase,
     /// Show help message in the prompt area.
     ShowHelp,
 }
@@ -360,11 +363,20 @@ where
     map.add_described_key_events(&["c-l"], "toggle line numbers", |_, ps| {
         InputEvent::UpdateLineNumber(!ps.line_numbers)
     });
-    map.add_described_key_events(&["end"], "bottom", |_, _| InputEvent::UpdateUpperMark(usize::MAX - 1));
+    map.add_described_key_events(&["end"], "bottom", |_, _| {
+        InputEvent::UpdateUpperMark(usize::MAX - 1)
+    });
     #[cfg(feature = "search")]
     {
-        map.add_described_key_events(&["/"], "search forward", |_, _| InputEvent::Search(SearchMode::Forward));
-        map.add_described_key_events(&["?"], "search backward", |_, _| InputEvent::Search(SearchMode::Reverse));
+        map.add_described_key_events(&["/"], "search forward", |_, _| {
+            InputEvent::Search(SearchMode::Forward)
+        });
+        map.add_described_key_events(&["?"], "search backward", |_, _| {
+            InputEvent::Search(SearchMode::Reverse)
+        });
+        map.add_described_key_events(&["m-i"], "toggle smart case", |_, _| {
+            InputEvent::ToggleSmartCase
+        });
         map.add_described_key_events(&["n"], "next match", |_, ps| {
             let position = ps.prefix_num.parse::<usize>().unwrap_or(1);
 
@@ -695,6 +707,12 @@ impl InputClassifier for DefaultInputClassifier {
                     Some(InputEvent::MoveToPrevMatch(position))
                 }
             }
+            #[cfg(feature = "search")]
+            Event::Key(KeyEvent {
+                code: KeyCode::Char('i'),
+                modifiers: KeyModifiers::ALT,
+                ..
+            }) => Some(InputEvent::ToggleSmartCase),
             _ => None,
         }
     }

src/input/tests.rs

@@ -502,12 +502,18 @@ fn test_help_key() {
         kind: crossterm::event::KeyEventKind::Press,
         state: KeyEventState::NONE,
     });
-    assert_eq!(pager.input_classifier.classify_input(alt_h.clone(), &pager), Some(InputEvent::Ignore));
+    assert_eq!(
+        pager.input_classifier.classify_input(alt_h.clone(), &pager),
+        Some(InputEvent::Ignore)
+    );
 
     // Attach default help key (alt-h / m-h)
     let mut reg = HashedEventRegister::default();
     reg.add_help_key(&[]);
-    assert_eq!(reg.classify_input(alt_h.clone(), &pager), Some(InputEvent::ShowHelp));
+    assert_eq!(
+        reg.classify_input(alt_h, &pager),
+        Some(InputEvent::ShowHelp)
+    );
 
     // Attach custom help key
     let mut reg_custom = HashedEventRegister::default();
@@ -518,12 +524,17 @@ fn test_help_key() {
         kind: crossterm::event::KeyEventKind::Press,
         state: KeyEventState::NONE,
     });
-    assert_eq!(reg_custom.classify_input(f1, &pager), Some(InputEvent::ShowHelp));
+    assert_eq!(
+        reg_custom.classify_input(f1, &pager),
+        Some(InputEvent::ShowHelp)
+    );
 
     // Dynamic help generation with described keys and omitted empty descriptions
     let mut reg_dynamic = HashedEventRegister::with_default_hasher();
     reg_dynamic.add_described_key_events(&["q", "c-c"], "quit", |_, _| InputEvent::Exit);
-    reg_dynamic.add_described_key_events(&["j", "down"], "scroll down", |_, _| InputEvent::UpdateUpperMark(1));
+    reg_dynamic.add_described_key_events(&["j", "down"], "scroll down", |_, _| {
+        InputEvent::UpdateUpperMark(1)
+    });
     // Undescribed key (empty description) should not appear in help text
     reg_dynamic.add_key_events(&["x"], |_, _| InputEvent::Exit);
 

src/pager.rs

@@ -303,10 +303,7 @@ impl Pager {
     /// This function will return a [`Err(MinusError::Communication)`](MinusError::Communication) if the data
     /// could not be sent to the receiver
     #[cfg(feature = "clipboard")]
-    pub fn set_clipboard_handler(
-        &self,
-        handler: ClipboardHandler,
-    ) -> Result<(), MinusError> {
+    pub fn set_clipboard_handler(&self, handler: ClipboardHandler) -> Result<(), MinusError> {
         Ok(self.tx.send(Command::SetClipboardHandler(handler))?)
     }
 
@@ -386,6 +383,21 @@ impl Pager {
         Ok(())
     }
 
+    /// Enable or disable smart case searching
+    ///
+    /// When enabled, search queries containing no uppercase characters are case-insensitive,
+    /// while queries containing uppercase characters remain case-sensitive.
+    ///
+    /// # Errors
+    /// This function will return a [`Err(MinusError::Communication)`](MinusError::Communication) if the data
+    /// could not be sent to the receiver end.
+    #[cfg(feature = "search")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "search")))]
+    pub fn set_smart_case(&self, smart_case: bool) -> crate::Result {
+        self.tx.send(Command::SetSmartCase(smart_case))?;
+        Ok(())
+    }
+
     /// Control whether to show the prompt
     ///
     /// Many applications don't want the prompt to be displayed at all. This function can be used to completely turn