6929a12f29
* Make `m` textobject look for pairs enclosing selections Right now, this textobject only looks for pairs that surround the cursor. This ensures that the pair found encloses each selection, which is likely to be intuitively what is expected of this textobject. * Simplification of match code Co-authored-by: Michael Davis <mcarsondavis@gmail.com> * Adjust logic for ensuring surround range encloses selection Prior, it was missing the case where the start of the selection came before the opening brace. We also had an off-by-one error where if the end of the selection was on the closing brace it would not work. * Refactor to search for the open pair specifically to avoid edge cases * Adjust wording of autoinfo to reflect new functionality * Implement tests for surround functionality in new integration style * Fix handling of skip values * Fix out of bounds error * Add `ma` version of tests * Fix formatting of tests * Reduce indentation levels for readability, and update comments * Preserve each selection's direction with enclosing pair surround * Add test case for multiple cursors resulting in overlap * Mark known failures as TODO * Make tests multi-threaded or they fail * Cargo fmt * Fix typos in integration test comments --------- Co-authored-by: Michael Davis <mcarsondavis@gmail.com>
588 lines
20 KiB
Rust
588 lines
20 KiB
Rust
use std::fmt::Display;
|
|
|
|
use ropey::RopeSlice;
|
|
use tree_sitter::{Node, QueryCursor};
|
|
|
|
use crate::chars::{categorize_char, char_is_whitespace, CharCategory};
|
|
use crate::graphemes::{next_grapheme_boundary, prev_grapheme_boundary};
|
|
use crate::line_ending::rope_is_line_ending;
|
|
use crate::movement::Direction;
|
|
use crate::surround;
|
|
use crate::syntax::LanguageConfiguration;
|
|
use crate::Range;
|
|
|
|
fn find_word_boundary(slice: RopeSlice, mut pos: usize, direction: Direction, long: bool) -> usize {
|
|
use CharCategory::{Eol, Whitespace};
|
|
|
|
let iter = match direction {
|
|
Direction::Forward => slice.chars_at(pos),
|
|
Direction::Backward => {
|
|
let mut iter = slice.chars_at(pos);
|
|
iter.reverse();
|
|
iter
|
|
}
|
|
};
|
|
|
|
let mut prev_category = match direction {
|
|
Direction::Forward if pos == 0 => Whitespace,
|
|
Direction::Forward => categorize_char(slice.char(pos - 1)),
|
|
Direction::Backward if pos == slice.len_chars() => Whitespace,
|
|
Direction::Backward => categorize_char(slice.char(pos)),
|
|
};
|
|
|
|
for ch in iter {
|
|
match categorize_char(ch) {
|
|
Eol | Whitespace => return pos,
|
|
category => {
|
|
if !long && category != prev_category && pos != 0 && pos != slice.len_chars() {
|
|
return pos;
|
|
} else {
|
|
match direction {
|
|
Direction::Forward => pos += 1,
|
|
Direction::Backward => pos = pos.saturating_sub(1),
|
|
}
|
|
prev_category = category;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pos
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
|
|
pub enum TextObject {
|
|
Around,
|
|
Inside,
|
|
/// Used for moving between objects.
|
|
Movement,
|
|
}
|
|
|
|
impl Display for TextObject {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
f.write_str(match self {
|
|
Self::Around => "around",
|
|
Self::Inside => "inside",
|
|
Self::Movement => "movement",
|
|
})
|
|
}
|
|
}
|
|
|
|
// count doesn't do anything yet
|
|
pub fn textobject_word(
|
|
slice: RopeSlice,
|
|
range: Range,
|
|
textobject: TextObject,
|
|
_count: usize,
|
|
long: bool,
|
|
) -> Range {
|
|
let pos = range.cursor(slice);
|
|
|
|
let word_start = find_word_boundary(slice, pos, Direction::Backward, long);
|
|
let word_end = match slice.get_char(pos).map(categorize_char) {
|
|
None | Some(CharCategory::Whitespace | CharCategory::Eol) => pos,
|
|
_ => find_word_boundary(slice, pos + 1, Direction::Forward, long),
|
|
};
|
|
|
|
// Special case.
|
|
if word_start == word_end {
|
|
return Range::new(word_start, word_end);
|
|
}
|
|
|
|
match textobject {
|
|
TextObject::Inside => Range::new(word_start, word_end),
|
|
TextObject::Around => {
|
|
let whitespace_count_right = slice
|
|
.chars_at(word_end)
|
|
.take_while(|c| char_is_whitespace(*c))
|
|
.count();
|
|
|
|
if whitespace_count_right > 0 {
|
|
Range::new(word_start, word_end + whitespace_count_right)
|
|
} else {
|
|
let whitespace_count_left = {
|
|
let mut iter = slice.chars_at(word_start);
|
|
iter.reverse();
|
|
iter.take_while(|c| char_is_whitespace(*c)).count()
|
|
};
|
|
Range::new(word_start - whitespace_count_left, word_end)
|
|
}
|
|
}
|
|
TextObject::Movement => unreachable!(),
|
|
}
|
|
}
|
|
|
|
pub fn textobject_paragraph(
|
|
slice: RopeSlice,
|
|
range: Range,
|
|
textobject: TextObject,
|
|
count: usize,
|
|
) -> Range {
|
|
let mut line = range.cursor_line(slice);
|
|
let prev_line_empty = rope_is_line_ending(slice.line(line.saturating_sub(1)));
|
|
let curr_line_empty = rope_is_line_ending(slice.line(line));
|
|
let next_line_empty = rope_is_line_ending(slice.line(line.saturating_sub(1)));
|
|
let last_char =
|
|
prev_grapheme_boundary(slice, slice.line_to_char(line + 1)) == range.cursor(slice);
|
|
let prev_empty_to_line = prev_line_empty && !curr_line_empty;
|
|
let curr_empty_to_line = curr_line_empty && !next_line_empty;
|
|
|
|
// skip character before paragraph boundary
|
|
let mut line_back = line; // line but backwards
|
|
if prev_empty_to_line || curr_empty_to_line {
|
|
line_back += 1;
|
|
}
|
|
// do not include current paragraph on paragraph end (include next)
|
|
if !(curr_empty_to_line && last_char) {
|
|
let mut lines = slice.lines_at(line_back);
|
|
lines.reverse();
|
|
let mut lines = lines.map(rope_is_line_ending).peekable();
|
|
while lines.next_if(|&e| e).is_some() {
|
|
line_back -= 1;
|
|
}
|
|
while lines.next_if(|&e| !e).is_some() {
|
|
line_back -= 1;
|
|
}
|
|
}
|
|
|
|
// skip character after paragraph boundary
|
|
if curr_empty_to_line && last_char {
|
|
line += 1;
|
|
}
|
|
let mut lines = slice.lines_at(line).map(rope_is_line_ending).peekable();
|
|
let mut count_done = 0; // count how many non-whitespace paragraphs done
|
|
for _ in 0..count {
|
|
let mut done = false;
|
|
while lines.next_if(|&e| !e).is_some() {
|
|
line += 1;
|
|
done = true;
|
|
}
|
|
while lines.next_if(|&e| e).is_some() {
|
|
line += 1;
|
|
}
|
|
count_done += done as usize;
|
|
}
|
|
|
|
// search one paragraph backwards for last paragraph
|
|
// makes `map` at the end of the paragraph with trailing newlines useful
|
|
let last_paragraph = count_done != count && lines.peek().is_none();
|
|
if last_paragraph {
|
|
let mut lines = slice.lines_at(line_back);
|
|
lines.reverse();
|
|
let mut lines = lines.map(rope_is_line_ending).peekable();
|
|
while lines.next_if(|&e| e).is_some() {
|
|
line_back -= 1;
|
|
}
|
|
while lines.next_if(|&e| !e).is_some() {
|
|
line_back -= 1;
|
|
}
|
|
}
|
|
|
|
// handle last whitespaces part separately depending on textobject
|
|
match textobject {
|
|
TextObject::Around => {}
|
|
TextObject::Inside => {
|
|
// remove last whitespace paragraph
|
|
let mut lines = slice.lines_at(line);
|
|
lines.reverse();
|
|
let mut lines = lines.map(rope_is_line_ending).peekable();
|
|
while lines.next_if(|&e| e).is_some() {
|
|
line -= 1;
|
|
}
|
|
}
|
|
TextObject::Movement => unreachable!(),
|
|
}
|
|
|
|
let anchor = slice.line_to_char(line_back);
|
|
let head = slice.line_to_char(line);
|
|
Range::new(anchor, head)
|
|
}
|
|
|
|
pub fn textobject_pair_surround(
|
|
slice: RopeSlice,
|
|
range: Range,
|
|
textobject: TextObject,
|
|
ch: char,
|
|
count: usize,
|
|
) -> Range {
|
|
textobject_pair_surround_impl(slice, range, textobject, Some(ch), count)
|
|
}
|
|
|
|
pub fn textobject_pair_surround_closest(
|
|
slice: RopeSlice,
|
|
range: Range,
|
|
textobject: TextObject,
|
|
count: usize,
|
|
) -> Range {
|
|
textobject_pair_surround_impl(slice, range, textobject, None, count)
|
|
}
|
|
|
|
fn textobject_pair_surround_impl(
|
|
slice: RopeSlice,
|
|
range: Range,
|
|
textobject: TextObject,
|
|
ch: Option<char>,
|
|
count: usize,
|
|
) -> Range {
|
|
let pair_pos = match ch {
|
|
Some(ch) => surround::find_nth_pairs_pos(slice, ch, range, count),
|
|
// Automatically find the closest surround pairs
|
|
None => surround::find_nth_closest_pairs_pos(slice, range, count),
|
|
};
|
|
pair_pos
|
|
.map(|(anchor, head)| match textobject {
|
|
TextObject::Inside => {
|
|
if anchor < head {
|
|
Range::new(next_grapheme_boundary(slice, anchor), head)
|
|
} else {
|
|
Range::new(anchor, next_grapheme_boundary(slice, head))
|
|
}
|
|
}
|
|
TextObject::Around => {
|
|
if anchor < head {
|
|
Range::new(anchor, next_grapheme_boundary(slice, head))
|
|
} else {
|
|
Range::new(next_grapheme_boundary(slice, anchor), head)
|
|
}
|
|
}
|
|
TextObject::Movement => unreachable!(),
|
|
})
|
|
.unwrap_or(range)
|
|
}
|
|
|
|
/// Transform the given range to select text objects based on tree-sitter.
|
|
/// `object_name` is a query capture base name like "function", "class", etc.
|
|
/// `slice_tree` is the tree-sitter node corresponding to given text slice.
|
|
pub fn textobject_treesitter(
|
|
slice: RopeSlice,
|
|
range: Range,
|
|
textobject: TextObject,
|
|
object_name: &str,
|
|
slice_tree: Node,
|
|
lang_config: &LanguageConfiguration,
|
|
_count: usize,
|
|
) -> Range {
|
|
let get_range = move || -> Option<Range> {
|
|
let byte_pos = slice.char_to_byte(range.cursor(slice));
|
|
|
|
let capture_name = format!("{}.{}", object_name, textobject); // eg. function.inner
|
|
let mut cursor = QueryCursor::new();
|
|
let node = lang_config
|
|
.textobject_query()?
|
|
.capture_nodes(&capture_name, slice_tree, slice, &mut cursor)?
|
|
.filter(|node| node.byte_range().contains(&byte_pos))
|
|
.min_by_key(|node| node.byte_range().len())?;
|
|
|
|
let len = slice.len_bytes();
|
|
let start_byte = node.start_byte();
|
|
let end_byte = node.end_byte();
|
|
if start_byte >= len || end_byte >= len {
|
|
return None;
|
|
}
|
|
|
|
let start_char = slice.byte_to_char(start_byte);
|
|
let end_char = slice.byte_to_char(end_byte);
|
|
|
|
Some(Range::new(start_char, end_char))
|
|
};
|
|
get_range().unwrap_or(range)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::TextObject::*;
|
|
use super::*;
|
|
|
|
use crate::Range;
|
|
use ropey::Rope;
|
|
|
|
#[test]
|
|
fn test_textobject_word() {
|
|
// (text, [(char position, textobject, final range), ...])
|
|
let tests = &[
|
|
(
|
|
"cursor at beginning of doc",
|
|
vec![(0, Inside, (0, 6)), (0, Around, (0, 7))],
|
|
),
|
|
(
|
|
"cursor at middle of word",
|
|
vec![
|
|
(13, Inside, (10, 16)),
|
|
(10, Inside, (10, 16)),
|
|
(15, Inside, (10, 16)),
|
|
(13, Around, (10, 17)),
|
|
(10, Around, (10, 17)),
|
|
(15, Around, (10, 17)),
|
|
],
|
|
),
|
|
(
|
|
"cursor between word whitespace",
|
|
vec![(6, Inside, (6, 6)), (6, Around, (6, 6))],
|
|
),
|
|
(
|
|
"cursor on word before newline\n",
|
|
vec![
|
|
(22, Inside, (22, 29)),
|
|
(28, Inside, (22, 29)),
|
|
(25, Inside, (22, 29)),
|
|
(22, Around, (21, 29)),
|
|
(28, Around, (21, 29)),
|
|
(25, Around, (21, 29)),
|
|
],
|
|
),
|
|
(
|
|
"cursor on newline\nnext line",
|
|
vec![(17, Inside, (17, 17)), (17, Around, (17, 17))],
|
|
),
|
|
(
|
|
"cursor on word after newline\nnext line",
|
|
vec![
|
|
(29, Inside, (29, 33)),
|
|
(30, Inside, (29, 33)),
|
|
(32, Inside, (29, 33)),
|
|
(29, Around, (29, 34)),
|
|
(30, Around, (29, 34)),
|
|
(32, Around, (29, 34)),
|
|
],
|
|
),
|
|
(
|
|
"cursor on #$%:;* punctuation",
|
|
vec![
|
|
(13, Inside, (10, 16)),
|
|
(10, Inside, (10, 16)),
|
|
(15, Inside, (10, 16)),
|
|
(13, Around, (10, 17)),
|
|
(10, Around, (10, 17)),
|
|
(15, Around, (10, 17)),
|
|
],
|
|
),
|
|
(
|
|
"cursor on punc%^#$:;.tuation",
|
|
vec![
|
|
(14, Inside, (14, 21)),
|
|
(20, Inside, (14, 21)),
|
|
(17, Inside, (14, 21)),
|
|
(14, Around, (14, 21)),
|
|
(20, Around, (14, 21)),
|
|
(17, Around, (14, 21)),
|
|
],
|
|
),
|
|
(
|
|
"cursor in extra whitespace",
|
|
vec![
|
|
(9, Inside, (9, 9)),
|
|
(10, Inside, (10, 10)),
|
|
(11, Inside, (11, 11)),
|
|
(9, Around, (9, 9)),
|
|
(10, Around, (10, 10)),
|
|
(11, Around, (11, 11)),
|
|
],
|
|
),
|
|
(
|
|
"cursor on word with extra whitespace",
|
|
vec![(11, Inside, (10, 14)), (11, Around, (10, 17))],
|
|
),
|
|
(
|
|
"cursor at end with extra whitespace",
|
|
vec![(28, Inside, (27, 37)), (28, Around, (24, 37))],
|
|
),
|
|
(
|
|
"cursor at end of doc",
|
|
vec![(19, Inside, (17, 20)), (19, Around, (16, 20))],
|
|
),
|
|
];
|
|
|
|
for (sample, scenario) in tests {
|
|
let doc = Rope::from(*sample);
|
|
let slice = doc.slice(..);
|
|
for &case in scenario {
|
|
let (pos, objtype, expected_range) = case;
|
|
// cursor is a single width selection
|
|
let range = Range::new(pos, pos + 1);
|
|
let result = textobject_word(slice, range, objtype, 1, false);
|
|
assert_eq!(
|
|
result,
|
|
expected_range.into(),
|
|
"\nCase failed: {:?} - {:?}",
|
|
sample,
|
|
case
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_textobject_paragraph_inside_single() {
|
|
let tests = [
|
|
("#[|]#", "#[|]#"),
|
|
("firs#[t|]#\n\nparagraph\n\n", "#[first\n|]#\nparagraph\n\n"),
|
|
(
|
|
"second\n\npa#[r|]#agraph\n\n",
|
|
"second\n\n#[paragraph\n|]#\n",
|
|
),
|
|
("#[f|]#irst char\n\n", "#[first char\n|]#\n"),
|
|
("last char\n#[\n|]#", "#[last char\n|]#\n"),
|
|
(
|
|
"empty to line\n#[\n|]#paragraph boundary\n\n",
|
|
"empty to line\n\n#[paragraph boundary\n|]#\n",
|
|
),
|
|
(
|
|
"line to empty\n\n#[p|]#aragraph boundary\n\n",
|
|
"line to empty\n\n#[paragraph boundary\n|]#\n",
|
|
),
|
|
];
|
|
|
|
for (before, expected) in tests {
|
|
let (s, selection) = crate::test::print(before);
|
|
let text = Rope::from(s.as_str());
|
|
let selection = selection
|
|
.transform(|r| textobject_paragraph(text.slice(..), r, TextObject::Inside, 1));
|
|
let actual = crate::test::plain(&s, selection);
|
|
assert_eq!(actual, expected, "\nbefore: `{:?}`", before);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_textobject_paragraph_inside_double() {
|
|
let tests = [
|
|
(
|
|
"last two\n\n#[p|]#aragraph\n\nwithout whitespaces\n\n",
|
|
"last two\n\n#[paragraph\n\nwithout whitespaces\n|]#\n",
|
|
),
|
|
(
|
|
"last two\n#[\n|]#paragraph\n\nwithout whitespaces\n\n",
|
|
"last two\n\n#[paragraph\n\nwithout whitespaces\n|]#\n",
|
|
),
|
|
];
|
|
|
|
for (before, expected) in tests {
|
|
let (s, selection) = crate::test::print(before);
|
|
let text = Rope::from(s.as_str());
|
|
let selection = selection
|
|
.transform(|r| textobject_paragraph(text.slice(..), r, TextObject::Inside, 2));
|
|
let actual = crate::test::plain(&s, selection);
|
|
assert_eq!(actual, expected, "\nbefore: `{:?}`", before);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_textobject_paragraph_around_single() {
|
|
let tests = [
|
|
("#[|]#", "#[|]#"),
|
|
("firs#[t|]#\n\nparagraph\n\n", "#[first\n\n|]#paragraph\n\n"),
|
|
(
|
|
"second\n\npa#[r|]#agraph\n\n",
|
|
"second\n\n#[paragraph\n\n|]#",
|
|
),
|
|
("#[f|]#irst char\n\n", "#[first char\n\n|]#"),
|
|
("last char\n#[\n|]#", "#[last char\n\n|]#"),
|
|
(
|
|
"empty to line\n#[\n|]#paragraph boundary\n\n",
|
|
"empty to line\n\n#[paragraph boundary\n\n|]#",
|
|
),
|
|
(
|
|
"line to empty\n\n#[p|]#aragraph boundary\n\n",
|
|
"line to empty\n\n#[paragraph boundary\n\n|]#",
|
|
),
|
|
];
|
|
|
|
for (before, expected) in tests {
|
|
let (s, selection) = crate::test::print(before);
|
|
let text = Rope::from(s.as_str());
|
|
let selection = selection
|
|
.transform(|r| textobject_paragraph(text.slice(..), r, TextObject::Around, 1));
|
|
let actual = crate::test::plain(&s, selection);
|
|
assert_eq!(actual, expected, "\nbefore: `{:?}`", before);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_textobject_surround() {
|
|
// (text, [(cursor position, textobject, final range, surround char, count), ...])
|
|
let tests = &[
|
|
(
|
|
"simple (single) surround pairs",
|
|
vec![
|
|
(3, Inside, (3, 3), '(', 1),
|
|
(7, Inside, (8, 14), ')', 1),
|
|
(10, Inside, (8, 14), '(', 1),
|
|
(14, Inside, (8, 14), ')', 1),
|
|
(3, Around, (3, 3), '(', 1),
|
|
(7, Around, (7, 15), ')', 1),
|
|
(10, Around, (7, 15), '(', 1),
|
|
(14, Around, (7, 15), ')', 1),
|
|
],
|
|
),
|
|
(
|
|
"samexx 'single' surround pairs",
|
|
vec![
|
|
(3, Inside, (3, 3), '\'', 1),
|
|
(7, Inside, (7, 7), '\'', 1),
|
|
(10, Inside, (8, 14), '\'', 1),
|
|
(14, Inside, (14, 14), '\'', 1),
|
|
(3, Around, (3, 3), '\'', 1),
|
|
(7, Around, (7, 7), '\'', 1),
|
|
(10, Around, (7, 15), '\'', 1),
|
|
(14, Around, (14, 14), '\'', 1),
|
|
],
|
|
),
|
|
(
|
|
"(nested (surround (pairs)) 3 levels)",
|
|
vec![
|
|
(0, Inside, (1, 35), '(', 1),
|
|
(6, Inside, (1, 35), ')', 1),
|
|
(8, Inside, (9, 25), '(', 1),
|
|
(8, Inside, (9, 35), ')', 2),
|
|
(20, Inside, (9, 25), '(', 2),
|
|
(20, Inside, (1, 35), ')', 3),
|
|
(0, Around, (0, 36), '(', 1),
|
|
(6, Around, (0, 36), ')', 1),
|
|
(8, Around, (8, 26), '(', 1),
|
|
(8, Around, (8, 36), ')', 2),
|
|
(20, Around, (8, 26), '(', 2),
|
|
(20, Around, (0, 36), ')', 3),
|
|
],
|
|
),
|
|
(
|
|
"(mixed {surround [pair] same} line)",
|
|
vec![
|
|
(2, Inside, (1, 34), '(', 1),
|
|
(9, Inside, (8, 28), '{', 1),
|
|
(18, Inside, (18, 22), '[', 1),
|
|
(2, Around, (0, 35), '(', 1),
|
|
(9, Around, (7, 29), '{', 1),
|
|
(18, Around, (17, 23), '[', 1),
|
|
],
|
|
),
|
|
(
|
|
"(stepped (surround) pairs (should) skip)",
|
|
vec![(22, Inside, (1, 39), '(', 1), (22, Around, (0, 40), '(', 1)],
|
|
),
|
|
(
|
|
"[surround pairs{\non different]\nlines}",
|
|
vec![
|
|
(7, Inside, (1, 29), '[', 1),
|
|
(15, Inside, (16, 36), '{', 1),
|
|
(7, Around, (0, 30), '[', 1),
|
|
(15, Around, (15, 37), '{', 1),
|
|
],
|
|
),
|
|
];
|
|
|
|
for (sample, scenario) in tests {
|
|
let doc = Rope::from(*sample);
|
|
let slice = doc.slice(..);
|
|
for &case in scenario {
|
|
let (pos, objtype, expected_range, ch, count) = case;
|
|
let result = textobject_pair_surround(slice, Range::point(pos), objtype, ch, count);
|
|
assert_eq!(
|
|
result,
|
|
expected_range.into(),
|
|
"\nCase failed: {:?} - {:?}",
|
|
sample,
|
|
case
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|