chore: cell data operation (#1656)

* chore: get all cells for specific field

* chore: auto format clippy wanrings

* chore: get cells for specific field type

Author: appflowy

frontend/rust-lib/dart-notify/src/entities/subject.rs

@@ -21,13 +21,13 @@ pub struct SubscribeObject {
 
 impl std::fmt::Display for SubscribeObject {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        let _ = f.write_str(&format!("{} changed: ", &self.source))?;
+        f.write_str(&format!("{} changed: ", &self.source))?;
         if let Some(payload) = &self.payload {
-            let _ = f.write_str(&format!("send {} payload", payload.len()))?;
+            f.write_str(&format!("send {} payload", payload.len()))?;
         }
 
         if let Some(payload) = &self.error {
-            let _ = f.write_str(&format!("receive {} error", payload.len()))?;
+            f.write_str(&format!("receive {} error", payload.len()))?;
         }
 
         Ok(())

frontend/rust-lib/flowy-database/src/lib.rs

@@ -35,7 +35,7 @@ pub fn init(storage_path: &str) -> Result<Database, io::Error> {
     let pool_config = PoolConfig::default();
     let database = Database::new(storage_path, DB_NAME, pool_config).map_err(as_io_error)?;
     let conn = database.get_connection().map_err(as_io_error)?;
-    let _ = embedded_migrations::run(&*conn).map_err(as_io_error)?;
+    embedded_migrations::run(&*conn).map_err(as_io_error)?;
     Ok(database)
 }
 

frontend/rust-lib/flowy-derive/src/proto_buf/util.rs

@@ -63,12 +63,9 @@ pub fn category_from_str(type_str: String) -> TypeCategory {
                     let cache: ProtoCache = serde_json::from_str(&s).unwrap();
                     CACHE_INFO
                         .entry(TypeCategory::Protobuf)
-                        .or_insert(vec![])
+                        .or_default()
                         .extend(cache.structs);
-                    CACHE_INFO
-                        .entry(TypeCategory::Enum)
-                        .or_insert(vec![])
-                        .extend(cache.enums);
+                    CACHE_INFO.entry(TypeCategory::Enum).or_default().extend(cache.enums);
                 }
             }
         }

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

@@ -82,7 +82,7 @@ impl RevisionObjectDeserializer for DocumentRevisionSerde {
     fn deserialize_revisions(_object_id: &str, revisions: Vec<Revision>) -> FlowyResult<Self::Output> {
         let mut tree = NodeTree::new(make_tree_context());
         let transaction = make_transaction_from_revisions(&revisions)?;
-        let _ = tree.apply_transaction(transaction)?;
+        tree.apply_transaction(transaction)?;
         let document = Document::new(tree);
         Result::<Document, FlowyError>::Ok(document)
     }
@@ -106,7 +106,7 @@ impl RevisionMergeable for DocumentRevisionMergeable {
 pub fn make_transaction_from_revisions(revisions: &[Revision]) -> FlowyResult<Transaction> {
     let mut transaction = Transaction::new();
     for revision in revisions {
-        let _ = transaction.compose(Transaction::from_bytes(&revision.bytes)?)?;
+        transaction.compose(Transaction::from_bytes(&revision.bytes)?)?;
     }
     Ok(transaction)
 }

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

@@ -17,8 +17,8 @@ impl Serialize for Document {
         S: Serializer,
     {
         let mut map = serializer.serialize_map(Some(1))?;
-        let _ = map.serialize_key("document")?;
-        let _ = map.serialize_value(&DocumentContentSerializer(self))?;
+        map.serialize_key("document")?;
+        map.serialize_value(&DocumentContentSerializer(self))?;
         map.end()
     }
 }
@@ -312,7 +312,7 @@ impl<'a> Serialize for DocumentContentSerializer<'a> {
             let mut seq = serializer.serialize_seq(Some(children.len()))?;
             for child in children {
                 if let Some(node_data) = get_document_node_data(child) {
-                    let _ = seq.serialize_element(&node_data)?;
+                    seq.serialize_element(&node_data)?;
                 }
             }
             seq.end()

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

@@ -50,7 +50,7 @@ impl AppFlowyDocumentEditor {
             .command_sender
             .send(Command::ComposeTransaction { transaction, ret })
             .await;
-        let _ = rx.await.map_err(internal_error)??;
+        rx.await.map_err(internal_error)??;
         Ok(())
     }
 
@@ -115,7 +115,7 @@ impl DocumentEditor for Arc<AppFlowyDocumentEditor> {
         let this = self.clone();
         FutureResult::new(async move {
             let transaction = DocumentTransaction::from_bytes(data)?;
-            let _ = this.apply_transaction(transaction.into()).await?;
+            this.apply_transaction(transaction.into()).await?;
             Ok(())
         })
     }

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

@@ -2,7 +2,7 @@ use crate::errors::ErrorCode;
 use flowy_derive::{ProtoBuf, ProtoBuf_Enum};
 use std::convert::TryInto;
 
-#[derive(PartialEq, Debug, ProtoBuf_Enum, Clone)]
+#[derive(PartialEq, Eq, Debug, ProtoBuf_Enum, Clone)]
 pub enum ExportType {
     Text = 0,
     Markdown = 1,
@@ -79,7 +79,7 @@ pub struct ExportPayloadPB {
     pub document_version: DocumentVersionPB,
 }
 
-#[derive(PartialEq, Debug, ProtoBuf_Enum, Clone)]
+#[derive(PartialEq, Eq, Debug, ProtoBuf_Enum, Clone)]
 pub enum DocumentVersionPB {
     /// this version's content of the document is build from `Delta`. It uses
     /// `DeltaDocumentEditor`.

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

@@ -26,7 +26,7 @@ pub(crate) async fn apply_edit_handler(
     manager: AFPluginState<Arc<DocumentManager>>,
 ) -> Result<(), FlowyError> {
     let params: EditParams = data.into_inner().try_into()?;
-    let _ = manager.apply_edit(params).await?;
+    manager.apply_edit(params).await?;
     Ok(())
 }
 

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

@@ -109,7 +109,7 @@ impl DocumentManager {
     /// Called immediately after the application launched with the user sign in/sign up.
     #[tracing::instrument(level = "trace", skip_all, err)]
     pub async fn initialize(&self, user_id: &str) -> FlowyResult<()> {
-        let _ = self.persistence.initialize(user_id)?;
+        self.persistence.initialize(user_id)?;
         listen_ws_state_changed(self.rev_web_socket.clone(), self.editor_map.clone());
         Ok(())
     }
@@ -138,7 +138,7 @@ impl DocumentManager {
 
     pub async fn apply_edit(&self, params: EditParams) -> FlowyResult<()> {
         let editor = self.get_document_editor(&params.doc_id).await?;
-        let _ = editor.compose_local_operations(Bytes::from(params.operations)).await?;
+        editor.compose_local_operations(Bytes::from(params.operations)).await?;
         Ok(())
     }
 
@@ -147,7 +147,7 @@ impl DocumentManager {
         let db_pool = self.persistence.database.db_pool()?;
         // Maybe we could save the document to disk without creating the RevisionManager
         let rev_manager = self.make_rev_manager(&doc_id, db_pool)?;
-        let _ = rev_manager.reset_object(revisions).await?;
+        rev_manager.reset_object(revisions).await?;
         Ok(())
     }
 

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

@@ -79,15 +79,15 @@ impl DeltaDocumentEditor {
             ret,
         };
         let _ = self.edit_cmd_tx.send(msg).await;
-        let _ = rx.await.map_err(internal_error)??;
+        rx.await.map_err(internal_error)??;
         Ok(())
     }
 
     pub async fn delete(&self, interval: Interval) -> Result<(), FlowyError> {
         let (ret, rx) = oneshot::channel::<CollaborateResult<()>>();
         let msg = EditorCommand::Delete { interval, ret };
         let _ = self.edit_cmd_tx.send(msg).await;
-        let _ = rx.await.map_err(internal_error)??;
+        rx.await.map_err(internal_error)??;
         Ok(())
     }
 
@@ -99,7 +99,7 @@ impl DeltaDocumentEditor {
             ret,
         };
         let _ = self.edit_cmd_tx.send(msg).await;
-        let _ = rx.await.map_err(internal_error)??;
+        rx.await.map_err(internal_error)??;
         Ok(())
     }
 
@@ -111,7 +111,7 @@ impl DeltaDocumentEditor {
             ret,
         };
         let _ = self.edit_cmd_tx.send(msg).await;
-        let _ = rx.await.map_err(internal_error)??;
+        rx.await.map_err(internal_error)??;
         Ok(())
     }
 
@@ -133,15 +133,15 @@ impl DeltaDocumentEditor {
         let (ret, rx) = oneshot::channel();
         let msg = EditorCommand::Undo { ret };
         let _ = self.edit_cmd_tx.send(msg).await;
-        let _ = rx.await.map_err(internal_error)??;
+        rx.await.map_err(internal_error)??;
         Ok(())
     }
 
     pub async fn redo(&self) -> Result<(), FlowyError> {
         let (ret, rx) = oneshot::channel();
         let msg = EditorCommand::Redo { ret };
         let _ = self.edit_cmd_tx.send(msg).await;
-        let _ = rx.await.map_err(internal_error)??;
+        rx.await.map_err(internal_error)??;
         Ok(())
     }
 }
@@ -193,7 +193,7 @@ impl DocumentEditor for Arc<DeltaDocumentEditor> {
             let msg = EditorCommand::ComposeLocalOperations { operations, ret };
 
             let _ = edit_cmd_tx.send(msg).await;
-            let _ = rx.await.map_err(internal_error)??;
+            rx.await.map_err(internal_error)??;
             Ok(())
         })
     }