Add undo manager

Author: davidbrochart

python/pycrdt/__init__.py

@@ -9,3 +9,4 @@
 from ._text import TextEvent as TextEvent
 from ._transaction import ReadTransaction as ReadTransaction
 from ._transaction import Transaction as Transaction
+from ._undo import UndoManager as UndoManager

python/pycrdt/_pycrdt.pyi

@@ -172,3 +172,21 @@ class Map:
     def unobserve(self, subscription: Subscription) -> None:
         """Unsubscribes previously subscribed event callback identified by given
         `subscription`."""
+
+class UndoManager:
+    """Undo manager."""
+
+    def can_undo(self) -> bool:
+        """Whether there is any change to undo."""
+
+    def undo(self) -> bool:
+        """Undo last action tracked by current undo manager."""
+
+    def can_redo(self) -> bool:
+        """Whether there is any change to redo."""
+
+    def redo(self) -> bool:
+        """Redo last action previously undone by current undo manager."""
+
+    def clear(self) -> None:
+        """Clear all items stored within current undo manager."""

python/pycrdt/_undo.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from ._base import BaseType
+from ._pycrdt import UndoManager as _UndoManager
+
+
+class UndoManager:
+    def __init__(self, scope: BaseType, capture_timeout_millis: int = 500) -> None:
+        undo_manager = _UndoManager()
+        method = getattr(undo_manager, f"from_{scope.type_name}")
+        self._undo_manager = method(scope.doc._doc, scope._integrated, capture_timeout_millis)
+
+    def can_undo(self) -> bool:
+        return self._undo_manager.can_undo()
+
+    def undo(self) -> bool:
+        return self._undo_manager.undo()
+
+    def can_redo(self) -> bool:
+        return self._undo_manager.can_redo()
+
+    def redo(self) -> bool:
+        return self._undo_manager.redo()
+
+    def clear(self) -> None:
+        self._undo_manager.clear()

src/array.rs

@@ -24,7 +24,7 @@ use crate::doc::Doc;
 
 #[pyclass(unsendable)]
 pub struct Array {
-    array: ArrayRef,
+    pub array: ArrayRef,
 }
 
 impl Array {

src/lib.rs

@@ -6,6 +6,7 @@ mod map;
 mod transaction;
 mod subscription;
 mod type_conversions;
+mod undo;
 use crate::doc::Doc;
 use crate::doc::TransactionEvent;
 use crate::doc::SubdocsEvent;
@@ -14,6 +15,7 @@ use crate::array::{Array, ArrayEvent};
 use crate::map::{Map, MapEvent};
 use crate::transaction::Transaction;
 use crate::subscription::Subscription;
+use crate::undo::UndoManager;
 
 #[pymodule]
 fn _pycrdt(_py: Python, m: &PyModule) -> PyResult<()> {
@@ -28,5 +30,6 @@ fn _pycrdt(_py: Python, m: &PyModule) -> PyResult<()> {
     m.add_class::<MapEvent>()?;
     m.add_class::<Transaction>()?;
     m.add_class::<Subscription>()?;
+    m.add_class::<UndoManager>()?;
     Ok(())
 }

src/map.rs

@@ -24,7 +24,7 @@ use crate::doc::Doc;
 
 #[pyclass(unsendable)]
 pub struct Map {
-    map: MapRef,
+    pub map: MapRef,
 }
 
 impl Map {

src/text.rs

@@ -15,7 +15,7 @@ use crate::type_conversions::ToPython;
 
 #[pyclass(unsendable)]
 pub struct Text {
-    text: TextRef,
+    pub text: TextRef,
 }
 
 impl Text {

src/undo.rs

@@ -0,0 +1,73 @@
+use pyo3::prelude::*;
+use pyo3::exceptions::PyRuntimeError;
+use yrs::{
+    UndoManager as _UndoManager,
+};
+use yrs::undo::Options;
+use crate::doc::Doc;
+use crate::text::Text;
+use crate::array::Array;
+use crate::map::Map;
+
+
+#[pyclass(unsendable)]
+pub struct UndoManager {
+    undo_manager: Option<_UndoManager>,
+}
+
+impl UndoManager {
+    fn get_options(&self, capture_timeout_millis: &u64) -> Options {
+        let mut options = Options::default();
+        options.capture_timeout_millis = *capture_timeout_millis;
+        options
+    }
+}
+
+#[pymethods]
+impl UndoManager {
+    #[new]
+    fn new() -> Self {
+        UndoManager { undo_manager: None }
+    }
+
+    pub fn from_text(&self, doc: &Doc, scope: &Text, capture_timeout_millis: u64) -> Self {
+        let options = self.get_options(&capture_timeout_millis);
+        let undo_manager = _UndoManager::with_options(&doc.doc, &scope.text, options);
+        UndoManager { undo_manager: Some(undo_manager) }
+    }
+
+    pub fn from_array(&self, doc: &Doc, scope: &Array, capture_timeout_millis: u64) -> Self {
+        let options = self.get_options(&capture_timeout_millis);
+        let undo_manager = _UndoManager::with_options(&doc.doc, &scope.array, options);
+        UndoManager { undo_manager: Some(undo_manager) }
+    }
+
+    pub fn from_map(&self, doc: &Doc, scope: &Map, capture_timeout_millis: u64) -> Self {
+        let options = self.get_options(&capture_timeout_millis);
+        let undo_manager = _UndoManager::with_options(&doc.doc, &scope.map, options);
+        UndoManager { undo_manager: Some(undo_manager) }
+    }
+
+    pub fn can_undo(&mut self)  -> bool {
+        self.undo_manager.as_ref().unwrap().can_undo()
+    }
+
+    pub fn undo(&mut self)  -> PyResult<bool> {
+        let Ok(res) = self.undo_manager.as_mut().unwrap().undo() else { return Err(PyRuntimeError::new_err("Cannot undo")) };
+        Ok(res)
+    }
+
+    pub fn can_redo(&mut self)  -> bool {
+        self.undo_manager.as_ref().unwrap().can_redo()
+    }
+
+    pub fn redo(&mut self)  -> PyResult<bool> {
+        let Ok(res) = self.undo_manager.as_mut().unwrap().redo() else { return Err(PyRuntimeError::new_err("Cannot redo")) };
+        Ok(res)
+    }
+
+    pub fn clear(&mut self)  -> PyResult<()> {
+        let Ok(res) = self.undo_manager.as_mut().unwrap().clear() else { return Err(PyRuntimeError::new_err("Cannot clear")) };
+        Ok(res)
+    }
+}

tests/test_undo.py

@@ -0,0 +1,74 @@
+from pycrdt import Array, Doc, Map, Text, UndoManager
+
+
+def undo_redo(data, undo_manager, val0, val1, val3):
+    assert undo_manager.can_undo()
+    undone = undo_manager.undo()
+    assert undone
+    assert data.to_py() == val1
+    assert undo_manager.can_undo()
+    undone = undo_manager.undo()
+    assert undone
+    assert data.to_py() == val0
+    assert not undo_manager.can_undo()
+    undone = undo_manager.undo()
+    assert not undone
+    assert undo_manager.can_redo()
+    redone = undo_manager.redo()
+    assert redone
+    assert data.to_py() == val1
+    assert undo_manager.can_redo()
+    redone = undo_manager.redo()
+    assert redone
+    assert data.to_py() == val3
+    assert not undo_manager.can_redo()
+    redone = undo_manager.redo()
+    assert not redone
+    assert undo_manager.can_undo()
+    undo_manager.clear()
+    assert not undo_manager.can_undo()
+
+
+def test_text_undo():
+    doc = Doc()
+    doc["data"] = data = Text()
+    undo_manager = UndoManager(data, capture_timeout_millis=0)
+    val0 = ""
+    val1 = "Hello"
+    val2 = ", World!"
+    val3 = val1 + val2
+    data += val1
+    assert data.to_py() == val1
+    data += val2
+    assert data.to_py() == val3
+    undo_redo(data, undo_manager, val0, val1, val3)
+
+
+def test_array_undo():
+    doc = Doc()
+    doc["data"] = data = Array()
+    undo_manager = UndoManager(data, capture_timeout_millis=0)
+    val0 = []
+    val1 = ["foo"]
+    val2 = ["bar"]
+    val3 = val1 + val2
+    data += val1
+    assert data.to_py() == val1
+    data += val2
+    assert data.to_py() == val3
+    undo_redo(data, undo_manager, val0, val1, val3)
+
+
+def test_map_undo():
+    doc = Doc()
+    doc["data"] = data = Map()
+    undo_manager = UndoManager(data, capture_timeout_millis=0)
+    val0 = {}
+    val1 = {"key0": "val0"}
+    val2 = {"key1": "val1"}
+    val3 = dict(**val1, **val2)
+    data.update(val1)
+    assert data.to_py() == val1
+    data.update(val2)
+    assert data.to_py() == val3
+    undo_redo(data, undo_manager, val0, val1, val3)