automerge-rb 0.1.1

data/vendor/automerge-rust/automerge/src/transaction/manual_transaction.rs

@@ -0,0 +1,147 @@
+use crate::exid::ExId;
+use crate::patches::PatchLog;
+use crate::ChangeHash;
+use crate::{automerge::Automerge, AutomergeError, PatchLogMismatch};
+
+use super::{CommitOptions, TransactionArgs, TransactionInner};
+
+/// A transaction on a document.
+/// Transactions group operations into a single change so that no other operations can happen
+/// in-between.
+///
+/// Created from [`Automerge::transaction()`].
+///
+/// ## Drop
+///
+/// This transaction should be manually committed or rolled back. If not done manually then it will
+/// be rolled back when it is dropped. This is to prevent the document being in an unsafe
+/// intermediate state.
+/// This is consistent with [`?`][std::ops::Try] error handling.
+#[derive(Debug)]
+pub struct Transaction<'a> {
+    // this is an option so that we can take it during commit and rollback to prevent it being
+    // rolled back during drop.
+    inner: Option<TransactionInner>,
+    patch_log: PatchLog,
+    doc: &'a mut Automerge,
+}
+
+impl<'a> Transaction<'a> {
+    pub(crate) fn new(
+        doc: &'a mut Automerge,
+        args: TransactionArgs,
+        mut patch_log: PatchLog,
+    ) -> Result<Self, PatchLogMismatch> {
+        patch_log
+            .migrate_actors(&doc.ops().actors)
+            .map_err(|_| PatchLogMismatch)?;
+        Ok(Self {
+            inner: Some(TransactionInner::new(args)),
+            doc,
+            patch_log,
+        })
+    }
+
+    /// Get the hash of the change that contains the given opid.
+    ///
+    /// Returns none if the opid:
+    /// - is the root object id
+    /// - does not exist in this document
+    /// - is for an operation in this transaction
+    pub fn hash_for_opid(&self, opid: &ExId) -> Option<ChangeHash> {
+        self.doc.hash_for_opid(opid)
+    }
+}
+
+impl<'a> Transaction<'a> {
+    pub(crate) fn empty(
+        doc: &'a mut Automerge,
+        args: TransactionArgs,
+        opts: CommitOptions,
+    ) -> ChangeHash {
+        TransactionInner::empty(doc, args, opts.message, opts.time)
+    }
+}
+
+impl Transaction<'_> {
+    /// Get the heads of the document before this transaction was started.
+    pub fn get_heads(&self) -> Vec<ChangeHash> {
+        self.doc.get_heads()
+    }
+
+    /// Commit the operations performed in this transaction, returning the hashes corresponding to
+    /// the new heads.
+    pub fn commit(mut self) -> (Option<ChangeHash>, PatchLog) {
+        let tx = self.inner.take().unwrap();
+        let hash = tx.commit(self.doc, None, None);
+        // TODO - remove this clone
+        (hash, self.patch_log.clone())
+    }
+
+    /// Commit the operations in this transaction with some options.
+    ///
+    /// ```
+    /// # use automerge::transaction::CommitOptions;
+    /// # use automerge::transaction::Transactable;
+    /// # use automerge::ROOT;
+    /// # use automerge::Automerge;
+    /// # use automerge::ObjType;
+    /// # use std::time::SystemTime;
+    /// let mut doc = Automerge::new();
+    /// let mut tx = doc.transaction();
+    /// tx.put_object(ROOT, "todos", ObjType::List).unwrap();
+    /// let now = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_secs() as
+    /// i64;
+    /// tx.commit_with(CommitOptions::default().with_message("Create todos list").with_time(now));
+    /// ```
+    pub fn commit_with(mut self, options: CommitOptions) -> (Option<ChangeHash>, PatchLog) {
+        let tx = self.inner.take().unwrap();
+        let hash = tx.commit(self.doc, options.message, options.time);
+        // TODO - remove this clone
+        (hash, self.patch_log.clone())
+    }
+
+    /// Undo the operations added in this transaction, returning the number of cancelled
+    /// operations.
+    pub fn rollback(mut self) -> usize {
+        self.inner.take().unwrap().rollback(self.doc)
+    }
+
+    fn do_tx<F, O>(&mut self, f: F) -> O
+    where
+        F: FnOnce(&mut TransactionInner, &mut Automerge, &mut PatchLog) -> O,
+    {
+        let tx = self.inner.as_mut().unwrap();
+        f(tx, self.doc, &mut self.patch_log)
+    }
+
+    fn get_scope(&self, heads: Option<&[ChangeHash]>) -> Option<crate::types::Clock> {
+        if let Some(h) = heads {
+            Some(self.doc.clock_at(h))
+        } else {
+            self.inner.as_ref().and_then(|i| i.get_scope().clone())
+        }
+    }
+
+    pub(crate) fn batch_init_root_map(
+        &mut self,
+        value: &crate::hydrate::Map,
+    ) -> Result<(), AutomergeError> {
+        self.do_tx(move |tx, doc, hist| tx.batch_init_root_map(doc, hist, value))
+    }
+}
+
+super::impl_read_doc_for_tx!(Transaction<'_>);
+super::impl_transactable_for_tx!(Transaction<'_>);
+
+impl Drop for Transaction<'_> {
+    /// If a transaction is not commited or rolled back manually then it can leave the document in
+    /// an intermediate state.
+    /// This defaults to rolling back the transaction to be compatible with [`?`][std::ops::Try]
+    /// error returning before reaching a call to [`Self::commit()`].
+    fn drop(&mut self) {
+        if let Some(txn) = self.inner.take() {
+            txn.rollback(self.doc);
+        }
+    }
+}

data/vendor/automerge-rust/automerge/src/transaction/owned_transaction.rs

@@ -0,0 +1,266 @@
+use crate::automerge::Automerge;
+use crate::exid::ExId;
+use crate::patches::PatchLog;
+use crate::{ChangeHash, PatchLogMismatch};
+
+use super::{CommitOptions, TransactionInner};
+
+/// A transaction that **owns** the `Automerge` document.
+///
+/// Like [`super::Transaction`], this groups operations into a single change. The difference is
+/// ownership: `Transaction<'a>` borrows `&'a mut Automerge`, while `OwnedTransaction` consumes
+/// it, making the type `'static` and `Send`. This is useful when lifetimes cannot be tracked
+/// across an API boundary (e.g. FFI, async runtimes, or storing a transaction in a struct that
+/// must be `'static`).
+///
+/// Created via [`Automerge::into_transaction`](crate::Automerge::into_transaction).
+#[derive(Debug)]
+pub struct OwnedTransaction {
+    // This is always `Some` — it's `Option` only because the shared `impl_transactable_for_tx!`
+    // macro (also used by `Transaction<'a>`, which needs `Option` for its `Drop` impl) accesses
+    // `self.inner` directly and expects it to be an Option<TransactionInner>
+    inner: Option<TransactionInner>,
+    patch_log: PatchLog,
+    doc: Automerge,
+}
+
+// Compile-time assertion that OwnedTransaction is Send.
+const _: () = {
+    fn _assert_send<T: Send>() {}
+    fn _assert_owned_tx() {
+        _assert_send::<OwnedTransaction>()
+    }
+};
+
+impl OwnedTransaction {
+    /// Create a new transaction, consuming the document.
+    pub(crate) fn new(
+        mut doc: Automerge,
+        patch_log: Option<PatchLog>,
+        heads: Option<&[ChangeHash]>,
+    ) -> Result<Self, PatchLogMismatch> {
+        let args = doc.transaction_args(heads);
+        let mut patch_log = patch_log.unwrap_or_else(PatchLog::inactive);
+        patch_log
+            .migrate_actors(&doc.ops().actors)
+            .map_err(|_| PatchLogMismatch)?;
+        Ok(Self {
+            inner: Some(TransactionInner::new(args)),
+            patch_log,
+            doc,
+        })
+    }
+
+    /// Get the hash of the change that contains the given opid.
+    ///
+    /// Returns none if the opid:
+    /// - is the root object id
+    /// - does not exist in this document
+    /// - is for an operation in this transaction
+    pub fn hash_for_opid(&self, opid: &ExId) -> Option<ChangeHash> {
+        self.doc.hash_for_opid(opid)
+    }
+
+    /// Get the heads of the document before this transaction was started.
+    pub fn get_heads(&self) -> Vec<ChangeHash> {
+        self.doc.get_heads()
+    }
+
+    /// Commit the transaction, returning the document, commit hash, and patch log.
+    ///
+    /// Unlike [`super::Transaction::commit`], no `PatchLog` clone is needed — it is moved out.
+    pub fn commit(mut self) -> (Automerge, Option<ChangeHash>, PatchLog) {
+        let tx = self.inner.take().unwrap();
+        let hash = tx.commit(&mut self.doc, None, None);
+        (self.doc, hash, self.patch_log)
+    }
+
+    /// Commit with options.
+    pub fn commit_with(
+        mut self,
+        options: CommitOptions,
+    ) -> (Automerge, Option<ChangeHash>, PatchLog) {
+        let tx = self.inner.take().unwrap();
+        let hash = tx.commit(&mut self.doc, options.message, options.time);
+        (self.doc, hash, self.patch_log)
+    }
+
+    /// Rollback the transaction, returning the document and number of cancelled ops.
+    pub fn rollback(mut self) -> (Automerge, usize) {
+        let cancelled = self.inner.take().unwrap().rollback(&mut self.doc);
+        (self.doc, cancelled)
+    }
+
+    fn do_tx<F, O>(&mut self, f: F) -> O
+    where
+        F: FnOnce(&mut TransactionInner, &mut Automerge, &mut PatchLog) -> O,
+    {
+        let tx = self.inner.as_mut().unwrap();
+        f(tx, &mut self.doc, &mut self.patch_log)
+    }
+
+    fn get_scope(&self, heads: Option<&[ChangeHash]>) -> Option<crate::types::Clock> {
+        if let Some(h) = heads {
+            Some(self.doc.clock_at(h))
+        } else {
+            self.inner.as_ref().and_then(|i| i.get_scope().clone())
+        }
+    }
+}
+
+super::impl_read_doc_for_tx!(OwnedTransaction);
+super::impl_transactable_for_tx!(OwnedTransaction);
+
+#[cfg(test)]
+mod tests {
+    use crate::transaction::{CommitOptions, Transactable};
+    use crate::{Automerge, ObjType, PatchLog, ReadDoc, ROOT};
+
+    #[test]
+    fn put_and_get_roundtrip() {
+        let doc = Automerge::new();
+        let mut tx = doc.into_transaction(None, None).unwrap();
+        tx.put(ROOT, "key", "value").unwrap();
+        let (doc, hash, _) = tx.commit();
+        assert!(hash.is_some());
+        assert_eq!(
+            doc.get(ROOT, "key").unwrap().unwrap().0.to_str().unwrap(),
+            "value"
+        );
+    }
+
+    #[test]
+    fn read_during_transaction() {
+        let doc = Automerge::new();
+        let mut tx = doc.into_transaction(None, None).unwrap();
+        tx.put(ROOT, "a", "1").unwrap();
+        // ReadDoc works on the transaction itself
+        let (val, _) = tx.get(ROOT, "a").unwrap().unwrap();
+        assert_eq!(val.to_str().unwrap(), "1");
+        tx.commit();
+    }
+
+    #[test]
+    fn nested_objects() {
+        let doc = Automerge::new();
+        let mut tx = doc.into_transaction(None, None).unwrap();
+        let list = tx.put_object(ROOT, "items", ObjType::List).unwrap();
+        tx.insert(&list, 0, "first").unwrap();
+        tx.insert(&list, 1, "second").unwrap();
+        let (doc, hash, _) = tx.commit();
+        assert!(hash.is_some());
+        assert_eq!(doc.length(list), 2);
+    }
+
+    #[test]
+    fn commit_with_options() {
+        let doc = Automerge::new();
+        let mut tx = doc.into_transaction(None, None).unwrap();
+        tx.put(ROOT, "x", 42).unwrap();
+        let (doc, hash, _) = tx.commit_with(CommitOptions::default().with_message("test commit"));
+        assert!(hash.is_some());
+        let change = doc.get_change_by_hash(&hash.unwrap()).unwrap();
+        assert_eq!(change.message().map(|s| s.as_str()), Some("test commit"));
+    }
+
+    #[test]
+    fn rollback_discards_ops() {
+        let mut doc = Automerge::new();
+        {
+            let mut tx = doc.transaction();
+            tx.put(ROOT, "keep", "yes").unwrap();
+            tx.commit();
+        }
+        let doc = doc.into_transaction(None, None).unwrap();
+        // Haven't written anything, just rollback
+        let (doc, cancelled) = doc.rollback();
+        assert_eq!(cancelled, 0);
+        assert_eq!(
+            doc.get(ROOT, "keep").unwrap().unwrap().0.to_str().unwrap(),
+            "yes"
+        );
+    }
+
+    #[test]
+    fn rollback_undoes_writes() {
+        let doc = Automerge::new();
+        let mut tx = doc.into_transaction(None, None).unwrap();
+        tx.put(ROOT, "gone", "soon").unwrap();
+        let (doc, cancelled) = tx.rollback();
+        assert_eq!(cancelled, 1);
+        assert!(doc.get(ROOT, "gone").unwrap().is_none());
+    }
+
+    #[test]
+    fn owned_transaction_at() {
+        let mut doc = Automerge::new();
+
+        // Make a first change
+        let mut tx = doc.transaction();
+        tx.put(ROOT, "v", 1).unwrap();
+        tx.commit();
+        let heads_v1 = doc.get_heads();
+
+        // Make a second change
+        let mut tx = doc.transaction();
+        tx.put(ROOT, "v", 2).unwrap();
+        tx.commit();
+
+        // Start an owned transaction isolated at v1 heads
+        let mut tx = doc.into_transaction(None, Some(&heads_v1)).unwrap();
+        // Should see v=1, not v=2
+        let (val, _) = tx.get(ROOT, "v").unwrap().unwrap();
+        assert_eq!(val.to_i64().unwrap(), 1);
+
+        tx.put(ROOT, "from_v1", true).unwrap();
+        let (doc, hash, _) = tx.commit();
+        assert!(hash.is_some());
+        assert!(doc.get(ROOT, "from_v1").unwrap().is_some());
+    }
+
+    #[test]
+    fn log_patches() {
+        let doc = Automerge::new();
+        let mut tx = doc
+            .into_transaction(Some(PatchLog::active()), None)
+            .unwrap();
+        tx.put(ROOT, "patched", "yes").unwrap();
+        let (doc, _, mut patch_log) = tx.commit();
+        let patches = doc.make_patches(&mut patch_log);
+        // We should have at least one patch from the put
+        assert!(!patches.is_empty());
+    }
+
+    #[test]
+    fn get_heads_returns_pre_tx_heads() {
+        let mut doc = Automerge::new();
+        let mut tx = doc.transaction();
+        tx.put(ROOT, "a", 1).unwrap();
+        tx.commit();
+        let heads = doc.get_heads();
+
+        let tx = doc.into_transaction(None, None).unwrap();
+        assert_eq!(tx.get_heads(), heads);
+        tx.commit();
+    }
+
+    #[test]
+    fn pending_ops() {
+        let doc = Automerge::new();
+        let mut tx = doc.into_transaction(None, None).unwrap();
+        assert_eq!(tx.pending_ops(), 0);
+        tx.put(ROOT, "a", 1).unwrap();
+        assert_eq!(tx.pending_ops(), 1);
+        tx.put(ROOT, "b", 2).unwrap();
+        assert_eq!(tx.pending_ops(), 2);
+        tx.commit();
+    }
+
+    #[test]
+    fn empty_commit_returns_none_hash() {
+        let doc = Automerge::new();
+        let tx = doc.into_transaction(None, None).unwrap();
+        let (_, hash, _) = tx.commit();
+        assert!(hash.is_none());
+    }
+}

data/vendor/automerge-rust/automerge/src/transaction/result.rs

@@ -0,0 +1,21 @@
+use crate::patches::PatchLog;
+use crate::ChangeHash;
+
+/// The result of a successful, and committed, transaction.
+#[derive(Debug)]
+pub struct Success<O> {
+    /// The result of the transaction.
+    pub result: O,
+    /// The hash of the change, will be `None` if the transaction did not create any operations
+    pub hash: Option<ChangeHash>,
+    pub patch_log: PatchLog,
+}
+
+/// The result of a failed, and rolled back, transaction.
+#[derive(Debug)]
+pub struct Failure<E> {
+    /// The error returned from the transaction.
+    pub error: E,
+    /// The number of operations cancelled.
+    pub cancelled: usize,
+}

data/vendor/automerge-rust/automerge/src/transaction/transactable.rs

@@ -0,0 +1,203 @@
+use std::borrow::Cow;
+
+use crate::exid::ExId;
+use crate::iter::Span;
+use crate::marks::{ExpandMark, Mark, UpdateSpansConfig};
+use crate::{AutomergeError, ChangeHash, ObjType, Prop, ReadDoc, ScalarValue};
+
+/// A way of mutating a document within a single change.
+pub trait Transactable: ReadDoc {
+    /// Get the number of pending operations in this transaction.
+    fn pending_ops(&self) -> usize;
+
+    /// Set the value of property `P` to value `V` in object `obj`.
+    ///
+    /// # Errors
+    ///
+    /// This will return an error if
+    /// - The object does not exist
+    /// - The key is the wrong type for the object
+    /// - The key does not exist in the object
+    fn put<O: AsRef<ExId>, P: Into<Prop>, V: Into<ScalarValue>>(
+        &mut self,
+        obj: O,
+        prop: P,
+        value: V,
+    ) -> Result<(), AutomergeError>;
+
+    /// Set the value of property `P` to the new object `V` in object `obj`.
+    ///
+    /// # Returns
+    ///
+    /// The id of the object which was created.
+    ///
+    /// # Errors
+    ///
+    /// This will return an error if
+    /// - The object does not exist
+    /// - The key is the wrong type for the object
+    /// - The key does not exist in the object
+    fn put_object<O: AsRef<ExId>, P: Into<Prop>>(
+        &mut self,
+        obj: O,
+        prop: P,
+        object: ObjType,
+    ) -> Result<ExId, AutomergeError>;
+
+    /// Insert a value into a list at the given index.
+    fn insert<O: AsRef<ExId>, V: Into<ScalarValue>>(
+        &mut self,
+        obj: O,
+        index: usize,
+        value: V,
+    ) -> Result<(), AutomergeError>;
+
+    /// Insert an object into a list at the given index.
+    fn insert_object<O: AsRef<ExId>>(
+        &mut self,
+        obj: O,
+        index: usize,
+        object: ObjType,
+    ) -> Result<ExId, AutomergeError>;
+
+    /// Increment the counter at the prop in the object by `value`.
+    fn increment<O: AsRef<ExId>, P: Into<Prop>>(
+        &mut self,
+        obj: O,
+        prop: P,
+        value: i64,
+    ) -> Result<(), AutomergeError>;
+
+    /// Delete the value at prop in the object.
+    fn delete<O: AsRef<ExId>, P: Into<Prop>>(
+        &mut self,
+        obj: O,
+        prop: P,
+    ) -> Result<(), AutomergeError>;
+
+    /// replace a section of a list. If `del` is positive then N values
+    /// are deleted after position `pos` and the new values inserted. If
+    /// it is negative then N values are deleted before position `pos` instead.
+    ///
+    /// Values can be scalars or nested objects (maps, lists, text). Scalar
+    /// values are inserted directly, while nested objects are created using
+    /// batch insertion for efficiency.
+    fn splice<O: AsRef<ExId>, V: Into<crate::hydrate::Value>, I: IntoIterator<Item = V>>(
+        &mut self,
+        obj: O,
+        pos: usize,
+        del: isize,
+        vals: I,
+    ) -> Result<(), AutomergeError>;
+
+    /// Like [`Self::splice`] but for text.
+    fn splice_text<O: AsRef<ExId>>(
+        &mut self,
+        obj: O,
+        pos: usize,
+        del: isize,
+        text: &str,
+    ) -> Result<(), AutomergeError>;
+
+    /// Mark a sequence
+    fn mark<O: AsRef<ExId>>(
+        &mut self,
+        obj: O,
+        mark: Mark,
+        expand: ExpandMark,
+    ) -> Result<(), AutomergeError>;
+
+    /// Remove a Mark from a sequence
+    fn unmark<O: AsRef<ExId>>(
+        &mut self,
+        obj: O,
+        key: &str,
+        start: usize,
+        end: usize,
+        expand: ExpandMark,
+    ) -> Result<(), AutomergeError>;
+
+    /// Insert a block marker into the text object `obj` at the given index.
+    ///
+    /// # Returns
+    ///
+    /// The ID of the new block marker. The block marker is a plain old map so you can use all the
+    /// normal methods of modifying a map to interact with it.
+    fn split_block<O>(&mut self, obj: O, index: usize) -> Result<ExId, AutomergeError>
+    where
+        O: AsRef<ExId>;
+
+    /// Delete a block marker at `index` from the text object `obj`.
+    fn join_block<O: AsRef<ExId>>(&mut self, text: O, index: usize) -> Result<(), AutomergeError>;
+
+    /// Replace a block marker at `index` in `obj` with a new marker and return the ID of the new
+    /// marker
+    fn replace_block<O>(&mut self, text: O, index: usize) -> Result<ExId, AutomergeError>
+    where
+        O: AsRef<ExId>;
+
+    /// Update the blocks and text in a text object
+    ///
+    /// This performs a diff against the current state of both the text and the block markers in a
+    /// text object and attempts to perform a reasonably minimal set of operations to update the
+    /// document to match the new text.
+    ///
+    /// The `config` argument is an [`UpdateSpansConfig`] object which is used to configure how the
+    /// [`ExpandMark`] flag will be set for spans which are created as part of the reconciliation
+    fn update_spans<O: AsRef<ExId>, I: IntoIterator<Item = Span>>(
+        &mut self,
+        text: O,
+        config: UpdateSpansConfig,
+        new_text: I,
+    ) -> Result<(), AutomergeError>;
+
+    /// The heads this transaction will be based on
+    fn base_heads(&self) -> Vec<ChangeHash>;
+
+    /// Update the value of a string
+    ///
+    /// This will calculate a diff between the current value and the new value and
+    /// then convert that diff into calls to {@link splice}. This will produce results
+    /// which don't merge as well as directly capturing the user input actions, but
+    /// sometimes it's not possible to capture user input and this is the best you
+    /// can do.
+    fn update_text<S: AsRef<str>>(&mut self, obj: &ExId, new_text: S)
+        -> Result<(), AutomergeError>;
+
+    fn update_object<O: AsRef<ExId>>(
+        &mut self,
+        obj: O,
+        new_value: &crate::hydrate::Value,
+    ) -> Result<(), crate::error::UpdateObjectError>;
+
+    /// Put or insert a nested `hydrate::Value` as a new object tree using
+    /// batch operations.
+    ///
+    /// This is much faster than decomposing the value into individual put/insert
+    /// operations because it only requires two OpSet splices instead of one per
+    /// node.
+    ///
+    /// When `insert` is true and `prop` is a sequence index, the value is
+    /// inserted at that index. When false, it overwrites the existing element.
+    /// For map keys, `insert` is ignored.
+    fn batch_create_object<O: AsRef<ExId>, P: Into<Prop>>(
+        &mut self,
+        obj: O,
+        prop: P,
+        value: &crate::hydrate::Value,
+        insert: bool,
+    ) -> Result<ExId, AutomergeError>;
+
+    /// Overwrite the keys of the root object with the values from `value`
+    ///
+    /// This is useful to initialize an empty document with a large initial
+    /// value. Note that existing keys which are not in `value` are left as is
+    fn init_root_from_hydrate(&mut self, value: &crate::hydrate::Map)
+        -> Result<(), AutomergeError>;
+}
+
+#[derive(Debug, PartialEq, Clone)]
+pub enum BlockOrText<'a> {
+    Block(crate::hydrate::Map),
+    Text(Cow<'a, str>),
+}