chore: compose operation

Author: appflowy

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;

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;

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"] }

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,18 +166,23 @@ 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)?;
         }
         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),
         }

shared-lib/lib-ot/src/core/document/operation.rs

@@ -1,21 +1,21 @@
 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")]
 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> {