1use 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#[derive(Copy, Clone, Debug)]
36pub struct AutoPairConfig {
37 pub paren: bool,
39 pub bracket: bool,
41 pub brace: bool,
43 pub dquote: bool,
45 pub squote: bool,
47 pub backtick: bool,
49 pub asterisk: bool,
51 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 #[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
89pub(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 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 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
144pub(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 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 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 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 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}