feat: optimaze operation size

* Feat/op compose (#1392)

* fix: support float value in attributes (#1396)

Co-authored-by: nathan <[email protected]>

* fix: changeset composing (#1398)

Co-authored-by: nathan <[email protected]>

Author: appflowy

frontend/app_flowy/pubspec.lock

@@ -35,7 +35,7 @@ packages:
       path: "packages/appflowy_editor"
       relative: true
     source: path
-    version: "0.0.6"
+    version: "0.0.7"
   appflowy_popover:
     dependency: "direct main"
     description:

frontend/rust-lib/flowy-document/src/editor/document.rs

@@ -2,9 +2,7 @@ use bytes::Bytes;
 use flowy_error::{FlowyError, FlowyResult};
 use flowy_revision::{RevisionCompress, RevisionObjectDeserializer, RevisionObjectSerializer};
 use flowy_sync::entities::revision::Revision;
-use lib_ot::core::{
-    Body, Extension, NodeDataBuilder, NodeOperation, NodeTree, NodeTreeContext, Selection, Transaction,
-};
+use lib_ot::core::{Extension, NodeDataBuilder, NodeOperation, NodeTree, NodeTreeContext, Selection, Transaction};
 use lib_ot::text_delta::DeltaTextOperationBuilder;
 
 #[derive(Debug)]
@@ -46,7 +44,7 @@ pub(crate) fn make_tree_context() -> NodeTreeContext {
 
 pub fn initial_document_content() -> String {
     let delta = DeltaTextOperationBuilder::new().insert("").build();
-    let node_data = NodeDataBuilder::new("text").insert_body(Body::Delta(delta)).build();
+    let node_data = NodeDataBuilder::new("text").insert_delta(delta).build();
     let editor_node = NodeDataBuilder::new("editor").add_node_data(node_data).build();
     let node_operation = NodeOperation::Insert {
         path: vec![0].into(),

frontend/rust-lib/flowy-document/src/editor/document_serde.rs

@@ -117,7 +117,8 @@ impl DocumentTransaction {
 
 impl std::convert::From<Transaction> for DocumentTransaction {
     fn from(transaction: Transaction) -> Self {
-        let (before_selection, after_selection) = match transaction.extension {
+        let (operations, extension) = transaction.split();
+        let (before_selection, after_selection) = match extension {
             Extension::Empty => (Selection::default(), Selection::default()),
             Extension::TextSelection {
                 before_selection,
@@ -126,9 +127,7 @@ impl std::convert::From<Transaction> for DocumentTransaction {
         };
 
         DocumentTransaction {
-            operations: transaction
-                .operations
-                .into_inner()
+            operations: operations
                 .into_iter()
                 .map(|operation| operation.as_ref().into())
                 .collect(),
@@ -139,19 +138,16 @@ impl std::convert::From<Transaction> for DocumentTransaction {
 }
 
 impl std::convert::From<DocumentTransaction> for Transaction {
-    fn from(transaction: DocumentTransaction) -> Self {
-        Transaction {
-            operations: transaction
-                .operations
-                .into_iter()
-                .map(|operation| operation.into())
-                .collect::<Vec<NodeOperation>>()
-                .into(),
-            extension: Extension::TextSelection {
-                before_selection: transaction.before_selection,
-                after_selection: transaction.after_selection,
-            },
+    fn from(document_transaction: DocumentTransaction) -> Self {
+        let mut transaction = Transaction::new();
+        for document_operation in document_transaction.operations {
+            transaction.push_operation(document_operation);
         }
+        transaction.extension = Extension::TextSelection {
+            before_selection: document_transaction.before_selection,
+            after_selection: document_transaction.after_selection,
+        };
+        transaction
     }
 }
 
@@ -374,6 +370,17 @@ mod tests {
         let _ = serde_json::to_string_pretty(&document).unwrap();
     }
 
+    // #[test]
+    // fn document_operation_compose_test() {
+    //     let json = include_str!("./test.json");
+    //     let transaction: Transaction = Transaction::from_json(json).unwrap();
+    //     let json = transaction.to_json().unwrap();
+    //     // let transaction: Transaction = Transaction::from_json(&json).unwrap();
+    //     let document = Document::from_transaction(transaction).unwrap();
+    //     let content = document.get_content(false).unwrap();
+    //     println!("{}", json);
+    // }
+
     const EXAMPLE_DOCUMENT: &str = r#"{
   "document": {
     "type": "editor",

frontend/rust-lib/flowy-document/tests/editor/op_test.rs

@@ -36,8 +36,7 @@ fn attributes_insert_text_at_middle() {
 
 #[test]
 fn delta_get_ops_in_interval_1() {
-    let operations = OperationsBuilder::new().insert("123").insert("4").build();
-    let delta = DeltaTextOperationBuilder::from_operations(operations);
+    let delta = DeltaTextOperationBuilder::new().insert("123").insert("4").build();
 
     let mut iterator = OperationIterator::from_interval(&delta, Interval::new(0, 4));
     assert_eq!(iterator.ops(), delta.ops);

frontend/rust-lib/flowy-document/tests/editor/serde_test.rs

@@ -89,7 +89,7 @@ fn delta_deserialize_null_test() {
     let delta1 = DeltaTextOperations::from_json(json).unwrap();
 
     let mut attribute = BuildInTextAttribute::Bold(true);
-    attribute.remove_value();
+    attribute.clear();
 
     let delta2 = DeltaOperationBuilder::new()
         .retain_with_attributes(7, attribute.into())

frontend/rust-lib/flowy-document/tests/new_document/script.rs

@@ -3,7 +3,7 @@ use flowy_document::editor::{AppFlowyDocumentEditor, Document, DocumentTransacti
 use flowy_document::entities::DocumentVersionPB;
 use flowy_test::helper::ViewTest;
 use flowy_test::FlowySDKTest;
-use lib_ot::core::{Body, Changeset, NodeDataBuilder, NodeOperation, Path, Transaction};
+use lib_ot::core::{Changeset, NodeDataBuilder, NodeOperation, Path, Transaction};
 use lib_ot::text_delta::DeltaTextOperations;
 use std::sync::Arc;
 
@@ -64,7 +64,7 @@ impl DocumentEditorTest {
     async fn run_script(&self, script: EditScript) {
         match script {
             EditScript::InsertText { path, delta } => {
-                let node_data = NodeDataBuilder::new("text").insert_body(Body::Delta(delta)).build();
+                let node_data = NodeDataBuilder::new("text").insert_delta(delta).build();
                 let operation = NodeOperation::Insert {
                     path,
                     nodes: vec![node_data],

frontend/rust-lib/flowy-folder/src/services/workspace/event_handler.rs

@@ -119,7 +119,6 @@ fn read_workspaces_on_server(
         let workspace_revs = server.read_workspace(&token, params).await?;
         let _ = persistence
             .begin_transaction(|transaction| {
-                tracing::trace!("Save {} workspace", workspace_revs.len());
                 for workspace_rev in &workspace_revs {
                     let m_workspace = workspace_rev.clone();
                     let app_revs = m_workspace.apps.clone();

shared-lib/lib-ot/src/core/attributes/attribute.rs

@@ -12,7 +12,14 @@ pub struct AttributeEntry {
 }
 
 impl AttributeEntry {
-    pub fn remove_value(&mut self) {
+    pub fn new<K: Into<AttributeKey>, V: Into<AttributeValue>>(key: K, value: V) -> Self {
+        Self {
+            key: key.into(),
+            value: value.into(),
+        }
+    }
+
+    pub fn clear(&mut self) {
         self.value.ty = None;
         self.value.value = None;
     }
@@ -108,6 +115,10 @@ impl AttributeHashMap {
     pub fn is_empty(&self) -> bool {
         self.0.is_empty()
     }
+
+    pub fn to_json(&self) -> Result<String, OTError> {
+        serde_json::to_string(self).map_err(|err| OTError::serde().context(err))
+    }
 }
 
 impl Display for AttributeHashMap {
@@ -203,11 +214,10 @@ impl AttributeValue {
     pub fn none() -> Self {
         Self { ty: None, value: None }
     }
-    pub fn from_int(val: usize) -> Self {
-        let value = if val > 0_usize { Some(val.to_string()) } else { None };
+    pub fn from_int(val: i64) -> Self {
         Self {
             ty: Some(ValueType::IntType),
-            value,
+            value: Some(val.to_string()),
         }
     }
 
@@ -261,7 +271,7 @@ impl std::convert::From<bool> for AttributeValue {
 
 impl std::convert::From<usize> for AttributeValue {
     fn from(value: usize) -> Self {
-        AttributeValue::from_int(value)
+        AttributeValue::from_int(value as i64)
     }
 }
 
@@ -277,6 +287,12 @@ impl std::convert::From<String> for AttributeValue {
     }
 }
 
+impl std::convert::From<f64> for AttributeValue {
+    fn from(value: f64) -> Self {
+        AttributeValue::from_float(value)
+    }
+}
+
 #[derive(Default)]
 pub struct AttributeBuilder {
     attributes: AttributeHashMap,

shared-lib/lib-ot/src/core/attributes/attribute_serde.rs

@@ -70,56 +70,70 @@ impl<'de> Deserialize<'de> for AttributeValue {
             where
                 E: de::Error,
             {
-                Ok(AttributeValue::from_int(value as usize))
+                Ok(AttributeValue::from_int(value as i64))
             }
 
             fn visit_i16<E>(self, value: i16) -> Result<Self::Value, E>
             where
                 E: de::Error,
             {
-                Ok(AttributeValue::from_int(value as usize))
+                Ok(AttributeValue::from_int(value as i64))
             }
 
             fn visit_i32<E>(self, value: i32) -> Result<Self::Value, E>
             where
                 E: de::Error,
             {
-                Ok(AttributeValue::from_int(value as usize))
+                Ok(AttributeValue::from_int(value as i64))
             }
 
             fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
             where
                 E: de::Error,
             {
-                Ok(AttributeValue::from_int(value as usize))
+                Ok(AttributeValue::from_int(value as i64))
             }
 
             fn visit_u8<E>(self, value: u8) -> Result<Self::Value, E>
             where
                 E: de::Error,
             {
-                Ok(AttributeValue::from_int(value as usize))
+                Ok(AttributeValue::from_int(value as i64))
             }
 
             fn visit_u16<E>(self, value: u16) -> Result<Self::Value, E>
             where
                 E: de::Error,
             {
-                Ok(AttributeValue::from_int(value as usize))
+                Ok(AttributeValue::from_int(value as i64))
             }
 
             fn visit_u32<E>(self, value: u32) -> Result<Self::Value, E>
             where
                 E: de::Error,
             {
-                Ok(AttributeValue::from_int(value as usize))
+                Ok(AttributeValue::from_int(value as i64))
             }
 
             fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
             where
                 E: de::Error,
             {
-                Ok(AttributeValue::from_int(value as usize))
+                Ok(AttributeValue::from_int(value as i64))
+            }
+
+            fn visit_f32<E>(self, value: f32) -> Result<Self::Value, E>
+            where
+                E: de::Error,
+            {
+                Ok(AttributeValue::from_float(value as f64))
+            }
+
+            fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E>
+            where
+                E: de::Error,
+            {
+                Ok(AttributeValue::from_float(value as f64))
             }
 
             fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>

shared-lib/lib-ot/src/core/delta/builder.rs

@@ -1,6 +1,5 @@
 use crate::core::delta::operation::OperationAttributes;
 use crate::core::delta::{trim, DeltaOperations};
-use crate::core::DeltaOperation;
 
 /// A builder for creating new [Operations] objects.
 ///
@@ -39,12 +38,13 @@ where
         DeltaOperationBuilder::default()
     }
 
-    pub fn from_operations(operations: Vec<DeltaOperation<T>>) -> DeltaOperations<T> {
-        let mut delta = DeltaOperationBuilder::default().build();
-        operations.into_iter().for_each(|operation| {
-            delta.add(operation);
+    pub fn from_delta_operation(delta_operation: DeltaOperations<T>) -> Self {
+        debug_assert!(delta_operation.utf16_base_len == 0);
+        let mut builder = DeltaOperationBuilder::new();
+        delta_operation.ops.into_iter().for_each(|operation| {
+            builder.delta.add(operation);
         });
-        delta
+        builder
     }
 
     /// Retain the 'n' characters with the attributes. Use 'retain' instead if you don't