#[cfg(test)]
mod tests;
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum Change {
Insert { x: usize, y: usize, c: char },
Delete { x: usize, y: usize, c: char },
}
#[derive(Clone, Debug, PartialEq)]
pub struct Step {
pub changes: Vec<Change>,
pub before: (usize, usize),
pub after: (usize, usize),
typing: bool,
}
pub struct History {
done: Vec<Step>,
undone: Vec<Step>,
open: Option<Step>,
saved: Option<usize>,
sealed: bool,
}
impl Default for History {
fn default() -> Self {
Self {
done: Vec::new(),
undone: Vec::new(),
open: None,
saved: Some(0),
sealed: false,
}
}
}
impl History {
pub fn begin(&mut self, cursor: (usize, usize), typing: bool) {
self.open = Some(Step {
changes: Vec::new(),
before: cursor,
after: cursor,
typing,
});
}
pub fn record(&mut self, change: Change) {
if let Some(step) = &mut self.open {
step.changes.push(change);
}
}
pub fn commit(&mut self, cursor: (usize, usize)) {
let Some(mut step) = self.open.take().filter(|step| !step.changes.is_empty()) else {
return;
};
step.after = cursor;
self.undone.clear();
if self.saved.is_some_and(|saved| saved > self.done.len()) {
self.saved = None;
}
match self.done.last_mut() {
Some(last) if last.typing && step.typing && last.after == step.before && !self.sealed => {
last.changes.append(&mut step.changes);
last.after = step.after;
}
_ => self.done.push(step),
}
self.sealed = false;
}
pub fn undo(&mut self) -> Option<Step> {
self.open = None;
let step = self.done.pop()?;
self.undone.push(step.clone());
Some(step)
}
pub fn redo(&mut self) -> Option<Step> {
self.open = None;
let step = self.undone.pop()?;
self.done.push(step.clone());
Some(step)
}
pub fn mark_saved(&mut self) {
self.saved = Some(self.done.len());
self.sealed = true;
}
pub fn is_saved(&self) -> bool {
self.saved == Some(self.done.len())
}
}