Skip to content

Bring projects, wikis, and teams together with AI. AppFlowy is the AI collaborative workspace where you achieve more without losing control of your data. The leading open source Notion alternative.

chore: compose operation

appflowy01589c6f941b
diff --git a/frontend/rust-lib/flowy-text-block/src/event_handler.rs b/frontend/rust-lib/flowy-text-block/src/event_handler.rs
index d7844ad12d..98ca7e19fe 100644
--- a/frontend/rust-lib/flowy-text-block/src/event_handler.rs
+++ b/frontend/rust-lib/flowy-text-block/src/event_handler.rs
@@ -1,7 +1,7 @@
use crate::entities::{EditParams, EditPayloadPB, ExportDataPB, ExportParams, ExportPayloadPB, TextBlockPB};
use crate::TextEditorManager;
use flowy_error::FlowyError;
-use flowy_sync::entities::text_block::{TextBlockDeltaPB, TextBlockIdPB};
+use flowy_sync::entities::text_block::TextBlockIdPB;
use lib_dispatch::prelude::{data_result, AppData, Data, DataResult};
use std::convert::TryInto;
use std::sync::Arc;
diff --git a/frontend/rust-lib/flowy-text-block/src/manager.rs b/frontend/rust-lib/flowy-text-block/src/manager.rs
index 424f7a8d50..2e10873523 100644
--- a/frontend/rust-lib/flowy-text-block/src/manager.rs
+++ b/frontend/rust-lib/flowy-text-block/src/manager.rs
@@ -1,4 +1,4 @@
-use crate::entities::{EditParams, EditPayloadPB};
+use crate::entities::EditParams;
use crate::queue::TextBlockRevisionCompactor;
use crate::{editor::TextBlockEditor, errors::FlowyError, TextEditorCloudService};
use bytes::Bytes;
diff --git a/shared-lib/lib-ot/Cargo.toml b/shared-lib/lib-ot/Cargo.toml
index 3d0bd5aadd..81b75507a0 100644
--- a/shared-lib/lib-ot/Cargo.toml
+++ b/shared-lib/lib-ot/Cargo.toml
@@ -7,7 +7,7 @@ edition = "2018"
[dependencies]
bytecount = "0.6.0"
-serde = { version = "1.0", features = ["derive"] }
+serde = { version = "1.0", features = ["derive", "rc"] }
#protobuf = {version = "2.18.0"}
#flowy-derive = { path = "../flowy-derive" }
tokio = { version = "1", features = ["sync"] }
diff --git a/shared-lib/lib-ot/src/core/document/node_tree.rs b/shared-lib/lib-ot/src/core/document/node_tree.rs
index 53f538cf77..700e55ef9c 100644
--- a/shared-lib/lib-ot/src/core/document/node_tree.rs
+++ b/shared-lib/lib-ot/src/core/document/node_tree.rs
@@ -3,6 +3,7 @@ use crate::core::document::path::Path;
use crate::core::{Node, NodeBodyChangeset, NodeData, NodeOperation, OperationTransform, Transaction};
use crate::errors::{ErrorBuilder, OTError, OTErrorCode};
use indextree::{Arena, Children, FollowingSiblings, NodeId};
+use std::rc::Rc;
use super::NodeOperationList;
@@ -26,14 +27,13 @@ impl NodeTree {
}
pub fn from_bytes(root_name: &str, bytes: Vec<u8>) -> Result<Self, OTError> {
- let operations = NodeOperationList::from_bytes(bytes)?.into_inner();
+ let operations = NodeOperationList::from_bytes(bytes)?;
Self::from_operations(root_name, operations)
}
- pub fn from_operations(root_name: &str, operations: Vec<NodeOperation>) -> Result<Self, OTError> {
+ pub fn from_operations(root_name: &str, operations: NodeOperationList) -> Result<Self, OTError> {
let mut node_tree = NodeTree::new(root_name);
-
- for operation in operations {
+ for operation in operations.into_inner().into_iter() {
let _ = node_tree.apply_op(operation)?;
}
Ok(node_tree)
@@ -54,13 +54,14 @@ impl NodeTree {
/// # Examples
///
/// ```
+ /// use std::rc::Rc;
/// use lib_ot::core::{NodeOperation, NodeTree, NodeData, Path};
/// let nodes = vec![NodeData::new("text".to_string())];
/// let root_path: Path = vec![0].into();
/// let op = NodeOperation::Insert {path: root_path.clone(),nodes };
///
/// let mut node_tree = NodeTree::new("root");
- /// node_tree.apply_op(op).unwrap();
+ /// node_tree.apply_op(Rc::new(op)).unwrap();
/// let node_id = node_tree.node_id_at_path(&root_path).unwrap();
/// let node_path = node_tree.path_from_node_id(node_id);
/// debug_assert_eq!(node_path, root_path);
@@ -105,23 +106,25 @@ impl NodeTree {
counter
}
- ///
+ /// Returns the note_id at the position of the tree with id note_id
/// # Arguments
///
- /// * `node_id`:
- /// * `index`:
+ /// * `node_id`: the node id of the child's parent
+ /// * `index`: index of the node in parent children list
///
/// returns: Option<NodeId>
///
/// # Examples
///
/// ```
+ /// use std::rc::Rc;
/// use lib_ot::core::{NodeOperation, NodeTree, NodeData, Path};
/// let node_1 = NodeData::new("text".to_string());
/// let inserted_path: Path = vec![0].into();
///
/// let mut node_tree = NodeTree::new("root");
- /// node_tree.apply_op(NodeOperation::Insert {path: inserted_path.clone(),nodes: vec![node_1.clone()] }).unwrap();
+ /// let op = NodeOperation::Insert {path: inserted_path.clone(),nodes: vec![node_1.clone()] };
+ /// node_tree.apply_op(Rc::new(op)).unwrap();
///
/// let node_2 = node_tree.get_node_at_path(&inserted_path).unwrap();
/// assert_eq!(node_2.node_type, node_1.node_type);
@@ -137,6 +140,10 @@ impl NodeTree {
None
}
+ /// Returns all children whose parent node id is node_id
+ ///
+ /// * `node_id`: the children's parent node id
+ ///
pub fn children_from_node(&self, node_id: NodeId) -> Children<'_, Node> {
node_id.children(&self.arena)
}
@@ -159,7 +166,7 @@ impl NodeTree {
node_id.following_siblings(&self.arena)
}
- pub fn apply(&mut self, transaction: Transaction) -> Result<(), OTError> {
+ pub fn apply_transaction(&mut self, transaction: Transaction) -> Result<(), OTError> {
let operations = transaction.into_operations();
for operation in operations {
self.apply_op(operation)?;
@@ -167,10 +174,15 @@ impl NodeTree {
Ok(())
}
- pub fn apply_op(&mut self, op: NodeOperation) -> Result<(), OTError> {
+ pub fn apply_op(&mut self, op: Rc<NodeOperation>) -> Result<(), OTError> {
+ let op = match Rc::try_unwrap(op) {
+ Ok(op) => op,
+ Err(op) => op.as_ref().clone(),
+ };
+
match op {
NodeOperation::Insert { path, nodes } => self.insert_nodes(&path, nodes),
- NodeOperation::UpdateAttributes { path, attributes, .. } => self.update_attributes(&path, attributes),
+ NodeOperation::UpdateAttributes { path, new, .. } => self.update_attributes(&path, new),
NodeOperation::UpdateBody { path, changeset } => self.update_body(&path, changeset),
NodeOperation::Delete { path, nodes } => self.delete_node(&path, nodes),
}
diff --git a/shared-lib/lib-ot/src/core/document/operation.rs b/shared-lib/lib-ot/src/core/document/operation.rs
index eb51eeac3d..c43fffd532 100644
--- a/shared-lib/lib-ot/src/core/document/operation.rs
+++ b/shared-lib/lib-ot/src/core/document/operation.rs
@@ -1,8 +1,9 @@
use crate::core::attributes::Attributes;
use crate::core::document::path::Path;
-use crate::core::{NodeBodyChangeset, NodeData, OperationTransform};
+use crate::core::{NodeBodyChangeset, NodeData};
use crate::errors::OTError;
use serde::{Deserialize, Serialize};
+use std::rc::Rc;
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "op")]
@@ -10,12 +11,11 @@ pub enum NodeOperation {
#[serde(rename = "insert")]
Insert { path: Path, nodes: Vec<NodeData> },
- #[serde(rename = "update")]
+ #[serde(rename = "update-attribute")]
UpdateAttributes {
path: Path,
- attributes: Attributes,
- #[serde(rename = "oldAttributes")]
- old_attributes: Attributes,
+ new: Attributes,
+ old: Attributes,
},
#[serde(rename = "update-body")]
@@ -27,35 +27,6 @@ pub enum NodeOperation {
Delete { path: Path, nodes: Vec<NodeData> },
}
-// impl OperationTransform for NodeOperation {
-// fn compose(&self, other: &Self) -> Result<Self, OTError>
-// where
-// Self: Sized,
-// {
-// match self {
-// NodeOperation::Insert { path, nodes } => {
-// let new_path = Path::transform(path, other.path(), nodes.len() as i64);
-// Ok((self.clone(), other.clone_with_new_path(new_path)))
-// }
-// NodeOperation::Delete { path, nodes } => {
-// let new_path = Path::transform(path, other.path(), nodes.len() as i64);
-// other.clone_with_new_path(new_path)
-// }
-// _ => other.clone(),
-// }
-// }
-//
-// fn transform(&self, other: &Self) -> Result<(Self, Self), OTError>
-// where
-// Self: Sized,
-// {
-// todo!()
-// }
-//
-// fn invert(&self, other: &Self) -> Self {
-// todo!()
-// }
-// }
impl NodeOperation {
pub fn get_path(&self) -> &Path {
match self {
@@ -83,12 +54,12 @@ impl NodeOperation {
},
NodeOperation::UpdateAttributes {
path,
- attributes,
- old_attributes,
+ new: attributes,
+ old: old_attributes,
} => NodeOperation::UpdateAttributes {
path: path.clone(),
- attributes: old_attributes.clone(),
- old_attributes: attributes.clone(),
+ new: old_attributes.clone(),
+ old: attributes.clone(),
},
NodeOperation::Delete { path, nodes } => NodeOperation::Insert {
path: path.clone(),
@@ -101,10 +72,10 @@ impl NodeOperation {
}
}
- /// Make the `other` operation to be applied to the version that has been modified.
+ /// Make the `other` operation can be applied to the version after applying the `self` operation.
/// The semantics of transform is used when editing conflicts occur, which is often determined by the version id。
- /// For example, if the inserted position has been acquired by others, then you need to do transform to make sure
- /// your position is value.
+ /// For example, if the inserted position has been acquired by others, then it's needed to do the transform to
+ /// make sure the inserted position is right.
///
/// # Arguments
///
@@ -143,24 +114,30 @@ impl NodeOperation {
let new_path = path.transform(other.get_path(), nodes.len());
*other.get_mut_path() = new_path;
}
- _ => {}
+ _ => {
+ // Only insert/delete will change the path.
+ }
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct NodeOperationList {
- operations: Vec<NodeOperation>,
+ operations: Vec<Rc<NodeOperation>>,
}
impl NodeOperationList {
- pub fn into_inner(self) -> Vec<NodeOperation> {
+ pub fn into_inner(self) -> Vec<Rc<NodeOperation>> {
self.operations
}
+
+ pub fn add_op(&mut self, operation: NodeOperation) {
+ self.operations.push(Rc::new(operation));
+ }
}
impl std::ops::Deref for NodeOperationList {
- type Target = Vec<NodeOperation>;
+ type Target = Vec<Rc<NodeOperation>>;
fn deref(&self) -> &Self::Target {
&self.operations
@@ -175,13 +152,15 @@ impl std::ops::DerefMut for NodeOperationList {
impl std::convert::From<Vec<NodeOperation>> for NodeOperationList {
fn from(operations: Vec<NodeOperation>) -> Self {
- Self { operations }
+ Self::new(operations)
}
}
impl NodeOperationList {
pub fn new(operations: Vec<NodeOperation>) -> Self {
- Self { operations }
+ Self {
+ operations: operations.into_iter().map(Rc::new).collect(),
+ }
}
pub fn from_bytes(bytes: Vec<u8>) -> Result<Self, OTError> {
diff --git a/shared-lib/lib-ot/src/core/document/path.rs b/shared-lib/lib-ot/src/core/document/path.rs
index 16fecfcefe..cf7ae647ed 100644
--- a/shared-lib/lib-ot/src/core/document/path.rs
+++ b/shared-lib/lib-ot/src/core/document/path.rs
@@ -1,6 +1,28 @@
use serde::{Deserialize, Serialize};
/// The `Path` represents as a path to reference to the node in the `NodeTree`.
+/// ┌─────────┐
+/// │ Root │
+/// └─────────┼──────────┐
+/// │0: Node A │
+/// └──────────┼────────────┐
+/// │0: Node A-1 │
+/// ├────────────┤
+/// │1: Node A-2 │
+/// ┌──────────┼────────────┘
+/// │1: Node B │
+/// └──────────┼────────────┐
+/// │0: Node B-1 │
+/// ├────────────┤
+/// │1: Node B-2 │
+/// ┌──────────┼────────────┘
+/// │2: Node C │
+/// └──────────┘
+///
+/// The path of Node A will be [0]
+/// The path of Node A-1 will be [0,0]
+/// The path of Node A-2 will be [0,1]
+/// The path of Node B-2 will be [1,1]
#[derive(Clone, Serialize, Deserialize, Eq, PartialEq, Debug)]
pub struct Path(pub Vec<usize>);
@@ -49,21 +71,90 @@ impl From<&[usize]> for Path {
}
impl Path {
+ /// Calling this function if there are two changes want to modify the same path.
///
- ///
- /// The path will be changed is
/// # Arguments
///
- /// * `other`:
- /// * `offset`: represents the len of nodes referenced by this path
+ /// * `other`: the path that need to be transformed
+ /// * `offset`: represents the len of nodes referenced by the current path
+ ///
+ /// If two changes modify the same path or the path was shared by them. Then it needs to do the
+ /// transformation to make sure the changes are applied to the right path.
///
- /// returns: Path
+ /// returns: the path represents the position that the other path reference to.
///
/// # Examples
///
/// ```
+ /// use lib_ot::core::Path;
+ /// let path = Path(vec![0, 1]);
+ /// for (old_path, len_of_nodes, expected_path) in vec![
+ /// // Try to modify the path [0, 1], but someone has inserted one element before the
+ /// // current path [0,1] in advance. That causes the modified path [0,1] to no longer
+ /// // valid. It needs to do the transformation to get the right path.
+ /// //
+ /// // [0,2] is the path you want to modify.
+ /// (Path(vec![0, 1]), 1, Path(vec![0, 2])),
+ /// (Path(vec![0, 1]), 5, Path(vec![0, 6])),
+ /// (Path(vec![0, 2]), 1, Path(vec![0, 3])),
+ /// // Try to modify the path [0, 2,3,4], but someone has inserted one element before the
+ /// // current path [0,1] in advance. That cause the prefix path [0,2] of [0,2,3,4]
+ /// // no longer valid.
+ /// // It needs to do the transformation to get the right path. So [0,2] is transformed to [0,3]
+ /// // and the suffix [3,4] of the [0,2,3,4] remains the same. So the transformed result is
+ /// //
+ /// // [0,3,3,4]
+ /// (Path(vec![0, 2, 3, 4]), 1, Path(vec![0, 3, 3, 4])),
+ /// ] {
+ /// assert_eq!(path.transform(&old_path, len_of_nodes), expected_path);
+ /// }
+ /// // The path remains the same in the following test. Because the shared path is not changed.
+ /// let path = Path(vec![0, 1, 2]);
+ /// for (old_path, len_of_nodes, expected_path) in vec![
+ /// // Try to modify the path [0,0,0,1,2], but someone has inserted one element
+ /// // before [0,1,2]. [0,0,0,1,2] and [0,1,2] share the same path [0,x], because
+ /// // the element was inserted at [0,1,2] that didn't affect the shared path [0, x].
+ /// // So, after the transformation, the path is not changed.
+ /// (Path(vec![0, 0, 0, 1, 2]), 1, Path(vec![0, 0, 0, 1, 2])),
+ /// (Path(vec![0, 1]), 1, Path(vec![0, 1])),
+ /// ] {
+ /// assert_eq!(path.transform(&old_path, len_of_nodes), expected_path);
+ /// }
///
+ /// let path = Path(vec![1, 1]);
+ /// for (old_path, len_of_nodes, expected_path) in vec![(Path(vec![1, 0]), 1, Path(vec![1, 0]))] {
+ /// assert_eq!(path.transform(&old_path, len_of_nodes), expected_path);
+ /// }
/// ```
+ /// For example, client A and client B want to insert a node at the same index, the server applies
+ /// the changes made by client B. But, before applying the client A's changes, server transforms
+ /// the changes first in order to make sure that client A modify the right position. After that,
+ /// the changes can be applied to the server.
+ ///
+ /// ┌──────────┐ ┌──────────┐ ┌──────────┐
+ /// │ Client A │ │ Server │ │ Client B │
+ /// └─────┬────┘ └─────┬────┘ └────┬─────┘
+ /// │ │ ┌ ─ ─ ─ ─ ─ ─ ─ ┐ │
+ /// │ │ Root │
+ /// │ │ │ 0:A │ │
+ /// │ │ ─ ─ ─ ─ ─ ─ ─ ─ │
+ /// │ │ ◀───────────────────────│
+ /// │ │ Insert B at index 1 │
+ /// │ │ │
+ /// │ │ ┌ ─ ─ ─ ─ ─ ─ ─ ┐ │
+ /// │ │ Root │
+ /// │ │ │ 0:A │ │
+ /// ├──────────────────────▶│ 1:B │
+ /// │ Insert C at index 1 │ └ ─ ─ ─ ─ ─ ─ ─ ┘ │
+ /// │ │ │
+ /// │ │ transform index 1 to 2 │
+ /// │ │ │
+ /// │ │ ┌ ─ ─ ─ ─ ─ ─ ─ ─ │
+ /// │ │ Root │ │
+ /// │ │ │ 0:A │
+ /// ▼ ▼ 1:B │ ▼
+ /// │ 2:C
+ /// ─ ─ ─ ─ ─ ─ ─ ─ ┘
pub fn transform(&self, other: &Path, offset: usize) -> Path {
if self.len() > other.len() {
return other.clone();
@@ -81,7 +172,7 @@ impl Path {
let second_last_index = self.0.len() - 1;
let mut prefix: Vec<usize> = self.0[0..second_last_index].into();
let mut suffix: Vec<usize> = other.0[self.0.len()..].into();
- let last_value = self.0.last().unwrap().clone();
+ let last_value = *self.0.last().unwrap();
let other_second_last_value = other.0[second_last_index];
@@ -96,81 +187,4 @@ impl Path {
prefix.append(&mut suffix);
Path(prefix)
}
-
- // delta is default to be 1
- pub fn transform3(pre_insert_path: &Path, b: &Path, offset: i64) -> Path {
- if pre_insert_path.len() > b.len() {
- return b.clone();
- }
- if pre_insert_path.is_empty() || b.is_empty() {
- return b.clone();
- }
- // check the prefix
- for i in 0..(pre_insert_path.len() - 1) {
- if pre_insert_path.0[i] != b.0[i] {
- return b.clone();
- }
- }
- let mut prefix: Vec<usize> = pre_insert_path.0[0..(pre_insert_path.len() - 1)].into();
- let mut suffix: Vec<usize> = b.0[pre_insert_path.0.len()..].into();
- let prev_insert_last: usize = *pre_insert_path.0.last().unwrap();
- let b_at_index = b.0[pre_insert_path.0.len() - 1];
- if prev_insert_last <= b_at_index {
- prefix.push(((b_at_index as i64) + offset) as usize);
- } else {
- prefix.push(b_at_index);
- }
- prefix.append(&mut suffix);
-
- Path(prefix)
- }
-}
-
-#[cfg(test)]
-mod tests {
- use crate::core::Path;
- #[test]
- fn path_transform_test_1() {
- assert_eq!(
- { Path::transform3(&Path(vec![0, 1]), &Path(vec![0, 1]), 1) }.0,
- vec![0, 2]
- );
-
- assert_eq!(
- { Path::transform3(&Path(vec![0, 1]), &Path(vec![0, 1]), 5) }.0,
- vec![0, 6]
- );
- }
-
- #[test]
- fn path_transform_test_2() {
- assert_eq!(
- { Path::transform3(&Path(vec![0, 1]), &Path(vec![0, 2]), 1) }.0,
- vec![0, 3]
- );
- }
-
- #[test]
- fn path_transform_test_3() {
- assert_eq!(
- { Path::transform3(&Path(vec![0, 1]), &Path(vec![0, 2, 7, 8, 9]), 1) }.0,
- vec![0, 3, 7, 8, 9]
- );
- }
-
- #[test]
- fn path_transform_no_changed_test() {
- assert_eq!(
- { Path::transform3(&Path(vec![0, 1, 2]), &Path(vec![0, 0, 7, 8, 9]), 1) }.0,
- vec![0, 0, 7, 8, 9]
- );
- assert_eq!(
- { Path::transform3(&Path(vec![0, 1, 2]), &Path(vec![0, 1]), 1) }.0,
- vec![0, 1]
- );
- assert_eq!(
- { Path::transform3(&Path(vec![1, 1]), &Path(vec![1, 0]), 1) }.0,
- vec![1, 0]
- );
- }
}
diff --git a/shared-lib/lib-ot/src/core/document/transaction.rs b/shared-lib/lib-ot/src/core/document/transaction.rs
index 28959bf7f2..dbe09bba4a 100644
--- a/shared-lib/lib-ot/src/core/document/transaction.rs
+++ b/shared-lib/lib-ot/src/core/document/transaction.rs
@@ -1,20 +1,20 @@
use crate::core::attributes::Attributes;
use crate::core::document::path::Path;
use crate::core::{NodeData, NodeOperation, NodeTree};
+use crate::errors::OTError;
use indextree::NodeId;
+use std::rc::Rc;
use super::{NodeBodyChangeset, NodeOperationList};
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
pub struct Transaction {
operations: NodeOperationList,
}
impl Transaction {
pub fn new() -> Self {
- Transaction {
- operations: vec![].into(),
- }
+ Self::default()
}
pub fn from_operations<T: Into<NodeOperationList>>(operations: T) -> Self {
@@ -23,25 +23,36 @@ impl Transaction {
}
}
- pub fn into_operations(self) -> Vec<NodeOperation> {
+ pub fn into_operations(self) -> Vec<Rc<NodeOperation>> {
self.operations.into_inner()
}
- /// Make the `other` to be applied to the version that has been modified.
+ /// Make the `other` can be applied to the version after applying the `self` transaction.
///
/// The semantics of transform is used when editing conflicts occur, which is often determined by the version id。
/// the operations of the transaction will be transformed into the conflict operations.
- pub fn transform(&self, other: &mut Transaction) {
- for other_operation in other.iter_mut() {
+ pub fn transform(&self, other: &Transaction) -> Result<Transaction, OTError> {
+ let mut new_transaction = other.clone();
+ for other_operation in new_transaction.iter_mut() {
+ let other_operation = Rc::make_mut(other_operation);
for operation in self.operations.iter() {
operation.transform(other_operation);
}
}
+ Ok(new_transaction)
+ }
+
+ pub fn compose(&mut self, other: &Transaction) -> Result<(), OTError> {
+ // For the moment, just append `other` operations to the end of `self`.
+ for operation in other.operations.iter() {
+ self.operations.push(operation.clone());
+ }
+ Ok(())
}
}
impl std::ops::Deref for Transaction {
- type Target = NodeOperationList;
+ type Target = Vec<Rc<NodeOperation>>;
fn deref(&self) -> &Self::Target {
&self.operations
@@ -85,7 +96,7 @@ impl<'a> TransactionBuilder<'a> {
/// let transaction = TransactionBuilder::new(&node_tree)
/// .insert_nodes_at_path(0,vec![ NodeData::new("text_1"), NodeData::new("text_2")])
/// .finalize();
- /// node_tree.apply(transaction).unwrap();
+ /// node_tree.apply_transaction(transaction).unwrap();
///
/// node_tree.node_id_at_path(vec![0, 0]);
/// ```
@@ -115,7 +126,7 @@ impl<'a> TransactionBuilder<'a> {
/// let transaction = TransactionBuilder::new(&node_tree)
/// .insert_node_at_path(0, NodeData::new("text"))
/// .finalize();
- /// node_tree.apply(transaction).unwrap();
+ /// node_tree.apply_transaction(transaction).unwrap();
/// ```
///
pub fn insert_node_at_path<T: Into<Path>>(self, path: T, node: NodeData) -> Self {
@@ -133,10 +144,10 @@ impl<'a> TransactionBuilder<'a> {
}
}
- self.operations.push(NodeOperation::UpdateAttributes {
+ self.operations.add_op(NodeOperation::UpdateAttributes {
path: path.clone(),
- attributes,
- old_attributes,
+ new: attributes,
+ old: old_attributes,
});
}
None => tracing::warn!("Update attributes at path: {:?} failed. Node is not exist", path),
@@ -147,7 +158,7 @@ impl<'a> TransactionBuilder<'a> {
pub fn update_body_at_path(mut self, path: &Path, changeset: NodeBodyChangeset) -> Self {
match self.node_tree.node_id_at_path(path) {
Some(_) => {
- self.operations.push(NodeOperation::UpdateBody {
+ self.operations.add_op(NodeOperation::UpdateBody {
path: path.clone(),
changeset,
});
@@ -169,7 +180,7 @@ impl<'a> TransactionBuilder<'a> {
node = self.node_tree.following_siblings(node).next().unwrap();
}
- self.operations.push(NodeOperation::Delete {
+ self.operations.add_op(NodeOperation::Delete {
path: path.clone(),
nodes: deleted_nodes,
});
@@ -193,7 +204,7 @@ impl<'a> TransactionBuilder<'a> {
}
pub fn push(mut self, op: NodeOperation) -> Self {
- self.operations.push(op);
+ self.operations.add_op(op);
self
}
diff --git a/shared-lib/lib-ot/tests/node/operation_test.rs b/shared-lib/lib-ot/tests/node/operation_test.rs
index bbd67ab1dd..a0be952afb 100644
--- a/shared-lib/lib-ot/tests/node/operation_test.rs
+++ b/shared-lib/lib-ot/tests/node/operation_test.rs
@@ -1,6 +1,6 @@
use crate::node::script::NodeScript::*;
use crate::node::script::NodeTest;
-use lib_ot::core::{AttributeBuilder, Node, NodeTree, Transaction, TransactionBuilder};
+use lib_ot::core::{AttributeBuilder, Node};
use lib_ot::{
core::{NodeBodyChangeset, NodeData, NodeDataBuilder, NodeOperation, Path},
text_delta::TextDeltaBuilder,
@@ -35,15 +35,14 @@ fn operation_insert_node_with_children_serde_test() {
fn operation_update_node_attributes_serde_test() {
let operation = NodeOperation::UpdateAttributes {
path: Path(vec![0, 1]),
- attributes: AttributeBuilder::new().insert("bold", true).build(),
- old_attributes: AttributeBuilder::new().insert("bold", false).build(),
+ new: AttributeBuilder::new().insert("bold", true).build(),
+ old: AttributeBuilder::new().insert("bold", false).build(),
};
let result = serde_json::to_string(&operation).unwrap();
-
assert_eq!(
result,
- r#"{"op":"update","path":[0,1],"attributes":{"bold":true},"oldAttributes":{"bold":null}}"#
+ r#"{"op":"update-attribute","path":[0,1],"new":{"bold":true},"old":{"bold":null}}"#
);
}
@@ -119,17 +118,17 @@ fn operation_insert_transform_one_level_path_test() {
let scripts = vec![
InsertNode {
path: 0.into(),
- node_data: node_data_1.clone(),
+ node_data: node_data_1,
rev_id: 1,
},
InsertNode {
path: 1.into(),
- node_data: node_data_2.clone(),
+ node_data: node_data_2,
rev_id: 2,
},
InsertNode {
path: 1.into(),
- node_data: node_data_3.clone(),
+ node_data: node_data_3,
rev_id: 1,
},
AssertNode {
@@ -157,12 +156,12 @@ fn operation_insert_transform_multiple_level_path_test() {
let scripts = vec![
InsertNode {
path: 0.into(),
- node_data: node_data_1.clone(),
+ node_data: node_data_1,
rev_id: 1,
},
InsertNode {
path: 1.into(),
- node_data: node_data_2.clone(),
+ node_data: node_data_2,
rev_id: 2,
},
InsertNode {
@@ -189,12 +188,12 @@ fn operation_delete_transform_path_test() {
let scripts = vec![
InsertNode {
path: 0.into(),
- node_data: node_data_1.clone(),
+ node_data: node_data_1,
rev_id: 1,
},
InsertNode {
path: 1.into(),
- node_data: node_data_2.clone(),
+ node_data: node_data_2,
rev_id: 2,
},
// The node's in the tree will be:
@@ -206,7 +205,7 @@ fn operation_delete_transform_path_test() {
// but it was moved to index 2.
InsertNode {
path: 1.into(),
- node_data: node_data_3.clone(),
+ node_data: node_data_3,
rev_id: 3,
},
// 0: text_1
diff --git a/shared-lib/lib-ot/tests/node/script.rs b/shared-lib/lib-ot/tests/node/script.rs
index 7c5f8f0515..678138e183 100644
--- a/shared-lib/lib-ot/tests/node/script.rs
+++ b/shared-lib/lib-ot/tests/node/script.rs
@@ -1,4 +1,4 @@
-use lib_ot::core::{Node, NodeOperation, Transaction};
+use lib_ot::core::{Node, Transaction};
use lib_ot::{
core::attributes::Attributes,
core::{NodeBody, NodeBodyChangeset, NodeData, NodeTree, Path, TransactionBuilder},
@@ -144,14 +144,14 @@ impl NodeTest {
fn apply_transaction(&mut self, transaction: Transaction) {
self.rev_id += 1;
self.rev_operations.insert(self.rev_id, transaction.clone());
- self.node_tree.apply(transaction).unwrap();
+ self.node_tree.apply_transaction(transaction).unwrap();
}
fn transform_transaction_if_need(&mut self, transaction: &mut Transaction, rev_id: usize) {
if self.rev_id >= rev_id {
for rev_id in rev_id..=self.rev_id {
let old_transaction = self.rev_operations.get(&rev_id).unwrap();
- old_transaction.transform(transaction);
+ *transaction = old_transaction.transform(transaction).unwrap();
}
}
}
diff --git a/shared-lib/lib-ot/tests/node/tree_test.rs b/shared-lib/lib-ot/tests/node/tree_test.rs
index 56314585b1..c1f1532385 100644
--- a/shared-lib/lib-ot/tests/node/tree_test.rs
+++ b/shared-lib/lib-ot/tests/node/tree_test.rs
@@ -114,7 +114,7 @@ fn node_insert_node_in_ordered_nodes_test() {
},
InsertNode {
path: path_3.clone(),
- node_data: node_3.clone(),
+ node_data: node_3,
rev_id: 3,
},
// 0:text_1
@@ -166,12 +166,12 @@ fn node_insert_nested_nodes_test() {
let scripts = vec![
InsertNode {
path: 0.into(),
- node_data: node_data_1.clone(),
+ node_data: node_data_1,
rev_id: 1,
},
InsertNode {
path: 1.into(),
- node_data: node_data_2.clone(),
+ node_data: node_data_2,
rev_id: 2,
},
// the tree will be:
@@ -214,7 +214,7 @@ fn node_insert_node_before_existing_nested_nodes_test() {
let scripts = vec![
InsertNode {
path: 0.into(),
- node_data: node_data_1.clone(),
+ node_data: node_data_1,
rev_id: 1,
},
// 0:text_1