Persistent Undo

helix-core/Cargo.toml

@@ -33,6 +33,8 @@ bitflags = "1.3"
 ahash = "0.8.3"
 hashbrown = { version = "0.13.2", features = ["raw"] }
 
+sha1_smol = "1.0"
+
 log = "0.4"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
@@ -47,5 +49,9 @@ chrono = { version = "0.4", default-features = false, features = ["alloc", "std"
 etcetera = "0.4"
 textwrap = "0.16.0"
 
+[target.'cfg(unix)'.dependencies]
+libc = "0.2"
+
 [dev-dependencies]
 quickcheck = { version = "1", default-features = false }
+tempfile = "3.3.0"

helix-core/src/history.rs

@@ -1,7 +1,11 @@
+use crate::parse::*;
 use crate::{Assoc, ChangeSet, Range, Rope, Selection, Transaction};
 use once_cell::sync::Lazy;
 use regex::Regex;
+use std::io::{Read, Write};
 use std::num::NonZeroUsize;
+use std::path::Path;
+use std::sync::Arc;
 use std::time::{Duration, Instant};
 
 #[derive(Debug, Clone)]
@@ -47,7 +51,7 @@ pub struct State {
 ///    delete, we also store an inversion of the transaction.
 ///
 /// Using time to navigate the history: <https://github.com/helix-editor/helix/pull/194>
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct History {
     revisions: Vec<Revision>,
     current: usize,
@@ -58,10 +62,10 @@ pub struct History {
 struct Revision {
     parent: usize,
     last_child: Option<NonZeroUsize>,
-    transaction: Transaction,
+    transaction: Arc<Transaction>,
     // We need an inversion for undos because delete transactions don't store
     // the deleted text.
-    inversion: Transaction,
+    inversion: Arc<Transaction>,
     timestamp: Instant,
 }
 
@@ -72,16 +76,116 @@ impl Default for History {
             revisions: vec![Revision {
                 parent: 0,
                 last_child: None,
-                transaction: Transaction::from(ChangeSet::new(&Rope::new())),
-                inversion: Transaction::from(ChangeSet::new(&Rope::new())),
+                transaction: Arc::new(Transaction::from(ChangeSet::new(&Rope::new()))),
+                inversion: Arc::new(Transaction::from(ChangeSet::new(&Rope::new()))),
                 timestamp: Instant::now(),
             }],
             current: 0,
         }
     }
 }
 
+impl Revision {
+    fn serialize<W: Write>(&self, writer: &mut W) -> std::io::Result<()> {
+        write_usize(writer, self.parent)?;
+        write_usize(writer, self.last_child.map(|n| n.get()).unwrap_or(0))?;
+        self.transaction.serialize(writer)?;
+        self.inversion.serialize(writer)?;
+
+        Ok(())
+    }
+
+    fn deserialize<R: Read>(reader: &mut R, timestamp: Instant) -> std::io::Result<Self> {
+        let parent = read_usize(reader)?;
+        let last_child = match read_usize(reader)? {
+            0 => None,
+            n => Some(unsafe { NonZeroUsize::new_unchecked(n) }),
+        };
+        let transaction = Arc::new(Transaction::deserialize(reader)?);
+        let inversion = Arc::new(Transaction::deserialize(reader)?);
+        Ok(Revision {
+            parent,
+            last_child,
+            transaction,
+            inversion,
+            timestamp,
+        })
+    }
+}
+
+const HEADER_TAG: &str = "Helix Undofile 1\n";
+
+fn get_hash<R: Read>(reader: &mut R) -> std::io::Result<[u8; 20]> {
+    const BUF_SIZE: usize = 8192;
+
+    let mut buf = [0u8; BUF_SIZE];
+    let mut hash = sha1_smol::Sha1::new();
+    loop {
+        let total_read = reader.read(&mut buf)?;
+        if total_read == 0 {
+            break;
+        }
+
+        hash.update(&buf[0..total_read]);
+    }
+    Ok(hash.digest().bytes())
+}
+
 impl History {
+    pub fn serialize<W: Write>(
+        &self,
+        writer: &mut W,
+        path: &Path,
+        last_saved_revision: usize,
+    ) -> std::io::Result<()> {
+        write_string(writer, HEADER_TAG)?;
+        write_usize(writer, self.current)?;
+        write_usize(writer, last_saved_revision)?;
+
+        let last_mtime = std::fs::metadata(path)?
+            .modified()?
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_secs();
+        write_u64(writer, last_mtime)?;
+        writer.write_all(&get_hash(&mut std::fs::File::open(path)?)?)?;
+        write_vec(writer, &self.revisions, |writer, rev| rev.serialize(writer))?;
+        Ok(())
+    }
+
+    pub fn deserialize<R: Read>(reader: &mut R, path: &Path) -> std::io::Result<(usize, Self)> {
+        let header = read_string(reader)?;
+        if HEADER_TAG != header {
+            Err(std::io::Error::new(
+                std::io::ErrorKind::Other,
+                "missing undofile header",
+            ))
+        } else {
+            let timestamp = Instant::now();
+            let current = read_usize(reader)?;
+            let last_saved_revision = read_usize(reader)?;
+            let mtime = read_u64(reader)?;
+            let last_mtime = std::fs::metadata(path)?
+                .modified()?
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_secs();
+            let mut hash = [0u8; 20];
+            reader.read_exact(&mut hash)?;
+
+            if mtime != last_mtime && hash != get_hash(&mut std::fs::File::open(path)?)? {
+                return Err(std::io::Error::new(
+                    std::io::ErrorKind::Other,
+                    "outdated undo file",
+                ));
+            }
+
+            let revisions = read_vec(reader, |reader| Revision::deserialize(reader, timestamp))?;
+            let history = History { current, revisions };
+            Ok((last_saved_revision, history))
+        }
+    }
+
     pub fn commit_revision(&mut self, transaction: &Transaction, original: &State) {
         self.commit_revision_at_timestamp(transaction, original, Instant::now());
     }
@@ -92,17 +196,19 @@ impl History {
         original: &State,
         timestamp: Instant,
     ) {
-        let inversion = transaction
-            .invert(&original.doc)
-            // Store the current cursor position
-            .with_selection(original.selection.clone());
+        let inversion = Arc::new(
+            transaction
+                .invert(&original.doc)
+                // Store the current cursor position
+                .with_selection(original.selection.clone()),
+        );
 
         let new_current = self.revisions.len();
         self.revisions[self.current].last_child = NonZeroUsize::new(new_current);
         self.revisions.push(Revision {
             parent: self.current,
             last_child: None,
-            transaction: transaction.clone(),
+            transaction: Arc::new(transaction.clone()),
             inversion,
             timestamp,
         });
@@ -128,8 +234,10 @@ impl History {
         let up_txns = up
             .iter()
             .rev()
-            .map(|&n| self.revisions[n].inversion.clone());
-        let down_txns = down.iter().map(|&n| self.revisions[n].transaction.clone());
+            .map(|&n| self.revisions[n].inversion.as_ref().clone());
+        let down_txns = down
+            .iter()
+            .map(|&n| self.revisions[n].transaction.as_ref().clone());
 
         down_txns.chain(up_txns).reduce(|acc, tx| tx.compose(acc))
     }
@@ -215,11 +323,13 @@ impl History {
         let up = self.path_up(self.current, lca);
         let down = self.path_up(to, lca);
         self.current = to;
-        let up_txns = up.iter().map(|&n| self.revisions[n].inversion.clone());
+        let up_txns = up
+            .iter()
+            .map(|&n| self.revisions[n].inversion.as_ref().clone());
         let down_txns = down
             .iter()
             .rev()
-            .map(|&n| self.revisions[n].transaction.clone());
+            .map(|&n| self.revisions[n].transaction.as_ref().clone());
         up_txns.chain(down_txns).collect()
     }
 
@@ -386,6 +496,8 @@ impl std::str::FromStr for UndoKind {
 
 #[cfg(test)]
 mod test {
+    use quickcheck::quickcheck;
+
     use super::*;
     use crate::Selection;
 
@@ -630,4 +742,27 @@ mod test {
             Err("duration too large".to_string())
         );
     }
+
+    quickcheck!(
+        fn serde_history(original: String, changes: Vec<String>) -> bool {
+            let mut history = History::default();
+            let mut original = Rope::from(original);
+
+            for c in changes.into_iter().map(Rope::from) {
+                let transaction = crate::diff::compare_ropes(&original, &c);
+                let state = State {
+                    doc: original,
+                    selection: Selection::point(0),
+                };
+                history.commit_revision(&transaction, &state);
+                original = c;
+            }
+
+            let mut buf = Vec::new();
+            let file = tempfile::NamedTempFile::new().unwrap();
+            history.serialize(&mut buf, file.path(), 0).unwrap();
+            History::deserialize(&mut buf.as_slice(), file.path()).unwrap();
+            true
+        }
+    );
 }

helix-core/src/lib.rs

@@ -16,6 +16,7 @@ pub mod macros;
 pub mod match_brackets;
 pub mod movement;
 pub mod object;
+pub mod parse;
 pub mod path;
 mod position;
 pub mod register;