rustyline/
highlight.rs

1//! Syntax highlighting
2
3use crate::config::CompletionType;
4use std::borrow::Cow::{self, Borrowed, Owned};
5use std::cell::Cell;
6
7/// Describe which kind of action has been triggering the call to `Highlighter`.
8#[derive(Copy, Clone, Debug, Eq, PartialEq)]
9pub enum CmdKind {
10    /// Cursor moved
11    MoveCursor,
12    /// Other action
13    Other,
14    /// Forced / final refresh (no auto-suggestion / hint, no matching bracket
15    /// highlighted, ...)
16    ForcedRefresh,
17}
18
19/// Syntax highlighter with [ANSI color](https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Graphic_Rendition)_parameters).
20///
21/// Currently, the highlighted version *must* have the same display width as
22/// the original input.
23pub trait Highlighter {
24    /// Takes the currently edited `line` with the cursor `pos`ition and
25    /// returns the highlighted version (with ANSI color).
26    ///
27    /// For example, you can implement
28    /// [blink-matching-paren](https://www.gnu.org/software/bash/manual/html_node/Readline-Init-File-Syntax.html).
29    fn highlight<'l>(&self, line: &'l str, pos: usize) -> Cow<'l, str> {
30        let _ = pos;
31        Borrowed(line)
32    }
33    /// Takes the `prompt` and
34    /// returns the highlighted version (with ANSI color).
35    fn highlight_prompt<'b, 's: 'b, 'p: 'b>(
36        &'s self,
37        prompt: &'p str,
38        default: bool,
39    ) -> Cow<'b, str> {
40        let _ = default;
41        Borrowed(prompt)
42    }
43    /// Takes the `hint` and
44    /// returns the highlighted version (with ANSI color).
45    fn highlight_hint<'h>(&self, hint: &'h str) -> Cow<'h, str> {
46        Borrowed(hint)
47    }
48    /// Takes the completion `candidate` and
49    /// returns the highlighted version (with ANSI color).
50    ///
51    /// Currently, used only with `CompletionType::List`.
52    fn highlight_candidate<'c>(
53        &self,
54        candidate: &'c str, // FIXME should be Completer::Candidate
55        completion: CompletionType,
56    ) -> Cow<'c, str> {
57        let _ = completion;
58        Borrowed(candidate)
59    }
60    /// Tells if `line` needs to be highlighted when a specific char is typed or
61    /// when cursor is moved under a specific char.
62    ///
63    /// Used to optimize refresh when a character is inserted or the cursor is
64    /// moved.
65    fn highlight_char(&self, line: &str, pos: usize, kind: CmdKind) -> bool {
66        let _ = (line, pos, kind);
67        false
68    }
69}
70
71impl Highlighter for () {}
72
73// TODO versus https://python-prompt-toolkit.readthedocs.io/en/master/pages/reference.html?highlight=HighlightMatchingBracketProcessor#prompt_toolkit.layout.processors.HighlightMatchingBracketProcessor
74
75/// Highlight matching bracket when typed or cursor moved on.
76#[derive(Default)]
77pub struct MatchingBracketHighlighter {
78    bracket: Cell<Option<(u8, usize)>>, // memorize the character to search...
79}
80
81impl MatchingBracketHighlighter {
82    /// Constructor
83    #[must_use]
84    pub fn new() -> Self {
85        Self {
86            bracket: Cell::new(None),
87        }
88    }
89}
90
91impl Highlighter for MatchingBracketHighlighter {
92    fn highlight<'l>(&self, line: &'l str, _pos: usize) -> Cow<'l, str> {
93        if line.len() <= 1 {
94            return Borrowed(line);
95        }
96        // highlight matching brace/bracket/parenthesis if it exists
97        if let Some((bracket, pos)) = self.bracket.get() {
98            if let Some((matching, idx)) = find_matching_bracket(line, pos, bracket) {
99                let mut copy = line.to_owned();
100                copy.replace_range(idx..=idx, &format!("\x1b[1;34m{}\x1b[0m", matching as char));
101                return Owned(copy);
102            }
103        }
104        Borrowed(line)
105    }
106
107    fn highlight_char(&self, line: &str, pos: usize, kind: CmdKind) -> bool {
108        if kind == CmdKind::ForcedRefresh {
109            self.bracket.set(None);
110            return false;
111        }
112        // will highlight matching brace/bracket/parenthesis if it exists
113        self.bracket.set(check_bracket(line, pos));
114        self.bracket.get().is_some()
115    }
116}
117
118fn find_matching_bracket(line: &str, pos: usize, bracket: u8) -> Option<(u8, usize)> {
119    let matching = matching_bracket(bracket);
120    let mut idx;
121    let mut unmatched = 1;
122    if is_open_bracket(bracket) {
123        // forward search
124        idx = pos + 1;
125        let bytes = &line.as_bytes()[idx..];
126        for b in bytes {
127            if *b == matching {
128                unmatched -= 1;
129                if unmatched == 0 {
130                    debug_assert_eq!(matching, line.as_bytes()[idx]);
131                    return Some((matching, idx));
132                }
133            } else if *b == bracket {
134                unmatched += 1;
135            }
136            idx += 1;
137        }
138        debug_assert_eq!(idx, line.len());
139    } else {
140        // backward search
141        idx = pos;
142        let bytes = &line.as_bytes()[..idx];
143        for b in bytes.iter().rev() {
144            if *b == matching {
145                unmatched -= 1;
146                if unmatched == 0 {
147                    debug_assert_eq!(matching, line.as_bytes()[idx - 1]);
148                    return Some((matching, idx - 1));
149                }
150            } else if *b == bracket {
151                unmatched += 1;
152            }
153            idx -= 1;
154        }
155        debug_assert_eq!(idx, 0);
156    }
157    None
158}
159
160// check under or before the cursor
161fn check_bracket(line: &str, pos: usize) -> Option<(u8, usize)> {
162    if line.is_empty() {
163        return None;
164    }
165    let mut pos = pos;
166    if pos >= line.len() {
167        pos = line.len() - 1; // before cursor
168        let b = line.as_bytes()[pos]; // previous byte
169        if is_close_bracket(b) {
170            Some((b, pos))
171        } else {
172            None
173        }
174    } else {
175        let mut under_cursor = true;
176        loop {
177            let b = line.as_bytes()[pos];
178            if is_close_bracket(b) {
179                return if pos == 0 { None } else { Some((b, pos)) };
180            } else if is_open_bracket(b) {
181                return if pos + 1 == line.len() {
182                    None
183                } else {
184                    Some((b, pos))
185                };
186            } else if under_cursor && pos > 0 {
187                under_cursor = false;
188                pos -= 1; // or before cursor
189            } else {
190                return None;
191            }
192        }
193    }
194}
195
196const fn matching_bracket(bracket: u8) -> u8 {
197    match bracket {
198        b'{' => b'}',
199        b'}' => b'{',
200        b'[' => b']',
201        b']' => b'[',
202        b'(' => b')',
203        b')' => b'(',
204        b => b,
205    }
206}
207const fn is_open_bracket(bracket: u8) -> bool {
208    matches!(bracket, b'{' | b'[' | b'(')
209}
210const fn is_close_bracket(bracket: u8) -> bool {
211    matches!(bracket, b'}' | b']' | b')')
212}
213
214#[cfg(test)]
215mod tests {
216    #[test]
217    pub fn find_matching_bracket() {
218        use super::find_matching_bracket;
219        assert_eq!(find_matching_bracket("(...", 0, b'('), None);
220        assert_eq!(find_matching_bracket("...)", 3, b')'), None);
221
222        assert_eq!(find_matching_bracket("()..", 0, b'('), Some((b')', 1)));
223        assert_eq!(find_matching_bracket("(..)", 0, b'('), Some((b')', 3)));
224
225        assert_eq!(find_matching_bracket("..()", 3, b')'), Some((b'(', 2)));
226        assert_eq!(find_matching_bracket("(..)", 3, b')'), Some((b'(', 0)));
227
228        assert_eq!(find_matching_bracket("(())", 0, b'('), Some((b')', 3)));
229        assert_eq!(find_matching_bracket("(())", 3, b')'), Some((b'(', 0)));
230    }
231    #[test]
232    pub fn check_bracket() {
233        use super::check_bracket;
234        assert_eq!(check_bracket(")...", 0), None);
235        assert_eq!(check_bracket("(...", 2), None);
236        assert_eq!(check_bracket("...(", 3), None);
237        assert_eq!(check_bracket("...(", 4), None);
238        assert_eq!(check_bracket("..).", 4), None);
239
240        assert_eq!(check_bracket("(...", 0), Some((b'(', 0)));
241        assert_eq!(check_bracket("(...", 1), Some((b'(', 0)));
242        assert_eq!(check_bracket("...)", 3), Some((b')', 3)));
243        assert_eq!(check_bracket("...)", 4), Some((b')', 3)));
244    }
245    #[test]
246    pub fn matching_bracket() {
247        use super::matching_bracket;
248        assert_eq!(matching_bracket(b'('), b')');
249        assert_eq!(matching_bracket(b')'), b'(');
250    }
251
252    #[test]
253    pub fn is_open_bracket() {
254        use super::is_close_bracket;
255        use super::is_open_bracket;
256        assert!(is_open_bracket(b'('));
257        assert!(is_close_bracket(b')'));
258    }
259}
rustyline/highlight.rs

rustyline/
highlight.rs
