Merge 916dfa06fc into 7ebf650029

helix-core/src/selection.rs

@@ -769,18 +769,27 @@ pub fn keep_or_remove_matches(
     selection: &Selection,
     regex: &rope::Regex,
     remove: bool,
-) -> Option<Selection> {
+) -> (Option<Selection>, Vec<usize>) {
+    let mut to_remove = vec![];
     let result: SmallVec<_> = selection
         .iter()
-        .filter(|range| regex.is_match(text.regex_input_at(range.from()..range.to())) ^ remove)
+        .enumerate()
+        .filter(|(i, range)| {
+            let keep = regex.is_match(text.regex_input_at(range.from()..range.to())) ^ remove;
+            if !keep {
+                to_remove.push(*i);
+            }
+            keep
+        })
+        .map(|(_, range)| range)
         .copied()
         .collect();
 
     // TODO: figure out a new primary index
     if !result.is_empty() {
-        return Some(Selection::new(result, 0));
+        return (Some(Selection::new(result, 0)), to_remove);
     }
-    None
+    (None, to_remove)
 }
 
 // TODO: support to split on capture #N instead of whole match
@@ -788,13 +797,15 @@ pub fn select_on_matches(
     text: RopeSlice,
     selection: &Selection,
     regex: &rope::Regex,
-) -> Option<Selection> {
+) -> Option<(Selection, Vec<Vec<String>>)> {
     let mut result = SmallVec::with_capacity(selection.len());
+    let mut captures = vec![vec![]; regex.captures_len()];
 
     for sel in selection {
-        for mat in regex.find_iter(text.regex_input_at(sel.from()..sel.to())) {
+        for cap in regex.captures_iter(text.regex_input_at(sel.from()..sel.to())) {
             // TODO: retain range direction
 
+            let mat = cap.get_match().unwrap();
             let start = text.byte_to_char(mat.start());
             let end = text.byte_to_char(mat.end());
 
@@ -803,13 +814,20 @@ pub fn select_on_matches(
             // These invalid matches can come from using RegEx anchors like `^`, `$`
             if range != Range::point(sel.to()) {
                 result.push(range);
+                for (i, captures) in captures.iter_mut().enumerate() {
+                    captures.push(
+                        cap.get_group(i)
+                            .map(|group| text.slice(group.range()).to_string())
+                            .unwrap_or_default(),
+                    );
+                }
             }
         }
     }
 
     // TODO: figure out a new primary index
     if !result.is_empty() {
-        return Some(Selection::new(result, 0));
+        return Some((Selection::new(result, 0), captures));
     }
 
     None
@@ -1104,9 +1122,9 @@ mod test {
         let selection = Selection::single(0, r.len_chars());
         assert_eq!(
             select_on_matches(s, &selection, &rope::Regex::new(r"[A-Z][a-z]*").unwrap()),
-            Some(Selection::new(
-                smallvec![Range::new(0, 6), Range::new(19, 26)],
-                0
+            Some((
+                Selection::new(smallvec![Range::new(0, 6), Range::new(19, 26)], 0),
+                vec![vec!["Nobody".to_string(), "Spanish".to_string()]]
             ))
         );
 
@@ -1125,7 +1143,7 @@ mod test {
         // line without ending
         assert_eq!(
             select_on_matches(s, &Selection::single(0, 4), &start_of_line),
-            Some(Selection::single(0, 0))
+            Some((Selection::single(0, 0), vec![vec!["".to_string()]]))
         );
         assert_eq!(
             select_on_matches(s, &Selection::single(0, 4), &end_of_line),
@@ -1134,23 +1152,23 @@ mod test {
         // line with ending
         assert_eq!(
             select_on_matches(s, &Selection::single(0, 5), &start_of_line),
-            Some(Selection::single(0, 0))
+            Some((Selection::single(0, 0), vec![vec!["".to_string()]]))
         );
         assert_eq!(
             select_on_matches(s, &Selection::single(0, 5), &end_of_line),
-            Some(Selection::single(4, 4))
+            Some((Selection::single(4, 4), vec![vec!["".to_string()]]))
         );
         // line with start of next line
         assert_eq!(
             select_on_matches(s, &Selection::single(0, 6), &start_of_line),
-            Some(Selection::new(
-                smallvec![Range::point(0), Range::point(5)],
-                0
+            Some((
+                Selection::new(smallvec![Range::point(0), Range::point(5)], 0),
+                vec![vec!["".to_string(), "".to_string()]]
             ))
         );
         assert_eq!(
             select_on_matches(s, &Selection::single(0, 6), &end_of_line),
-            Some(Selection::single(4, 4))
+            Some((Selection::single(4, 4), vec![vec!["".to_string()]]))
         );
 
         // multiple lines
@@ -1163,9 +1181,16 @@ mod test {
                     .build(r"^[a-z ]*$")
                     .unwrap()
             ),
-            Some(Selection::new(
-                smallvec![Range::point(12), Range::new(13, 30), Range::new(31, 36)],
-                0
+            Some((
+                Selection::new(
+                    smallvec![Range::point(12), Range::new(13, 30), Range::new(31, 36)],
+                    0
+                ),
+                vec![vec![
+                    "".to_string(),
+                    "contains multiple".to_string(),
+                    "lines".to_string()
+                ]]
             ))
         );
     }

helix-term/src/commands.rs

@@ -2057,10 +2057,11 @@ fn select_regex(cx: &mut Context) {
                 return;
             }
             let text = doc.text().slice(..);
-            if let Some(selection) =
+            if let Some((selection, captures)) =
                 selection::select_on_matches(text, doc.selection(view.id), &regex)
             {
                 doc.set_selection(view.id, selection);
+                cx.editor.registers.write_search_results(captures);
             } else {
                 cx.editor.set_error("nothing selected");
             }
@@ -2141,20 +2142,31 @@ fn search_impl(
 
     // 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 cap = regex.create_captures();
+    match direction {
+        Direction::Forward => regex.captures(doc.regex_input_at_bytes(start..), &mut cap),
+        Direction::Backward => {
+            cap = regex
+                .captures_iter(doc.regex_input_at_bytes(..start))
+                .last()
+                .unwrap_or(cap)
+        }
+    }
 
-    if mat.is_none() {
+    if !cap.is_match() {
         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(),
+            match direction {
+                Direction::Forward => regex.captures(doc.regex_input(), &mut cap),
+                Direction::Backward => {
+                    cap = regex
+                        .captures_iter(doc.regex_input_at_bytes(start..))
+                        .last()
+                        .unwrap_or(cap)
+                }
             };
         }
         if show_warnings {
-            if wrap_around && mat.is_some() {
+            if wrap_around && cap.is_match() {
                 editor.set_status("Wrapped around document");
             } else {
                 editor.set_error("No more matches");
@@ -2166,7 +2178,7 @@ fn search_impl(
     let text = doc.text().slice(..);
     let selection = doc.selection(view.id);
 
-    if let Some(mat) = mat {
+    if let Some(mat) = cap.get_match() {
         let start = text.byte_to_char(mat.start());
         let end = text.byte_to_char(mat.end());
 
@@ -2179,11 +2191,49 @@ fn search_impl(
         let primary = selection.primary();
         let range = Range::new(start, end).with_direction(primary.direction());
 
+        let should_update_search_results =
+            selection.len() == editor.registers.search_result_count();
         let selection = match movement {
             Movement::Extend => selection.clone().push(range),
-            Movement::Move => selection.clone().replace(selection.primary_index(), range),
+            Movement::Move => {
+                if should_update_search_results {
+                    editor
+                        .registers
+                        .remove_search_result(selection.primary_index());
+                }
+                selection.clone().replace(selection.primary_index(), range)
+            }
         };
 
+        let capture_groups = cap
+            .iter()
+            .map(|span| {
+                span.map(|span| text.slice(span.range()).to_string())
+                    .unwrap_or_default()
+            })
+            .collect();
+        if should_update_search_results {
+            if selection.len() == editor.registers.search_result_count() {
+                editor
+                    .registers
+                    .remove_search_result(selection.primary_index());
+            }
+            editor
+                .registers
+                .insert_search_result(selection.primary_index(), capture_groups);
+        } else {
+            editor.registers.write_search_results(vec![
+                vec!["".to_string(); selection.len()];
+                regex.captures_len()
+            ]);
+            editor
+                .registers
+                .remove_search_result(selection.primary_index());
+            editor
+                .registers
+                .insert_search_result(selection.primary_index(), capture_groups);
+        }
+
         doc.set_selection(view.id, selection);
         view.ensure_cursor_in_view_center(doc, scrolloff);
     };
@@ -5029,13 +5079,21 @@ fn keep_or_remove_selections_impl(cx: &mut Context, remove: bool) {
             }
             let text = doc.text().slice(..);
 
-            if let Some(selection) =
-                selection::keep_or_remove_matches(text, doc.selection(view.id), &regex, remove)
-            {
+            let selection = doc.selection(view.id);
+            let should_update_search_results =
+                selection.len() == cx.editor.registers.search_result_count();
+            let (selection, to_remove) =
+                selection::keep_or_remove_matches(text, selection, &regex, remove);
+            if let Some(selection) = selection {
                 doc.set_selection(view.id, selection);
             } else {
                 cx.editor.set_error("no selections remaining");
             }
+            if should_update_search_results {
+                for idx in to_remove.into_iter().rev() {
+                    cx.editor.registers.remove_search_result(idx);
+                }
+            }
         },
     )
 }
@@ -5074,6 +5132,9 @@ fn remove_primary_selection(cx: &mut Context) {
         return;
     }
     let index = selection.primary_index();
+    if selection.len() == cx.editor.registers.search_result_count() {
+        cx.editor.registers.remove_search_result(index);
+    }
     let selection = selection.clone().remove(index);
 
     doc.set_selection(view.id, selection);

helix-view/src/register.rs

@@ -80,7 +80,9 @@ impl Registers {
     pub fn write(&mut self, name: char, mut values: Vec<String>) -> Result<()> {
         match name {
             '_' => Ok(()),
-            '#' | '.' | '%' => Err(anyhow::anyhow!("Register {name} does not support writing")),
+            '#' | '.' | '%' | '&' | '1'..='9' => {
+                Err(anyhow::anyhow!("Register {name} does not support writing"))
+            }
             '*' | '+' => {
                 self.clipboard_provider.load().set_contents(
                     &values.join(NATIVE_LINE_ENDING.as_str()),
@@ -105,7 +107,9 @@ impl Registers {
     pub fn push(&mut self, name: char, mut value: String) -> Result<()> {
         match name {
             '_' => Ok(()),
-            '#' | '.' | '%' => Err(anyhow::anyhow!("Register {name} does not support pushing")),
+            '#' | '.' | '%' | '&' | '1'..='9' => {
+                Err(anyhow::anyhow!("Register {name} does not support pushing"))
+            }
             '*' | '+' => {
                 let clipboard_type = match name {
                     '+' => ClipboardType::Clipboard,
@@ -140,6 +144,44 @@ impl Registers {
         }
     }
 
+    pub fn write_search_results(&mut self, search_results: Vec<Vec<String>>) {
+        let len = search_results.len();
+        for (i, mut values) in search_results.into_iter().enumerate() {
+            values.reverse();
+            self.inner.insert(search_register_name(i), values);
+        }
+        for i in len..=9 {
+            self.inner.remove(&search_register_name(i));
+        }
+    }
+
+    pub fn insert_search_result(&mut self, idx: usize, search_results: Vec<String>) {
+        let idx = self.search_result_count() - idx;
+        let len = search_results.len();
+        for (i, value) in search_results.into_iter().enumerate() {
+            let entry = self.inner.entry(search_register_name(i)).or_default();
+            entry.insert(idx, value);
+        }
+        for i in len..=9 {
+            if let Some(entry) = self.inner.get_mut(&search_register_name(i)) {
+                entry.insert(idx, String::new());
+            }
+        }
+    }
+
+    pub fn remove_search_result(&mut self, idx: usize) {
+        let idx = self.search_result_count() - idx - 1;
+        for i in 0..=9 {
+            if let Some(entry) = self.inner.get_mut(&search_register_name(i)) {
+                entry.remove(idx);
+            }
+        }
+    }
+
+    pub fn search_result_count(&self) -> usize {
+        self.inner.get(&'&').map(|v| v.len()).unwrap_or(0)
+    }
+
     pub fn first<'a>(&'a self, name: char, editor: &'a Editor) -> Option<Cow<'a, str>> {
         self.read(name, editor).and_then(|mut values| values.next())
     }
@@ -168,6 +210,16 @@ impl Registers {
                     ('%', "<document path>"),
                     ('+', "<system clipboard>"),
                     ('*', "<primary clipboard>"),
+                    ('&', "<last regex match>"),
+                    ('1', "<last regex match group 1>"),
+                    ('2', "<last regex match group 2>"),
+                    ('3', "<last regex match group 3>"),
+                    ('4', "<last regex match group 4>"),
+                    ('5', "<last regex match group 5>"),
+                    ('6', "<last regex match group 6>"),
+                    ('7', "<last regex match group 7>"),
+                    ('8', "<last regex match group 8>"),
+                    ('9', "<last regex match group 9>"),
                 ]
                 .iter()
                 .copied(),
@@ -192,7 +244,7 @@ impl Registers {
 
                 true
             }
-            '_' | '#' | '.' | '%' => false,
+            '_' | '#' | '.' | '%' | '&' | '1'..='9' => false,
             _ => self.inner.remove(&name).is_some(),
         }
     }
@@ -218,6 +270,14 @@ impl Registers {
     }
 }
 
+fn search_register_name(i: usize) -> char {
+    if i == 0 {
+        '&'
+    } else {
+        char::from(i as u8 + b'0')
+    }
+}
+
 fn read_from_clipboard<'a>(
     provider: &ClipboardProvider,
     saved_values: Option<&'a Vec<String>>,