feat: Ctrl+f in the glob prompt now toggles the mode from case-insensitive to sensitive.

Byron · Byron · commit bbe368f3c33c · 2025-09-15T05:48:48.000+02:00
diff --git a/src/interactive/app/eventloop.rs b/src/interactive/app/eventloop.rs
@@ -294,7 +294,11 @@ impl AppState {
                 Glob => {
                     let glob_pane = window.glob_pane.as_mut().expect("glob pane");
                     match key.code {
-                        Enter => self.search_glob_pattern(&mut tree_view, &glob_pane.input, glob_pane.case_sensitive),
+                        Enter => self.search_glob_pattern(
+                            &mut tree_view,
+                            &glob_pane.input,
+                            glob_pane.case,
+                        ),
                         _ => glob_pane.process_events(key),
                     }
                 }
@@ -476,9 +480,19 @@ impl AppState {
         }
     }
 
-    fn search_glob_pattern(&mut self, tree_view: &mut TreeView<'_>, glob_pattern: &str, case_sensitive: bool) {
+    fn search_glob_pattern(
+        &mut self,
+        tree_view: &mut TreeView<'_>,
+        glob_pattern: &str,
+        case: gix_glob::pattern::Case,
+    ) {
         use FocussedPane::*;
-        match glob_search(tree_view.tree(), self.navigation.view_root, glob_pattern, case_sensitive) {
+        match glob_search(
+            tree_view.tree(),
+            self.navigation.view_root,
+            glob_pattern,
+            case,
+        ) {
             Ok(matches) if matches.is_empty() => {
                 self.message = Some("No match found".into());
             }
diff --git a/src/interactive/app/tests/journeys_with_writes.rs b/src/interactive/app/tests/journeys_with_writes.rs
@@ -12,7 +12,8 @@ fn basic_user_journey_with_deletion() -> Result<()> {
     use crate::interactive::app::tests::utils::into_events;
 
     let fixture = WritableFixture::from("sample-02");
-    let (mut terminal, mut app) = initialized_app_and_terminal_from_paths(&[fixture.root.clone()])?;
+    let (mut terminal, mut app) =
+        initialized_app_and_terminal_from_paths(std::slice::from_ref(&fixture.root))?;
 
     // With a selection of items
     app.process_events(&mut terminal, into_codes("doddd"))?;
diff --git a/src/interactive/app/tests/unit.rs b/src/interactive/app/tests/unit.rs
@@ -4,6 +4,7 @@ use crate::interactive::app::tests::utils::{
 use crate::interactive::widgets::glob_search;
 use anyhow::Result;
 use dua::traverse::TreeIndex;
+use gix_glob::pattern::Case;
 use pretty_assertions::assert_eq;
 
 #[test]
@@ -35,19 +36,24 @@ fn it_can_handle_ending_traversal_without_reaching_the_top() -> Result<()> {
 #[test]
 fn it_can_do_a_glob_search() {
     let (tree, root_index) = sample_02_tree(false);
-    let result = glob_search(&tree, root_index, "tests/fixtures/sample-02", false).unwrap();
+    let result = glob_search(&tree, root_index, "tests/fixtures/sample-02", Case::Fold).unwrap();
     let expected = vec![TreeIndex::from(1)];
     assert_eq!(result, expected);
 }
 
 #[test]
 fn it_can_do_a_case_sensitive_glob_search() {
     let (tree, root_index) = sample_02_tree(false);
-    // This should match case-insensitively
-    let result_insensitive = glob_search(&tree, root_index, "TESTS/FIXTURES/SAMPLE-02", false).unwrap();
+    let result_insensitive =
+        glob_search(&tree, root_index, "TESTS/FIXTURES/SAMPLE-02", Case::Fold).unwrap();
     assert_eq!(result_insensitive, vec![TreeIndex::from(1)]);
-    
-    // This should not match case-sensitively 
-    let result_sensitive = glob_search(&tree, root_index, "TESTS/FIXTURES/SAMPLE-02", true).unwrap();
+
+    let result_sensitive = glob_search(
+        &tree,
+        root_index,
+        "TESTS/FIXTURES/SAMPLE-02",
+        Case::Sensitive,
+    )
+    .unwrap();
     assert!(result_sensitive.is_empty());
 }
diff --git a/src/interactive/widgets/glob.rs b/src/interactive/widgets/glob.rs
@@ -3,6 +3,7 @@ use bstr::BString;
 use crosstermion::crossterm::event::KeyEventKind;
 use crosstermion::input::Key;
 use dua::traverse::{Tree, TreeIndex};
+use gix_glob::pattern::Case;
 use petgraph::Direction;
 use std::borrow::Borrow;
 use tui::{
@@ -26,16 +27,24 @@ pub struct GlobPaneProps {
     pub has_focus: bool,
 }
 
-#[derive(Default)]
 pub struct GlobPane {
     pub input: String,
     /// The index of the grapheme the cursor currently points to.
     /// This hopefully rightfully assumes that a grapheme will be matching the block size on screen
     /// and is treated as 'one character'. If not, it will be off, which isn't the end of the world.
     // TODO: use `tui-textarea` for proper cursor handling, needs native crossterm events.
     cursor_grapheme_idx: usize,
-    /// Whether the glob search should be case-sensitive
-    pub case_sensitive: bool,
+    pub case: Case,
+}
+
+impl Default for GlobPane {
+    fn default() -> Self {
+        GlobPane {
+            input: "".to_string(),
+            cursor_grapheme_idx: 0,
+            case: Case::Fold,
+        }
+    }
 }
 
 impl GlobPane {
@@ -46,8 +55,11 @@ impl GlobPane {
             return;
         }
         match key.code {
-            Char('i') if key.modifiers.contains(KeyModifiers::CONTROL) => {
-                self.case_sensitive = !self.case_sensitive;
+            Char('f') if key.modifiers.contains(KeyModifiers::CONTROL) => {
+                self.case = match self.case {
+                    Case::Sensitive => Case::Fold,
+                    Case::Fold => Case::Sensitive,
+                };
             }
             Char(to_insert) => {
                 self.enter_char(to_insert);
@@ -119,11 +131,11 @@ impl GlobPane {
             has_focus,
         } = props.borrow();
 
-        let title = if self.case_sensitive {
-            "Git-Glob (case-sensitive)"
-        } else {
-            "Git-Glob (case-insensitive)"
+        let title = match self.case {
+            Case::Sensitive => "Git-Glob (case-sensitive)",
+            Case::Fold => "Git-Glob (case-insensitive)",
         };
+
         let block = Block::default()
             .title(title)
             .border_style(*border_style)
@@ -156,7 +168,7 @@ impl GlobPane {
 }
 
 fn draw_top_right_help(area: Rect, title: &str, buf: &mut Buffer) -> Rect {
-    let help_text = " search = enter | case = ^I | cancel = esc ";
+    let help_text = " search = enter | case = ^f | cancel = esc ";
     let help_text_block_width = block_width(help_text);
     let bound = Rect {
         width: area.width.saturating_sub(1),
@@ -188,7 +200,7 @@ fn glob_search_neighbours(
     root_index: TreeIndex,
     glob: &gix_glob::Pattern,
     path: &mut BString,
-    case_sensitive: bool,
+    case: Case,
 ) {
     for node_index in tree.neighbors_directed(root_index, Direction::Outgoing) {
         if let Some(node) = tree.node_weight(node_index) {
@@ -200,33 +212,33 @@ fn glob_search_neighbours(
                 Some(previous_len + 1)
             };
             path.extend_from_slice(gix_path::into_bstr(&node.name).as_ref());
-            let case_mode = if case_sensitive {
-                gix_glob::pattern::Case::Sensitive
-            } else {
-                gix_glob::pattern::Case::Fold
-            };
             if glob.matches_repo_relative_path(
                 path.as_ref(),
                 basename_start,
                 Some(node.is_dir),
-                case_mode,
+                case,
                 gix_glob::wildmatch::Mode::NO_MATCH_SLASH_LITERAL,
             ) {
                 results.push(node_index);
             } else {
-                glob_search_neighbours(results, tree, node_index, glob, path, case_sensitive);
+                glob_search_neighbours(results, tree, node_index, glob, path, case);
             }
             path.truncate(previous_len);
         }
     }
 }
 
-pub fn glob_search(tree: &Tree, root_index: TreeIndex, glob: &str, case_sensitive: bool) -> Result<Vec<TreeIndex>> {
+pub fn glob_search(
+    tree: &Tree,
+    root_index: TreeIndex,
+    glob: &str,
+    case: gix_glob::pattern::Case,
+) -> Result<Vec<TreeIndex>> {
     let glob = gix_glob::Pattern::from_bytes_without_negation(glob.as_bytes())
         .with_context(|| anyhow!("Glob was empty or only whitespace"))?;
     let mut results = Vec::new();
     let mut path = Default::default();
-    glob_search_neighbours(&mut results, tree, root_index, &glob, &mut path, case_sensitive);
+    glob_search_neighbours(&mut results, tree, root_index, &glob, &mut path, case);
     Ok(results)
 }
 
@@ -236,43 +248,21 @@ mod tests {
     use crosstermion::crossterm::event::{KeyCode, KeyEventKind, KeyModifiers};
 
     #[test]
-    fn test_i_key_types_into_input() {
+    fn ctrl_f_key_types_into_input() {
         let mut glob_pane = GlobPane::default();
         assert_eq!(glob_pane.input, "");
-        assert!(!glob_pane.case_sensitive); // default is case-insensitive
+        assert_eq!(glob_pane.case, Case::Fold); // default is case-insensitive
 
-        // Test that typing 'I' adds it to the input
-        let key_i = Key {
-            code: KeyCode::Char('I'),
-            modifiers: KeyModifiers::empty(),
-            kind: KeyEventKind::Press,
-            state: crosstermion::crossterm::event::KeyEventState::empty(),
-        };
-        glob_pane.process_events(key_i);
-        
-        assert_eq!(glob_pane.input, "I");
-        assert!(!glob_pane.case_sensitive); // should remain unchanged
-    }
-
-    #[test]
-    fn test_ctrl_i_toggles_case_sensitivity() {
-        let mut glob_pane = GlobPane::default();
-        assert!(!glob_pane.case_sensitive); // default is case-insensitive
-
-        // Test that Ctrl+I toggles case sensitivity
-        let key_ctrl_i = Key {
-            code: KeyCode::Char('i'),
+        let ctrl_f = Key {
+            code: KeyCode::Char('f'),
             modifiers: KeyModifiers::CONTROL,
             kind: KeyEventKind::Press,
             state: crosstermion::crossterm::event::KeyEventState::empty(),
         };
-        glob_pane.process_events(key_ctrl_i);
-        
-        assert_eq!(glob_pane.input, ""); // input should remain empty
-        assert!(glob_pane.case_sensitive); // should toggle to case-sensitive
-        
-        // Test toggling back
-        glob_pane.process_events(key_ctrl_i);
-        assert!(! glob_pane.case_sensitive); // should toggle back to case-insensitive
+        glob_pane.process_events(ctrl_f);
+        assert_eq!(glob_pane.case, Case::Sensitive);
+
+        glob_pane.process_events(ctrl_f);
+        assert_eq!(glob_pane.case, Case::Fold);
     }
 }
