feat: create folder node & add tests

Author: appflowy

shared-lib/flowy-sync/src/client_folder/app_node.rs

@@ -0,0 +1,95 @@
+use crate::client_folder::view_node::ViewNode;
+use crate::client_folder::{get_attributes_str_value, set_attributes_str_value, AtomicNodeTree};
+use crate::errors::CollaborateResult;
+use folder_rev_model::{AppRevision, ViewRevision};
+use lib_ot::core::{NodeData, NodeDataBuilder, NodeOperation, Path, Transaction};
+use std::sync::Arc;
+
+#[derive(Debug, Clone)]
+pub struct AppNode {
+    pub id: String,
+    tree: Arc<AtomicNodeTree>,
+    pub(crate) path: Path,
+    views: Vec<Arc<ViewNode>>,
+}
+
+impl AppNode {
+    pub(crate) fn from_app_revision(
+        transaction: &mut Transaction,
+        revision: AppRevision,
+        tree: Arc<AtomicNodeTree>,
+        path: Path,
+    ) -> CollaborateResult<Self> {
+        let app_id = revision.id.clone();
+        let app_node = NodeDataBuilder::new("app")
+            .insert_attribute("id", revision.id)
+            .insert_attribute("name", revision.name)
+            .insert_attribute("workspace_id", revision.workspace_id)
+            .build();
+
+        transaction.push_operation(NodeOperation::Insert {
+            path: path.clone(),
+            nodes: vec![app_node],
+        });
+
+        let views = revision
+            .belongings
+            .into_iter()
+            .enumerate()
+            .map(|(index, app)| (path.clone_with(index), app))
+            .flat_map(
+                |(path, app)| match ViewNode::from_view_revision(transaction, app, tree.clone(), path) {
+                    Ok(view_node) => Some(Arc::new(view_node)),
+                    Err(err) => {
+                        tracing::error!("create view node failed: {:?}", err);
+                        None
+                    }
+                },
+            )
+            .collect::<Vec<Arc<ViewNode>>>();
+
+        Ok(Self {
+            id: app_id,
+            tree,
+            path,
+            views,
+        })
+    }
+
+    pub fn get_name(&self) -> Option<String> {
+        get_attributes_str_value(self.tree.clone(), &self.path, "name")
+    }
+
+    pub fn set_name(&self, name: &str) -> CollaborateResult<()> {
+        set_attributes_str_value(self.tree.clone(), &self.path, "name", name.to_string())
+    }
+
+    fn get_workspace_id(&self) -> Option<String> {
+        get_attributes_str_value(self.tree.clone(), &self.path, "workspace_id")
+    }
+
+    fn set_workspace_id(&self, workspace_id: String) -> CollaborateResult<()> {
+        set_attributes_str_value(self.tree.clone(), &self.path, "workspace_id", workspace_id)
+    }
+
+    fn get_view(&self, view_id: &str) -> Option<&Arc<ViewNode>> {
+        todo!()
+    }
+
+    fn get_mut_view(&mut self, view_id: &str) -> Option<&mut Arc<ViewNode>> {
+        todo!()
+    }
+
+    fn add_view(&mut self, revision: ViewRevision) -> CollaborateResult<()> {
+        let mut transaction = Transaction::new();
+        let path = self.path.clone_with(self.views.len());
+        let view_node = ViewNode::from_view_revision(&mut transaction, revision, self.tree.clone(), path)?;
+        let _ = self.tree.write().apply_transaction(transaction)?;
+        self.views.push(Arc::new(view_node));
+        todo!()
+    }
+
+    fn remove_view(&mut self, view_id: &str) {
+        todo!()
+    }
+}

shared-lib/flowy-sync/src/client_folder/folder_node.rs

@@ -0,0 +1,155 @@
+use crate::client_folder::workspace_node::WorkspaceNode;
+use crate::errors::{CollaborateError, CollaborateResult};
+use folder_rev_model::{AppRevision, ViewRevision, WorkspaceRevision};
+use lib_ot::core::{
+    AttributeEntry, AttributeHashMap, AttributeValue, Changeset, Node, NodeDataBuilder, NodeOperation, NodeTree, Path,
+    Transaction,
+};
+use parking_lot::RwLock;
+use std::string::ToString;
+use std::sync::Arc;
+
+pub type AtomicNodeTree = RwLock<NodeTree>;
+
+pub struct FolderNodePad {
+    tree: Arc<AtomicNodeTree>,
+    workspaces: Vec<Arc<WorkspaceNode>>,
+    trash: Vec<Arc<TrashNode>>,
+}
+
+impl FolderNodePad {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn get_workspace(&self, workspace_id: &str) -> Option<&Arc<WorkspaceNode>> {
+        self.workspaces.iter().find(|workspace| workspace.id == workspace_id)
+    }
+
+    pub fn get_mut_workspace(&mut self, workspace_id: &str) -> Option<&mut Arc<WorkspaceNode>> {
+        self.workspaces
+            .iter_mut()
+            .find(|workspace| workspace.id == workspace_id)
+    }
+
+    pub fn remove_workspace(&mut self, workspace_id: &str) {
+        if let Some(workspace) = self.workspaces.iter().find(|workspace| workspace.id == workspace_id) {
+            let mut nodes = vec![];
+            let workspace_node = self.tree.read().get_node_data_at_path(&workspace.path);
+            debug_assert!(workspace_node.is_some());
+
+            if let Some(node_data) = workspace_node {
+                nodes.push(node_data);
+            }
+            let delete_operation = NodeOperation::Delete {
+                path: workspace.path.clone(),
+                nodes,
+            };
+            let _ = self.tree.write().apply_op(delete_operation);
+        }
+    }
+
+    pub fn add_workspace(&mut self, revision: WorkspaceRevision) -> CollaborateResult<()> {
+        let mut transaction = Transaction::new();
+        let workspace_node = WorkspaceNode::from_workspace_revision(
+            &mut transaction,
+            revision,
+            self.tree.clone(),
+            workspaces_path().clone_with(self.workspaces.len()),
+        )?;
+        let _ = self.tree.write().apply_transaction(transaction)?;
+        self.workspaces.push(Arc::new(workspace_node));
+        Ok(())
+    }
+
+    pub fn to_json(&self, pretty: bool) -> CollaborateResult<String> {
+        self.tree
+            .read()
+            .to_json(pretty)
+            .map_err(|e| CollaborateError::serde().context(e))
+    }
+}
+
+fn folder_path() -> Path {
+    vec![0].into()
+}
+
+fn workspaces_path() -> Path {
+    folder_path().clone_with(0)
+}
+
+fn trash_path() -> Path {
+    folder_path().clone_with(1)
+}
+
+pub fn get_attributes(tree: Arc<AtomicNodeTree>, path: &Path) -> Option<AttributeHashMap> {
+    tree.read()
+        .get_node_at_path(&path)
+        .and_then(|node| Some(node.attributes.clone()))
+}
+
+pub fn get_attributes_value(tree: Arc<AtomicNodeTree>, path: &Path, key: &str) -> Option<AttributeValue> {
+    tree.read()
+        .get_node_at_path(&path)
+        .and_then(|node| node.attributes.get(key).cloned())
+}
+
+pub fn get_attributes_str_value(tree: Arc<AtomicNodeTree>, path: &Path, key: &str) -> Option<String> {
+    tree.read()
+        .get_node_at_path(&path)
+        .and_then(|node| node.attributes.get(key).cloned())
+        .and_then(|value| value.str_value())
+}
+
+pub fn set_attributes_str_value(
+    tree: Arc<AtomicNodeTree>,
+    path: &Path,
+    key: &str,
+    value: String,
+) -> CollaborateResult<()> {
+    let old_attributes = match get_attributes(tree.clone(), path) {
+        None => AttributeHashMap::new(),
+        Some(attributes) => attributes,
+    };
+    let mut new_attributes = old_attributes.clone();
+    new_attributes.insert(key, value);
+
+    let update_operation = NodeOperation::Update {
+        path: path.clone(),
+        changeset: Changeset::Attributes {
+            new: new_attributes,
+            old: old_attributes,
+        },
+    };
+    let _ = tree.write().apply_op(update_operation)?;
+    Ok(())
+}
+
+impl std::default::Default for FolderNodePad {
+    fn default() -> Self {
+        let workspace_node = NodeDataBuilder::new("workspaces").build();
+        let trash_node = NodeDataBuilder::new("trash").build();
+        let folder_node = NodeDataBuilder::new("folder")
+            .add_node_data(workspace_node)
+            .add_node_data(trash_node)
+            .build();
+
+        let operation = NodeOperation::Insert {
+            path: folder_path(),
+            nodes: vec![folder_node],
+        };
+        let mut tree = NodeTree::default();
+        let _ = tree.apply_op(operation).unwrap();
+
+        Self {
+            tree: Arc::new(RwLock::new(tree)),
+            workspaces: vec![],
+            trash: vec![],
+        }
+    }
+}
+
+pub struct TrashNode {
+    tree: Arc<AtomicNodeTree>,
+    parent_path: Path,
+}

shared-lib/flowy-sync/src/client_folder/mod.rs

@@ -1,4 +1,9 @@
+mod app_node;
 mod builder;
+mod folder_node;
 mod folder_pad;
+mod view_node;
+mod workspace_node;
 
+pub use folder_node::*;
 pub use folder_pad::*;

shared-lib/flowy-sync/src/client_folder/view_node.rs

@@ -0,0 +1,44 @@
+use crate::client_folder::AtomicNodeTree;
+use crate::errors::CollaborateResult;
+use folder_rev_model::ViewRevision;
+use lib_ot::core::{NodeDataBuilder, NodeOperation, Path, Transaction};
+use std::sync::Arc;
+
+#[derive(Debug, Clone)]
+pub struct ViewNode {
+    tree: Arc<AtomicNodeTree>,
+    path: Path,
+}
+
+impl ViewNode {
+    pub(crate) fn from_view_revision(
+        transaction: &mut Transaction,
+        revision: ViewRevision,
+        tree: Arc<AtomicNodeTree>,
+        path: Path,
+    ) -> CollaborateResult<Self> {
+        let view_node = NodeDataBuilder::new("view")
+            .insert_attribute("id", revision.id)
+            .insert_attribute("name", revision.name)
+            .build();
+
+        transaction.push_operation(NodeOperation::Insert {
+            path: path.clone(),
+            nodes: vec![view_node],
+        });
+
+        Ok(Self { tree, path })
+    }
+
+    fn get_id(&self) -> &str {
+        todo!()
+    }
+
+    fn get_app_id(&self) -> &str {
+        todo!()
+    }
+
+    fn set_app_id(&self, workspace_id: String) {
+        todo!()
+    }
+}