git.iko.soy/helix
on master help sign in
feat(core): add plaintext matching fallback to tree-sitter matching (#4288)
a2b8cfdAlex Vinyals
helix-core/src/match_brackets.rs+112−9
compare with master
unifiedsplit
@@ -2,6 +2,9 @@ use tree_sitter::Node;
2
2
3use crate::{Rope, Syntax};
3use crate::{Rope, Syntax};
4
4
5+const MAX_PLAINTEXT_SCAN: usize = 10000;
6+
7+// Limit matching pairs to only ( ) { } [ ] < > ' ' " "
5const PAIRS: &[(char, char)] = &[
8const PAIRS: &[(char, char)] = &[
6 ('(', ')'),
9 ('(', ')'),
7 ('{', '}'),
10 ('{', '}'),
@@ -11,15 +14,15 @@ const PAIRS: &[(char, char)] = &[
11 ('\"', '\"'),
14 ('\"', '\"'),
12];
15];
13
16
14−// limit matching pairs to only ( ) { } [ ] < > ' ' " "
15−
16−// Returns the position of the matching bracket under cursor.
17+/// Returns the position of the matching bracket under cursor.
17−//
18+///
18−// If the cursor is one the opening bracket, the position of
19+/// If the cursor is on the opening bracket, the position of
19−// the closing bracket is returned. If the cursor in the closing
20+/// the closing bracket is returned. If the cursor on the closing
20−// bracket, the position of the opening bracket is returned.
21+/// bracket, the position of the opening bracket is returned.
21−//
22+///
22−// If the cursor is not on a bracket, `None` is returned.
23+/// If the cursor is not on a bracket, `None` is returned.
24+///
25+/// If no matching bracket is found, `None` is returned.
23#[must_use]
26#[must_use]
24pub fn find_matching_bracket(syntax: &Syntax, doc: &Rope, pos: usize) -> Option<usize> {
27pub fn find_matching_bracket(syntax: &Syntax, doc: &Rope, pos: usize) -> Option<usize> {
25 if pos >= doc.len_chars() || !is_valid_bracket(doc.char(pos)) {
28 if pos >= doc.len_chars() || !is_valid_bracket(doc.char(pos)) {
@@ -70,10 +73,77 @@ fn find_pair(syntax: &Syntax, doc: &Rope, pos: usize, traverse_parents: bool) ->
70 }
73 }
71}
74}
72
75
76+/// Returns the position of the matching bracket under cursor.
77+/// This function works on plain text and ignores tree-sitter grammar.
78+/// The search is limited to `MAX_PLAINTEXT_SCAN` characters
79+///
80+/// If the cursor is on the opening bracket, the position of
81+/// the closing bracket is returned. If the cursor on the closing
82+/// bracket, the position of the opening bracket is returned.
83+///
84+/// If the cursor is not on a bracket, `None` is returned.
85+///
86+/// If no matching bracket is found, `None` is returned.
87+#[must_use]
88+pub fn find_matching_bracket_current_line_plaintext(
89+ doc: &Rope,
90+ cursor_pos: usize,
91+) -> Option<usize> {
92+ // Don't do anything when the cursor is not on top of a bracket.
93+ let bracket = doc.char(cursor_pos);
94+ if !is_valid_bracket(bracket) {
95+ return None;
96+ }
97+
98+ // Determine the direction of the matching.
99+ let is_fwd = is_forward_bracket(bracket);
100+ let chars_iter = if is_fwd {
101+ doc.chars_at(cursor_pos + 1)
102+ } else {
103+ doc.chars_at(cursor_pos).reversed()
104+ };
105+
106+ let mut open_cnt = 1;
107+
108+ for (i, candidate) in chars_iter.take(MAX_PLAINTEXT_SCAN).enumerate() {
109+ if candidate == bracket {
110+ open_cnt += 1;
111+ } else if is_valid_pair(
112+ doc,
113+ if is_fwd {
114+ cursor_pos
115+ } else {
116+ cursor_pos - i - 1
117+ },
118+ if is_fwd {
119+ cursor_pos + i + 1
120+ } else {
121+ cursor_pos
122+ },
123+ ) {
124+ // Return when all pending brackets have been closed.
125+ if open_cnt == 1 {
126+ return Some(if is_fwd {
127+ cursor_pos + i + 1
128+ } else {
129+ cursor_pos - i - 1
130+ });
131+ }
132+ open_cnt -= 1;
133+ }
134+ }
135+
136+ None
137+}
138+
73fn is_valid_bracket(c: char) -> bool {
139fn is_valid_bracket(c: char) -> bool {
74 PAIRS.iter().any(|(l, r)| *l == c || *r == c)
140 PAIRS.iter().any(|(l, r)| *l == c || *r == c)
75}
141}
76
142
143+fn is_forward_bracket(c: char) -> bool {
144+ PAIRS.iter().any(|(l, _)| *l == c)
145+}
146+
77fn is_valid_pair(doc: &Rope, start_char: usize, end_char: usize) -> bool {
147fn is_valid_pair(doc: &Rope, start_char: usize, end_char: usize) -> bool {
78 PAIRS.contains(&(doc.char(start_char), doc.char(end_char)))
148 PAIRS.contains(&(doc.char(start_char), doc.char(end_char)))
79}
149}
@@ -90,3 +160,36 @@ fn surrounding_bytes(doc: &Rope, node: &Node) -> Option<(usize, usize)> {
90
160
91 Some((start_byte, end_byte))
161 Some((start_byte, end_byte))
92}
162}
163+
164+#[cfg(test)]
165+mod tests {
166+ use super::*;
167+
168+ #[test]
169+ fn test_find_matching_bracket_current_line_plaintext() {
170+ let assert = |input: &str, pos, expected| {
171+ let input = &Rope::from(input);
172+ let actual = find_matching_bracket_current_line_plaintext(input, pos);
173+ assert_eq!(expected, actual.unwrap());
174+
175+ let actual = find_matching_bracket_current_line_plaintext(input, expected);
176+ assert_eq!(pos, actual.unwrap(), "expected symmetrical behaviour");
177+ };
178+
179+ assert("(hello)", 0, 6);
180+ assert("((hello))", 0, 8);
181+ assert("((hello))", 1, 7);
182+ assert("(((hello)))", 2, 8);
183+
184+ assert("key: ${value}", 6, 12);
185+ assert("key: ${value} # (some comment)", 16, 29);
186+
187+ assert("(paren (paren {bracket}))", 0, 24);
188+ assert("(paren (paren {bracket}))", 7, 23);
189+ assert("(paren (paren {bracket}))", 14, 22);
190+
191+ assert("(prev line\n ) (middle) ( \n next line)", 0, 12);
192+ assert("(prev line\n ) (middle) ( \n next line)", 14, 21);
193+ assert("(prev line\n ) (middle) ( \n next line)", 23, 36);
194+ }
195+}
helix-term/src/commands.rs+16−13
@@ -4528,20 +4528,23 @@ fn select_prev_sibling(cx: &mut Context) {
4528
4528
4529fn match_brackets(cx: &mut Context) {
4529fn match_brackets(cx: &mut Context) {
4530 let (view, doc) = current!(cx.editor);
4530 let (view, doc) = current!(cx.editor);
4531+ let is_select = cx.editor.mode == Mode::Select;
4532+ let text = doc.text();
4533+ let text_slice = text.slice(..);
4531
4534
4532− if let Some(syntax) = doc.syntax() {
4533− let text = doc.text().slice(..);
4534− let selection = doc.selection(view.id).clone().transform(|range| {
4535+ let selection = doc.selection(view.id).clone().transform(|range| {
4535− if let Some(pos) =
4536+ let pos = range.cursor(text_slice);
4537+ if let Some(matched_pos) = doc.syntax().map_or_else(
4538+ || match_brackets::find_matching_bracket_current_line_plaintext(text, pos),
4536− match_brackets::find_matching_bracket_fuzzy(syntax, doc.text(), range.cursor(text))
4539+ |syntax| match_brackets::find_matching_bracket_fuzzy(syntax, text, pos),
4537− {
4540+ ) {
4538− range.put_cursor(text, pos, cx.editor.mode == Mode::Select)
4541+ range.put_cursor(text_slice, matched_pos, is_select)
4539− } else {
4542+ } else {
4540− range
4543+ range
4541− }
4544+ }
4542− });
4545+ });
4546+
4543− doc.set_selection(view.id, selection);
4547+ doc.set_selection(view.id, selection);
4544− }
4545}
4548}
4546
4549
4547//
4550//