From c5a4fa78aa8d09f5ea10a1c0e01a6eeb7345e1d9 Mon Sep 17 00:00:00 2001 From: Jesse Luehrs Date: Sat, 18 Jan 2025 02:04:13 -0500 Subject: [PATCH 1/3] write to search registers when selecting by regex --- helix-core/src/selection.rs | 48 ++++++++++++++++++++++++------------- helix-term/src/commands.rs | 3 ++- helix-view/src/register.rs | 39 +++++++++++++++++++++++++++--- 3 files changed, 70 insertions(+), 20 deletions(-) diff --git a/helix-core/src/selection.rs b/helix-core/src/selection.rs index 76de63628..f74e1ab90 100644 --- a/helix-core/src/selection.rs +++ b/helix-core/src/selection.rs @@ -783,13 +783,15 @@ pub fn select_on_matches( text: RopeSlice, selection: &Selection, regex: &rope::Regex, -) -> Option { +) -> Option<(Selection, Vec>)> { 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()); @@ -798,13 +800,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 @@ -1099,9 +1108,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()]] )) ); @@ -1120,7 +1129,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), @@ -1129,23 +1138,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 @@ -1158,9 +1167,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() + ]] )) ); } diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs index ecaa18a0e..12fbd43a3 100644 --- a/helix-term/src/commands.rs +++ b/helix-term/src/commands.rs @@ -2012,10 +2012,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), ®ex) { doc.set_selection(view.id, selection); + cx.editor.registers.write_search_results(captures); } else { cx.editor.set_error("nothing selected"); } diff --git a/helix-view/src/register.rs b/helix-view/src/register.rs index d286a85cc..d34b94867 100644 --- a/helix-view/src/register.rs +++ b/helix-view/src/register.rs @@ -80,7 +80,9 @@ impl Registers { pub fn write(&mut self, name: char, mut values: Vec) -> 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,17 @@ impl Registers { } } + pub fn write_search_results(&mut self, search_results: Vec>) { + 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 first<'a>(&'a self, name: char, editor: &'a Editor) -> Option> { self.read(name, editor).and_then(|mut values| values.next()) } @@ -168,6 +183,16 @@ impl Registers { ('%', ""), ('+', ""), ('*', ""), + ('&', ""), + ('1', ""), + ('2', ""), + ('3', ""), + ('4', ""), + ('5', ""), + ('6', ""), + ('7', ""), + ('8', ""), + ('9', ""), ] .iter() .copied(), @@ -192,7 +217,7 @@ impl Registers { true } - '_' | '#' | '.' | '%' => false, + '_' | '#' | '.' | '%' | '&' | '1'..='9' => false, _ => self.inner.remove(&name).is_some(), } } @@ -218,6 +243,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>, From 22dd74b0bb7b63c50e3013f253d39f9f94365f1c Mon Sep 17 00:00:00 2001 From: Jesse Luehrs Date: Sat, 18 Jan 2025 02:04:13 -0500 Subject: [PATCH 2/3] remove the corresponding capture group when removing a selection --- helix-core/src/selection.rs | 17 +++++++++++++---- helix-term/src/commands.rs | 17 ++++++++++++++--- helix-view/src/register.rs | 13 +++++++++++++ 3 files changed, 40 insertions(+), 7 deletions(-) diff --git a/helix-core/src/selection.rs b/helix-core/src/selection.rs index f74e1ab90..5c932d8a4 100644 --- a/helix-core/src/selection.rs +++ b/helix-core/src/selection.rs @@ -764,18 +764,27 @@ pub fn keep_or_remove_matches( selection: &Selection, regex: &rope::Regex, remove: bool, -) -> Option { +) -> (Option, Vec) { + 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 diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs index 12fbd43a3..50b7cab5f 100644 --- a/helix-term/src/commands.rs +++ b/helix-term/src/commands.rs @@ -4883,13 +4883,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), ®ex, 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, ®ex, 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); + } + } }, ) } @@ -4928,6 +4936,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); diff --git a/helix-view/src/register.rs b/helix-view/src/register.rs index d34b94867..9a5459576 100644 --- a/helix-view/src/register.rs +++ b/helix-view/src/register.rs @@ -155,6 +155,19 @@ impl Registers { } } + 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> { self.read(name, editor).and_then(|mut values| values.next()) } From 916dfa06fcf7735c41c46b3815c6dcfe27882633 Mon Sep 17 00:00:00 2001 From: Jesse Luehrs Date: Sat, 18 Jan 2025 02:04:13 -0500 Subject: [PATCH 3/3] update capture groups when doing additional searches --- helix-term/src/commands.rs | 71 ++++++++++++++++++++++++++++++++------ helix-view/src/register.rs | 14 ++++++++ 2 files changed, 74 insertions(+), 11 deletions(-) diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs index 50b7cab5f..8b5243213 100644 --- a/helix-term/src/commands.rs +++ b/helix-term/src/commands.rs @@ -2097,20 +2097,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"); @@ -2122,7 +2133,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()); @@ -2135,11 +2146,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); }; diff --git a/helix-view/src/register.rs b/helix-view/src/register.rs index 9a5459576..18ce3919f 100644 --- a/helix-view/src/register.rs +++ b/helix-view/src/register.rs @@ -155,6 +155,20 @@ impl Registers { } } + pub fn insert_search_result(&mut self, idx: usize, search_results: Vec) { + 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 {