use continuity_buffer::Buffer;
use continuity_text::{Position, Selection};
use ropey::Rope;
use crate::edit_planning::{advance_position, finalize_specs, EditSpec};
use crate::selection_edit::SelectionEditPlan;
use crate::Error;
#[derive(Copy, Clone, Debug)]
pub struct AutoPairConfig {
pub paren: bool,
pub bracket: bool,
pub brace: bool,
pub dquote: bool,
pub squote: bool,
pub backtick: bool,
pub asterisk: bool,
pub underscore: bool,
}
impl Default for AutoPairConfig {
fn default() -> Self {
Self {
paren: true,
bracket: true,
brace: true,
dquote: true,
squote: true,
backtick: true,
asterisk: false,
underscore: false,
}
}
}
impl AutoPairConfig {
#[must_use]
pub fn pair_for(&self, c: char) -> Option<(char, char)> {
match c {
'(' if self.paren => Some(('(', ')')),
'[' if self.bracket => Some(('[', ']')),
'{' if self.brace => Some(('{', '}')),
'"' if self.dquote => Some(('"', '"')),
'\'' if self.squote => Some(('\'', '\'')),
'`' if self.backtick => Some(('`', '`')),
'*' if self.asterisk => Some(('*', '*')),
'_' if self.underscore => Some(('_', '_')),
_ => None,
}
}
}
pub(crate) fn plan_insert_pair(
buffer: &Buffer,
open: &str,
close: &str,
) -> Result<Option<SelectionEditPlan>, Error> {
let selections_before = buffer.selections().to_vec();
let rope = buffer.rope();
let mut specs: Vec<EditSpec> = Vec::with_capacity(selections_before.len() * 2);
let mut selections_after: Vec<Selection> = Vec::with_capacity(selections_before.len());
for selection in &selections_before {
let ordered = selection.ordered_range();
let start_byte = ordered.start.to_byte_offset(rope)?;
let end_byte = ordered.end.to_byte_offset(rope)?;
if start_byte == end_byte {
let combined = format!("{open}{close}");
specs.push(EditSpec::insert(rope, start_byte, combined)?);
let head = advance_position(ordered.start, open);
selections_after.push(Selection::caret_at(head));
} else {
let start_char = rope.byte_to_char(start_byte);
let end_char = rope.byte_to_char(end_byte);
let content: String = rope.slice(start_char..end_char).into();
let wrapped = format!("{open}{content}{close}");
specs.push(EditSpec::replace(
rope,
start_byte,
end_byte,
wrapped.clone(),
)?);
let head = advance_position(ordered.start, &wrapped);
selections_after.push(Selection::caret_at(head));
}
}
Ok(finalize_specs(specs, selections_before, selections_after))
}
pub(crate) fn plan_delete_pair(
buffer: &Buffer,
open: char,
close: char,
) -> Result<Option<SelectionEditPlan>, Error> {
let selections_before = buffer.selections().to_vec();
let rope = buffer.rope();
let mut specs: Vec<EditSpec> = Vec::with_capacity(selections_before.len());
let mut selections_after: Vec<Selection> = Vec::with_capacity(selections_before.len());
for selection in &selections_before {
let ordered = selection.ordered_range();
let start_byte = ordered.start.to_byte_offset(rope)?;
let end_byte = ordered.end.to_byte_offset(rope)?;
if start_byte != end_byte {
return Ok(None);
}
let Some(prev) = char_before(rope, start_byte) else {
return Ok(None);
};
let Some(next) = char_at(rope, start_byte) else {
return Ok(None);
};
if prev != open || next != close {
return Ok(None);
}
let prev_len = prev.len_utf8();
let next_len = next.len_utf8();
let delete_start = start_byte - prev_len;
let delete_end = start_byte + next_len;
specs.push(EditSpec::delete(rope, delete_start, delete_end)?);
selections_after.push(Selection::caret_at(position_for_byte(rope, delete_start)?));
}
Ok(finalize_specs(specs, selections_before, selections_after))
}
fn position_for_byte(rope: &Rope, byte: usize) -> Result<Position, Error> {
Ok(Position::from_byte_offset(rope, byte)?)
}
fn char_before(rope: &Rope, byte: usize) -> Option<char> {
if byte == 0 {
return None;
}
let lo = byte.saturating_sub(4);
let mut start = lo;
while start < byte {
if let Ok(pos) = Position::from_byte_offset(rope, start) {
let _ = pos;
let slice = rope.slice(rope.byte_to_char(start)..rope.byte_to_char(byte));
let s: String = slice.chars().collect();
return s.chars().next_back();
}
start += 1;
}
None
}
fn char_at(rope: &Rope, byte: usize) -> Option<char> {
if byte >= rope.len_bytes() {
return None;
}
let char_idx = rope.byte_to_char(byte);
rope.chars_at(char_idx).next()
}
#[cfg(test)]
mod tests {
use continuity_buffer::Buffer;
use continuity_text::{Position, Selection};
use super::*;
use crate::selection_edit::apply_plan;
#[test]
fn defaults_pair_brackets_not_emphasis() {
let cfg = AutoPairConfig::default();
assert_eq!(cfg.pair_for('('), Some(('(', ')')));
assert_eq!(cfg.pair_for('['), Some(('[', ']')));
assert_eq!(cfg.pair_for('{'), Some(('{', '}')));
assert_eq!(cfg.pair_for('"'), Some(('"', '"')));
assert_eq!(cfg.pair_for('*'), None);
assert_eq!(cfg.pair_for('_'), None);
}
#[test]
fn insert_pair_at_caret_lands_between() {
let mut buffer = Buffer::from_text("ab");
buffer.set_selections(vec![Selection::caret_at(Position::new(0, 1))]);
let plan = plan_insert_pair(&buffer, "(", ")")
.expect("plan ok")
.expect("plan some");
assert_eq!(plan.ops.len(), 1);
apply_plan(&mut buffer, &plan).expect("apply ok");
assert_eq!(buffer.rope().to_string(), "a()b");
let head = buffer.selections()[0].head;
assert_eq!((head.line, head.byte_in_line), (0, 2));
}
#[test]
fn insert_pair_wraps_non_empty_selection() {
let mut buffer = Buffer::from_text("hello");
buffer.set_selections(vec![Selection::new(
Position::new(0, 0),
Position::new(0, 5),
continuity_text::SelectionKind::Caret,
)]);
let plan = plan_insert_pair(&buffer, "[", "]")
.expect("plan ok")
.expect("plan some");
apply_plan(&mut buffer, &plan).expect("apply ok");
assert_eq!(buffer.rope().to_string(), "[hello]");
}
#[test]
fn delete_pair_between_empty_pair_succeeds() {
let mut buffer = Buffer::from_text("()");
buffer.set_selections(vec![Selection::caret_at(Position::new(0, 1))]);
let plan = plan_delete_pair(&buffer, '(', ')')
.expect("plan ok")
.expect("plan some");
apply_plan(&mut buffer, &plan).expect("apply ok");
assert_eq!(buffer.rope().to_string(), "");
}
#[test]
fn delete_pair_when_not_adjacent_returns_none() {
let mut buf = Buffer::from_text("(a)");
buf.set_selections(vec![Selection::caret_at(Position::new(0, 1))]);
let plan = plan_delete_pair(&buf, '(', ')').expect("plan ok");
assert!(plan.is_none());
}
}