Merge 36eb43e525 into 7ebf650029

book/src/editor.md

@@ -135,6 +135,7 @@ The following statusline elements can be configured:
 | `diagnostics` | The number of warnings and/or errors |
 | `workspace-diagnostics` | The number of warnings and/or errors on workspace |
 | `selections` | The number of active selections |
+| `search-position` | Current search match and total matches in the view `[<current>/<total>]` |
 | `primary-selection-length` | The number of characters currently in primary selection |
 | `position` | The cursor position |
 | `position-percentage` | The cursor position as a percentage of the total number of lines |
@@ -275,6 +276,7 @@ Search specific options.
 |--|--|---------|
 | `smart-case` | Enable smart case regex searching (case-insensitive unless pattern contains upper case characters) | `true` |
 | `wrap-around`| Whether the search should wrap after depleting the matches | `true` |
+| `max-matches`| Maximum number of matches that will be counted for the denominator of `search-position`. Possible values are integers or `"none"` for no limit. | `100` |
 
 ### `[editor.whitespace]` Section
 

helix-term/src/commands.rs

@@ -42,8 +42,8 @@ use helix_core::{
     Selection, SmallVec, Syntax, Tendril, Transaction,
 };
 use helix_view::{
-    document::{FormatterError, Mode, SCRATCH_BUFFER_NAME},
-    editor::Action,
+    document::{FormatterError, Mode, SearchMatch, SearchMatchLimit, SCRATCH_BUFFER_NAME},
+    editor::{Action, OptionToml, SearchConfig},
     info::Info,
     input::KeyEvent,
     keyboard::KeyCode,
@@ -2113,12 +2113,13 @@ fn search_impl(
     movement: Movement,
     direction: Direction,
     scrolloff: usize,
-    wrap_around: bool,
+    search_config: &SearchConfig,
     show_warnings: bool,
 ) {
     let (view, doc) = current!(editor);
     let text = doc.text().slice(..);
     let selection = doc.selection(view.id);
+    let wrap_around = search_config.wrap_around;
 
     // Get the right side of the primary block cursor for forward search, or the
     // grapheme before the start of the selection for reverse search.
@@ -2139,54 +2140,126 @@ fn search_impl(
     // it out, we need to add it back to the position of the selection.
     let doc = doc!(editor).text().slice(..);
 
-    // use find_at to find the next match after the cursor, loop around the end
-    // Careful, `Regex` uses `bytes` as offsets, not character indices!
-    let mut mat = match direction {
-        Direction::Forward => regex.find(doc.regex_input_at_bytes(start..)),
-        Direction::Backward => regex.find_iter(doc.regex_input_at_bytes(..start)).last(),
-    };
+    let mut all_matches = regex.find_iter(doc.regex_input()).enumerate().peekable();
 
-    if mat.is_none() {
-        if wrap_around {
-            mat = match direction {
-                Direction::Forward => regex.find(doc.regex_input()),
-                Direction::Backward => regex.find_iter(doc.regex_input_at_bytes(start..)).last(),
-            };
-        }
+    if all_matches.peek().is_none() {
         if show_warnings {
-            if wrap_around && mat.is_some() {
-                editor.set_status("Wrapped around document");
-            } else {
-                editor.set_error("No more matches");
-            }
+            editor.set_error("No matches");
         }
+        return;
     }
 
+    // We will get the number of the current match and total matches from
+    // `all_matches`. So, here we look in the iterator until we find exactly
+    // the match we were looking for (either after or behind `start`). In the
+    // `Backward` case, in particular, we need to look the match ahead to know
+    // if this is the one we need.
+
+    // Careful, `Regex` uses `bytes` as offsets, not character indices!
+    let mut mat = match direction {
+        Direction::Forward => all_matches.by_ref().find(|&(_, m)| m.start() >= start),
+        Direction::Backward => {
+            let one_behind = std::iter::once(None).chain(all_matches.by_ref().map(Some));
+            one_behind
+                .zip(regex.find_iter(doc.regex_input()))
+                .find(|&(_, m1)| m1.start() >= start)
+                .map(|(m0, _)| m0)
+                .unwrap_or(None)
+        }
+    };
+
+    if mat.is_none() && !wrap_around {
+        if show_warnings {
+            editor.set_error("No more matches");
+        }
+        return;
+    }
+
+    // If we didn't find a match before, lets wrap the search.
+    if mat.is_none() {
+        if show_warnings {
+            editor.set_status("Wrapped around document");
+        }
+
+        let doc = doc!(editor).text().slice(..);
+        all_matches = regex.find_iter(doc.regex_input()).enumerate().peekable();
+        mat = match direction {
+            Direction::Forward => all_matches.by_ref().next(),
+            Direction::Backward => all_matches.by_ref().last(),
+        };
+    }
+
+    let (idx, mat) = mat.unwrap();
+    let match_count = match search_config.max_matches {
+        OptionToml::None => match all_matches.last() {
+            None => SearchMatchLimit::Limitless(idx + 1),
+            Some((last_idx, _)) => SearchMatchLimit::Limitless(last_idx + 1),
+        },
+        OptionToml::Some(max) => {
+            if all_matches.peek().is_none() {
+                // Case #1: If we consumed `all_matches`, it means that we have
+                // the last match in `mat`. Hence, we know exactly how many
+                // matches there are. To respect the `max` option, if it goes
+                // beyong `max`, we limit the counter to `max`.
+                if idx + 1 > max {
+                    SearchMatchLimit::Limited(max)
+                } else {
+                    SearchMatchLimit::Limitless(idx + 1)
+                }
+            } else {
+                // Case #2: If we are here, we have at least one match in
+                // `all_matches`. We need to find the last match that's
+                // less than `max`. If we find it, we simply return it as a
+                // `Limitless` denominator because it doesn't go beyong the
+                // user option. The two remaining cases are `last_idx == max`
+                // and `None` (when the remaining matches are all greater than
+                // `max`) for which we return a `Limited` denominator.
+                match all_matches.take_while(|(idx, _)| idx <= &max).last() {
+                    Some((last_idx, _)) if last_idx < max => {
+                        SearchMatchLimit::Limitless(last_idx + 1)
+                    }
+                    _ => SearchMatchLimit::Limited(max),
+                }
+            }
+        }
+    };
+
+    // Move the cursor to the match.
     let (view, doc) = current!(editor);
     let text = doc.text().slice(..);
     let selection = doc.selection(view.id);
 
-    if let Some(mat) = mat {
-        let start = text.byte_to_char(mat.start());
-        let end = text.byte_to_char(mat.end());
+    let start = text.byte_to_char(mat.start());
+    let end = text.byte_to_char(mat.end());
 
-        if end == 0 {
-            // skip empty matches that don't make sense
-            return;
-        }
+    if end == 0 {
+        // skip empty matches that don't make sense
+        return;
+    }
 
-        // Determine range direction based on the primary range
-        let primary = selection.primary();
-        let range = Range::new(start, end).with_direction(primary.direction());
+    // Determine range direction based on the primary range
+    let primary = selection.primary();
+    let range = Range::new(start, end).with_direction(primary.direction());
 
-        let selection = match movement {
-            Movement::Extend => selection.clone().push(range),
-            Movement::Move => selection.clone().replace(selection.primary_index(), range),
-        };
-
-        doc.set_selection(view.id, selection);
-        view.ensure_cursor_in_view_center(doc, scrolloff);
+    let selection = match movement {
+        Movement::Extend => selection.clone().push(range),
+        Movement::Move => selection.clone().replace(selection.primary_index(), range),
     };
+
+    doc.set_selection(view.id, selection);
+    view.ensure_cursor_in_view_center(doc, scrolloff);
+
+    // Set the index of this match and total number of matchs in the doc. It's
+    // important to set it after `set_selection` since that method resets the
+    // last match position.
+    let (view, doc) = current!(editor);
+    doc.set_last_search_match(
+        view.id,
+        SearchMatch {
+            idx: idx + 1,
+            count: match_count,
+        },
+    );
 }
 
 fn search_completions(cx: &mut Context, reg: Option<char>) -> Vec<String> {
@@ -2210,7 +2283,6 @@ fn searcher(cx: &mut Context, direction: Direction) {
     let reg = cx.register.unwrap_or('/');
     let config = cx.editor.config();
     let scrolloff = config.scrolloff;
-    let wrap_around = config.search.wrap_around;
     let movement = if cx.editor.mode() == Mode::Select {
         Movement::Extend
     } else {
@@ -2243,7 +2315,7 @@ fn searcher(cx: &mut Context, direction: Direction) {
                 movement,
                 direction,
                 scrolloff,
-                wrap_around,
+                &config.search,
                 false,
             );
         },
@@ -2264,7 +2336,6 @@ fn search_next_or_prev_impl(cx: &mut Context, movement: Movement, direction: Dir
         } else {
             false
         };
-        let wrap_around = search_config.wrap_around;
         if let Ok(regex) = rope::RegexBuilder::new()
             .syntax(
                 rope::Config::new()
@@ -2280,7 +2351,7 @@ fn search_next_or_prev_impl(cx: &mut Context, movement: Movement, direction: Dir
                     movement,
                     direction,
                     scrolloff,
-                    wrap_around,
+                    search_config,
                     true,
                 );
             }

helix-term/src/ui/statusline.rs

@@ -2,7 +2,7 @@ use helix_core::{coords_at_pos, encoding, Position};
 use helix_lsp::lsp::DiagnosticSeverity;
 use helix_view::document::DEFAULT_LANGUAGE_NAME;
 use helix_view::{
-    document::{Mode, SCRATCH_BUFFER_NAME},
+    document::{Mode, SearchMatch, SearchMatchLimit, SCRATCH_BUFFER_NAME},
     graphics::Rect,
     theme::Style,
     Document, Editor, View,
@@ -163,6 +163,7 @@ where
         helix_view::editor::StatusLineElement::Spacer => render_spacer,
         helix_view::editor::StatusLineElement::VersionControl => render_version_control,
         helix_view::editor::StatusLineElement::Register => render_register,
+        helix_view::editor::StatusLineElement::SearchPosition => render_search_position,
     }
 }
 
@@ -531,3 +532,16 @@ where
         write(context, format!(" reg={} ", reg), None)
     }
 }
+
+fn render_search_position<F>(context: &mut RenderContext, write: F)
+where
+    F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
+{
+    if let Some(SearchMatch { idx, count }) = context.doc.get_last_search_match(context.view.id) {
+        let count_str = match count {
+            SearchMatchLimit::Limitless(count) => format!("{}", count),
+            SearchMatchLimit::Limited(max) => format!(">{}", max),
+        };
+        write(context, format!(" [{}/{}] ", idx, count_str), None);
+    }
+}

helix-view/src/document.rs

@@ -136,12 +136,28 @@ pub enum DocumentOpenError {
     IoError(#[from] io::Error),
 }
 
+#[derive(Debug, Clone, Copy)]
+pub enum SearchMatchLimit {
+    Limitless(usize),
+    Limited(usize),
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct SearchMatch {
+    /// nth match from the beginning of the document.
+    pub idx: usize,
+    /// Total number of matches in the document.
+    pub count: SearchMatchLimit,
+}
+
 pub struct Document {
     pub(crate) id: DocumentId,
     text: Rope,
     selections: HashMap<ViewId, Selection>,
     view_data: HashMap<ViewId, ViewData>,
     pub active_snippet: Option<ActiveSnippet>,
+    /// Current search information.
+    last_search_match: HashMap<ViewId, SearchMatch>,
 
     /// Inlay hints annotations for the document, by view.
     ///
@@ -693,6 +709,7 @@ impl Document {
             text,
             selections: HashMap::default(),
             inlay_hints: HashMap::default(),
+            last_search_match: HashMap::default(),
             inlay_hints_oudated: false,
             view_data: Default::default(),
             indent_style: DEFAULT_INDENT,
@@ -1290,6 +1307,8 @@ impl Document {
 
     /// Select text within the [`Document`].
     pub fn set_selection(&mut self, view_id: ViewId, selection: Selection) {
+        self.last_search_match.remove(&view_id);
+
         // TODO: use a transaction?
         self.selections
             .insert(view_id, selection.ensure_invariants(self.text().slice(..)));
@@ -1299,6 +1318,14 @@ impl Document {
         })
     }
 
+    pub fn set_last_search_match(&mut self, view_id: ViewId, search_match: SearchMatch) {
+        self.last_search_match.insert(view_id, search_match);
+    }
+
+    pub fn get_last_search_match(&self, view_id: ViewId) -> Option<SearchMatch> {
+        self.last_search_match.get(&view_id).copied()
+    }
+
     /// Find the origin selection of the text in a document, i.e. where
     /// a single cursor would go if it were on the first grapheme. If
     /// the text is empty, returns (0, 0).

helix-view/src/editor.rs

@@ -480,6 +480,14 @@ impl Default for LspConfig {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub enum OptionToml<T> {
+    None,
+    #[serde(untagged)]
+    Some(T),
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "kebab-case", default, deny_unknown_fields)]
 pub struct SearchConfig {
@@ -487,6 +495,8 @@ pub struct SearchConfig {
     pub smart_case: bool,
     /// Whether the search should wrap after depleting the matches. Default to true.
     pub wrap_around: bool,
+    /// Maximum number of counted matches when searching in a document. `None` means no limit. Default to 100.
+    pub max_matches: OptionToml<usize>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
@@ -608,6 +618,9 @@ pub enum StatusLineElement {
 
     /// Indicator for selected register
     Register,
+
+    /// Search index and count
+    SearchPosition,
 }
 
 // Cursor shape is read and used on every rendered frame and so needs
@@ -1026,6 +1039,7 @@ impl Default for SearchConfig {
         Self {
             wrap_around: true,
             smart_case: true,
+            max_matches: OptionToml::Some(100),
         }
     }
 }