diff --git a/shared-lib/lib-ot/src/core/document/node.rs b/shared-lib/lib-ot/src/core/document/node.rs index c8f9ebf0c9..0fc712c96c 100644 --- a/shared-lib/lib-ot/src/core/document/node.rs +++ b/shared-lib/lib-ot/src/core/document/node.rs @@ -4,7 +4,7 @@ use crate::errors::OTError; use serde::{Deserialize, Serialize}; #[derive(Default, Clone, Serialize, Deserialize, Eq, PartialEq)] -pub struct Node { +pub struct NodeData { #[serde(rename = "type")] pub node_type: String, @@ -15,32 +15,32 @@ pub struct Node { pub body: NodeBody, #[serde(skip_serializing_if = "Vec::is_empty")] - pub children: Vec, + pub children: Vec, } -impl Node { - pub fn new(node_type: T) -> Node { - Node { +impl NodeData { + pub fn new(node_type: T) -> NodeData { + NodeData { node_type: node_type.to_string(), ..Default::default() } } } -/// Builder for [`Node`] +/// Builder for [`NodeData`] pub struct NodeBuilder { - node: Node, + node: NodeData, } impl NodeBuilder { pub fn new(node_type: T) -> Self { Self { - node: Node::new(node_type.to_string()), + node: NodeData::new(node_type.to_string()), } } /// Appends a new node to the end of the builder's node children. - pub fn add_node(mut self, node: Node) -> Self { + pub fn add_node(mut self, node: NodeData) -> Self { self.node.children.push(node); self } @@ -60,7 +60,7 @@ impl NodeBuilder { } /// Returns the builder's node - pub fn build(self) -> Node { + pub fn build(self) -> NodeData { self.node } } @@ -157,18 +157,18 @@ impl NodeBodyChangeset { } } -/// [`NodeData`] represents as a leaf data in the [`NodeTree`]. +/// [`Node`] represents as a leaf in the [`NodeTree`]. /// #[derive(Clone, Eq, PartialEq, Debug)] -pub struct NodeData { +pub struct Node { pub node_type: String, pub body: NodeBody, pub attributes: NodeAttributes, } -impl NodeData { - pub fn new(node_type: &str) -> NodeData { - NodeData { +impl Node { + pub fn new(node_type: &str) -> Node { + Node { node_type: node_type.into(), attributes: NodeAttributes::new(), body: NodeBody::Empty, @@ -185,8 +185,8 @@ impl NodeData { } } -impl std::convert::From for NodeData { - fn from(node: Node) -> Self { +impl std::convert::From for Node { + fn from(node: NodeData) -> Self { Self { node_type: node.node_type, attributes: node.attributes, @@ -195,8 +195,8 @@ impl std::convert::From for NodeData { } } -impl std::convert::From<&Node> for NodeData { - fn from(node: &Node) -> Self { +impl std::convert::From<&NodeData> for Node { + fn from(node: &NodeData) -> Self { Self { node_type: node.node_type.clone(), attributes: node.attributes.clone(), 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 dd3c3c31ad..15e167ace9 100644 --- a/shared-lib/lib-ot/src/core/document/node_tree.rs +++ b/shared-lib/lib-ot/src/core/document/node_tree.rs @@ -5,7 +5,7 @@ use indextree::{Arena, Children, FollowingSiblings, NodeId}; /// pub struct NodeTree { - arena: Arena, + arena: Arena, root: NodeId, } @@ -18,11 +18,11 @@ impl Default for NodeTree { impl NodeTree { pub fn new() -> NodeTree { let mut arena = Arena::new(); - let root = arena.new_node(NodeData::new("root")); + let root = arena.new_node(Node::new("root")); NodeTree { arena, root } } - pub fn get_node_data(&self, node_id: NodeId) -> Option<&NodeData> { + pub fn get_node(&self, node_id: NodeId) -> Option<&Node> { Some(self.arena.get(node_id)?.get()) } @@ -30,8 +30,8 @@ impl NodeTree { /// # Examples /// /// ``` - /// use lib_ot::core::{NodeOperation, NodeTree, Node, Path}; - /// let nodes = vec![Node::new("text".to_string())]; + /// 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 }; /// @@ -92,15 +92,15 @@ impl NodeTree { /// # Examples /// /// ``` - /// use lib_ot::core::{NodeOperation, NodeTree, Node, Path}; - /// let node = Node::new("text".to_string()); + /// use lib_ot::core::{NodeOperation, NodeTree, NodeData, Path}; + /// let node = NodeData::new("text".to_string()); /// let inserted_path: Path = vec![0].into(); /// /// let mut node_tree = NodeTree::new(); /// node_tree.apply_op(&NodeOperation::Insert {path: inserted_path.clone(),nodes: vec![node.clone()] }).unwrap(); /// /// let inserted_note = node_tree.node_at_path(&inserted_path).unwrap(); - /// let inserted_data = node_tree.get_node_data(inserted_note).unwrap(); + /// let inserted_data = node_tree.get_node(inserted_note).unwrap(); /// assert_eq!(inserted_data.node_type, node.node_type); /// ``` pub fn child_from_node_at_index(&self, node_id: NodeId, index: usize) -> Option { @@ -114,7 +114,7 @@ impl NodeTree { None } - pub fn children_from_node(&self, node_id: NodeId) -> Children<'_, NodeData> { + pub fn children_from_node(&self, node_id: NodeId) -> Children<'_, Node> { node_id.children(&self.arena) } @@ -132,7 +132,7 @@ impl NodeTree { } } - pub fn following_siblings(&self, node_id: NodeId) -> FollowingSiblings<'_, NodeData> { + pub fn following_siblings(&self, node_id: NodeId) -> FollowingSiblings<'_, Node> { node_id.following_siblings(&self.arena) } @@ -155,7 +155,7 @@ impl NodeTree { /// /// returns error if the path is empty /// - fn insert_nodes(&mut self, path: &Path, nodes: &[Node]) -> Result<(), OTError> { + fn insert_nodes(&mut self, path: &Path, nodes: &[NodeData]) -> Result<(), OTError> { debug_assert!(!path.is_empty()); if path.is_empty() { return Err(OTErrorCode::PathIsEmpty.into()); @@ -172,7 +172,7 @@ impl NodeTree { /// Inserts nodes before the node with node_id /// - fn insert_nodes_before(&mut self, node_id: &NodeId, nodes: &[Node]) { + fn insert_nodes_before(&mut self, node_id: &NodeId, nodes: &[NodeData]) { for node in nodes { let new_node_id = self.arena.new_node(node.into()); if node_id.is_removed(&self.arena) { @@ -185,7 +185,12 @@ impl NodeTree { } } - fn insert_nodes_at_index(&mut self, parent: NodeId, index: usize, insert_children: &[Node]) -> Result<(), OTError> { + fn insert_nodes_at_index( + &mut self, + parent: NodeId, + index: usize, + insert_children: &[NodeData], + ) -> Result<(), OTError> { if index == 0 && parent.children(&self.arena).next().is_none() { self.append_nodes(&parent, insert_children); return Ok(()); @@ -204,7 +209,7 @@ impl NodeTree { Ok(()) } - fn append_nodes(&mut self, parent: &NodeId, nodes: &[Node]) { + fn append_nodes(&mut self, parent: &NodeId, nodes: &[NodeData]) { for node in nodes { let new_node_id = self.arena.new_node(node.into()); parent.append(new_node_id, &mut self.arena); @@ -214,14 +219,14 @@ impl NodeTree { } fn update_attributes(&mut self, path: &Path, attributes: &NodeAttributes) -> Result<(), OTError> { - self.mut_node_at_path(path, |node_data| { - let new_attributes = NodeAttributes::compose(&node_data.attributes, attributes)?; - node_data.attributes = new_attributes; + self.mut_node_at_path(path, |node| { + let new_attributes = NodeAttributes::compose(&node.attributes, attributes)?; + node.attributes = new_attributes; Ok(()) }) } - fn delete_node(&mut self, path: &Path, nodes: &[Node]) -> Result<(), OTError> { + fn delete_node(&mut self, path: &Path, nodes: &[NodeData]) -> Result<(), OTError> { let mut update_node = self .node_at_path(path) .ok_or_else(|| ErrorBuilder::new(OTErrorCode::PathNotFound).build())?; @@ -239,15 +244,15 @@ impl NodeTree { } fn update_body(&mut self, path: &Path, changeset: &NodeBodyChangeset) -> Result<(), OTError> { - self.mut_node_at_path(path, |node_data| { - node_data.apply_body_changeset(changeset); + self.mut_node_at_path(path, |node| { + node.apply_body_changeset(changeset); Ok(()) }) } fn mut_node_at_path(&mut self, path: &Path, f: F) -> Result<(), OTError> where - F: Fn(&mut NodeData) -> Result<(), OTError>, + F: Fn(&mut Node) -> Result<(), OTError>, { let node_id = self .node_at_path(path) @@ -255,8 +260,8 @@ impl NodeTree { match self.arena.get_mut(node_id) { None => tracing::warn!("The path: {:?} does not contain any nodes", path), Some(node) => { - let node_data = node.get_mut(); - let _ = f(node_data)?; + let node = node.get_mut(); + let _ = f(node)?; } } Ok(()) diff --git a/shared-lib/lib-ot/src/core/document/operation.rs b/shared-lib/lib-ot/src/core/document/operation.rs index fd6536b401..c22fd6ca54 100644 --- a/shared-lib/lib-ot/src/core/document/operation.rs +++ b/shared-lib/lib-ot/src/core/document/operation.rs @@ -1,12 +1,12 @@ use crate::core::document::operation_serde::*; use crate::core::document::path::Path; -use crate::core::{Node, NodeAttributes, NodeBodyChangeset}; +use crate::core::{NodeAttributes, NodeBodyChangeset, NodeData}; #[derive(Clone, serde::Serialize, serde::Deserialize)] #[serde(tag = "op")] pub enum NodeOperation { #[serde(rename = "insert")] - Insert { path: Path, nodes: Vec }, + Insert { path: Path, nodes: Vec }, #[serde(rename = "update")] UpdateAttributes { @@ -22,7 +22,7 @@ pub enum NodeOperation { UpdateBody { path: Path, changeset: NodeBodyChangeset }, #[serde(rename = "delete")] - Delete { path: Path, nodes: Vec }, + Delete { path: Path, nodes: Vec }, } impl NodeOperation { @@ -101,12 +101,12 @@ impl NodeOperation { #[cfg(test)] mod tests { - use crate::core::{Node, NodeAttributes, NodeBodyChangeset, NodeBuilder, NodeOperation, Path, TextDelta}; + use crate::core::{NodeAttributes, NodeBodyChangeset, NodeBuilder, NodeData, NodeOperation, Path, TextDelta}; #[test] fn test_serialize_insert_operation() { let insert = NodeOperation::Insert { path: Path(vec![0, 1]), - nodes: vec![Node::new("text".to_owned())], + nodes: vec![NodeData::new("text".to_owned())], }; let result = serde_json::to_string(&insert).unwrap(); assert_eq!(result, r#"{"op":"insert","path":[0,1],"nodes":[{"type":"text"}]}"#); @@ -116,7 +116,9 @@ mod tests { fn test_serialize_insert_sub_trees() { let insert = NodeOperation::Insert { path: Path(vec![0, 1]), - nodes: vec![NodeBuilder::new("text").add_node(Node::new("text".to_owned())).build()], + nodes: vec![NodeBuilder::new("text") + .add_node(NodeData::new("text".to_owned())) + .build()], }; let result = serde_json::to_string(&insert).unwrap(); assert_eq!( diff --git a/shared-lib/lib-ot/src/core/document/transaction.rs b/shared-lib/lib-ot/src/core/document/transaction.rs index b7f71cc267..ddd6168d38 100644 --- a/shared-lib/lib-ot/src/core/document/transaction.rs +++ b/shared-lib/lib-ot/src/core/document/transaction.rs @@ -1,5 +1,5 @@ use crate::core::document::path::Path; -use crate::core::{Node, NodeAttributes, NodeOperation, NodeTree}; +use crate::core::{NodeAttributes, NodeData, NodeOperation, NodeTree}; use indextree::NodeId; pub struct Transaction { @@ -38,17 +38,17 @@ impl<'a> TransactionBuilder<'a> { /// // -- 0 (root) /// // 0 -- text_1 /// // 1 -- text_2 - /// use lib_ot::core::{NodeTree, Node, TransactionBuilder}; + /// use lib_ot::core::{NodeTree, NodeData, TransactionBuilder}; /// let mut node_tree = NodeTree::new(); /// let transaction = TransactionBuilder::new(&node_tree) - /// .insert_nodes_at_path(0,vec![ Node::new("text_1"), Node::new("text_2")]) + /// .insert_nodes_at_path(0,vec![ NodeData::new("text_1"), NodeData::new("text_2")]) /// .finalize(); /// node_tree.apply(transaction).unwrap(); /// /// node_tree.node_at_path(vec![0, 0]); /// ``` /// - pub fn insert_nodes_at_path>(self, path: T, nodes: Vec) -> Self { + pub fn insert_nodes_at_path>(self, path: T, nodes: Vec) -> Self { self.push(NodeOperation::Insert { path: path.into(), nodes, @@ -68,22 +68,22 @@ impl<'a> TransactionBuilder<'a> { /// // 0 /// // -- 0 /// // |-- text - /// use lib_ot::core::{NodeTree, Node, TransactionBuilder}; + /// use lib_ot::core::{NodeTree, NodeData, TransactionBuilder}; /// let mut node_tree = NodeTree::new(); /// let transaction = TransactionBuilder::new(&node_tree) - /// .insert_node_at_path(0, Node::new("text")) + /// .insert_node_at_path(0, NodeData::new("text")) /// .finalize(); /// node_tree.apply(transaction).unwrap(); /// ``` /// - pub fn insert_node_at_path>(self, path: T, node: Node) -> Self { + pub fn insert_node_at_path>(self, path: T, node: NodeData) -> Self { self.insert_nodes_at_path(path, vec![node]) } pub fn update_attributes_at_path(self, path: &Path, attributes: NodeAttributes) -> Self { let mut old_attributes = NodeAttributes::new(); let node = self.node_tree.node_at_path(path).unwrap(); - let node_data = self.node_tree.get_node_data(node).unwrap(); + let node_data = self.node_tree.get_node(node).unwrap(); for key in attributes.keys() { let old_attrs = &node_data.attributes; @@ -118,15 +118,15 @@ impl<'a> TransactionBuilder<'a> { self } - fn get_deleted_nodes(&self, node_id: NodeId) -> Node { - let node_data = self.node_tree.get_node_data(node_id).unwrap(); + fn get_deleted_nodes(&self, node_id: NodeId) -> NodeData { + let node_data = self.node_tree.get_node(node_id).unwrap(); let mut children = vec![]; self.node_tree.children_from_node(node_id).for_each(|child_id| { children.push(self.get_deleted_nodes(child_id)); }); - Node { + NodeData { node_type: node_data.node_type.clone(), attributes: node_data.attributes.clone(), body: node_data.body.clone(), diff --git a/shared-lib/lib-ot/tests/node/script.rs b/shared-lib/lib-ot/tests/node/script.rs index c263a1330c..91f36d0e8b 100644 --- a/shared-lib/lib-ot/tests/node/script.rs +++ b/shared-lib/lib-ot/tests/node/script.rs @@ -1,11 +1,11 @@ -use lib_ot::core::{Node, NodeAttributes, NodeTree, Path, TransactionBuilder}; +use lib_ot::core::{NodeAttributes, NodeData, NodeTree, Path, TransactionBuilder}; pub enum NodeScript { - InsertNode { path: Path, node: Node }, + InsertNode { path: Path, node: NodeData }, InsertAttributes { path: Path, attributes: NodeAttributes }, DeleteNode { path: Path }, AssertNumberOfChildrenAtPath { path: Option, len: usize }, - AssertNode { path: Path, expected: Option }, + AssertNode { path: Path, expected: Option }, } pub struct NodeTest { @@ -52,7 +52,7 @@ impl NodeTest { match node_id { None => assert!(node_id.is_none()), Some(node_id) => { - let node_data = self.node_tree.get_node_data(node_id).cloned(); + let node_data = self.node_tree.get_node(node_id).cloned(); assert_eq!(node_data, expected.and_then(|e| Some(e.into()))); } } diff --git a/shared-lib/lib-ot/tests/node/test.rs b/shared-lib/lib-ot/tests/node/test.rs index 1979396838..6def19a025 100644 --- a/shared-lib/lib-ot/tests/node/test.rs +++ b/shared-lib/lib-ot/tests/node/test.rs @@ -1,11 +1,11 @@ use crate::node::script::NodeScript::*; use crate::node::script::NodeTest; -use lib_ot::core::{Node, NodeBuilder, Path}; +use lib_ot::core::{NodeBuilder, NodeData, Path}; #[test] fn node_insert_test() { let mut test = NodeTest::new(); - let inserted_node = Node::new("text"); + let inserted_node = NodeData::new("text"); let path: Path = 0.into(); let scripts = vec![ InsertNode { @@ -23,7 +23,7 @@ fn node_insert_test() { #[test] fn node_insert_node_with_children_test() { let mut test = NodeTest::new(); - let inserted_node = NodeBuilder::new("text").add_node(Node::new("image")).build(); + let inserted_node = NodeBuilder::new("text").add_node(NodeData::new("image")).build(); let path: Path = 0.into(); let scripts = vec![ InsertNode { @@ -42,13 +42,13 @@ fn node_insert_node_with_children_test() { fn node_insert_multi_nodes_test() { let mut test = NodeTest::new(); let path_1: Path = 0.into(); - let node_1 = Node::new("text_1"); + let node_1 = NodeData::new("text_1"); let path_2: Path = 1.into(); - let node_2 = Node::new("text_2"); + let node_2 = NodeData::new("text_2"); let path_3: Path = 2.into(); - let node_3 = Node::new("text_3"); + let node_3 = NodeData::new("text_3"); let scripts = vec![ InsertNode { @@ -83,14 +83,14 @@ fn node_insert_multi_nodes_test() { fn node_insert_node_in_ordered_nodes_test() { let mut test = NodeTest::new(); let path_1: Path = 0.into(); - let node_1 = Node::new("text_1"); + let node_1 = NodeData::new("text_1"); let path_2: Path = 1.into(); - let node_2_1 = Node::new("text_2_1"); - let node_2_2 = Node::new("text_2_2"); + let node_2_1 = NodeData::new("text_2_1"); + let node_2_2 = NodeData::new("text_2_2"); let path_3: Path = 2.into(); - let node_3 = Node::new("text_3"); + let node_3 = NodeData::new("text_3"); let path_4: Path = 3.into(); @@ -138,7 +138,7 @@ fn node_insert_node_in_ordered_nodes_test() { fn node_insert_with_attributes_test() { let mut test = NodeTest::new(); let path: Path = 0.into(); - let mut inserted_node = Node::new("text"); + let mut inserted_node = NodeData::new("text"); inserted_node.attributes.insert("bold", true); inserted_node.attributes.insert("underline", true); @@ -162,7 +162,7 @@ fn node_insert_with_attributes_test() { #[test] fn node_delete_test() { let mut test = NodeTest::new(); - let inserted_node = Node::new("text"); + let inserted_node = NodeData::new("text"); let path: Path = 0.into(); let scripts = vec![