use crate::buffer::TextBuffer;
use super::Command;
fn insert_text_at(
buffer: &mut TextBuffer,
line: usize,
col: usize,
text: &str,
) -> (usize, usize) {
let mut current_line = line;
let mut current_col = col;
for ch in text.chars() {
if ch == '\n' {
buffer.insert_newline(current_line, current_col);
current_line += 1;
current_col = 0;
} else {
buffer.insert_char(current_line, current_col, ch);
current_col += 1;
}
}
(current_line, current_col)
}
#[derive(Debug, Clone)]
pub struct InsertCharCommand {
line: usize,
col: usize,
ch: char,
cursor_before: (usize, usize),
cursor_after: (usize, usize),
}
impl InsertCharCommand {
pub fn new(
line: usize,
col: usize,
ch: char,
cursor: (usize, usize),
) -> Self {
Self {
line,
col,
ch,
cursor_before: cursor,
cursor_after: (line, col + 1),
}
}
}
impl Command for InsertCharCommand {
fn execute(
&mut self,
buffer: &mut TextBuffer,
cursor: &mut (usize, usize),
) {
buffer.insert_char(self.line, self.col, self.ch);
*cursor = self.cursor_after;
}
fn undo(&mut self, buffer: &mut TextBuffer, cursor: &mut (usize, usize)) {
buffer.delete_forward(self.line, self.col);
*cursor = self.cursor_before;
}
}
#[derive(Debug, Clone)]
pub struct DeleteCharCommand {
line: usize,
col: usize,
deleted_char: Option<char>,
merged_line: bool,
cursor_before: (usize, usize),
cursor_after: (usize, usize),
}
impl DeleteCharCommand {
pub fn new(
buffer: &TextBuffer,
line: usize,
col: usize,
cursor: (usize, usize),
) -> Self {
let (deleted_char, merged_line, cursor_after) = if col > 0 {
let line_str = buffer.line(line);
let ch = line_str.chars().nth(col - 1);
(ch, false, (line, col - 1))
} else if line > 0 {
let prev_line_len = buffer.line_len(line - 1);
(None, true, (line - 1, prev_line_len))
} else {
(None, false, cursor)
};
Self {
line,
col,
deleted_char,
merged_line,
cursor_before: cursor,
cursor_after,
}
}
}
impl Command for DeleteCharCommand {
fn execute(
&mut self,
buffer: &mut TextBuffer,
cursor: &mut (usize, usize),
) {
buffer.delete_char(self.line, self.col);
*cursor = self.cursor_after;
}
fn undo(&mut self, buffer: &mut TextBuffer, cursor: &mut (usize, usize)) {
if self.merged_line {
buffer.insert_newline(self.cursor_after.0, self.cursor_after.1);
} else if let Some(ch) = self.deleted_char {
buffer.insert_char(self.line, self.col - 1, ch);
}
*cursor = self.cursor_before;
}
}
#[derive(Debug, Clone)]
pub struct DeleteForwardCommand {
line: usize,
col: usize,
deleted_char: Option<char>,
merged_next_line: bool,
cursor_before: (usize, usize),
}
impl DeleteForwardCommand {
pub fn new(
buffer: &TextBuffer,
line: usize,
col: usize,
cursor: (usize, usize),
) -> Self {
let line_len = buffer.line_len(line);
let (deleted_char, merged_next_line) = if col < line_len {
let ch = buffer.line(line).chars().nth(col);
(ch, false)
} else if line + 1 < buffer.line_count() {
(None, true)
} else {
(None, false)
};
Self {
line,
col,
deleted_char,
merged_next_line,
cursor_before: cursor,
}
}
}
impl Command for DeleteForwardCommand {
fn execute(
&mut self,
buffer: &mut TextBuffer,
cursor: &mut (usize, usize),
) {
buffer.delete_forward(self.line, self.col);
*cursor = self.cursor_before; }
fn undo(&mut self, buffer: &mut TextBuffer, cursor: &mut (usize, usize)) {
if self.merged_next_line {
buffer.insert_newline(self.line, self.col);
} else if let Some(ch) = self.deleted_char {
buffer.insert_char(self.line, self.col, ch);
}
*cursor = self.cursor_before;
}
}
#[derive(Debug, Clone)]
pub struct InsertNewlineCommand {
line: usize,
col: usize,
cursor_before: (usize, usize),
cursor_after: (usize, usize),
indent: String,
}
impl InsertNewlineCommand {
pub fn with_indent(
line: usize,
col: usize,
cursor: (usize, usize),
indent: String,
) -> Self {
let indent_len = indent.chars().count();
Self {
line,
col,
cursor_before: cursor,
cursor_after: (line + 1, indent_len),
indent,
}
}
}
impl Command for InsertNewlineCommand {
fn execute(
&mut self,
buffer: &mut TextBuffer,
cursor: &mut (usize, usize),
) {
buffer.insert_newline(self.line, self.col);
for (i, c) in self.indent.chars().enumerate() {
buffer.insert_char(self.line + 1, i, c);
}
*cursor = self.cursor_after;
}
fn undo(&mut self, buffer: &mut TextBuffer, cursor: &mut (usize, usize)) {
for _ in 0..self.indent.chars().count() {
buffer.delete_forward(self.line + 1, 0);
}
if self.line + 1 < buffer.line_count() {
buffer.delete_char(self.line + 1, 0);
}
*cursor = self.cursor_before;
}
}
#[derive(Debug, Clone)]
pub struct InsertTextCommand {
line: usize,
col: usize,
text: String,
cursor_before: (usize, usize),
cursor_after: (usize, usize),
insert_end: (usize, usize),
}
impl InsertTextCommand {
pub fn new(
line: usize,
col: usize,
text: String,
cursor: (usize, usize),
) -> Self {
let lines: Vec<&str> = text.split('\n').collect();
let insert_end = if lines.len() == 1 {
(line, col + text.chars().count())
} else {
let last_line_len = lines.last().map_or(0, |l| l.chars().count());
(line + lines.len() - 1, last_line_len)
};
Self {
line,
col,
text,
cursor_before: cursor,
cursor_after: insert_end,
insert_end,
}
}
pub(crate) fn with_cursor_after(
mut self,
cursor_after: (usize, usize),
) -> Self {
self.cursor_after = cursor_after;
self
}
}
impl Command for InsertTextCommand {
fn execute(
&mut self,
buffer: &mut TextBuffer,
cursor: &mut (usize, usize),
) {
insert_text_at(buffer, self.line, self.col, &self.text);
*cursor = self.cursor_after;
}
fn undo(&mut self, buffer: &mut TextBuffer, cursor: &mut (usize, usize)) {
let mut current_line = self.insert_end.0;
let mut current_col = self.insert_end.1;
for ch in self.text.chars().rev() {
if ch == '\n' {
if current_line > 0 {
let prev_line_len = buffer.line_len(current_line - 1);
buffer.delete_char(current_line, 0);
current_line -= 1;
current_col = prev_line_len;
}
} else {
if current_col > 0 {
buffer.delete_char(current_line, current_col);
current_col -= 1;
}
}
}
*cursor = self.cursor_before;
}
}
#[derive(Debug, Clone)]
pub struct DeleteRangeCommand {
start: (usize, usize),
end: (usize, usize),
deleted_text: String,
cursor_before: (usize, usize),
}
impl DeleteRangeCommand {
pub fn new(
buffer: &TextBuffer,
start: (usize, usize),
end: (usize, usize),
cursor: (usize, usize),
) -> Self {
let mut deleted_text = String::new();
if start.0 == end.0 {
let line = buffer.line(start.0);
let chars: Vec<char> = line.chars().collect();
for ch in chars.iter().skip(start.1).take(
end.1
.saturating_sub(start.1)
.min(chars.len().saturating_sub(start.1)),
) {
deleted_text.push(*ch);
}
} else {
for line_idx in start.0..=end.0 {
let line = buffer.line(line_idx);
let chars: Vec<char> = line.chars().collect();
if line_idx == start.0 {
for ch in chars.iter().skip(start.1) {
deleted_text.push(*ch);
}
deleted_text.push('\n');
} else if line_idx == end.0 {
for ch in chars.iter().take(end.1.min(chars.len())) {
deleted_text.push(*ch);
}
} else {
deleted_text.push_str(line);
deleted_text.push('\n');
}
}
}
Self { start, end, deleted_text, cursor_before: cursor }
}
}
impl Command for DeleteRangeCommand {
fn execute(
&mut self,
buffer: &mut TextBuffer,
cursor: &mut (usize, usize),
) {
if self.start == self.end {
*cursor = self.start;
return;
}
if self.start.0 == self.end.0 {
buffer.replace_range(
self.start.0,
self.start.1,
self.end.1 - self.start.1,
"",
);
} else {
let tail: String =
buffer.line(self.end.0).chars().skip(self.end.1).collect();
let first_line_len = buffer.line_len(self.start.0);
buffer.replace_range(
self.start.0,
self.start.1,
first_line_len - self.start.1,
&tail,
);
for _ in self.start.0..self.end.0 {
buffer.remove_line(self.start.0 + 1);
}
}
*cursor = self.start;
}
fn undo(&mut self, buffer: &mut TextBuffer, cursor: &mut (usize, usize)) {
if self.start.0 == self.end.0 {
buffer.replace_range(
self.start.0,
self.start.1,
0,
&self.deleted_text,
);
} else {
let segments: Vec<&str> = self.deleted_text.split('\n').collect();
if let [first_segment, middle_segments @ .., last_segment] =
segments.as_slice()
{
let tail: String = buffer
.line(self.start.0)
.chars()
.skip(self.start.1)
.collect();
buffer.replace_range(
self.start.0,
self.start.1,
tail.chars().count(),
first_segment,
);
for (offset, segment) in middle_segments.iter().enumerate() {
buffer.insert_line(
self.start.0 + 1 + offset,
(*segment).to_string(),
);
}
buffer.insert_line(self.end.0, format!("{last_segment}{tail}"));
}
}
*cursor = self.cursor_before;
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_insert_text_at_single_line() {
let mut buffer = TextBuffer::new("hello");
let end = insert_text_at(&mut buffer, 0, 5, "!!");
assert_eq!(buffer.line(0), "hello!!");
assert_eq!(end, (0, 7));
}
#[test]
fn test_insert_text_at_with_newlines_returns_end_position() {
let mut buffer = TextBuffer::new("ac");
let end = insert_text_at(&mut buffer, 0, 1, "b\nb");
assert_eq!(buffer.line(0), "ab");
assert_eq!(buffer.line(1), "bc");
assert_eq!(end, (1, 1));
}
#[test]
fn test_insert_text_at_empty_string_is_noop() {
let mut buffer = TextBuffer::new("hello");
let end = insert_text_at(&mut buffer, 0, 2, "");
assert_eq!(buffer.line(0), "hello");
assert_eq!(end, (0, 2));
}
#[test]
fn test_insert_char_command() {
let mut buffer = TextBuffer::new("hello");
let mut cursor = (0, 5);
let mut cmd = InsertCharCommand::new(0, 5, '!', cursor);
cmd.execute(&mut buffer, &mut cursor);
assert_eq!(buffer.line(0), "hello!");
assert_eq!(cursor, (0, 6));
cmd.undo(&mut buffer, &mut cursor);
assert_eq!(buffer.line(0), "hello");
assert_eq!(cursor, (0, 5));
}
#[test]
fn test_delete_char_command() {
let mut buffer = TextBuffer::new("hello");
let mut cursor = (0, 5);
let mut cmd = DeleteCharCommand::new(&buffer, 0, 5, cursor);
cmd.execute(&mut buffer, &mut cursor);
assert_eq!(buffer.line(0), "hell");
assert_eq!(cursor, (0, 4));
cmd.undo(&mut buffer, &mut cursor);
assert_eq!(buffer.line(0), "hello");
assert_eq!(cursor, (0, 5));
}
#[test]
fn test_delete_char_command_merge_undo_restores_both_lines() {
let mut buffer = TextBuffer::new("hello\nworld");
let mut cursor = (1, 0);
let mut cmd = DeleteCharCommand::new(&buffer, 1, 0, cursor);
cmd.execute(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "helloworld");
assert_eq!(cursor, (0, 5));
cmd.undo(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "hello\nworld");
assert_eq!(cursor, (1, 0));
}
#[test]
fn test_delete_char_command_merge_undo_with_empty_lines() {
let mut buffer = TextBuffer::new("text\n\n");
let mut cursor = (1, 0);
let mut cmd = DeleteCharCommand::new(&buffer, 1, 0, cursor);
cmd.execute(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "text\n");
cmd.undo(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "text\n\n");
let mut buffer = TextBuffer::new("\ntext");
let mut cursor = (1, 0);
let mut cmd = DeleteCharCommand::new(&buffer, 1, 0, cursor);
cmd.execute(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "text");
cmd.undo(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "\ntext");
}
#[test]
fn test_delete_forward_command() {
let mut buffer = TextBuffer::new("hello");
let mut cursor = (0, 4);
let mut cmd = DeleteForwardCommand::new(&buffer, 0, 4, cursor);
cmd.execute(&mut buffer, &mut cursor);
assert_eq!(buffer.line(0), "hell");
assert_eq!(cursor, (0, 4));
cmd.undo(&mut buffer, &mut cursor);
assert_eq!(buffer.line(0), "hello");
assert_eq!(cursor, (0, 4));
}
#[test]
fn test_delete_forward_command_merge_undo_restores_both_lines() {
let mut buffer = TextBuffer::new("hello\nworld");
let mut cursor = (0, 5);
let mut cmd = DeleteForwardCommand::new(&buffer, 0, 5, cursor);
cmd.execute(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "helloworld");
assert_eq!(cursor, (0, 5));
cmd.undo(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "hello\nworld");
assert_eq!(cursor, (0, 5));
}
#[test]
fn test_delete_forward_command_merge_undo_with_empty_lines() {
let mut buffer = TextBuffer::new("text\n\n");
let mut cursor = (0, 4);
let mut cmd = DeleteForwardCommand::new(&buffer, 0, 4, cursor);
cmd.execute(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "text\n");
cmd.undo(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "text\n\n");
let mut buffer = TextBuffer::new("\ntext");
let mut cursor = (0, 0);
let mut cmd = DeleteForwardCommand::new(&buffer, 0, 0, cursor);
cmd.execute(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "text");
cmd.undo(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "\ntext");
}
#[test]
fn test_insert_newline_command() {
let mut buffer = TextBuffer::new("hello world");
let mut cursor = (0, 5);
let mut cmd =
InsertNewlineCommand::with_indent(0, 5, cursor, String::new());
cmd.execute(&mut buffer, &mut cursor);
assert_eq!(buffer.line(0), "hello");
assert_eq!(buffer.line(1), " world");
assert_eq!(cursor, (1, 0));
cmd.undo(&mut buffer, &mut cursor);
assert_eq!(buffer.line(0), "hello world");
assert_eq!(cursor, (0, 5));
}
#[test]
fn test_insert_newline_with_indent_spaces() {
let mut buffer = TextBuffer::new(" hello");
let mut cursor = (0, 9);
let mut cmd =
InsertNewlineCommand::with_indent(0, 9, cursor, " ".to_string());
cmd.execute(&mut buffer, &mut cursor);
assert_eq!(buffer.line(0), " hello");
assert_eq!(buffer.line(1), " ");
assert_eq!(cursor, (1, 4));
cmd.undo(&mut buffer, &mut cursor);
assert_eq!(buffer.line(0), " hello");
assert_eq!(buffer.line_count(), 1);
assert_eq!(cursor, (0, 9));
}
#[test]
fn test_insert_newline_with_indent_mid_line() {
let mut buffer = TextBuffer::new(" hello world");
let mut cursor = (0, 9);
let mut cmd =
InsertNewlineCommand::with_indent(0, 9, cursor, " ".to_string());
cmd.execute(&mut buffer, &mut cursor);
assert_eq!(buffer.line(0), " hello");
assert_eq!(buffer.line(1), " world"); assert_eq!(cursor, (1, 4));
cmd.undo(&mut buffer, &mut cursor);
assert_eq!(buffer.line(0), " hello world");
assert_eq!(buffer.line_count(), 1);
assert_eq!(cursor, (0, 9));
}
#[test]
fn test_insert_newline_with_indent_tab() {
let mut buffer = TextBuffer::new("\thello");
let mut cursor = (0, 6);
let mut cmd =
InsertNewlineCommand::with_indent(0, 6, cursor, "\t".to_string());
cmd.execute(&mut buffer, &mut cursor);
assert_eq!(buffer.line(0), "\thello");
assert_eq!(buffer.line(1), "\t");
assert_eq!(cursor, (1, 1));
cmd.undo(&mut buffer, &mut cursor);
assert_eq!(buffer.line(0), "\thello");
assert_eq!(buffer.line_count(), 1);
assert_eq!(cursor, (0, 6));
}
#[test]
fn test_insert_text_command() {
let mut buffer = TextBuffer::new("hello");
let mut cursor = (0, 5);
let mut cmd =
InsertTextCommand::new(0, 5, " world".to_string(), cursor);
cmd.execute(&mut buffer, &mut cursor);
assert_eq!(buffer.line(0), "hello world");
assert_eq!(cursor, (0, 11));
cmd.undo(&mut buffer, &mut cursor);
assert_eq!(buffer.line(0), "hello");
assert_eq!(cursor, (0, 5));
}
#[test]
fn test_insert_text_command_undo_ignores_overridden_cursor_after() {
let mut buffer = TextBuffer::new("abc");
let mut cursor = (0, 0);
let mut cmd = InsertTextCommand::new(0, 0, "a".to_string(), cursor)
.with_cursor_after((0, 0));
cmd.execute(&mut buffer, &mut cursor);
assert_eq!(buffer.line(0), "aabc");
assert_eq!(cursor, (0, 0), "caret rests on the pasted character");
cmd.undo(&mut buffer, &mut cursor);
assert_eq!(buffer.line(0), "abc");
assert_eq!(cursor, (0, 0));
}
#[test]
fn test_insert_text_command_undo_multiline_with_overridden_cursor_after() {
let mut buffer = TextBuffer::new("one\ntwo");
let mut cursor = (0, 0);
let mut cmd = InsertTextCommand::new(1, 0, "one\n".to_string(), cursor)
.with_cursor_after((1, 0));
cmd.execute(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "one\none\ntwo");
assert_eq!(cursor, (1, 0));
cmd.undo(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "one\ntwo");
assert_eq!(cursor, (0, 0));
}
#[test]
fn test_delete_range_command() {
let mut buffer = TextBuffer::new("hello world");
let mut cursor = (0, 0);
let mut cmd = DeleteRangeCommand::new(&buffer, (0, 0), (0, 5), cursor);
cmd.execute(&mut buffer, &mut cursor);
assert_eq!(buffer.line(0), " world");
assert_eq!(cursor, (0, 0));
cmd.undo(&mut buffer, &mut cursor);
assert_eq!(buffer.line(0), "hello world");
assert_eq!(cursor, (0, 0));
}
#[test]
fn test_delete_range_command_multiline() {
let mut buffer = TextBuffer::new("hello\nworld\nfoo\nbar");
let mut cursor = (0, 0);
let mut cmd = DeleteRangeCommand::new(&buffer, (0, 2), (2, 1), cursor);
cmd.execute(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "heoo\nbar");
assert_eq!(cursor, (0, 2));
cmd.undo(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "hello\nworld\nfoo\nbar");
assert_eq!(cursor, (0, 0));
}
#[test]
fn test_delete_range_command_range_ending_at_column_zero() {
let mut buffer = TextBuffer::new("ab\ncd");
let mut cursor = (0, 0);
let mut cmd = DeleteRangeCommand::new(&buffer, (0, 1), (1, 0), cursor);
cmd.execute(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "acd");
assert_eq!(cursor, (0, 1));
cmd.undo(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "ab\ncd");
assert_eq!(cursor, (0, 0));
}
#[test]
fn test_delete_range_command_empty_selection() {
let mut buffer = TextBuffer::new("hello world");
let mut cursor = (0, 3);
let mut cmd = DeleteRangeCommand::new(&buffer, (0, 3), (0, 3), cursor);
cmd.execute(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "hello world");
assert_eq!(cursor, (0, 3));
cmd.undo(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "hello world");
assert_eq!(cursor, (0, 3));
}
#[test]
fn test_delete_range_command_at_buffer_start() {
let mut buffer = TextBuffer::new("hello\nworld");
let mut cursor = (0, 0);
let mut cmd = DeleteRangeCommand::new(&buffer, (0, 0), (1, 2), cursor);
cmd.execute(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "rld");
assert_eq!(cursor, (0, 0));
cmd.undo(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "hello\nworld");
assert_eq!(cursor, (0, 0));
}
#[test]
fn test_delete_range_command_at_buffer_end() {
let mut buffer = TextBuffer::new("hello\nworld");
let mut cursor = (0, 0);
let mut cmd = DeleteRangeCommand::new(&buffer, (0, 3), (1, 5), cursor);
cmd.execute(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "hel");
assert_eq!(cursor, (0, 3));
cmd.undo(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "hello\nworld");
assert_eq!(cursor, (0, 0));
}
#[test]
fn test_delete_range_command_many_lines() {
let original = "one\ntwo\nthree\nfour\nfive\nsix\nseven";
let mut buffer = TextBuffer::new(original);
let mut cursor = (0, 0);
let mut cmd = DeleteRangeCommand::new(&buffer, (1, 1), (5, 2), cursor);
cmd.execute(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), "one\ntx\nseven");
assert_eq!(cursor, (1, 1));
cmd.undo(&mut buffer, &mut cursor);
assert_eq!(buffer.to_string(), original);
assert_eq!(cursor, (0, 0));
}
}