Skip to main content

continuity_engine/
edit_pairs.rs

1//! Storage-neutral auto-pair planner.
2//!
3//! Sister module to [`crate::edit_inline`] etc. Builds
4//! [`crate::selection_edit::SelectionEditPlan`]s for the two new
5//! `SelectionEdit` variants the auto-pair feature added:
6//!
7//! * [`crate::SelectionEdit::InsertPair`] — inserts `open` immediately
8//!   followed by `close` at every caret (or surrounds non-empty
9//!   selections with the pair). Always one undo group.
10//! * [`crate::SelectionEdit::DeletePair`] — backspace-aware delete that
11//!   removes both halves when the caret sits between an empty pair, and
12//!   returns `Ok(None)` otherwise so the caller can fall through to a
13//!   plain [`crate::SelectionEdit::DeleteBack`].
14//!
15//! ## Configuration
16//!
17//! [`AutoPairConfig`] enumerates which characters should auto-pair.
18//! The dispatch decision *which* `SelectionEdit` to enqueue lives in
19//! the command/UI layer (so the planner stays free of any settings
20//! plumbing) — this module just turns "you want a pair here" into a
21//! plan. `Default` matches spec §12 prose-friendliness: `()`, `[]`,
22//! `{}`, `""`, `''`, and `` ` `` are paired by default; `*` and `_`
23//! are not.
24
25use continuity_buffer::Buffer;
26use continuity_text::{Position, Selection};
27use ropey::Rope;
28
29use crate::edit_planning::{advance_position, finalize_specs, EditSpec};
30use crate::selection_edit::SelectionEditPlan;
31use crate::Error;
32
33/// Per-character toggle bag for the auto-pair feature. Mirrored on
34/// [`continuity_config::Settings`] (see `[editor].auto_pair_*`).
35#[derive(Copy, Clone, Debug)]
36pub struct AutoPairConfig {
37    /// `(` → `()`.
38    pub paren: bool,
39    /// `[` → `[]`.
40    pub bracket: bool,
41    /// `{` → `{}`.
42    pub brace: bool,
43    /// `"` → `""`.
44    pub dquote: bool,
45    /// `'` → `''`.
46    pub squote: bool,
47    /// `` ` `` → `` `` ``.
48    pub backtick: bool,
49    /// `*` → `**`. Off by default — hurts more than helps in prose.
50    pub asterisk: bool,
51    /// `_` → `__`. Off by default — same rationale.
52    pub underscore: bool,
53}
54
55impl Default for AutoPairConfig {
56    fn default() -> Self {
57        Self {
58            paren: true,
59            bracket: true,
60            brace: true,
61            dquote: true,
62            squote: true,
63            backtick: true,
64            asterisk: false,
65            underscore: false,
66        }
67    }
68}
69
70impl AutoPairConfig {
71    /// If `c` is one of the configured open characters, return its
72    /// `(open, close)` pair. Otherwise `None`.
73    #[must_use]
74    pub fn pair_for(&self, c: char) -> Option<(char, char)> {
75        match c {
76            '(' if self.paren => Some(('(', ')')),
77            '[' if self.bracket => Some(('[', ']')),
78            '{' if self.brace => Some(('{', '}')),
79            '"' if self.dquote => Some(('"', '"')),
80            '\'' if self.squote => Some(('\'', '\'')),
81            '`' if self.backtick => Some(('`', '`')),
82            '*' if self.asterisk => Some(('*', '*')),
83            '_' if self.underscore => Some(('_', '_')),
84            _ => None,
85        }
86    }
87}
88
89/// Plan one auto-pair insertion per active selection. Empty (caret)
90/// selections insert `open` immediately followed by `close` and leave
91/// the caret between them. Non-empty selections wrap the range with the
92/// pair and leave the caret just after the trailing `close`.
93///
94/// # Errors
95///
96/// Returns the buffer-layer error if any selection position is outside
97/// the rope.
98pub(crate) fn plan_insert_pair(
99    buffer: &Buffer,
100    open: &str,
101    close: &str,
102) -> Result<Option<SelectionEditPlan>, Error> {
103    let selections_before = buffer.selections().to_vec();
104    let rope = buffer.rope();
105    let mut specs: Vec<EditSpec> = Vec::with_capacity(selections_before.len() * 2);
106    let mut selections_after: Vec<Selection> = Vec::with_capacity(selections_before.len());
107    for selection in &selections_before {
108        let ordered = selection.ordered_range();
109        let start_byte = ordered.start.to_byte_offset(rope)?;
110        let end_byte = ordered.end.to_byte_offset(rope)?;
111        if start_byte == end_byte {
112            // Caret: insert "open close" at the caret, leave the caret
113            // sitting between them. The post-edit caret position is
114            // `start_position` advanced by `open` (no newlines in pair
115            // chars in practice, but `advance_position` handles them
116            // correctly anyway).
117            let combined = format!("{open}{close}");
118            specs.push(EditSpec::insert(rope, start_byte, combined)?);
119            let head = advance_position(ordered.start, open);
120            selections_after.push(Selection::caret_at(head));
121        } else {
122            // Non-empty selection: wrap as one replace spec covering
123            // [start, end) with `open + content + close`. Using a
124            // single replace (rather than two paired inserts) keeps the
125            // post-edit caret math local — it is just `start_position`
126            // advanced by the entire replacement string.
127            let start_char = rope.byte_to_char(start_byte);
128            let end_char = rope.byte_to_char(end_byte);
129            let content: String = rope.slice(start_char..end_char).into();
130            let wrapped = format!("{open}{content}{close}");
131            specs.push(EditSpec::replace(
132                rope,
133                start_byte,
134                end_byte,
135                wrapped.clone(),
136            )?);
137            let head = advance_position(ordered.start, &wrapped);
138            selections_after.push(Selection::caret_at(head));
139        }
140    }
141    Ok(finalize_specs(specs, selections_before, selections_after))
142}
143
144/// Plan a delete-pair backspace: at each caret, if the byte immediately
145/// before the caret is `open` and the byte immediately after is
146/// `close`, delete both. Returns `Ok(None)` when no caret matches —
147/// the caller should then fall through to the plain
148/// [`crate::SelectionEdit::DeleteBack`] planner.
149///
150/// # Errors
151///
152/// Returns the buffer-layer error if any selection position is outside
153/// the rope.
154pub(crate) fn plan_delete_pair(
155    buffer: &Buffer,
156    open: char,
157    close: char,
158) -> Result<Option<SelectionEditPlan>, Error> {
159    let selections_before = buffer.selections().to_vec();
160    let rope = buffer.rope();
161    let mut specs: Vec<EditSpec> = Vec::with_capacity(selections_before.len());
162    let mut selections_after: Vec<Selection> = Vec::with_capacity(selections_before.len());
163    for selection in &selections_before {
164        let ordered = selection.ordered_range();
165        let start_byte = ordered.start.to_byte_offset(rope)?;
166        let end_byte = ordered.end.to_byte_offset(rope)?;
167        if start_byte != end_byte {
168            // A non-empty selection isn't an auto-pair backspace — bail
169            // out so the caller falls through to plain DeleteBack.
170            return Ok(None);
171        }
172        let Some(prev) = char_before(rope, start_byte) else {
173            return Ok(None);
174        };
175        let Some(next) = char_at(rope, start_byte) else {
176            return Ok(None);
177        };
178        if prev != open || next != close {
179            return Ok(None);
180        }
181        let prev_len = prev.len_utf8();
182        let next_len = next.len_utf8();
183        let delete_start = start_byte - prev_len;
184        let delete_end = start_byte + next_len;
185        specs.push(EditSpec::delete(rope, delete_start, delete_end)?);
186        selections_after.push(Selection::caret_at(position_for_byte(rope, delete_start)?));
187    }
188    Ok(finalize_specs(specs, selections_before, selections_after))
189}
190
191fn position_for_byte(rope: &Rope, byte: usize) -> Result<Position, Error> {
192    Ok(Position::from_byte_offset(rope, byte)?)
193}
194
195fn char_before(rope: &Rope, byte: usize) -> Option<char> {
196    if byte == 0 {
197        return None;
198    }
199    // Rewind one char by walking back up to 4 bytes (longest UTF-8).
200    let lo = byte.saturating_sub(4);
201    let mut start = lo;
202    while start < byte {
203        if let Ok(pos) = Position::from_byte_offset(rope, start) {
204            let _ = pos;
205            // Round to the nearest grapheme/codepoint boundary by
206            // re-decoding the slice [start, byte).
207            let slice = rope.slice(rope.byte_to_char(start)..rope.byte_to_char(byte));
208            let s: String = slice.chars().collect();
209            return s.chars().next_back();
210        }
211        start += 1;
212    }
213    None
214}
215
216fn char_at(rope: &Rope, byte: usize) -> Option<char> {
217    if byte >= rope.len_bytes() {
218        return None;
219    }
220    let char_idx = rope.byte_to_char(byte);
221    rope.chars_at(char_idx).next()
222}
223
224#[cfg(test)]
225mod tests {
226    use continuity_buffer::Buffer;
227    use continuity_text::{Position, Selection};
228
229    use super::*;
230    use crate::selection_edit::apply_plan;
231
232    #[test]
233    fn defaults_pair_brackets_not_emphasis() {
234        let cfg = AutoPairConfig::default();
235        assert_eq!(cfg.pair_for('('), Some(('(', ')')));
236        assert_eq!(cfg.pair_for('['), Some(('[', ']')));
237        assert_eq!(cfg.pair_for('{'), Some(('{', '}')));
238        assert_eq!(cfg.pair_for('"'), Some(('"', '"')));
239        assert_eq!(cfg.pair_for('*'), None);
240        assert_eq!(cfg.pair_for('_'), None);
241    }
242
243    #[test]
244    fn insert_pair_at_caret_lands_between() {
245        let mut buffer = Buffer::from_text("ab");
246        buffer.set_selections(vec![Selection::caret_at(Position::new(0, 1))]);
247        let plan = plan_insert_pair(&buffer, "(", ")")
248            .expect("plan ok")
249            .expect("plan some");
250        assert_eq!(plan.ops.len(), 1);
251        apply_plan(&mut buffer, &plan).expect("apply ok");
252        assert_eq!(buffer.rope().to_string(), "a()b");
253        let head = buffer.selections()[0].head;
254        assert_eq!((head.line, head.byte_in_line), (0, 2));
255    }
256
257    #[test]
258    fn insert_pair_wraps_non_empty_selection() {
259        let mut buffer = Buffer::from_text("hello");
260        buffer.set_selections(vec![Selection::new(
261            Position::new(0, 0),
262            Position::new(0, 5),
263            continuity_text::SelectionKind::Caret,
264        )]);
265        let plan = plan_insert_pair(&buffer, "[", "]")
266            .expect("plan ok")
267            .expect("plan some");
268        apply_plan(&mut buffer, &plan).expect("apply ok");
269        assert_eq!(buffer.rope().to_string(), "[hello]");
270    }
271
272    #[test]
273    fn delete_pair_between_empty_pair_succeeds() {
274        let mut buffer = Buffer::from_text("()");
275        buffer.set_selections(vec![Selection::caret_at(Position::new(0, 1))]);
276        let plan = plan_delete_pair(&buffer, '(', ')')
277            .expect("plan ok")
278            .expect("plan some");
279        apply_plan(&mut buffer, &plan).expect("apply ok");
280        assert_eq!(buffer.rope().to_string(), "");
281    }
282
283    #[test]
284    fn delete_pair_when_not_adjacent_returns_none() {
285        // Caret between `(` and `a` — `next` is `a`, not `)`, so no pair.
286        let mut buf = Buffer::from_text("(a)");
287        buf.set_selections(vec![Selection::caret_at(Position::new(0, 1))]);
288        let plan = plan_delete_pair(&buf, '(', ')').expect("plan ok");
289        assert!(plan.is_none());
290    }
291}