Change to Edit command

Cargo.toml

@@ -15,6 +15,9 @@ edition = "2021"
 colored = { version = "2", optional = true }
 serde = { version = "1", optional = true, default-features = false, features = ["derive"] }
 
+[dev-dependencies]
+chrono = "0.4"
+
 [features]
 default = ["std"]
 std = ["alloc", "serde?/std"]

README.md

@@ -6,38 +6,40 @@
 [![Crates.io](https://img.shields.io/crates/v/undo.svg)](https://crates.io/crates/undo)
 [![Docs](https://docs.rs/undo/badge.svg)](https://docs.rs/undo)
 
-It is an implementation of the [command pattern](https://en.wikipedia.org/wiki/Command_pattern),
-where all modifications are done by creating objects that applies the modifications.
+An implementation of the [command pattern](https://en.wikipedia.org/wiki/Command_pattern),
+where all edits are done by creating objects that applies the modifications.
 All objects 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.
+structures it is easy to undo and redo edits made to a target.
+
+See the [documentation](https://docs.rs/undo) and [examples](https://github.com/evenorog/undo/tree/master/examples) for more information.
 
 ## Examples
 
 ```rust
-use undo::{Action, Record};
+use undo::{Edit, Record};
 
-struct Push(char);
+struct Add(char);
 
-impl Action for Push {
+impl Edit for Add {
     type Target = String;
     type Output = ();
 
-    fn apply(&mut self, target: &mut String) {
+    fn edit(&mut self, target: &mut String) {
         target.push(self.0);
     }
 
     fn undo(&mut self, target: &mut String) {
-        self.0 = target.pop().expect("cannot pop empty string");
+        self.0 = target.pop().unwrap();
     }
 }
 
 fn main() {
     let mut target = String::new();
     let mut record = Record::new();
 
-    record.apply(&mut target, Push('a'));
-    record.apply(&mut target, Push('b'));
-    record.apply(&mut target, Push('c'));
+    record.edit(&mut target, Add('a'));
+    record.edit(&mut target, Add('b'));
+    record.edit(&mut target, Add('c'));
     assert_eq!(target, "abc");
 
     record.undo(&mut target);

examples/history.rs

@@ -1,55 +1,56 @@
-use core::fmt::{self, Display, Formatter};
-use undo::{Action, History};
-
-struct Push(char);
-
-impl Action for Push {
-    type Target = String;
-    type Output = ();
-
-    fn apply(&mut self, string: &mut String) {
-        string.push(self.0);
-    }
-
-    fn undo(&mut self, string: &mut String) {
-        self.0 = string.pop().expect("cannot pop empty string");
-    }
-}
-
-impl Display for Push {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "Push '{}'", self.0)
-    }
+use chrono::{DateTime, Local};
+use std::io;
+use std::time::SystemTime;
+use undo::{Add, At, History};
+
+fn custom_st_fmt(_: SystemTime, at: SystemTime) -> String {
+    let dt = DateTime::<Local>::from(at);
+    dt.format("%H:%M:%S").to_string()
 }
 
-fn main() {
-    let mut history = History::new();
+fn main() -> io::Result<()> {
+    let stdin = io::stdin();
     let mut target = String::new();
-
-    history.apply(&mut target, Push('a'));
-    history.apply(&mut target, Push('b'));
-    history.apply(&mut target, Push('c'));
-    assert_eq!(target, "abc");
-
-    let abc_branch = history.branch();
-    let abc_current = history.current();
-
-    history.undo(&mut target);
-    assert_eq!(target, "ab");
-
-    history.apply(&mut target, Push('d'));
-    history.apply(&mut target, Push('e'));
-    history.apply(&mut target, Push('f'));
-    assert_eq!(target, "abdef");
-
-    let abdef_branch = history.branch();
-    let abdef_current = history.current();
-
-    history.go_to(&mut target, abc_branch, abc_current);
-    assert_eq!(target, "abc");
-
-    history.go_to(&mut target, abdef_branch, abdef_current);
-    assert_eq!(target, "abdef");
-
-    println!("{}", history.display());
+    let mut history = History::<_>::builder().limit(10).capacity(10).build();
+
+    loop {
+        println!(
+            "Enter a string. Use '<' to undo, '>' to redo, '*' to save, and '! i-j' for goto: "
+        );
+        let mut buf = String::new();
+        let n = stdin.read_line(&mut buf)?;
+        if n == 0 {
+            return Ok(());
+        }
+
+        // Clears the terminal.
+        print!("{}c", 27 as char);
+
+        let mut chars = buf.trim().chars();
+        while let Some(c) = chars.next() {
+            if c == '!' {
+                let tail = chars.collect::<String>();
+                let mut at = tail
+                    .trim()
+                    .split('-')
+                    .filter_map(|n| n.parse::<usize>().ok());
+
+                let root = at.next().unwrap_or_default();
+                let index = at.next().unwrap_or_default();
+                history.go_to(&mut target, At::new(root, index));
+                break;
+            } else if c == '<' {
+                history.undo(&mut target);
+            } else if c == '>' {
+                history.redo(&mut target);
+            } else if c == '*' {
+                history.set_saved(true);
+            } else {
+                history.edit(&mut target, Add(c));
+            }
+        }
+
+        println!("{}\n", history.display().set_st_fmt(&custom_st_fmt));
+        println!("Target: {target}");
+    }
 }

examples/record.rs

@@ -1,43 +1,22 @@
-use core::fmt::{self, Display, Formatter};
-use undo::{Action, Record};
-
-struct Push(char);
-
-impl Action for Push {
-    type Target = String;
-    type Output = ();
-
-    fn apply(&mut self, target: &mut String) {
-        target.push(self.0);
-    }
-
-    fn undo(&mut self, target: &mut String) {
-        self.0 = target.pop().expect("cannot pop empty string");
-    }
-}
-
-impl Display for Push {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "Push '{}'", self.0)
-    }
-}
+use undo::{Add, Record};
 
 fn main() {
-    let mut record = Record::new();
     let mut target = String::new();
+    let mut record = Record::new();
 
-    record.apply(&mut target, Push('a'));
-    record.apply(&mut target, Push('b'));
-    record.apply(&mut target, Push('c'));
-    assert_eq!(target, "abc");
+    record.edit(&mut target, Add('a'));
+    record.edit(&mut target, Add('b'));
+    record.edit(&mut target, Add('c'));
+    record.edit(&mut target, Add('d'));
+    record.edit(&mut target, Add('e'));
+    record.edit(&mut target, Add('f'));
+    assert_eq!(target, "abcdef");
+
+    record.set_saved(true);
 
     record.undo(&mut target);
     record.undo(&mut target);
-    assert_eq!(target, "a");
-
-    record.redo(&mut target);
-    record.redo(&mut target);
-    assert_eq!(target, "abc");
+    assert_eq!(target, "abcd");
 
     println!("{}", record.display());
 }

src/add.rs

@@ -0,0 +1,28 @@
+use alloc::string::String;
+use core::fmt::{self, Display, Formatter};
+
+/// This is the edit used in all the examples.
+///
+/// Not part of the API and can change at any time.
+#[doc(hidden)]
+#[derive(Clone, Copy, Debug)]
+pub struct Add(pub char);
+
+impl crate::Edit for Add {
+    type Target = String;
+    type Output = ();
+
+    fn edit(&mut self, string: &mut String) {
+        string.push(self.0);
+    }
+
+    fn undo(&mut self, string: &mut String) {
+        self.0 = string.pop().unwrap();
+    }
+}
+
+impl Display for Add {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "Add '{}'", self.0)
+    }
+}