use crate::buffer::TextBuffer;
use crate::canvas_editor::CodeEditor;
use crate::canvas_editor::editing::command::{
Command, CompositeCommand, DeleteRangeCommand, InsertTextCommand,
};
use crate::canvas_editor::lsp::{LspPosition, LspTextChange};
#[derive(Debug, PartialEq, Eq)]
struct ResolvedEdit {
start: (usize, usize),
end: (usize, usize),
text: String,
}
fn clamp_position(
buffer: &TextBuffer,
position: LspPosition,
) -> (usize, usize) {
let last_line = buffer.line_count().saturating_sub(1);
let line = position.line as usize;
if line > last_line {
return (last_line, buffer.line_len(last_line));
}
(line, (position.character as usize).min(buffer.line_len(line)))
}
fn resolve_edits(
buffer: &TextBuffer,
edits: &[LspTextChange],
) -> Option<Vec<ResolvedEdit>> {
let mut resolved: Vec<ResolvedEdit> = edits
.iter()
.map(|edit| {
let start = clamp_position(buffer, edit.range.start);
let end = clamp_position(buffer, edit.range.end);
let (start, end) =
if start <= end { (start, end) } else { (end, start) };
ResolvedEdit { start, end, text: edit.text.clone() }
})
.filter(|edit| !(edit.start == edit.end && edit.text.is_empty()))
.collect();
resolved.sort_by_key(|edit| edit.start);
if resolved.windows(2).any(|pair| pair[1].start < pair[0].end) {
return None;
}
Some(resolved)
}
impl CodeEditor {
pub fn apply_lsp_text_edits(&mut self, edits: &[LspTextChange]) -> bool {
let Some(resolved) = resolve_edits(&self.buffer, edits) else {
return false;
};
if resolved.is_empty() {
return false;
}
self.end_grouping_if_active();
let cursor_before = self.cursors.primary_position();
let mut composite = CompositeCommand::new();
for edit in resolved.iter().rev() {
composite.add(Box::new(DeleteRangeCommand::new(
&self.buffer,
edit.start,
edit.end,
cursor_before,
)));
if !edit.text.is_empty() {
composite.add(Box::new(InsertTextCommand::new(
edit.start.0,
edit.start.1,
edit.text.clone(),
cursor_before,
)));
}
}
let mut cursor_position = cursor_before;
composite.execute(&mut self.buffer, &mut cursor_position);
self.history.push(Box::new(composite));
self.cursors.set_single(self.clamp_to_buffer(cursor_before));
self.pre_edit_line = 0;
self.pre_edit_last_line = usize::MAX;
self.finish_edit_operation();
true
}
fn clamp_to_buffer(&self, position: (usize, usize)) -> (usize, usize) {
let line = position.0.min(self.buffer.line_count().saturating_sub(1));
(line, position.1.min(self.buffer.line_len(line)))
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::canvas_editor::lsp::LspRange;
fn edit(start: (u32, u32), end: (u32, u32), text: &str) -> LspTextChange {
LspTextChange {
range: LspRange {
start: LspPosition { line: start.0, character: start.1 },
end: LspPosition { line: end.0, character: end.1 },
},
text: text.to_string(),
}
}
#[test]
fn test_clamp_position_keeps_an_in_bounds_position() {
let buffer = TextBuffer::new("abc\ndef");
assert_eq!(
clamp_position(&buffer, LspPosition { line: 1, character: 2 }),
(1, 2)
);
}
#[test]
fn test_clamp_position_folds_a_past_the_end_position_onto_the_document() {
let buffer = TextBuffer::new("abc\ndef");
assert_eq!(
clamp_position(
&buffer,
LspPosition { line: u32::MAX, character: 0 }
),
(1, 3)
);
assert_eq!(
clamp_position(
&buffer,
LspPosition { line: 0, character: u32::MAX }
),
(0, 3)
);
}
#[test]
fn test_resolve_edits_sorts_and_drops_no_ops() {
let buffer = TextBuffer::new("abcdef");
let resolved = resolve_edits(
&buffer,
&[
edit((0, 4), (0, 5), "Y"),
edit((0, 2), (0, 2), ""),
edit((0, 0), (0, 1), "X"),
],
);
assert_eq!(
resolved,
Some(vec![
ResolvedEdit {
start: (0, 0),
end: (0, 1),
text: "X".to_string()
},
ResolvedEdit {
start: (0, 4),
end: (0, 5),
text: "Y".to_string()
},
])
);
}
#[test]
fn test_resolve_edits_refuses_overlapping_ranges() {
let buffer = TextBuffer::new("abcdef");
assert_eq!(
resolve_edits(
&buffer,
&[edit((0, 0), (0, 3), "X"), edit((0, 2), (0, 4), "Y")]
),
None
);
}
#[test]
fn test_resolve_edits_accepts_ranges_that_only_touch() {
let buffer = TextBuffer::new("abcdef");
let resolved = resolve_edits(
&buffer,
&[edit((0, 0), (0, 2), "X"), edit((0, 2), (0, 4), "Y")],
);
assert!(resolved.is_some_and(|edits| edits.len() == 2));
}
#[test]
fn test_apply_replaces_the_whole_document() {
let mut editor = CodeEditor::new("fn main( ) {}", "rs");
let applied = editor.apply_lsp_text_edits(&[edit(
(0, 0),
(1, 0),
"fn main() {}",
)]);
assert!(applied);
assert_eq!(editor.content(), "fn main() {}");
}
#[test]
fn test_apply_several_edits_uses_the_original_coordinates() {
let mut editor = CodeEditor::new("aXbYc", "rs");
let applied = editor.apply_lsp_text_edits(&[
edit((0, 1), (0, 2), "1"),
edit((0, 3), (0, 4), "22"),
]);
assert!(applied);
assert_eq!(editor.content(), "a1b22c");
}
#[test]
fn test_apply_across_lines_reflows_the_document() {
let mut editor = CodeEditor::new("one\ntwo\nthree", "rs");
let applied =
editor.apply_lsp_text_edits(&[edit((0, 3), (2, 0), "\n")]);
assert!(applied);
assert_eq!(editor.content(), "one\nthree");
}
#[test]
fn test_apply_is_a_single_undo_step() {
let mut editor = CodeEditor::new("a\nb\nc", "rs");
let applied = editor.apply_lsp_text_edits(&[
edit((0, 0), (0, 1), "A"),
edit((2, 0), (2, 1), "C"),
]);
assert!(applied);
assert_eq!(editor.content(), "A\nb\nC");
let _ = editor.update(&crate::canvas_editor::Message::Undo);
assert_eq!(editor.content(), "a\nb\nc");
}
#[test]
fn test_apply_keeps_the_cursor_where_it_was() {
let mut editor = CodeEditor::new("one\ntwo\nthree", "rs");
let _ = editor.set_cursor(1, 2);
assert!(editor.apply_lsp_text_edits(&[edit((0, 0), (0, 3), "1")]));
assert_eq!(editor.cursor_position(), (1, 2));
}
#[test]
fn test_apply_clamps_a_cursor_the_edits_left_out_of_bounds() {
let mut editor = CodeEditor::new("one\ntwo\nthree", "rs");
let _ = editor.set_cursor(2, 5);
assert!(editor.apply_lsp_text_edits(&[edit((0, 0), (2, 5), "x")]));
assert_eq!(editor.cursor_position(), (0, 1));
}
#[test]
fn test_apply_reports_nothing_done_for_an_empty_reply() {
let mut editor = CodeEditor::new("fn main() {}", "rs");
assert!(!editor.apply_lsp_text_edits(&[]));
assert_eq!(editor.content(), "fn main() {}");
}
#[test]
fn test_apply_reports_nothing_done_for_overlapping_edits() {
let mut editor = CodeEditor::new("abcdef", "rs");
assert!(!editor.apply_lsp_text_edits(&[
edit((0, 0), (0, 3), "X"),
edit((0, 2), (0, 4), "Y"),
]));
assert_eq!(editor.content(), "abcdef");
}
#[test]
fn test_apply_marks_the_document_modified() {
let mut editor = CodeEditor::new("fn main() {}", "rs");
assert!(!editor.is_modified());
assert!(editor.apply_lsp_text_edits(&[edit((0, 2), (0, 4), " ")]));
assert!(editor.is_modified());
}
}