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,9 @@ class Map:
     def unobserve(self, subscription: Subscription) -> None:
         """Unsubscribes previously subscribed event callback identified by given
         `subscription`."""
+
+class UndoManager:
+    """Undo manager."""
+
+    def undo(self) -> bool:
+        """Undo last action tracked by current undo manager."""

python/pycrdt/_undo.py

@@ -0,0 +1,14 @@
+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 undo(self) -> None:
+        self._undo_manager.undo()

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,55 @@
+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 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)
+    }
+}

tests/test_undo.py

@@ -0,0 +1,43 @@
+from pycrdt import Array, Doc, Map, Text, UndoManager
+
+
+def test_text_undo():
+    doc = Doc()
+    doc["text"] = text = Text()
+    undo_manager = UndoManager(text, capture_timeout_millis=0)
+    text += "Hello"
+    assert str(text) == "Hello"
+    text += ", World!"
+    assert str(text) == "Hello, World!"
+    undo_manager.undo()
+    assert str(text) == "Hello"
+    undo_manager.undo()
+    assert str(text) == ""
+
+
+def test_array_undo():
+    doc = Doc()
+    doc["array"] = array = Array()
+    undo_manager = UndoManager(array, capture_timeout_millis=0)
+    array.append("foo")
+    assert array.to_py() == ["foo"]
+    array.append("bar")
+    assert array.to_py() == ["foo", "bar"]
+    undo_manager.undo()
+    assert array.to_py() == ["foo"]
+    undo_manager.undo()
+    assert array.to_py() == []
+
+
+def test_map_undo():
+    doc = Doc()
+    doc["map0"] = map0 = Map()
+    undo_manager = UndoManager(map0, capture_timeout_millis=0)
+    map0["key0"] = "val0"
+    assert map0.to_py() == {"key0": "val0"}
+    map0["key1"] = "val1"
+    assert map0.to_py() == {"key0": "val0", "key1": "val1"}
+    undo_manager.undo()
+    assert map0.to_py() == {"key0": "val0"}
+    undo_manager.undo()
+    assert map0.to_py() == {}