Crate undo

Expand description

A undo-redo library.

It is an implementation of the action pattern, where all modifications are done by creating objects of actions that applies the modifications. All actions knows how to undo the changes it applies, and by using the provided data structures it is easy to apply, undo, and redo changes made to a target.

Features

Action provides the base functionality for all actions.
Record provides basic undo-redo functionality.
History provides non-linear undo-redo functionality that allows you to jump between different branches.
Queues that wraps a record or history and extends them with queue functionality.
Checkpoints that wraps a record or history and extends them with checkpoint functionality.
Actions can be merged into a single action by implementing the merge method on the action. This allows smaller actions to be used to build more complex operations, or smaller incremental changes to be merged into larger changes that can be undone and redone in a single step.
The target can be marked as being saved to disk and the data-structures can track the saved state and notify when it changes.
The amount of changes being tracked can be configured by the user so only the N most recent changes are stored.
Configurable display formatting using the display structure.

Cargo Feature Flags

alloc: Enables the use of the alloc crate, enabled by default.
colored: Enables colored output when visualizing the display structures, enabled by default.
time: Enables time stamps and time travel.
serde: Enables serialization and deserialization.

Examples

use undo::{Action, History};

struct Push(char);

impl Action for Push {
    type Target = String;
    type Output = ();

    fn apply(&mut self, s: &mut String) {
        s.push(self.0);
    }

    fn undo(&mut self, s: &mut String) {
        self.0 = s.pop().expect("s is empty");
    }
}

fn main() {
    let mut target = String::new();
    let mut history = History::new();
    history.apply(&mut target, Push('a'));
    history.apply(&mut target, Push('b'));
    history.apply(&mut target, Push('c'));
    assert_eq!(target, "abc");
    history.undo(&mut target);
    history.undo(&mut target);
    history.undo(&mut target);
    assert_eq!(target, "");
    history.redo(&mut target);
    history.redo(&mut target);
    history.redo(&mut target);
    assert_eq!(target, "abc");
}