From 4549ed20e770dfddf15fe39b5ad00132fa5879e3 Mon Sep 17 00:00:00 2001
From: "Nathan.fooo" <86001920+appflowy@users.noreply.github.com>
Date: Mon, 10 Oct 2022 11:56:48 +0800
Subject: [PATCH] Refactor/rename delta (#1256)
* chore: rename delta
* chore: renanme delta
---
frontend/rust-lib/flowy-folder/src/manager.rs | 4 +-
.../src/services/folder_editor.rs | 9 +-
.../flowy-folder/src/services/web_socket.rs | 8 +-
frontend/rust-lib/flowy-grid/src/manager.rs | 8 +-
.../flowy-grid/src/services/block_editor.rs | 9 +-
.../flowy-grid/src/services/grid_editor.rs | 15 +-
.../src/services/grid_view_editor.rs | 2 +-
.../src/services/grid_view_manager.rs | 7 +-
.../flowy-net/src/local_server/server.rs | 4 +-
.../src/cache/disk/document_impl.rs | 2 +-
.../src/cache/disk/grid_block_impl.rs | 2 +-
.../src/cache/disk/grid_impl.rs | 2 +-
.../src/cache/disk/grid_view_impl.rs | 2 +-
.../flowy-revision/src/conflict_resolve.rs | 26 +-
.../flowy-revision/src/rev_manager.rs | 10 +-
.../flowy-sdk/src/deps_resolve/folder_deps.rs | 4 +-
.../rust-lib/flowy-text-block/src/editor.rs | 20 +-
.../rust-lib/flowy-text-block/src/queue.rs | 50 ++--
.../flowy-text-block/src/web_socket.rs | 12 +-
.../flowy-text-block/tests/document/script.rs | 4 +-
.../tests/editor/attribute_test.rs | 12 +-
.../flowy-text-block/tests/editor/mod.rs | 60 ++---
.../flowy-text-block/tests/editor/op_test.rs | 236 +++++++++---------
.../tests/editor/serde_test.rs | 26 +-
.../flowy-sync/src/client_document/data.rs | 12 -
.../src/client_document/default/mod.rs | 12 +-
.../src/client_document/document_pad.rs | 173 +++++++------
.../extensions/delete/default_delete.rs | 4 +-
.../delete/preserve_line_format_merge.rs | 6 +-
.../extensions/format/resolve_block_format.rs | 4 +-
.../format/resolve_inline_format.rs | 4 +-
.../src/client_document/extensions/helper.rs | 6 +-
.../extensions/insert/auto_exit_block.rs | 4 +-
.../extensions/insert/auto_format.rs | 8 +-
.../extensions/insert/default_insert.rs | 10 +-
.../client_document/extensions/insert/mod.rs | 18 +-
.../insert/preserve_block_format.rs | 8 +-
.../insert/preserve_inline_format.rs | 8 +-
.../insert/reset_format_on_new_line.rs | 8 +-
.../src/client_document/extensions/mod.rs | 8 +-
.../flowy-sync/src/client_document/history.rs | 18 +-
.../flowy-sync/src/client_document/mod.rs | 1 -
.../flowy-sync/src/client_document/view.rs | 43 ++--
.../flowy-sync/src/client_folder/builder.rs | 15 +-
.../src/client_folder/folder_pad.rs | 212 +++++++++-------
.../src/client_grid/block_revision_pad.rs | 79 +++---
.../src/client_grid/grid_revision_pad.rs | 59 +++--
.../src/client_grid/view_revision_pad.rs | 41 +--
shared-lib/flowy-sync/src/entities/folder.rs | 3 -
.../flowy-sync/src/entities/revision.rs | 32 +--
.../flowy-sync/src/entities/text_block.rs | 8 +-
shared-lib/flowy-sync/src/lib.rs | 2 +-
.../src/server_document/document_manager.rs | 10 +-
.../src/server_document/document_pad.rs | 52 ++--
.../src/server_folder/folder_manager.rs | 15 +-
.../src/server_folder/folder_pad.rs | 38 +--
.../flowy-sync/src/server_folder/mod.rs | 1 +
shared-lib/flowy-sync/src/synchronizer.rs | 84 ++++---
shared-lib/flowy-sync/src/util.rs | 55 ++--
.../lib-ot/src/core/attributes/attribute.rs | 56 ++---
shared-lib/lib-ot/src/core/delta/builder.rs | 20 +-
shared-lib/lib-ot/src/core/delta/cursor.rs | 34 +--
shared-lib/lib-ot/src/core/delta/iterator.rs | 54 ++--
.../src/core/delta/operation/builder.rs | 16 +-
.../src/core/delta/operation/operation.rs | 110 ++++----
.../core/delta/operation/operation_serde.rs | 22 +-
shared-lib/lib-ot/src/core/delta/ops.rs | 165 ++++++------
shared-lib/lib-ot/src/core/delta/ops_serde.rs | 12 +-
shared-lib/lib-ot/src/core/node_tree/node.rs | 19 +-
.../lib-ot/src/core/node_tree/node_serde.rs | 6 +-
.../lib-ot/src/core/node_tree/operation.rs | 18 +-
.../src/core/node_tree/operation_serde.rs | 6 +-
.../lib-ot/src/core/node_tree/transaction.rs | 16 +-
shared-lib/lib-ot/src/core/node_tree/tree.rs | 12 +-
.../lib-ot/src/text_delta/attributes.rs | 8 +-
shared-lib/lib-ot/src/text_delta/delta.rs | 13 +-
shared-lib/lib-ot/tests/node/editor_test.rs | 4 +-
.../lib-ot/tests/node/operation_test.rs | 4 +-
shared-lib/lib-ot/tests/node/script.rs | 8 +-
shared-lib/lib-ot/tests/node/tree_test.rs | 6 +-
80 files changed, 1126 insertions(+), 1078 deletions(-)
delete mode 100644 shared-lib/flowy-sync/src/client_document/data.rs
diff --git a/frontend/rust-lib/flowy-folder/src/manager.rs b/frontend/rust-lib/flowy-folder/src/manager.rs
index 3a62924e83..3df48e428e 100644
--- a/frontend/rust-lib/flowy-folder/src/manager.rs
+++ b/frontend/rust-lib/flowy-folder/src/manager.rs
@@ -16,7 +16,7 @@ use flowy_error::FlowyError;
use flowy_folder_data_model::user_default;
use flowy_revision::disk::SQLiteTextBlockRevisionPersistence;
use flowy_revision::{RevisionManager, RevisionPersistence, RevisionWebSocket, SQLiteRevisionSnapshotPersistence};
-use flowy_sync::client_document::default::{initial_quill_delta_string, initial_read_me};
+use flowy_sync::client_document::default::{initial_document_str, initial_read_me};
use flowy_sync::{client_folder::FolderPad, entities::ws_data::ServerRevisionWSData};
use lazy_static::lazy_static;
use lib_infra::future::FutureResult;
@@ -218,7 +218,7 @@ impl DefaultFolderBuilder {
let view_data = if index == 0 {
initial_read_me().json_str()
} else {
- initial_quill_delta_string()
+ initial_document_str()
};
let _ = view_controller.set_latest_view(&view.id);
let layout_type = ViewLayoutTypePB::from(view.layout.clone());
diff --git a/frontend/rust-lib/flowy-folder/src/services/folder_editor.rs b/frontend/rust-lib/flowy-folder/src/services/folder_editor.rs
index 6f68497edd..a8c54fd0ad 100644
--- a/frontend/rust-lib/flowy-folder/src/services/folder_editor.rs
+++ b/frontend/rust-lib/flowy-folder/src/services/folder_editor.rs
@@ -4,13 +4,14 @@ use flowy_error::{FlowyError, FlowyResult};
use flowy_revision::{
RevisionCloudService, RevisionCompactor, RevisionManager, RevisionObjectBuilder, RevisionWebSocket,
};
-use flowy_sync::util::make_text_delta_from_revisions;
+use flowy_sync::util::make_operations_from_revisions;
use flowy_sync::{
client_folder::{FolderChangeset, FolderPad},
entities::{revision::Revision, ws_data::ServerRevisionWSData},
};
use lib_infra::future::FutureResult;
+use lib_ot::core::EmptyAttributes;
use parking_lot::RwLock;
use std::sync::Arc;
@@ -77,7 +78,7 @@ impl FolderEditor {
}
pub(crate) fn apply_change(&self, change: FolderChangeset) -> FlowyResult<()> {
- let FolderChangeset { delta, md5 } = change;
+ let FolderChangeset { operations: delta, md5 } = change;
let (base_rev_id, rev_id) = self.rev_manager.next_rev_id_pair();
let delta_data = delta.json_bytes();
let revision = Revision::new(
@@ -131,7 +132,7 @@ impl FolderEditor {
pub struct FolderRevisionCompactor();
impl RevisionCompactor for FolderRevisionCompactor {
fn bytes_from_revisions(&self, revisions: Vec<Revision>) -> FlowyResult<Bytes> {
- let delta = make_text_delta_from_revisions(revisions)?;
- Ok(delta.json_bytes())
+ let operations = make_operations_from_revisions::<EmptyAttributes>(revisions)?;
+ Ok(operations.json_bytes())
}
}
diff --git a/frontend/rust-lib/flowy-folder/src/services/web_socket.rs b/frontend/rust-lib/flowy-folder/src/services/web_socket.rs
index 40eeb77177..ce122073eb 100644
--- a/frontend/rust-lib/flowy-folder/src/services/web_socket.rs
+++ b/frontend/rust-lib/flowy-folder/src/services/web_socket.rs
@@ -52,10 +52,10 @@ struct FolderConflictResolver {
}
impl ConflictResolver<EmptyAttributes> for FolderConflictResolver {
- fn compose_delta(&self, delta: Delta) -> BoxResultFuture<DeltaMD5, FlowyError> {
+ fn compose_delta(&self, delta: Delta) -> BoxResultFuture<OperationsMD5, FlowyError> {
let folder_pad = self.folder_pad.clone();
Box::pin(async move {
- let md5 = folder_pad.write().compose_remote_delta(delta)?;
+ let md5 = folder_pad.write().compose_remote_operations(delta)?;
Ok(md5)
})
}
@@ -70,7 +70,7 @@ impl ConflictResolver<EmptyAttributes> for FolderConflictResolver {
// Do nothing
client_prime = delta;
} else {
- let (s_prime, c_prime) = read_guard.delta().transform(&delta)?;
+ let (s_prime, c_prime) = read_guard.get_operations().transform(&delta)?;
client_prime = c_prime;
server_prime = Some(s_prime);
}
@@ -82,7 +82,7 @@ impl ConflictResolver<EmptyAttributes> for FolderConflictResolver {
})
}
- fn reset_delta(&self, delta: Delta) -> BoxResultFuture<DeltaMD5, FlowyError> {
+ fn reset_delta(&self, delta: Delta) -> BoxResultFuture<OperationsMD5, FlowyError> {
let folder_pad = self.folder_pad.clone();
Box::pin(async move {
let md5 = folder_pad.write().reset_folder(delta)?;
diff --git a/frontend/rust-lib/flowy-grid/src/manager.rs b/frontend/rust-lib/flowy-grid/src/manager.rs
index 3e7b97f50b..24811ca889 100644
--- a/frontend/rust-lib/flowy-grid/src/manager.rs
+++ b/frontend/rust-lib/flowy-grid/src/manager.rs
@@ -14,7 +14,7 @@ use flowy_error::{FlowyError, FlowyResult};
use flowy_grid_data_model::revision::{BuildGridContext, GridRevision, GridViewRevision};
use flowy_revision::disk::{SQLiteGridBlockRevisionPersistence, SQLiteGridRevisionPersistence};
use flowy_revision::{RevisionManager, RevisionPersistence, RevisionWebSocket, SQLiteRevisionSnapshotPersistence};
-use flowy_sync::client_grid::{make_grid_block_delta, make_grid_delta, make_grid_view_delta};
+use flowy_sync::client_grid::{make_grid_block_operations, make_grid_operations, make_grid_view_operations};
use flowy_sync::entities::revision::{RepeatedRevision, Revision};
use std::sync::Arc;
use tokio::sync::RwLock;
@@ -198,7 +198,7 @@ pub async fn make_grid_view_data(
});
// Create grid's block
- let grid_block_delta = make_grid_block_delta(block_meta_data);
+ let grid_block_delta = make_grid_block_operations(block_meta_data);
let block_delta_data = grid_block_delta.json_bytes();
let repeated_revision: RepeatedRevision =
Revision::initial_revision(user_id, block_id, block_delta_data).into();
@@ -210,7 +210,7 @@ pub async fn make_grid_view_data(
let grid_rev = GridRevision::from_build_context(&grid_id, field_revs, block_metas);
// Create grid
- let grid_rev_delta = make_grid_delta(&grid_rev);
+ let grid_rev_delta = make_grid_operations(&grid_rev);
let grid_rev_delta_bytes = grid_rev_delta.json_bytes();
let repeated_revision: RepeatedRevision =
Revision::initial_revision(user_id, &grid_id, grid_rev_delta_bytes.clone()).into();
@@ -222,7 +222,7 @@ pub async fn make_grid_view_data(
} else {
GridViewRevision::from_json(grid_view_revision_data)?
};
- let grid_view_delta = make_grid_view_delta(&grid_view);
+ let grid_view_delta = make_grid_view_operations(&grid_view);
let grid_view_delta_bytes = grid_view_delta.json_bytes();
let repeated_revision: RepeatedRevision =
Revision::initial_revision(user_id, view_id, grid_view_delta_bytes).into();
diff --git a/frontend/rust-lib/flowy-grid/src/services/block_editor.rs b/frontend/rust-lib/flowy-grid/src/services/block_editor.rs
index f576742c90..0c313a869f 100644
--- a/frontend/rust-lib/flowy-grid/src/services/block_editor.rs
+++ b/frontend/rust-lib/flowy-grid/src/services/block_editor.rs
@@ -5,9 +5,10 @@ use flowy_grid_data_model::revision::{CellRevision, GridBlockRevision, RowChange
use flowy_revision::{RevisionCloudService, RevisionCompactor, RevisionManager, RevisionObjectBuilder};
use flowy_sync::client_grid::{GridBlockRevisionChangeset, GridBlockRevisionPad};
use flowy_sync::entities::revision::Revision;
-use flowy_sync::util::make_text_delta_from_revisions;
+use flowy_sync::util::make_operations_from_revisions;
use lib_infra::future::FutureResult;
+use lib_ot::core::EmptyAttributes;
use std::borrow::Cow;
use std::sync::Arc;
use tokio::sync::RwLock;
@@ -162,7 +163,7 @@ impl GridBlockRevisionEditor {
}
async fn apply_change(&self, change: GridBlockRevisionChangeset) -> FlowyResult<()> {
- let GridBlockRevisionChangeset { delta, md5 } = change;
+ let GridBlockRevisionChangeset { operations: delta, md5 } = change;
let user_id = self.user_id.clone();
let (base_rev_id, rev_id) = self.rev_manager.next_rev_id_pair();
let delta_data = delta.json_bytes();
@@ -204,7 +205,7 @@ impl RevisionObjectBuilder for GridBlockRevisionPadBuilder {
pub struct GridBlockRevisionCompactor();
impl RevisionCompactor for GridBlockRevisionCompactor {
fn bytes_from_revisions(&self, revisions: Vec<Revision>) -> FlowyResult<Bytes> {
- let delta = make_text_delta_from_revisions(revisions)?;
- Ok(delta.json_bytes())
+ let operations = make_operations_from_revisions::<EmptyAttributes>(revisions)?;
+ Ok(operations.json_bytes())
}
}
diff --git a/frontend/rust-lib/flowy-grid/src/services/grid_editor.rs b/frontend/rust-lib/flowy-grid/src/services/grid_editor.rs
index 3607a1ce74..bbcdb56e1b 100644
--- a/frontend/rust-lib/flowy-grid/src/services/grid_editor.rs
+++ b/frontend/rust-lib/flowy-grid/src/services/grid_editor.rs
@@ -17,9 +17,10 @@ use flowy_revision::{RevisionCloudService, RevisionCompactor, RevisionManager, R
use flowy_sync::client_grid::{GridRevisionChangeset, GridRevisionPad, JsonDeserializer};
use flowy_sync::entities::revision::Revision;
use flowy_sync::errors::CollaborateResult;
-use flowy_sync::util::make_text_delta_from_revisions;
+use flowy_sync::util::make_operations_from_revisions;
use lib_infra::future::{wrap_future, FutureResult};
+use lib_ot::core::EmptyAttributes;
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::RwLock;
@@ -147,7 +148,7 @@ impl GridRevisionEditor {
}
pub async fn next_field_rev(&self, field_type: &FieldType) -> FlowyResult<FieldRevision> {
- let name = format!("Property {}", self.grid_pad.read().await.fields().len() + 1);
+ let name = format!("Property {}", self.grid_pad.read().await.get_fields().len() + 1);
let field_rev = FieldBuilder::from_field_type(field_type).name(&name).build();
Ok(field_rev)
}
@@ -675,10 +676,6 @@ impl GridRevisionEditor {
Ok(())
}
- pub async fn delta_bytes(&self) -> Bytes {
- self.grid_pad.read().await.delta_bytes()
- }
-
pub async fn duplicate_grid(&self) -> FlowyResult<BuildGridContext> {
let grid_pad = self.grid_pad.read().await;
let grid_view_revision_data = self.view_manager.duplicate_grid_view().await?;
@@ -750,7 +747,7 @@ impl GridRevisionEditor {
}
async fn apply_change(&self, change: GridRevisionChangeset) -> FlowyResult<()> {
- let GridRevisionChangeset { delta, md5 } = change;
+ let GridRevisionChangeset { operations: delta, md5 } = change;
let user_id = self.user.user_id()?;
let (base_rev_id, rev_id) = self.rev_manager.next_rev_id_pair();
let delta_data = delta.json_bytes();
@@ -844,8 +841,8 @@ impl RevisionCloudService for GridRevisionCloudService {
pub struct GridRevisionCompactor();
impl RevisionCompactor for GridRevisionCompactor {
fn bytes_from_revisions(&self, revisions: Vec<Revision>) -> FlowyResult<Bytes> {
- let delta = make_text_delta_from_revisions(revisions)?;
- Ok(delta.json_bytes())
+ let operations = make_operations_from_revisions::<EmptyAttributes>(revisions)?;
+ Ok(operations.json_bytes())
}
}
diff --git a/frontend/rust-lib/flowy-grid/src/services/grid_view_editor.rs b/frontend/rust-lib/flowy-grid/src/services/grid_view_editor.rs
index ce0edbef6f..d9f245c8b9 100644
--- a/frontend/rust-lib/flowy-grid/src/services/grid_view_editor.rs
+++ b/frontend/rust-lib/flowy-grid/src/services/grid_view_editor.rs
@@ -435,7 +435,7 @@ async fn apply_change(
rev_manager: Arc<RevisionManager>,
change: GridViewRevisionChangeset,
) -> FlowyResult<()> {
- let GridViewRevisionChangeset { delta, md5 } = change;
+ let GridViewRevisionChangeset { operations: delta, md5 } = change;
let (base_rev_id, rev_id) = rev_manager.next_rev_id_pair();
let delta_data = delta.json_bytes();
let revision = Revision::new(&rev_manager.object_id, base_rev_id, rev_id, delta_data, user_id, md5);
diff --git a/frontend/rust-lib/flowy-grid/src/services/grid_view_manager.rs b/frontend/rust-lib/flowy-grid/src/services/grid_view_manager.rs
index 65ed1af6c5..c57dbda2f2 100644
--- a/frontend/rust-lib/flowy-grid/src/services/grid_view_manager.rs
+++ b/frontend/rust-lib/flowy-grid/src/services/grid_view_manager.rs
@@ -12,8 +12,9 @@ use flowy_grid_data_model::revision::{FieldRevision, RowChangeset, RowRevision};
use flowy_revision::disk::SQLiteGridViewRevisionPersistence;
use flowy_revision::{RevisionCompactor, RevisionManager, RevisionPersistence, SQLiteRevisionSnapshotPersistence};
use flowy_sync::entities::revision::Revision;
-use flowy_sync::util::make_text_delta_from_revisions;
+use flowy_sync::util::make_operations_from_revisions;
use lib_infra::future::AFFuture;
+use lib_ot::core::EmptyAttributes;
use std::sync::Arc;
type ViewId = String;
@@ -262,7 +263,7 @@ pub async fn make_grid_view_rev_manager(user: &Arc<dyn GridUser>, view_id: &str)
pub struct GridViewRevisionCompactor();
impl RevisionCompactor for GridViewRevisionCompactor {
fn bytes_from_revisions(&self, revisions: Vec<Revision>) -> FlowyResult<Bytes> {
- let delta = make_text_delta_from_revisions(revisions)?;
- Ok(delta.json_bytes())
+ let operations = make_operations_from_revisions::<EmptyAttributes>(revisions)?;
+ Ok(operations.json_bytes())
}
}
diff --git a/frontend/rust-lib/flowy-net/src/local_server/server.rs b/frontend/rust-lib/flowy-net/src/local_server/server.rs
index 060abf08bf..fbdba41098 100644
--- a/frontend/rust-lib/flowy-net/src/local_server/server.rs
+++ b/frontend/rust-lib/flowy-net/src/local_server/server.rs
@@ -4,7 +4,7 @@ use bytes::Bytes;
use flowy_error::{internal_error, FlowyError};
use flowy_folder::event_map::FolderCouldServiceV1;
use flowy_sync::{
- client_document::default::initial_quill_delta_string,
+ client_document::default::initial_document_str,
entities::{
text_block::{CreateTextBlockParams, DocumentPB, ResetTextBlockParams, TextBlockIdPB},
ws_data::{ClientRevisionWSData, ClientRevisionWSDataType},
@@ -422,7 +422,7 @@ impl TextEditorCloudService for LocalServer {
fn read_text_block(&self, _token: &str, params: TextBlockIdPB) -> FutureResult<Option<DocumentPB>, FlowyError> {
let doc = DocumentPB {
block_id: params.value,
- text: initial_quill_delta_string(),
+ text: initial_document_str(),
rev_id: 0,
base_rev_id: 0,
};
diff --git a/frontend/rust-lib/flowy-revision/src/cache/disk/document_impl.rs b/frontend/rust-lib/flowy-revision/src/cache/disk/document_impl.rs
index 31b69e0291..a220f0e625 100644
--- a/frontend/rust-lib/flowy-revision/src/cache/disk/document_impl.rs
+++ b/frontend/rust-lib/flowy-revision/src/cache/disk/document_impl.rs
@@ -109,7 +109,7 @@ impl TextRevisionSql {
dsl::doc_id.eq(record.revision.object_id),
dsl::base_rev_id.eq(record.revision.base_rev_id),
dsl::rev_id.eq(record.revision.rev_id),
- dsl::data.eq(record.revision.delta_data),
+ dsl::data.eq(record.revision.bytes),
dsl::state.eq(rev_state),
dsl::ty.eq(RevTableType::Local),
)
diff --git a/frontend/rust-lib/flowy-revision/src/cache/disk/grid_block_impl.rs b/frontend/rust-lib/flowy-revision/src/cache/disk/grid_block_impl.rs
index 2fcdb7e748..a12c5c1ad5 100644
--- a/frontend/rust-lib/flowy-revision/src/cache/disk/grid_block_impl.rs
+++ b/frontend/rust-lib/flowy-revision/src/cache/disk/grid_block_impl.rs
@@ -108,7 +108,7 @@ impl GridMetaRevisionSql {
dsl::object_id.eq(record.revision.object_id),
dsl::base_rev_id.eq(record.revision.base_rev_id),
dsl::rev_id.eq(record.revision.rev_id),
- dsl::data.eq(record.revision.delta_data),
+ dsl::data.eq(record.revision.bytes),
dsl::state.eq(rev_state),
)
})
diff --git a/frontend/rust-lib/flowy-revision/src/cache/disk/grid_impl.rs b/frontend/rust-lib/flowy-revision/src/cache/disk/grid_impl.rs
index bb6e561c91..aef127baea 100644
--- a/frontend/rust-lib/flowy-revision/src/cache/disk/grid_impl.rs
+++ b/frontend/rust-lib/flowy-revision/src/cache/disk/grid_impl.rs
@@ -107,7 +107,7 @@ impl GridRevisionSql {
dsl::object_id.eq(record.revision.object_id),
dsl::base_rev_id.eq(record.revision.base_rev_id),
dsl::rev_id.eq(record.revision.rev_id),
- dsl::data.eq(record.revision.delta_data),
+ dsl::data.eq(record.revision.bytes),
dsl::state.eq(rev_state),
)
})
diff --git a/frontend/rust-lib/flowy-revision/src/cache/disk/grid_view_impl.rs b/frontend/rust-lib/flowy-revision/src/cache/disk/grid_view_impl.rs
index 2d7cbd59b2..71d923e046 100644
--- a/frontend/rust-lib/flowy-revision/src/cache/disk/grid_view_impl.rs
+++ b/frontend/rust-lib/flowy-revision/src/cache/disk/grid_view_impl.rs
@@ -106,7 +106,7 @@ impl GridViewRevisionSql {
dsl::object_id.eq(record.revision.object_id),
dsl::base_rev_id.eq(record.revision.base_rev_id),
dsl::rev_id.eq(record.revision.rev_id),
- dsl::data.eq(record.revision.delta_data),
+ dsl::data.eq(record.revision.bytes),
dsl::state.eq(rev_state),
)
})
diff --git a/frontend/rust-lib/flowy-revision/src/conflict_resolve.rs b/frontend/rust-lib/flowy-revision/src/conflict_resolve.rs
index 51e37a363c..d51e503a59 100644
--- a/frontend/rust-lib/flowy-revision/src/conflict_resolve.rs
+++ b/frontend/rust-lib/flowy-revision/src/conflict_resolve.rs
@@ -6,23 +6,23 @@ use flowy_sync::{
revision::{RepeatedRevision, Revision, RevisionRange},
ws_data::ServerRevisionWSDataType,
},
- util::make_delta_from_revisions,
+ util::make_operations_from_revisions,
};
use lib_infra::future::BoxResultFuture;
-use lib_ot::core::{Attributes, EmptyAttributes, OperationAttributes, Operations};
+use lib_ot::core::{AttributeHashMap, DeltaOperations, EmptyAttributes, OperationAttributes};
use serde::de::DeserializeOwned;
use std::{convert::TryFrom, sync::Arc};
-pub type DeltaMD5 = String;
+pub type OperationsMD5 = String;
pub trait ConflictResolver<T>
where
T: OperationAttributes + Send + Sync,
{
- fn compose_delta(&self, delta: Operations<T>) -> BoxResultFuture<DeltaMD5, FlowyError>;
- fn transform_delta(&self, delta: Operations<T>) -> BoxResultFuture<TransformDeltas<T>, FlowyError>;
- fn reset_delta(&self, delta: Operations<T>) -> BoxResultFuture<DeltaMD5, FlowyError>;
+ fn compose_delta(&self, delta: DeltaOperations<T>) -> BoxResultFuture<OperationsMD5, FlowyError>;
+ fn transform_delta(&self, delta: DeltaOperations<T>) -> BoxResultFuture<TransformDeltas<T>, FlowyError>;
+ fn reset_delta(&self, delta: DeltaOperations<T>) -> BoxResultFuture<OperationsMD5, FlowyError>;
}
pub trait ConflictRevisionSink: Send + Sync + 'static {
@@ -30,7 +30,7 @@ pub trait ConflictRevisionSink: Send + Sync + 'static {
fn ack(&self, rev_id: String, ty: ServerRevisionWSDataType) -> BoxResultFuture<(), FlowyError>;
}
-pub type RichTextConflictController = ConflictController<Attributes>;
+pub type RichTextConflictController = ConflictController<AttributeHashMap>;
pub type PlainTextConflictController = ConflictController<EmptyAttributes>;
pub struct ConflictController<T>
@@ -103,7 +103,7 @@ where
}
}
- let new_delta = make_delta_from_revisions(revisions.clone())?;
+ let new_delta = make_operations_from_revisions(revisions.clone())?;
let TransformDeltas {
client_prime,
@@ -142,8 +142,8 @@ where
fn make_client_and_server_revision<T>(
user_id: &str,
rev_manager: &Arc<RevisionManager>,
- client_delta: Operations<T>,
- server_delta: Option<Operations<T>>,
+ client_delta: DeltaOperations<T>,
+ server_delta: Option<DeltaOperations<T>>,
md5: String,
) -> (Revision, Option<Revision>)
where
@@ -175,12 +175,12 @@ where
}
}
-pub type RichTextTransformDeltas = TransformDeltas<Attributes>;
+pub type RichTextTransformDeltas = TransformDeltas<AttributeHashMap>;
pub struct TransformDeltas<T>
where
T: OperationAttributes,
{
- pub client_prime: Operations<T>,
- pub server_prime: Option<Operations<T>>,
+ pub client_prime: DeltaOperations<T>,
+ pub server_prime: Option<DeltaOperations<T>>,
}
diff --git a/frontend/rust-lib/flowy-revision/src/rev_manager.rs b/frontend/rust-lib/flowy-revision/src/rev_manager.rs
index bd4d01740d..73592cad85 100644
--- a/frontend/rust-lib/flowy-revision/src/rev_manager.rs
+++ b/frontend/rust-lib/flowy-revision/src/rev_manager.rs
@@ -9,6 +9,8 @@ use flowy_sync::{
use lib_infra::future::FutureResult;
use std::sync::Arc;
+pub type SyncObject = lib_ot::text_delta::TextOperations;
+
pub trait RevisionCloudService: Send + Sync {
fn fetch_object(&self, user_id: &str, object_id: &str) -> FutureResult<Vec<Revision>, FlowyError>;
}
@@ -33,8 +35,8 @@ pub trait RevisionCompactor: Send + Sync {
let (base_rev_id, rev_id) = first_revision.pair_rev_id();
let md5 = last_revision.md5.clone();
- let delta_data = self.bytes_from_revisions(revisions)?;
- Ok(Revision::new(object_id, base_rev_id, rev_id, delta_data, user_id, md5))
+ let bytes = self.bytes_from_revisions(revisions)?;
+ Ok(Revision::new(object_id, base_rev_id, rev_id, bytes, user_id, md5))
}
fn bytes_from_revisions(&self, revisions: Vec<Revision>) -> FlowyResult<Bytes>;
@@ -113,7 +115,7 @@ impl RevisionManager {
#[tracing::instrument(level = "debug", skip(self, revision), err)]
pub async fn add_remote_revision(&self, revision: &Revision) -> Result<(), FlowyError> {
- if revision.delta_data.is_empty() {
+ if revision.bytes.is_empty() {
return Err(FlowyError::internal().context("Delta data should be empty"));
}
@@ -125,7 +127,7 @@ impl RevisionManager {
#[tracing::instrument(level = "debug", skip_all, err)]
pub async fn add_local_revision(&self, revision: &Revision) -> Result<(), FlowyError> {
- if revision.delta_data.is_empty() {
+ if revision.bytes.is_empty() {
return Err(FlowyError::internal().context("Delta data should be empty"));
}
let rev_id = self
diff --git a/frontend/rust-lib/flowy-sdk/src/deps_resolve/folder_deps.rs b/frontend/rust-lib/flowy-sdk/src/deps_resolve/folder_deps.rs
index f9eac21ba0..c2730afe4e 100644
--- a/frontend/rust-lib/flowy-sdk/src/deps_resolve/folder_deps.rs
+++ b/frontend/rust-lib/flowy-sdk/src/deps_resolve/folder_deps.rs
@@ -16,7 +16,7 @@ use flowy_net::{
http_server::folder::FolderHttpCloudService, local_server::LocalServer, ws::connection::FlowyWebSocketConnect,
};
use flowy_revision::{RevisionWebSocket, WSStateReceiver};
-use flowy_sync::client_document::default::initial_quill_delta_string;
+use flowy_sync::client_document::default::initial_document_str;
use flowy_sync::entities::revision::{RepeatedRevision, Revision};
use flowy_sync::entities::ws_data::ClientRevisionWSData;
use flowy_text_block::TextEditorManager;
@@ -191,7 +191,7 @@ impl ViewDataProcessor for TextBlockViewDataProcessor {
let view_id = view_id.to_string();
let manager = self.0.clone();
FutureResult::new(async move {
- let view_data = initial_quill_delta_string();
+ let view_data = initial_document_str();
let delta_data = Bytes::from(view_data);
let repeated_revision: RepeatedRevision =
Revision::initial_revision(&user_id, &view_id, delta_data.clone()).into();
diff --git a/frontend/rust-lib/flowy-text-block/src/editor.rs b/frontend/rust-lib/flowy-text-block/src/editor.rs
index 8698cebc7f..6e57b281f5 100644
--- a/frontend/rust-lib/flowy-text-block/src/editor.rs
+++ b/frontend/rust-lib/flowy-text-block/src/editor.rs
@@ -11,12 +11,12 @@ use flowy_sync::entities::ws_data::ServerRevisionWSData;
use flowy_sync::{
entities::{revision::Revision, text_block::DocumentPB},
errors::CollaborateResult,
- util::make_delta_from_revisions,
+ util::make_operations_from_revisions,
};
use lib_ot::core::AttributeEntry;
use lib_ot::{
- core::{Interval, Operation},
- text_delta::TextDelta,
+ core::{DeltaOperation, Interval},
+ text_delta::TextOperations,
};
use lib_ws::WSConnectState;
use std::sync::Arc;
@@ -150,7 +150,7 @@ impl TextBlockEditor {
#[tracing::instrument(level = "trace", skip(self, data), err)]
pub(crate) async fn compose_local_delta(&self, data: Bytes) -> Result<(), FlowyError> {
- let delta = TextDelta::from_bytes(&data)?;
+ let delta = TextOperations::from_bytes(&data)?;
let (ret, rx) = oneshot::channel::<CollaborateResult<()>>();
let msg = EditorCommand::ComposeLocalDelta {
delta: delta.clone(),
@@ -196,7 +196,7 @@ impl std::ops::Drop for TextBlockEditor {
fn spawn_edit_queue(
user: Arc<dyn TextEditorUser>,
rev_manager: Arc<RevisionManager>,
- delta: TextDelta,
+ delta: TextOperations,
) -> EditorCommandSender {
let (sender, receiver) = mpsc::channel(1000);
let edit_queue = EditBlockQueue::new(user, rev_manager, delta, receiver);
@@ -215,8 +215,8 @@ fn spawn_edit_queue(
#[cfg(feature = "flowy_unit_test")]
impl TextBlockEditor {
- pub async fn text_block_delta(&self) -> FlowyResult<TextDelta> {
- let (ret, rx) = oneshot::channel::<CollaborateResult<TextDelta>>();
+ pub async fn text_block_delta(&self) -> FlowyResult<TextOperations> {
+ let (ret, rx) = oneshot::channel::<CollaborateResult<TextOperations>>();
let msg = EditorCommand::ReadDelta { ret };
let _ = self.edit_cmd_tx.send(msg).await;
let delta = rx.await.map_err(internal_error)??;
@@ -234,7 +234,7 @@ impl RevisionObjectBuilder for TextBlockInfoBuilder {
fn build_object(object_id: &str, revisions: Vec<Revision>) -> FlowyResult<Self::Output> {
let (base_rev_id, rev_id) = revisions.last().unwrap().pair_rev_id();
- let mut delta = make_delta_from_revisions(revisions)?;
+ let mut delta = make_operations_from_revisions(revisions)?;
correct_delta(&mut delta);
Result::<DocumentPB, FlowyError>::Ok(DocumentPB {
@@ -248,12 +248,12 @@ impl RevisionObjectBuilder for TextBlockInfoBuilder {
// quill-editor requires the delta should end with '\n' and only contains the
// insert operation. The function, correct_delta maybe be removed in the future.
-fn correct_delta(delta: &mut TextDelta) {
+fn correct_delta(delta: &mut TextOperations) {
if let Some(op) = delta.ops.last() {
let op_data = op.get_data();
if !op_data.ends_with('\n') {
tracing::warn!("The document must end with newline. Correcting it by inserting newline op");
- delta.ops.push(Operation::Insert("\n".into()));
+ delta.ops.push(DeltaOperation::Insert("\n".into()));
}
}
diff --git a/frontend/rust-lib/flowy-text-block/src/queue.rs b/frontend/rust-lib/flowy-text-block/src/queue.rs
index 510205c1ba..f6dd5f56b1 100644
--- a/frontend/rust-lib/flowy-text-block/src/queue.rs
+++ b/frontend/rust-lib/flowy-text-block/src/queue.rs
@@ -3,18 +3,18 @@ use crate::TextEditorUser;
use async_stream::stream;
use bytes::Bytes;
use flowy_error::{FlowyError, FlowyResult};
-use flowy_revision::{DeltaMD5, RevisionCompactor, RevisionManager, RichTextTransformDeltas, TransformDeltas};
-use flowy_sync::util::make_delta_from_revisions;
+use flowy_revision::{OperationsMD5, RevisionCompactor, RevisionManager, RichTextTransformDeltas, TransformDeltas};
+use flowy_sync::util::make_operations_from_revisions;
use flowy_sync::{
client_document::{history::UndoResult, ClientDocument},
entities::revision::{RevId, Revision},
errors::CollaborateError,
};
use futures::stream::StreamExt;
-use lib_ot::core::{AttributeEntry, Attributes};
+use lib_ot::core::{AttributeEntry, AttributeHashMap};
use lib_ot::{
core::{Interval, OperationTransform},
- text_delta::TextDelta,
+ text_delta::TextOperations,
};
use std::sync::Arc;
use tokio::sync::{oneshot, RwLock};
@@ -32,10 +32,10 @@ impl EditBlockQueue {
pub(crate) fn new(
user: Arc<dyn TextEditorUser>,
rev_manager: Arc<RevisionManager>,
- delta: TextDelta,
+ delta: TextOperations,
receiver: EditorCommandReceiver,
) -> Self {
- let document = Arc::new(RwLock::new(ClientDocument::from_delta(delta)));
+ let document = Arc::new(RwLock::new(ClientDocument::from_operations(delta)));
Self {
document,
user,
@@ -69,7 +69,7 @@ impl EditBlockQueue {
match command {
EditorCommand::ComposeLocalDelta { delta, ret } => {
let mut document = self.document.write().await;
- let _ = document.compose_delta(delta.clone())?;
+ let _ = document.compose_operations(delta.clone())?;
let md5 = document.md5();
drop(document);
let _ = self.save_local_delta(delta, md5).await?;
@@ -77,14 +77,14 @@ impl EditBlockQueue {
}
EditorCommand::ComposeRemoteDelta { client_delta, ret } => {
let mut document = self.document.write().await;
- let _ = document.compose_delta(client_delta.clone())?;
+ let _ = document.compose_operations(client_delta.clone())?;
let md5 = document.md5();
drop(document);
let _ = ret.send(Ok(md5));
}
EditorCommand::ResetDelta { delta, ret } => {
let mut document = self.document.write().await;
- let _ = document.set_delta(delta);
+ let _ = document.set_operations(delta);
let md5 = document.md5();
drop(document);
let _ = ret.send(Ok(md5));
@@ -92,14 +92,14 @@ impl EditBlockQueue {
EditorCommand::TransformDelta { delta, ret } => {
let f = || async {
let read_guard = self.document.read().await;
- let mut server_prime: Option<TextDelta> = None;
- let client_prime: TextDelta;
+ let mut server_prime: Option<TextOperations> = None;
+ let client_prime: TextOperations;
if read_guard.is_empty() {
// Do nothing
client_prime = delta;
} else {
- let (s_prime, c_prime) = read_guard.delta().transform(&delta)?;
+ let (s_prime, c_prime) = read_guard.get_operations().transform(&delta)?;
client_prime = c_prime;
server_prime = Some(s_prime);
}
@@ -151,31 +151,31 @@ impl EditBlockQueue {
}
EditorCommand::Undo { ret } => {
let mut write_guard = self.document.write().await;
- let UndoResult { delta } = write_guard.undo()?;
+ let UndoResult { operations: delta } = write_guard.undo()?;
let md5 = write_guard.md5();
let _ = self.save_local_delta(delta, md5).await?;
let _ = ret.send(Ok(()));
}
EditorCommand::Redo { ret } => {
let mut write_guard = self.document.write().await;
- let UndoResult { delta } = write_guard.redo()?;
+ let UndoResult { operations: delta } = write_guard.redo()?;
let md5 = write_guard.md5();
let _ = self.save_local_delta(delta, md5).await?;
let _ = ret.send(Ok(()));
}
EditorCommand::ReadDeltaStr { ret } => {
- let data = self.document.read().await.delta_str();
+ let data = self.document.read().await.get_operations_json();
let _ = ret.send(Ok(data));
}
EditorCommand::ReadDelta { ret } => {
- let delta = self.document.read().await.delta().clone();
+ let delta = self.document.read().await.get_operations().clone();
let _ = ret.send(Ok(delta));
}
}
Ok(())
}
- async fn save_local_delta(&self, delta: TextDelta, md5: String) -> Result<RevId, FlowyError> {
+ async fn save_local_delta(&self, delta: TextOperations, md5: String) -> Result<RevId, FlowyError> {
let delta_data = delta.json_bytes();
let (base_rev_id, rev_id) = self.rev_manager.next_rev_id_pair();
let user_id = self.user.user_id()?;
@@ -195,7 +195,7 @@ impl EditBlockQueue {
pub(crate) struct TextBlockRevisionCompactor();
impl RevisionCompactor for TextBlockRevisionCompactor {
fn bytes_from_revisions(&self, revisions: Vec<Revision>) -> FlowyResult<Bytes> {
- let delta = make_delta_from_revisions::<Attributes>(revisions)?;
+ let delta = make_operations_from_revisions::<AttributeHashMap>(revisions)?;
Ok(delta.json_bytes())
}
}
@@ -204,19 +204,19 @@ pub(crate) type Ret<T> = oneshot::Sender<Result<T, CollaborateError>>;
pub(crate) enum EditorCommand {
ComposeLocalDelta {
- delta: TextDelta,
+ delta: TextOperations,
ret: Ret<()>,
},
ComposeRemoteDelta {
- client_delta: TextDelta,
- ret: Ret<DeltaMD5>,
+ client_delta: TextOperations,
+ ret: Ret<OperationsMD5>,
},
ResetDelta {
- delta: TextDelta,
- ret: Ret<DeltaMD5>,
+ delta: TextOperations,
+ ret: Ret<OperationsMD5>,
},
TransformDelta {
- delta: TextDelta,
+ delta: TextOperations,
ret: Ret<RichTextTransformDeltas>,
},
Insert {
@@ -255,7 +255,7 @@ pub(crate) enum EditorCommand {
},
#[allow(dead_code)]
ReadDelta {
- ret: Ret<TextDelta>,
+ ret: Ret<TextOperations>,
},
}
diff --git a/frontend/rust-lib/flowy-text-block/src/web_socket.rs b/frontend/rust-lib/flowy-text-block/src/web_socket.rs
index 06b2791664..742962dd4d 100644
--- a/frontend/rust-lib/flowy-text-block/src/web_socket.rs
+++ b/frontend/rust-lib/flowy-text-block/src/web_socket.rs
@@ -10,9 +10,9 @@ use flowy_sync::{
errors::CollaborateResult,
};
use lib_infra::future::{BoxResultFuture, FutureResult};
-use lib_ot::core::Attributes;
+use lib_ot::core::AttributeHashMap;
-use lib_ot::text_delta::TextDelta;
+use lib_ot::text_delta::TextOperations;
use lib_ws::WSConnectState;
use std::{sync::Arc, time::Duration};
use tokio::sync::{
@@ -112,8 +112,8 @@ struct TextBlockConflictResolver {
edit_cmd_tx: EditorCommandSender,
}
-impl ConflictResolver<Attributes> for TextBlockConflictResolver {
- fn compose_delta(&self, delta: TextDelta) -> BoxResultFuture<DeltaMD5, FlowyError> {
+impl ConflictResolver<AttributeHashMap> for TextBlockConflictResolver {
+ fn compose_delta(&self, delta: TextOperations) -> BoxResultFuture<OperationsMD5, FlowyError> {
let tx = self.edit_cmd_tx.clone();
Box::pin(async move {
let (ret, rx) = oneshot::channel();
@@ -132,7 +132,7 @@ impl ConflictResolver<Attributes> for TextBlockConflictResolver {
fn transform_delta(
&self,
- delta: TextDelta,
+ delta: TextOperations,
) -> BoxResultFuture<flowy_revision::RichTextTransformDeltas, FlowyError> {
let tx = self.edit_cmd_tx.clone();
Box::pin(async move {
@@ -147,7 +147,7 @@ impl ConflictResolver<Attributes> for TextBlockConflictResolver {
})
}
- fn reset_delta(&self, delta: TextDelta) -> BoxResultFuture<DeltaMD5, FlowyError> {
+ fn reset_delta(&self, delta: TextOperations) -> BoxResultFuture<OperationsMD5, FlowyError> {
let tx = self.edit_cmd_tx.clone();
Box::pin(async move {
let (ret, rx) = oneshot::channel();
diff --git a/frontend/rust-lib/flowy-text-block/tests/document/script.rs b/frontend/rust-lib/flowy-text-block/tests/document/script.rs
index ae3209020a..8157debd16 100644
--- a/frontend/rust-lib/flowy-text-block/tests/document/script.rs
+++ b/frontend/rust-lib/flowy-text-block/tests/document/script.rs
@@ -2,7 +2,7 @@ use flowy_revision::disk::RevisionState;
use flowy_test::{helper::ViewTest, FlowySDKTest};
use flowy_text_block::editor::TextBlockEditor;
use flowy_text_block::TEXT_BLOCK_SYNC_INTERVAL_IN_MILLIS;
-use lib_ot::{core::Interval, text_delta::TextDelta};
+use lib_ot::{core::Interval, text_delta::TextOperations};
use std::sync::Arc;
use tokio::time::{sleep, Duration};
@@ -71,7 +71,7 @@ impl TextBlockEditorTest {
assert_eq!(next_revision.rev_id, rev_id.unwrap());
}
EditorScript::AssertJson(expected) => {
- let expected_delta: TextDelta = serde_json::from_str(expected).unwrap();
+ let expected_delta: TextOperations = serde_json::from_str(expected).unwrap();
let delta = self.editor.text_block_delta().await.unwrap();
if expected_delta != delta {
eprintln!("✅ expect: {}", expected,);
diff --git a/frontend/rust-lib/flowy-text-block/tests/editor/attribute_test.rs b/frontend/rust-lib/flowy-text-block/tests/editor/attribute_test.rs
index 16dc3a69a9..44016fee15 100644
--- a/frontend/rust-lib/flowy-text-block/tests/editor/attribute_test.rs
+++ b/frontend/rust-lib/flowy-text-block/tests/editor/attribute_test.rs
@@ -3,7 +3,7 @@ use crate::editor::{TestBuilder, TestOp::*};
use flowy_sync::client_document::{NewlineDoc, EmptyDoc};
use lib_ot::core::{Interval, OperationTransform, NEW_LINE, WHITESPACE, OTString};
use unicode_segmentation::UnicodeSegmentation;
-use lib_ot::text_delta::TextDelta;
+use lib_ot::text_delta::TextOperations;
#[test]
fn attributes_bold_added() {
@@ -762,12 +762,12 @@ fn attributes_preserve_list_format_on_merge() {
#[test]
fn delta_compose() {
- let mut delta = TextDelta::from_json(r#"[{"insert":"\n"}]"#).unwrap();
+ let mut delta = TextOperations::from_json(r#"[{"insert":"\n"}]"#).unwrap();
let deltas = vec![
- TextDelta::from_json(r#"[{"retain":1,"attributes":{"list":"unchecked"}}]"#).unwrap(),
- TextDelta::from_json(r#"[{"insert":"a"}]"#).unwrap(),
- TextDelta::from_json(r#"[{"retain":1},{"insert":"\n","attributes":{"list":"unchecked"}}]"#).unwrap(),
- TextDelta::from_json(r#"[{"retain":2},{"retain":1,"attributes":{"list":""}}]"#).unwrap(),
+ TextOperations::from_json(r#"[{"retain":1,"attributes":{"list":"unchecked"}}]"#).unwrap(),
+ TextOperations::from_json(r#"[{"insert":"a"}]"#).unwrap(),
+ TextOperations::from_json(r#"[{"retain":1},{"insert":"\n","attributes":{"list":"unchecked"}}]"#).unwrap(),
+ TextOperations::from_json(r#"[{"retain":2},{"retain":1,"attributes":{"list":""}}]"#).unwrap(),
];
for d in deltas {
diff --git a/frontend/rust-lib/flowy-text-block/tests/editor/mod.rs b/frontend/rust-lib/flowy-text-block/tests/editor/mod.rs
index c2eb30e3f4..1cce5aaeca 100644
--- a/frontend/rust-lib/flowy-text-block/tests/editor/mod.rs
+++ b/frontend/rust-lib/flowy-text-block/tests/editor/mod.rs
@@ -5,10 +5,10 @@ mod serde_test;
mod undo_redo_test;
use derive_more::Display;
-use flowy_sync::client_document::{ClientDocument, InitialDocumentText};
+use flowy_sync::client_document::{ClientDocument, InitialDocumentContent};
use lib_ot::{
core::*,
- text_delta::{BuildInTextAttribute, TextDelta},
+ text_delta::{BuildInTextAttribute, TextOperations},
};
use rand::{prelude::*, Rng as WrappedRng};
use std::{sync::Once, time::Duration};
@@ -81,8 +81,8 @@ pub enum TestOp {
pub struct TestBuilder {
documents: Vec<ClientDocument>,
- deltas: Vec<Option<TextDelta>>,
- primes: Vec<Option<TextDelta>>,
+ deltas: Vec<Option<TextOperations>>,
+ primes: Vec<Option<TextOperations>>,
}
impl TestBuilder {
@@ -169,29 +169,29 @@ impl TestBuilder {
}
TestOp::Transform(delta_a_i, delta_b_i) => {
let (a_prime, b_prime) = self.documents[*delta_a_i]
- .delta()
- .transform(self.documents[*delta_b_i].delta())
+ .get_operations()
+ .transform(self.documents[*delta_b_i].get_operations())
.unwrap();
tracing::trace!("a:{:?},b:{:?}", a_prime, b_prime);
- let data_left = self.documents[*delta_a_i].delta().compose(&b_prime).unwrap();
- let data_right = self.documents[*delta_b_i].delta().compose(&a_prime).unwrap();
+ let data_left = self.documents[*delta_a_i].get_operations().compose(&b_prime).unwrap();
+ let data_right = self.documents[*delta_b_i].get_operations().compose(&a_prime).unwrap();
- self.documents[*delta_a_i].set_delta(data_left);
- self.documents[*delta_b_i].set_delta(data_right);
+ self.documents[*delta_a_i].set_operations(data_left);
+ self.documents[*delta_b_i].set_operations(data_right);
}
TestOp::TransformPrime(a_doc_index, b_doc_index) => {
let (prime_left, prime_right) = self.documents[*a_doc_index]
- .delta()
- .transform(self.documents[*b_doc_index].delta())
+ .get_operations()
+ .transform(self.documents[*b_doc_index].get_operations())
.unwrap();
self.primes.insert(*a_doc_index, Some(prime_left));
self.primes.insert(*b_doc_index, Some(prime_right));
}
TestOp::Invert(delta_a_i, delta_b_i) => {
- let delta_a = &self.documents[*delta_a_i].delta();
- let delta_b = &self.documents[*delta_b_i].delta();
+ let delta_a = &self.documents[*delta_a_i].get_operations();
+ let delta_b = &self.documents[*delta_b_i].get_operations();
tracing::debug!("Invert: ");
tracing::debug!("a: {}", delta_a.json_str());
tracing::debug!("b: {}", delta_b.json_str());
@@ -209,7 +209,7 @@ impl TestBuilder {
assert_eq!(delta_a, &&new_delta_after_undo);
- self.documents[*delta_a_i].set_delta(new_delta_after_undo);
+ self.documents[*delta_a_i].set_operations(new_delta_after_undo);
}
TestOp::Undo(delta_i) => {
self.documents[*delta_i].undo().unwrap();
@@ -221,13 +221,13 @@ impl TestBuilder {
std::thread::sleep(Duration::from_millis(*mills_sec as u64));
}
TestOp::AssertStr(delta_i, expected) => {
- assert_eq!(&self.documents[*delta_i].to_plain_string(), expected);
+ assert_eq!(&self.documents[*delta_i].to_content(), expected);
}
TestOp::AssertDocJson(delta_i, expected) => {
- let delta_json = self.documents[*delta_i].delta_str();
- let expected_delta: TextDelta = serde_json::from_str(expected).unwrap();
- let target_delta: TextDelta = serde_json::from_str(&delta_json).unwrap();
+ let delta_json = self.documents[*delta_i].get_operations_json();
+ let expected_delta: TextOperations = serde_json::from_str(expected).unwrap();
+ let target_delta: TextOperations = serde_json::from_str(&delta_json).unwrap();
if expected_delta != target_delta {
log::error!("✅ expect: {}", expected,);
@@ -238,8 +238,8 @@ impl TestBuilder {
TestOp::AssertPrimeJson(doc_i, expected) => {
let prime_json = self.primes[*doc_i].as_ref().unwrap().json_str();
- let expected_prime: TextDelta = serde_json::from_str(expected).unwrap();
- let target_prime: TextDelta = serde_json::from_str(&prime_json).unwrap();
+ let expected_prime: TextOperations = serde_json::from_str(expected).unwrap();
+ let target_prime: TextOperations = serde_json::from_str(&prime_json).unwrap();
if expected_prime != target_prime {
log::error!("✅ expect prime: {}", expected,);
@@ -249,7 +249,7 @@ impl TestBuilder {
}
TestOp::DocComposeDelta(doc_index, delta_i) => {
let delta = self.deltas.get(*delta_i).unwrap().as_ref().unwrap();
- self.documents[*doc_index].compose_delta(delta.clone()).unwrap();
+ self.documents[*doc_index].compose_operations(delta.clone()).unwrap();
}
TestOp::DocComposePrime(doc_index, prime_i) => {
let delta = self
@@ -258,13 +258,13 @@ impl TestBuilder {
.expect("Must call TransformPrime first")
.as_ref()
.unwrap();
- let new_delta = self.documents[*doc_index].delta().compose(delta).unwrap();
- self.documents[*doc_index].set_delta(new_delta);
+ let new_delta = self.documents[*doc_index].get_operations().compose(delta).unwrap();
+ self.documents[*doc_index].set_operations(new_delta);
}
}
}
- pub fn run_scripts<C: InitialDocumentText>(mut self, scripts: Vec<TestOp>) {
+ pub fn run_scripts<C: InitialDocumentContent>(mut self, scripts: Vec<TestOp>) {
self.documents = vec![ClientDocument::new::<C>(), ClientDocument::new::<C>()];
self.primes = vec![None, None];
self.deltas = vec![None, None];
@@ -297,8 +297,8 @@ impl Rng {
.collect()
}
- pub fn gen_delta(&mut self, s: &str) -> TextDelta {
- let mut delta = TextDelta::default();
+ pub fn gen_delta(&mut self, s: &str) -> TextOperations {
+ let mut delta = TextOperations::default();
let s = OTString::from(s);
loop {
let left = s.utf16_len() - delta.utf16_base_len;
@@ -312,18 +312,18 @@ impl Rng {
};
match self.0.gen_range(0.0..1.0) {
f if f < 0.2 => {
- delta.insert(&self.gen_string(i), Attributes::default());
+ delta.insert(&self.gen_string(i), AttributeHashMap::default());
}
f if f < 0.4 => {
delta.delete(i);
}
_ => {
- delta.retain(i, Attributes::default());
+ delta.retain(i, AttributeHashMap::default());
}
}
}
if self.0.gen_range(0.0..1.0) < 0.3 {
- delta.insert(&("1".to_owned() + &self.gen_string(10)), Attributes::default());
+ delta.insert(&("1".to_owned() + &self.gen_string(10)), AttributeHashMap::default());
}
delta
}
diff --git a/frontend/rust-lib/flowy-text-block/tests/editor/op_test.rs b/frontend/rust-lib/flowy-text-block/tests/editor/op_test.rs
index 3676bce207..df1320ca51 100644
--- a/frontend/rust-lib/flowy-text-block/tests/editor/op_test.rs
+++ b/frontend/rust-lib/flowy-text-block/tests/editor/op_test.rs
@@ -1,8 +1,8 @@
#![allow(clippy::all)]
use crate::editor::{Rng, TestBuilder, TestOp::*};
use flowy_sync::client_document::{EmptyDoc, NewlineDoc};
-use lib_ot::text_delta::TextDeltaBuilder;
-use lib_ot::{core::Interval, core::*, text_delta::TextDelta};
+use lib_ot::text_delta::TextOperationBuilder;
+use lib_ot::{core::Interval, core::*, text_delta::TextOperations};
#[test]
fn attributes_insert_text() {
@@ -37,7 +37,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 = TextDeltaBuilder::from_operations(operations);
+ let delta = TextOperationBuilder::from_operations(operations);
let mut iterator = OperationIterator::from_interval(&delta, Interval::new(0, 4));
assert_eq!(iterator.ops(), delta.ops);
@@ -45,11 +45,11 @@ fn delta_get_ops_in_interval_1() {
#[test]
fn delta_get_ops_in_interval_2() {
- let mut delta = TextDelta::default();
- let insert_a = Operation::insert("123");
- let insert_b = Operation::insert("4");
- let insert_c = Operation::insert("5");
- let retain_a = Operation::retain(3);
+ let mut delta = TextOperations::default();
+ let insert_a = DeltaOperation::insert("123");
+ let insert_b = DeltaOperation::insert("4");
+ let insert_c = DeltaOperation::insert("5");
+ let retain_a = DeltaOperation::retain(3);
delta.add(insert_a.clone());
delta.add(retain_a.clone());
@@ -58,12 +58,12 @@ fn delta_get_ops_in_interval_2() {
assert_eq!(
OperationIterator::from_interval(&delta, Interval::new(0, 2)).ops(),
- vec![Operation::insert("12")]
+ vec![DeltaOperation::insert("12")]
);
assert_eq!(
OperationIterator::from_interval(&delta, Interval::new(1, 3)).ops(),
- vec![Operation::insert("23")]
+ vec![DeltaOperation::insert("23")]
);
assert_eq!(
@@ -73,7 +73,7 @@ fn delta_get_ops_in_interval_2() {
assert_eq!(
OperationIterator::from_interval(&delta, Interval::new(0, 4)).ops(),
- vec![insert_a.clone(), Operation::retain(1)]
+ vec![insert_a.clone(), DeltaOperation::retain(1)]
);
assert_eq!(
@@ -89,21 +89,21 @@ fn delta_get_ops_in_interval_2() {
#[test]
fn delta_get_ops_in_interval_3() {
- let mut delta = TextDelta::default();
- let insert_a = Operation::insert("123456");
+ let mut delta = TextOperations::default();
+ let insert_a = DeltaOperation::insert("123456");
delta.add(insert_a.clone());
assert_eq!(
OperationIterator::from_interval(&delta, Interval::new(3, 5)).ops(),
- vec![Operation::insert("45")]
+ vec![DeltaOperation::insert("45")]
);
}
#[test]
fn delta_get_ops_in_interval_4() {
- let mut delta = TextDelta::default();
- let insert_a = Operation::insert("12");
- let insert_b = Operation::insert("34");
- let insert_c = Operation::insert("56");
+ let mut delta = TextOperations::default();
+ let insert_a = DeltaOperation::insert("12");
+ let insert_b = DeltaOperation::insert("34");
+ let insert_c = DeltaOperation::insert("56");
delta.ops.push(insert_a.clone());
delta.ops.push(insert_b.clone());
@@ -124,20 +124,20 @@ fn delta_get_ops_in_interval_4() {
assert_eq!(
OperationIterator::from_interval(&delta, Interval::new(2, 5)).ops(),
- vec![Operation::insert("34"), Operation::insert("5")]
+ vec![DeltaOperation::insert("34"), DeltaOperation::insert("5")]
);
}
#[test]
fn delta_get_ops_in_interval_5() {
- let mut delta = TextDelta::default();
- let insert_a = Operation::insert("123456");
- let insert_b = Operation::insert("789");
+ let mut delta = TextOperations::default();
+ let insert_a = DeltaOperation::insert("123456");
+ let insert_b = DeltaOperation::insert("789");
delta.ops.push(insert_a.clone());
delta.ops.push(insert_b.clone());
assert_eq!(
OperationIterator::from_interval(&delta, Interval::new(4, 8)).ops(),
- vec![Operation::insert("56"), Operation::insert("78")]
+ vec![DeltaOperation::insert("56"), DeltaOperation::insert("78")]
);
// assert_eq!(
@@ -148,40 +148,40 @@ fn delta_get_ops_in_interval_5() {
#[test]
fn delta_get_ops_in_interval_6() {
- let mut delta = TextDelta::default();
- let insert_a = Operation::insert("12345678");
+ let mut delta = TextOperations::default();
+ let insert_a = DeltaOperation::insert("12345678");
delta.add(insert_a.clone());
assert_eq!(
OperationIterator::from_interval(&delta, Interval::new(4, 6)).ops(),
- vec![Operation::insert("56")]
+ vec![DeltaOperation::insert("56")]
);
}
#[test]
fn delta_get_ops_in_interval_7() {
- let mut delta = TextDelta::default();
- let insert_a = Operation::insert("12345");
- let retain_a = Operation::retain(3);
+ let mut delta = TextOperations::default();
+ let insert_a = DeltaOperation::insert("12345");
+ let retain_a = DeltaOperation::retain(3);
delta.add(insert_a.clone());
delta.add(retain_a.clone());
let mut iter_1 = OperationIterator::from_offset(&delta, 2);
- assert_eq!(iter_1.next_op().unwrap(), Operation::insert("345"));
- assert_eq!(iter_1.next_op().unwrap(), Operation::retain(3));
+ assert_eq!(iter_1.next_op().unwrap(), DeltaOperation::insert("345"));
+ assert_eq!(iter_1.next_op().unwrap(), DeltaOperation::retain(3));
let mut iter_2 = OperationIterator::new(&delta);
- assert_eq!(iter_2.next_op_with_len(2).unwrap(), Operation::insert("12"));
- assert_eq!(iter_2.next_op().unwrap(), Operation::insert("345"));
+ assert_eq!(iter_2.next_op_with_len(2).unwrap(), DeltaOperation::insert("12"));
+ assert_eq!(iter_2.next_op().unwrap(), DeltaOperation::insert("345"));
- assert_eq!(iter_2.next_op().unwrap(), Operation::retain(3));
+ assert_eq!(iter_2.next_op().unwrap(), DeltaOperation::retain(3));
}
#[test]
fn delta_op_seek() {
- let mut delta = TextDelta::default();
- let insert_a = Operation::insert("12345");
- let retain_a = Operation::retain(3);
+ let mut delta = TextOperations::default();
+ let insert_a = DeltaOperation::insert("12345");
+ let retain_a = DeltaOperation::retain(3);
delta.add(insert_a.clone());
delta.add(retain_a.clone());
let mut iter = OperationIterator::new(&delta);
@@ -191,92 +191,92 @@ fn delta_op_seek() {
#[test]
fn delta_utf16_code_unit_seek() {
- let mut delta = TextDelta::default();
- delta.add(Operation::insert("12345"));
+ let mut delta = TextOperations::default();
+ delta.add(DeltaOperation::insert("12345"));
let mut iter = OperationIterator::new(&delta);
iter.seek::<Utf16CodeUnitMetric>(3);
- assert_eq!(iter.next_op_with_len(2).unwrap(), Operation::insert("45"));
+ assert_eq!(iter.next_op_with_len(2).unwrap(), DeltaOperation::insert("45"));
}
#[test]
fn delta_utf16_code_unit_seek_with_attributes() {
- let mut delta = TextDelta::default();
+ let mut delta = TextOperations::default();
let attributes = AttributeBuilder::new()
.insert("bold", true)
.insert("italic", true)
.build();
- delta.add(Operation::insert_with_attributes("1234", attributes.clone()));
- delta.add(Operation::insert("\n"));
+ delta.add(DeltaOperation::insert_with_attributes("1234", attributes.clone()));
+ delta.add(DeltaOperation::insert("\n"));
let mut iter = OperationIterator::new(&delta);
iter.seek::<Utf16CodeUnitMetric>(0);
assert_eq!(
iter.next_op_with_len(4).unwrap(),
- Operation::insert_with_attributes("1234", attributes),
+ DeltaOperation::insert_with_attributes("1234", attributes),
);
}
#[test]
fn delta_next_op_len() {
- let mut delta = TextDelta::default();
- delta.add(Operation::insert("12345"));
+ let mut delta = TextOperations::default();
+ delta.add(DeltaOperation::insert("12345"));
let mut iter = OperationIterator::new(&delta);
- assert_eq!(iter.next_op_with_len(2).unwrap(), Operation::insert("12"));
- assert_eq!(iter.next_op_with_len(2).unwrap(), Operation::insert("34"));
- assert_eq!(iter.next_op_with_len(2).unwrap(), Operation::insert("5"));
+ assert_eq!(iter.next_op_with_len(2).unwrap(), DeltaOperation::insert("12"));
+ assert_eq!(iter.next_op_with_len(2).unwrap(), DeltaOperation::insert("34"));
+ assert_eq!(iter.next_op_with_len(2).unwrap(), DeltaOperation::insert("5"));
assert_eq!(iter.next_op_with_len(1), None);
}
#[test]
fn delta_next_op_len_with_chinese() {
- let mut delta = TextDelta::default();
- delta.add(Operation::insert("你好"));
+ let mut delta = TextOperations::default();
+ delta.add(DeltaOperation::insert("你好"));
let mut iter = OperationIterator::new(&delta);
assert_eq!(iter.next_op_len().unwrap(), 2);
- assert_eq!(iter.next_op_with_len(2).unwrap(), Operation::insert("你好"));
+ assert_eq!(iter.next_op_with_len(2).unwrap(), DeltaOperation::insert("你好"));
}
#[test]
fn delta_next_op_len_with_english() {
- let mut delta = TextDelta::default();
- delta.add(Operation::insert("ab"));
+ let mut delta = TextOperations::default();
+ delta.add(DeltaOperation::insert("ab"));
let mut iter = OperationIterator::new(&delta);
assert_eq!(iter.next_op_len().unwrap(), 2);
- assert_eq!(iter.next_op_with_len(2).unwrap(), Operation::insert("ab"));
+ assert_eq!(iter.next_op_with_len(2).unwrap(), DeltaOperation::insert("ab"));
}
#[test]
fn delta_next_op_len_after_seek() {
- let mut delta = TextDelta::default();
- delta.add(Operation::insert("12345"));
+ let mut delta = TextOperations::default();
+ delta.add(DeltaOperation::insert("12345"));
let mut iter = OperationIterator::new(&delta);
assert_eq!(iter.next_op_len().unwrap(), 5);
iter.seek::<Utf16CodeUnitMetric>(3);
assert_eq!(iter.next_op_len().unwrap(), 2);
- assert_eq!(iter.next_op_with_len(1).unwrap(), Operation::insert("4"));
+ assert_eq!(iter.next_op_with_len(1).unwrap(), DeltaOperation::insert("4"));
assert_eq!(iter.next_op_len().unwrap(), 1);
- assert_eq!(iter.next_op().unwrap(), Operation::insert("5"));
+ assert_eq!(iter.next_op().unwrap(), DeltaOperation::insert("5"));
}
#[test]
fn delta_next_op_len_none() {
- let mut delta = TextDelta::default();
- delta.add(Operation::insert("12345"));
+ let mut delta = TextOperations::default();
+ delta.add(DeltaOperation::insert("12345"));
let mut iter = OperationIterator::new(&delta);
assert_eq!(iter.next_op_len().unwrap(), 5);
- assert_eq!(iter.next_op_with_len(5).unwrap(), Operation::insert("12345"));
+ assert_eq!(iter.next_op_with_len(5).unwrap(), DeltaOperation::insert("12345"));
assert_eq!(iter.next_op_len(), None);
}
#[test]
fn delta_next_op_with_len_zero() {
- let mut delta = TextDelta::default();
- delta.add(Operation::insert("12345"));
+ let mut delta = TextOperations::default();
+ delta.add(DeltaOperation::insert("12345"));
let mut iter = OperationIterator::new(&delta);
assert_eq!(iter.next_op_with_len(0), None,);
assert_eq!(iter.next_op_len().unwrap(), 5);
@@ -284,29 +284,29 @@ fn delta_next_op_with_len_zero() {
#[test]
fn delta_next_op_with_len_cross_op_return_last() {
- let mut delta = TextDelta::default();
- delta.add(Operation::insert("12345"));
- delta.add(Operation::retain(1));
- delta.add(Operation::insert("678"));
+ let mut delta = TextOperations::default();
+ delta.add(DeltaOperation::insert("12345"));
+ delta.add(DeltaOperation::retain(1));
+ delta.add(DeltaOperation::insert("678"));
let mut iter = OperationIterator::new(&delta);
iter.seek::<Utf16CodeUnitMetric>(4);
assert_eq!(iter.next_op_len().unwrap(), 1);
- assert_eq!(iter.next_op_with_len(2).unwrap(), Operation::retain(1));
+ assert_eq!(iter.next_op_with_len(2).unwrap(), DeltaOperation::retain(1));
}
#[test]
fn lengths() {
- let mut delta = TextDelta::default();
+ let mut delta = TextOperations::default();
assert_eq!(delta.utf16_base_len, 0);
assert_eq!(delta.utf16_target_len, 0);
- delta.retain(5, Attributes::default());
+ delta.retain(5, AttributeHashMap::default());
assert_eq!(delta.utf16_base_len, 5);
assert_eq!(delta.utf16_target_len, 5);
- delta.insert("abc", Attributes::default());
+ delta.insert("abc", AttributeHashMap::default());
assert_eq!(delta.utf16_base_len, 5);
assert_eq!(delta.utf16_target_len, 8);
- delta.retain(2, Attributes::default());
+ delta.retain(2, AttributeHashMap::default());
assert_eq!(delta.utf16_base_len, 7);
assert_eq!(delta.utf16_target_len, 10);
delta.delete(2);
@@ -315,11 +315,11 @@ fn lengths() {
}
#[test]
fn sequence() {
- let mut delta = TextDelta::default();
- delta.retain(5, Attributes::default());
- delta.retain(0, Attributes::default());
- delta.insert("appflowy", Attributes::default());
- delta.insert("", Attributes::default());
+ let mut delta = TextOperations::default();
+ delta.retain(5, AttributeHashMap::default());
+ delta.retain(0, AttributeHashMap::default());
+ delta.insert("appflowy", AttributeHashMap::default());
+ delta.insert("", AttributeHashMap::default());
delta.delete(3);
delta.delete(0);
assert_eq!(delta.ops.len(), 3);
@@ -348,16 +348,16 @@ fn apply_test() {
#[test]
fn base_len_test() {
- let mut delta_a = TextDelta::default();
- delta_a.insert("a", Attributes::default());
- delta_a.insert("b", Attributes::default());
- delta_a.insert("c", Attributes::default());
+ let mut delta_a = TextOperations::default();
+ delta_a.insert("a", AttributeHashMap::default());
+ delta_a.insert("b", AttributeHashMap::default());
+ delta_a.insert("c", AttributeHashMap::default());
let s = "hello world,".to_owned();
delta_a.delete(s.len());
let after_a = delta_a.apply(&s).unwrap();
- delta_a.insert("d", Attributes::default());
+ delta_a.insert("d", AttributeHashMap::default());
assert_eq!("abc", &after_a);
}
@@ -387,62 +387,62 @@ fn invert_test() {
#[test]
fn empty_ops() {
- let mut delta = TextDelta::default();
- delta.retain(0, Attributes::default());
- delta.insert("", Attributes::default());
+ let mut delta = TextOperations::default();
+ delta.retain(0, AttributeHashMap::default());
+ delta.insert("", AttributeHashMap::default());
delta.delete(0);
assert_eq!(delta.ops.len(), 0);
}
#[test]
fn eq() {
- let mut delta_a = TextDelta::default();
+ let mut delta_a = TextOperations::default();
delta_a.delete(1);
- delta_a.insert("lo", Attributes::default());
- delta_a.retain(2, Attributes::default());
- delta_a.retain(3, Attributes::default());
- let mut delta_b = TextDelta::default();
+ delta_a.insert("lo", AttributeHashMap::default());
+ delta_a.retain(2, AttributeHashMap::default());
+ delta_a.retain(3, AttributeHashMap::default());
+ let mut delta_b = TextOperations::default();
delta_b.delete(1);
- delta_b.insert("l", Attributes::default());
- delta_b.insert("o", Attributes::default());
- delta_b.retain(5, Attributes::default());
+ delta_b.insert("l", AttributeHashMap::default());
+ delta_b.insert("o", AttributeHashMap::default());
+ delta_b.retain(5, AttributeHashMap::default());
assert_eq!(delta_a, delta_b);
delta_a.delete(1);
- delta_b.retain(1, Attributes::default());
+ delta_b.retain(1, AttributeHashMap::default());
assert_ne!(delta_a, delta_b);
}
#[test]
fn ops_merging() {
- let mut delta = TextDelta::default();
+ let mut delta = TextOperations::default();
assert_eq!(delta.ops.len(), 0);
- delta.retain(2, Attributes::default());
+ delta.retain(2, AttributeHashMap::default());
assert_eq!(delta.ops.len(), 1);
- assert_eq!(delta.ops.last(), Some(&Operation::retain(2)));
- delta.retain(3, Attributes::default());
+ assert_eq!(delta.ops.last(), Some(&DeltaOperation::retain(2)));
+ delta.retain(3, AttributeHashMap::default());
assert_eq!(delta.ops.len(), 1);
- assert_eq!(delta.ops.last(), Some(&Operation::retain(5)));
- delta.insert("abc", Attributes::default());
+ assert_eq!(delta.ops.last(), Some(&DeltaOperation::retain(5)));
+ delta.insert("abc", AttributeHashMap::default());
assert_eq!(delta.ops.len(), 2);
- assert_eq!(delta.ops.last(), Some(&Operation::insert("abc")));
- delta.insert("xyz", Attributes::default());
+ assert_eq!(delta.ops.last(), Some(&DeltaOperation::insert("abc")));
+ delta.insert("xyz", AttributeHashMap::default());
assert_eq!(delta.ops.len(), 2);
- assert_eq!(delta.ops.last(), Some(&Operation::insert("abcxyz")));
+ assert_eq!(delta.ops.last(), Some(&DeltaOperation::insert("abcxyz")));
delta.delete(1);
assert_eq!(delta.ops.len(), 3);
- assert_eq!(delta.ops.last(), Some(&Operation::delete(1)));
+ assert_eq!(delta.ops.last(), Some(&DeltaOperation::delete(1)));
delta.delete(1);
assert_eq!(delta.ops.len(), 3);
- assert_eq!(delta.ops.last(), Some(&Operation::delete(2)));
+ assert_eq!(delta.ops.last(), Some(&DeltaOperation::delete(2)));
}
#[test]
fn is_noop() {
- let mut delta = TextDelta::default();
+ let mut delta = TextOperations::default();
assert!(delta.is_noop());
- delta.retain(5, Attributes::default());
+ delta.retain(5, AttributeHashMap::default());
assert!(delta.is_noop());
- delta.retain(3, Attributes::default());
+ delta.retain(3, AttributeHashMap::default());
assert!(delta.is_noop());
- delta.insert("lorem", Attributes::default());
+ delta.insert("lorem", AttributeHashMap::default());
assert!(!delta.is_noop());
}
#[test]
@@ -484,15 +484,15 @@ fn transform_random_delta() {
#[test]
fn transform_with_two_delta() {
- let mut a = TextDelta::default();
+ let mut a = TextOperations::default();
let mut a_s = String::new();
a.insert("123", AttributeBuilder::new().insert("bold", true).build());
a_s = a.apply(&a_s).unwrap();
assert_eq!(&a_s, "123");
- let mut b = TextDelta::default();
+ let mut b = TextOperations::default();
let mut b_s = String::new();
- b.insert("456", Attributes::default());
+ b.insert("456", AttributeHashMap::default());
b_s = b.apply(&b_s).unwrap();
assert_eq!(&b_s, "456");
@@ -580,12 +580,12 @@ fn transform_two_conflict_non_seq_delta() {
#[test]
fn delta_invert_no_attribute_delta() {
- let mut delta = TextDelta::default();
- delta.add(Operation::insert("123"));
+ let mut delta = TextOperations::default();
+ delta.add(DeltaOperation::insert("123"));
- let mut change = TextDelta::default();
- change.add(Operation::retain(3));
- change.add(Operation::insert("456"));
+ let mut change = TextOperations::default();
+ change.add(DeltaOperation::retain(3));
+ change.add(DeltaOperation::insert("456"));
let undo = change.invert(&delta);
let new_delta = delta.compose(&change).unwrap();
diff --git a/frontend/rust-lib/flowy-text-block/tests/editor/serde_test.rs b/frontend/rust-lib/flowy-text-block/tests/editor/serde_test.rs
index 3609f90fff..1553530668 100644
--- a/frontend/rust-lib/flowy-text-block/tests/editor/serde_test.rs
+++ b/frontend/rust-lib/flowy-text-block/tests/editor/serde_test.rs
@@ -2,7 +2,7 @@ use flowy_sync::client_document::{ClientDocument, EmptyDoc};
use lib_ot::text_delta::TextOperation;
use lib_ot::{
core::*,
- text_delta::{BuildInTextAttribute, TextDelta},
+ text_delta::{BuildInTextAttribute, TextOperations},
};
#[test]
@@ -11,7 +11,7 @@ fn operation_insert_serialize_test() {
.insert("bold", true)
.insert("italic", true)
.build();
- let operation = Operation::insert_with_attributes("123", attributes);
+ let operation = DeltaOperation::insert_with_attributes("123", attributes);
let json = serde_json::to_string(&operation).unwrap();
eprintln!("{}", json);
@@ -21,7 +21,7 @@ fn operation_insert_serialize_test() {
#[test]
fn operation_retain_serialize_test() {
- let operation = Operation::Retain(12.into());
+ let operation = DeltaOperation::Retain(12.into());
let json = serde_json::to_string(&operation).unwrap();
eprintln!("{}", json);
let insert_op: TextOperation = serde_json::from_str(&json).unwrap();
@@ -42,7 +42,7 @@ fn attributes_serialize_test() {
.insert_entry(BuildInTextAttribute::Bold(true))
.insert_entry(BuildInTextAttribute::Italic(true))
.build();
- let retain = Operation::insert_with_attributes("123", attributes);
+ let retain = DeltaOperation::insert_with_attributes("123", attributes);
let json = serde_json::to_string(&retain).unwrap();
eprintln!("{}", json);
@@ -50,22 +50,22 @@ fn attributes_serialize_test() {
#[test]
fn delta_serialize_multi_attribute_test() {
- let mut delta = Operations::default();
+ let mut delta = DeltaOperations::default();
let attributes = AttributeBuilder::new()
.insert_entry(BuildInTextAttribute::Bold(true))
.insert_entry(BuildInTextAttribute::Italic(true))
.build();
- let retain = Operation::insert_with_attributes("123", attributes);
+ let retain = DeltaOperation::insert_with_attributes("123", attributes);
delta.add(retain);
- delta.add(Operation::Retain(5.into()));
- delta.add(Operation::Delete(3));
+ delta.add(DeltaOperation::Retain(5.into()));
+ delta.add(DeltaOperation::Delete(3));
let json = serde_json::to_string(&delta).unwrap();
eprintln!("{}", json);
- let delta_from_json = Operations::from_json(&json).unwrap();
+ let delta_from_json = DeltaOperations::from_json(&json).unwrap();
assert_eq!(delta_from_json, delta);
}
@@ -77,7 +77,7 @@ fn delta_deserialize_test() {
{"retain":2,"attributes":{"italic":true,"bold":true}},
{"retain":2,"attributes":{"italic":true,"bold":true}}
]"#;
- let delta = TextDelta::from_json(json).unwrap();
+ let delta = TextOperations::from_json(json).unwrap();
eprintln!("{}", delta);
}
@@ -86,7 +86,7 @@ fn delta_deserialize_null_test() {
let json = r#"[
{"retain":7,"attributes":{"bold":null}}
]"#;
- let delta1 = TextDelta::from_json(json).unwrap();
+ let delta1 = TextOperations::from_json(json).unwrap();
let mut attribute = BuildInTextAttribute::Bold(true);
attribute.remove_value();
@@ -104,10 +104,10 @@ fn document_insert_serde_test() {
let mut document = ClientDocument::new::<EmptyDoc>();
document.insert(0, "\n").unwrap();
document.insert(0, "123").unwrap();
- let json = document.delta_str();
+ let json = document.get_operations_json();
assert_eq!(r#"[{"insert":"123\n"}]"#, json);
assert_eq!(
r#"[{"insert":"123\n"}]"#,
- ClientDocument::from_json(&json).unwrap().delta_str()
+ ClientDocument::from_json(&json).unwrap().get_operations_json()
);
}
diff --git a/shared-lib/flowy-sync/src/client_document/data.rs b/shared-lib/flowy-sync/src/client_document/data.rs
deleted file mode 100644
index 449b8bd136..0000000000
--- a/shared-lib/flowy-sync/src/client_document/data.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct ImageData {
- image: String,
-}
-
-impl ToString for ImageData {
- fn to_string(&self) -> String {
- self.image.clone()
- }
-}
diff --git a/shared-lib/flowy-sync/src/client_document/default/mod.rs b/shared-lib/flowy-sync/src/client_document/default/mod.rs
index 0ebfd29b3e..a6303081b8 100644
--- a/shared-lib/flowy-sync/src/client_document/default/mod.rs
+++ b/shared-lib/flowy-sync/src/client_document/default/mod.rs
@@ -1,19 +1,19 @@
-use lib_ot::{core::OperationBuilder, text_delta::TextDelta};
+use lib_ot::{core::OperationBuilder, text_delta::TextOperations};
#[inline]
-pub fn initial_quill_delta() -> TextDelta {
+pub fn initial_document_operations() -> TextOperations {
OperationBuilder::new().insert("\n").build()
}
#[inline]
-pub fn initial_quill_delta_string() -> String {
- initial_quill_delta().json_str()
+pub fn initial_document_str() -> String {
+ initial_document_operations().json_str()
}
#[inline]
-pub fn initial_read_me() -> TextDelta {
+pub fn initial_read_me() -> TextOperations {
let json = include_str!("READ_ME.json");
- TextDelta::from_json(json).unwrap()
+ TextOperations::from_json(json).unwrap()
}
#[cfg(test)]
diff --git a/shared-lib/flowy-sync/src/client_document/document_pad.rs b/shared-lib/flowy-sync/src/client_document/document_pad.rs
index e15c9beb61..cdf5fdfad9 100644
--- a/shared-lib/flowy-sync/src/client_document/document_pad.rs
+++ b/shared-lib/flowy-sync/src/client_document/document_pad.rs
@@ -1,35 +1,35 @@
+use crate::client_document::default::initial_document_str;
use crate::{
client_document::{
- default::initial_quill_delta,
history::{History, UndoResult},
view::{ViewExtensions, RECORD_THRESHOLD},
},
errors::CollaborateError,
};
use bytes::Bytes;
-use lib_ot::{core::*, text_delta::TextDelta};
+use lib_ot::{core::*, text_delta::TextOperations};
use tokio::sync::mpsc;
-pub trait InitialDocumentText {
- fn initial_delta() -> TextDelta;
+pub trait InitialDocumentContent {
+ fn json_str() -> String;
}
pub struct EmptyDoc();
-impl InitialDocumentText for EmptyDoc {
- fn initial_delta() -> TextDelta {
- TextDelta::new()
+impl InitialDocumentContent for EmptyDoc {
+ fn json_str() -> String {
+ TextOperations::default().json_str()
}
}
pub struct NewlineDoc();
-impl InitialDocumentText for NewlineDoc {
- fn initial_delta() -> TextDelta {
- initial_quill_delta()
+impl InitialDocumentContent for NewlineDoc {
+ fn json_str() -> String {
+ initial_document_str()
}
}
pub struct ClientDocument {
- delta: TextDelta,
+ operations: TextOperations,
history: History,
view: ViewExtensions,
last_edit_time: usize,
@@ -37,13 +37,14 @@ pub struct ClientDocument {
}
impl ClientDocument {
- pub fn new<C: InitialDocumentText>() -> Self {
- Self::from_delta(C::initial_delta())
+ pub fn new<C: InitialDocumentContent>() -> Self {
+ let content = C::json_str();
+ Self::from_json(&content).unwrap()
}
- pub fn from_delta(delta: TextDelta) -> Self {
+ pub fn from_operations(operations: TextOperations) -> Self {
ClientDocument {
- delta,
+ operations,
history: History::new(),
view: ViewExtensions::new(),
last_edit_time: 0,
@@ -52,24 +53,24 @@ impl ClientDocument {
}
pub fn from_json(json: &str) -> Result<Self, CollaborateError> {
- let delta = TextDelta::from_json(json)?;
- Ok(Self::from_delta(delta))
+ let operations = TextOperations::from_json(json)?;
+ Ok(Self::from_operations(operations))
}
- pub fn delta_str(&self) -> String {
- self.delta.json_str()
+ pub fn get_operations_json(&self) -> String {
+ self.operations.json_str()
}
pub fn to_bytes(&self) -> Bytes {
- self.delta.json_bytes()
+ self.operations.json_bytes()
}
- pub fn to_plain_string(&self) -> String {
- self.delta.apply("").unwrap()
+ pub fn to_content(&self) -> String {
+ self.operations.content().unwrap()
}
- pub fn delta(&self) -> &TextDelta {
- &self.delta
+ pub fn get_operations(&self) -> &TextOperations {
+ &self.operations
}
pub fn md5(&self) -> String {
@@ -81,9 +82,9 @@ impl ClientDocument {
self.notify = Some(notify);
}
- pub fn set_delta(&mut self, data: TextDelta) {
- tracing::trace!("document: {}", data.json_str());
- self.delta = data;
+ pub fn set_operations(&mut self, operations: TextOperations) {
+ tracing::trace!("document: {}", operations.json_str());
+ self.operations = operations;
match &self.notify {
None => {}
@@ -93,74 +94,78 @@ impl ClientDocument {
}
}
- pub fn compose_delta(&mut self, delta: TextDelta) -> Result<(), CollaborateError> {
- tracing::trace!("{} compose {}", &self.delta.json_str(), delta.json_str());
- let composed_delta = self.delta.compose(&delta)?;
- let mut undo_delta = delta.invert(&self.delta);
+ pub fn compose_operations(&mut self, operations: TextOperations) -> Result<(), CollaborateError> {
+ tracing::trace!("{} compose {}", &self.operations.json_str(), operations.json_str());
+ let composed_operations = self.operations.compose(&operations)?;
+ let mut undo_operations = operations.invert(&self.operations);
let now = chrono::Utc::now().timestamp_millis() as usize;
if now - self.last_edit_time < RECORD_THRESHOLD {
- if let Some(last_delta) = self.history.undo() {
+ if let Some(last_operation) = self.history.undo() {
tracing::trace!("compose previous change");
- tracing::trace!("current = {}", undo_delta);
- tracing::trace!("previous = {}", last_delta);
- undo_delta = undo_delta.compose(&last_delta)?;
+ tracing::trace!("current = {}", undo_operations);
+ tracing::trace!("previous = {}", last_operation);
+ undo_operations = undo_operations.compose(&last_operation)?;
}
} else {
self.last_edit_time = now;
}
- if !undo_delta.is_empty() {
- tracing::trace!("add history delta: {}", undo_delta);
- self.history.record(undo_delta);
+ if !undo_operations.is_empty() {
+ tracing::trace!("add history operations: {}", undo_operations);
+ self.history.record(undo_operations);
}
- self.set_delta(composed_delta);
+ self.set_operations(composed_operations);
Ok(())
}
- pub fn insert<T: ToString>(&mut self, index: usize, data: T) -> Result<TextDelta, CollaborateError> {
+ pub fn insert<T: ToString>(&mut self, index: usize, data: T) -> Result<TextOperations, CollaborateError> {
let text = data.to_string();
let interval = Interval::new(index, index);
- let _ = validate_interval(&self.delta, &interval)?;
- let delta = self.view.insert(&self.delta, &text, interval)?;
- self.compose_delta(delta.clone())?;
- Ok(delta)
+ let _ = validate_interval(&self.operations, &interval)?;
+ let operations = self.view.insert(&self.operations, &text, interval)?;
+ self.compose_operations(operations.clone())?;
+ Ok(operations)
}
- pub fn delete(&mut self, interval: Interval) -> Result<TextDelta, CollaborateError> {
- let _ = validate_interval(&self.delta, &interval)?;
+ pub fn delete(&mut self, interval: Interval) -> Result<TextOperations, CollaborateError> {
+ let _ = validate_interval(&self.operations, &interval)?;
debug_assert!(!interval.is_empty());
- let delete = self.view.delete(&self.delta, interval)?;
- if !delete.is_empty() {
- let _ = self.compose_delta(delete.clone())?;
+ let operations = self.view.delete(&self.operations, interval)?;
+ if !operations.is_empty() {
+ let _ = self.compose_operations(operations.clone())?;
}
- Ok(delete)
+ Ok(operations)
}
- pub fn format(&mut self, interval: Interval, attribute: AttributeEntry) -> Result<TextDelta, CollaborateError> {
- let _ = validate_interval(&self.delta, &interval)?;
+ pub fn format(
+ &mut self,
+ interval: Interval,
+ attribute: AttributeEntry,
+ ) -> Result<TextOperations, CollaborateError> {
+ let _ = validate_interval(&self.operations, &interval)?;
tracing::trace!("format {} with {:?}", interval, attribute);
- let format_delta = self.view.format(&self.delta, attribute, interval).unwrap();
- self.compose_delta(format_delta.clone())?;
- Ok(format_delta)
+ let operations = self.view.format(&self.operations, attribute, interval).unwrap();
+ self.compose_operations(operations.clone())?;
+ Ok(operations)
}
- pub fn replace<T: ToString>(&mut self, interval: Interval, data: T) -> Result<TextDelta, CollaborateError> {
- let _ = validate_interval(&self.delta, &interval)?;
- let mut delta = TextDelta::default();
+ pub fn replace<T: ToString>(&mut self, interval: Interval, data: T) -> Result<TextOperations, CollaborateError> {
+ let _ = validate_interval(&self.operations, &interval)?;
+ let mut operations = TextOperations::default();
let text = data.to_string();
if !text.is_empty() {
- delta = self.view.insert(&self.delta, &text, interval)?;
- self.compose_delta(delta.clone())?;
+ operations = self.view.insert(&self.operations, &text, interval)?;
+ self.compose_operations(operations.clone())?;
}
if !interval.is_empty() {
let delete = self.delete(interval)?;
- delta = delta.compose(&delete)?;
+ operations = operations.compose(&delete)?;
}
- Ok(delta)
+ Ok(operations)
}
pub fn can_undo(&self) -> bool {
@@ -174,11 +179,13 @@ impl ClientDocument {
pub fn undo(&mut self) -> Result<UndoResult, CollaborateError> {
match self.history.undo() {
None => Err(CollaborateError::undo().context("Undo stack is empty")),
- Some(undo_delta) => {
- let (new_delta, inverted_delta) = self.invert(&undo_delta)?;
- self.set_delta(new_delta);
- self.history.add_redo(inverted_delta);
- Ok(UndoResult { delta: undo_delta })
+ Some(undo_operations) => {
+ let (new_operations, inverted_operations) = self.invert(&undo_operations)?;
+ self.set_operations(new_operations);
+ self.history.add_redo(inverted_operations);
+ Ok(UndoResult {
+ operations: undo_operations,
+ })
}
}
}
@@ -186,35 +193,41 @@ impl ClientDocument {
pub fn redo(&mut self) -> Result<UndoResult, CollaborateError> {
match self.history.redo() {
None => Err(CollaborateError::redo()),
- Some(redo_delta) => {
- let (new_delta, inverted_delta) = self.invert(&redo_delta)?;
- self.set_delta(new_delta);
- self.history.add_undo(inverted_delta);
- Ok(UndoResult { delta: redo_delta })
+ Some(redo_operations) => {
+ let (new_operations, inverted_operations) = self.invert(&redo_operations)?;
+ self.set_operations(new_operations);
+ self.history.add_undo(inverted_operations);
+ Ok(UndoResult {
+ operations: redo_operations,
+ })
}
}
}
pub fn is_empty(&self) -> bool {
// The document is empty if its text is equal to the initial text.
- self.delta == NewlineDoc::initial_delta()
+ self.operations.json_str() == NewlineDoc::json_str()
}
}
impl ClientDocument {
- fn invert(&self, delta: &TextDelta) -> Result<(TextDelta, TextDelta), CollaborateError> {
+ fn invert(&self, operations: &TextOperations) -> Result<(TextOperations, TextOperations), CollaborateError> {
// c = a.compose(b)
// d = b.invert(a)
// a = c.compose(d)
- let new_delta = self.delta.compose(delta)?;
- let inverted_delta = delta.invert(&self.delta);
- Ok((new_delta, inverted_delta))
+ let new_operations = self.operations.compose(operations)?;
+ let inverted_operations = operations.invert(&self.operations);
+ Ok((new_operations, inverted_operations))
}
}
-fn validate_interval(delta: &TextDelta, interval: &Interval) -> Result<(), CollaborateError> {
- if delta.utf16_target_len < interval.end {
- log::error!("{:?} out of bounds. should 0..{}", interval, delta.utf16_target_len);
+fn validate_interval(operations: &TextOperations, interval: &Interval) -> Result<(), CollaborateError> {
+ if operations.utf16_target_len < interval.end {
+ log::error!(
+ "{:?} out of bounds. should 0..{}",
+ interval,
+ operations.utf16_target_len
+ );
return Err(CollaborateError::out_of_bound());
}
Ok(())
diff --git a/shared-lib/flowy-sync/src/client_document/extensions/delete/default_delete.rs b/shared-lib/flowy-sync/src/client_document/extensions/delete/default_delete.rs
index c02a7f1fe9..5fcf100299 100644
--- a/shared-lib/flowy-sync/src/client_document/extensions/delete/default_delete.rs
+++ b/shared-lib/flowy-sync/src/client_document/extensions/delete/default_delete.rs
@@ -1,7 +1,7 @@
use crate::client_document::DeleteExt;
use lib_ot::{
core::{Interval, OperationBuilder},
- text_delta::TextDelta,
+ text_delta::TextOperations,
};
pub struct DefaultDelete {}
@@ -10,7 +10,7 @@ impl DeleteExt for DefaultDelete {
"DefaultDelete"
}
- fn apply(&self, _delta: &TextDelta, interval: Interval) -> Option<TextDelta> {
+ fn apply(&self, _delta: &TextOperations, interval: Interval) -> Option<TextOperations> {
Some(
OperationBuilder::new()
.retain(interval.start)
diff --git a/shared-lib/flowy-sync/src/client_document/extensions/delete/preserve_line_format_merge.rs b/shared-lib/flowy-sync/src/client_document/extensions/delete/preserve_line_format_merge.rs
index 4148ee4531..0f30102616 100644
--- a/shared-lib/flowy-sync/src/client_document/extensions/delete/preserve_line_format_merge.rs
+++ b/shared-lib/flowy-sync/src/client_document/extensions/delete/preserve_line_format_merge.rs
@@ -1,7 +1,7 @@
use crate::{client_document::DeleteExt, util::is_newline};
use lib_ot::{
core::{Interval, OperationAttributes, OperationBuilder, OperationIterator, Utf16CodeUnitMetric, NEW_LINE},
- text_delta::{empty_attributes, TextDelta},
+ text_delta::{empty_attributes, TextOperations},
};
pub struct PreserveLineFormatOnMerge {}
@@ -10,7 +10,7 @@ impl DeleteExt for PreserveLineFormatOnMerge {
"PreserveLineFormatOnMerge"
}
- fn apply(&self, delta: &TextDelta, interval: Interval) -> Option<TextDelta> {
+ fn apply(&self, delta: &TextOperations, interval: Interval) -> Option<TextOperations> {
if interval.is_empty() {
return None;
}
@@ -45,7 +45,7 @@ impl DeleteExt for PreserveLineFormatOnMerge {
attributes.remove_all_value();
if newline_op.has_attribute() {
- attributes.extend_other(newline_op.get_attributes());
+ attributes.extend(newline_op.get_attributes());
}
new_delta.retain(line_break, empty_attributes());
diff --git a/shared-lib/flowy-sync/src/client_document/extensions/format/resolve_block_format.rs b/shared-lib/flowy-sync/src/client_document/extensions/format/resolve_block_format.rs
index 26d0562687..c2c2006e3e 100644
--- a/shared-lib/flowy-sync/src/client_document/extensions/format/resolve_block_format.rs
+++ b/shared-lib/flowy-sync/src/client_document/extensions/format/resolve_block_format.rs
@@ -2,7 +2,7 @@ use lib_ot::core::AttributeEntry;
use lib_ot::text_delta::is_block;
use lib_ot::{
core::{Interval, OperationBuilder, OperationIterator},
- text_delta::{empty_attributes, AttributeScope, TextDelta},
+ text_delta::{empty_attributes, AttributeScope, TextOperations},
};
use crate::{
@@ -16,7 +16,7 @@ impl FormatExt for ResolveBlockFormat {
"ResolveBlockFormat"
}
- fn apply(&self, delta: &TextDelta, interval: Interval, attribute: &AttributeEntry) -> Option<TextDelta> {
+ fn apply(&self, delta: &TextOperations, interval: Interval, attribute: &AttributeEntry) -> Option<TextOperations> {
if !is_block(&attribute.key) {
return None;
}
diff --git a/shared-lib/flowy-sync/src/client_document/extensions/format/resolve_inline_format.rs b/shared-lib/flowy-sync/src/client_document/extensions/format/resolve_inline_format.rs
index c4e7086715..7ee82dcadc 100644
--- a/shared-lib/flowy-sync/src/client_document/extensions/format/resolve_inline_format.rs
+++ b/shared-lib/flowy-sync/src/client_document/extensions/format/resolve_inline_format.rs
@@ -2,7 +2,7 @@ use lib_ot::core::AttributeEntry;
use lib_ot::text_delta::is_inline;
use lib_ot::{
core::{Interval, OperationBuilder, OperationIterator},
- text_delta::{AttributeScope, TextDelta},
+ text_delta::{AttributeScope, TextOperations},
};
use crate::{
@@ -16,7 +16,7 @@ impl FormatExt for ResolveInlineFormat {
"ResolveInlineFormat"
}
- fn apply(&self, delta: &TextDelta, interval: Interval, attribute: &AttributeEntry) -> Option<TextDelta> {
+ fn apply(&self, delta: &TextOperations, interval: Interval, attribute: &AttributeEntry) -> Option<TextOperations> {
if !is_inline(&attribute.key) {
return None;
}
diff --git a/shared-lib/flowy-sync/src/client_document/extensions/helper.rs b/shared-lib/flowy-sync/src/client_document/extensions/helper.rs
index 547eab71e1..6e267f0cd0 100644
--- a/shared-lib/flowy-sync/src/client_document/extensions/helper.rs
+++ b/shared-lib/flowy-sync/src/client_document/extensions/helper.rs
@@ -1,9 +1,9 @@
use crate::util::find_newline;
use lib_ot::core::AttributeEntry;
-use lib_ot::text_delta::{empty_attributes, AttributeScope, TextDelta, TextOperation};
+use lib_ot::text_delta::{empty_attributes, AttributeScope, TextOperation, TextOperations};
-pub(crate) fn line_break(op: &TextOperation, attribute: &AttributeEntry, scope: AttributeScope) -> TextDelta {
- let mut new_delta = TextDelta::new();
+pub(crate) fn line_break(op: &TextOperation, attribute: &AttributeEntry, scope: AttributeScope) -> TextOperations {
+ let mut new_delta = TextOperations::new();
let mut start = 0;
let end = op.len();
let mut s = op.get_data();
diff --git a/shared-lib/flowy-sync/src/client_document/extensions/insert/auto_exit_block.rs b/shared-lib/flowy-sync/src/client_document/extensions/insert/auto_exit_block.rs
index 1a7ce78690..52ed6165cd 100644
--- a/shared-lib/flowy-sync/src/client_document/extensions/insert/auto_exit_block.rs
+++ b/shared-lib/flowy-sync/src/client_document/extensions/insert/auto_exit_block.rs
@@ -1,6 +1,6 @@
use crate::{client_document::InsertExt, util::is_newline};
use lib_ot::core::{is_empty_line_at_index, OperationBuilder, OperationIterator};
-use lib_ot::text_delta::{attributes_except_header, BuildInTextAttributeKey, TextDelta};
+use lib_ot::text_delta::{attributes_except_header, BuildInTextAttributeKey, TextOperations};
pub struct AutoExitBlock {}
@@ -9,7 +9,7 @@ impl InsertExt for AutoExitBlock {
"AutoExitBlock"
}
- fn apply(&self, delta: &TextDelta, replace_len: usize, text: &str, index: usize) -> Option<TextDelta> {
+ fn apply(&self, delta: &TextOperations, replace_len: usize, text: &str, index: usize) -> Option<TextOperations> {
// Auto exit block will be triggered by enter two new lines
if !is_newline(text) {
return None;
diff --git a/shared-lib/flowy-sync/src/client_document/extensions/insert/auto_format.rs b/shared-lib/flowy-sync/src/client_document/extensions/insert/auto_format.rs
index b2deae600d..2fe7b70b0e 100644
--- a/shared-lib/flowy-sync/src/client_document/extensions/insert/auto_format.rs
+++ b/shared-lib/flowy-sync/src/client_document/extensions/insert/auto_format.rs
@@ -1,8 +1,8 @@
use crate::{client_document::InsertExt, util::is_whitespace};
-use lib_ot::core::Attributes;
+use lib_ot::core::AttributeHashMap;
use lib_ot::{
core::{count_utf16_code_units, OperationBuilder, OperationIterator},
- text_delta::{empty_attributes, BuildInTextAttribute, TextDelta},
+ text_delta::{empty_attributes, BuildInTextAttribute, TextOperations},
};
use std::cmp::min;
use url::Url;
@@ -13,7 +13,7 @@ impl InsertExt for AutoFormatExt {
"AutoFormatExt"
}
- fn apply(&self, delta: &TextDelta, replace_len: usize, text: &str, index: usize) -> Option<TextDelta> {
+ fn apply(&self, delta: &TextOperations, replace_len: usize, text: &str, index: usize) -> Option<TextOperations> {
// enter whitespace to trigger auto format
if !is_whitespace(text) {
return None;
@@ -61,7 +61,7 @@ pub enum AutoFormatter {
}
impl AutoFormatter {
- pub fn to_attributes(&self) -> Attributes {
+ pub fn to_attributes(&self) -> AttributeHashMap {
match self {
AutoFormatter::Url(url) => BuildInTextAttribute::Link(url.as_str()).into(),
}
diff --git a/shared-lib/flowy-sync/src/client_document/extensions/insert/default_insert.rs b/shared-lib/flowy-sync/src/client_document/extensions/insert/default_insert.rs
index b8be2ad5d3..948cf7f994 100644
--- a/shared-lib/flowy-sync/src/client_document/extensions/insert/default_insert.rs
+++ b/shared-lib/flowy-sync/src/client_document/extensions/insert/default_insert.rs
@@ -1,8 +1,8 @@
use crate::client_document::InsertExt;
-use lib_ot::core::Attributes;
+use lib_ot::core::AttributeHashMap;
use lib_ot::{
core::{OperationAttributes, OperationBuilder, OperationIterator, NEW_LINE},
- text_delta::{BuildInTextAttributeKey, TextDelta},
+ text_delta::{BuildInTextAttributeKey, TextOperations},
};
pub struct DefaultInsertAttribute {}
@@ -11,9 +11,9 @@ impl InsertExt for DefaultInsertAttribute {
"DefaultInsertAttribute"
}
- fn apply(&self, delta: &TextDelta, replace_len: usize, text: &str, index: usize) -> Option<TextDelta> {
+ fn apply(&self, delta: &TextOperations, replace_len: usize, text: &str, index: usize) -> Option<TextOperations> {
let iter = OperationIterator::new(delta);
- let mut attributes = Attributes::new();
+ let mut attributes = AttributeHashMap::new();
// Enable each line split by "\n" remains the block attributes. for example:
// insert "\n" to "123456" at index 3
@@ -28,7 +28,7 @@ impl InsertExt for DefaultInsertAttribute {
.get_attributes()
.contains_key(BuildInTextAttributeKey::Header.as_ref())
{
- attributes.extend_other(op.get_attributes());
+ attributes.extend(op.get_attributes());
}
}
}
diff --git a/shared-lib/flowy-sync/src/client_document/extensions/insert/mod.rs b/shared-lib/flowy-sync/src/client_document/extensions/insert/mod.rs
index 5206cb4a09..19661006e6 100644
--- a/shared-lib/flowy-sync/src/client_document/extensions/insert/mod.rs
+++ b/shared-lib/flowy-sync/src/client_document/extensions/insert/mod.rs
@@ -2,7 +2,7 @@ use crate::client_document::InsertExt;
pub use auto_exit_block::*;
pub use auto_format::*;
pub use default_insert::*;
-use lib_ot::text_delta::TextDelta;
+use lib_ot::text_delta::TextOperations;
pub use preserve_block_format::*;
pub use preserve_inline_format::*;
pub use reset_format_on_new_line::*;
@@ -20,7 +20,13 @@ impl InsertExt for InsertEmbedsExt {
"InsertEmbedsExt"
}
- fn apply(&self, _delta: &TextDelta, _replace_len: usize, _text: &str, _index: usize) -> Option<TextDelta> {
+ fn apply(
+ &self,
+ _delta: &TextOperations,
+ _replace_len: usize,
+ _text: &str,
+ _index: usize,
+ ) -> Option<TextOperations> {
None
}
}
@@ -31,7 +37,13 @@ impl InsertExt for ForceNewlineForInsertsAroundEmbedExt {
"ForceNewlineForInsertsAroundEmbedExt"
}
- fn apply(&self, _delta: &TextDelta, _replace_len: usize, _text: &str, _index: usize) -> Option<TextDelta> {
+ fn apply(
+ &self,
+ _delta: &TextOperations,
+ _replace_len: usize,
+ _text: &str,
+ _index: usize,
+ ) -> Option<TextOperations> {
None
}
}
diff --git a/shared-lib/flowy-sync/src/client_document/extensions/insert/preserve_block_format.rs b/shared-lib/flowy-sync/src/client_document/extensions/insert/preserve_block_format.rs
index 1b8ba41399..3ce1d1f9f0 100644
--- a/shared-lib/flowy-sync/src/client_document/extensions/insert/preserve_block_format.rs
+++ b/shared-lib/flowy-sync/src/client_document/extensions/insert/preserve_block_format.rs
@@ -1,8 +1,8 @@
use crate::{client_document::InsertExt, util::is_newline};
-use lib_ot::core::Attributes;
+use lib_ot::core::AttributeHashMap;
use lib_ot::{
core::{OperationBuilder, OperationIterator, NEW_LINE},
- text_delta::{attributes_except_header, empty_attributes, BuildInTextAttributeKey, TextDelta},
+ text_delta::{attributes_except_header, empty_attributes, BuildInTextAttributeKey, TextOperations},
};
pub struct PreserveBlockFormatOnInsert {}
@@ -11,7 +11,7 @@ impl InsertExt for PreserveBlockFormatOnInsert {
"PreserveBlockFormatOnInsert"
}
- fn apply(&self, delta: &TextDelta, replace_len: usize, text: &str, index: usize) -> Option<TextDelta> {
+ fn apply(&self, delta: &TextOperations, replace_len: usize, text: &str, index: usize) -> Option<TextOperations> {
if !is_newline(text) {
return None;
}
@@ -26,7 +26,7 @@ impl InsertExt for PreserveBlockFormatOnInsert {
return None;
}
- let mut reset_attribute = Attributes::new();
+ let mut reset_attribute = AttributeHashMap::new();
if newline_attributes.contains_key(BuildInTextAttributeKey::Header.as_ref()) {
reset_attribute.insert(BuildInTextAttributeKey::Header, 1);
}
diff --git a/shared-lib/flowy-sync/src/client_document/extensions/insert/preserve_inline_format.rs b/shared-lib/flowy-sync/src/client_document/extensions/insert/preserve_inline_format.rs
index 94890b198b..f8bd30dc9b 100644
--- a/shared-lib/flowy-sync/src/client_document/extensions/insert/preserve_inline_format.rs
+++ b/shared-lib/flowy-sync/src/client_document/extensions/insert/preserve_inline_format.rs
@@ -4,7 +4,7 @@ use crate::{
};
use lib_ot::{
core::{OpNewline, OperationBuilder, OperationIterator, NEW_LINE},
- text_delta::{empty_attributes, BuildInTextAttributeKey, TextDelta},
+ text_delta::{empty_attributes, BuildInTextAttributeKey, TextOperations},
};
pub struct PreserveInlineFormat {}
@@ -13,7 +13,7 @@ impl InsertExt for PreserveInlineFormat {
"PreserveInlineFormat"
}
- fn apply(&self, delta: &TextDelta, replace_len: usize, text: &str, index: usize) -> Option<TextDelta> {
+ fn apply(&self, delta: &TextOperations, replace_len: usize, text: &str, index: usize) -> Option<TextOperations> {
if contain_newline(text) {
return None;
}
@@ -59,7 +59,7 @@ impl InsertExt for PreserveLineFormatOnSplit {
"PreserveLineFormatOnSplit"
}
- fn apply(&self, delta: &TextDelta, replace_len: usize, text: &str, index: usize) -> Option<TextDelta> {
+ fn apply(&self, delta: &TextOperations, replace_len: usize, text: &str, index: usize) -> Option<TextOperations> {
if !is_newline(text) {
return None;
}
@@ -76,7 +76,7 @@ impl InsertExt for PreserveLineFormatOnSplit {
return None;
}
- let mut new_delta = TextDelta::new();
+ let mut new_delta = TextOperations::new();
new_delta.retain(index + replace_len, empty_attributes());
if newline_status.is_contain() {
diff --git a/shared-lib/flowy-sync/src/client_document/extensions/insert/reset_format_on_new_line.rs b/shared-lib/flowy-sync/src/client_document/extensions/insert/reset_format_on_new_line.rs
index 0043ed89d0..3a15e9dba0 100644
--- a/shared-lib/flowy-sync/src/client_document/extensions/insert/reset_format_on_new_line.rs
+++ b/shared-lib/flowy-sync/src/client_document/extensions/insert/reset_format_on_new_line.rs
@@ -1,8 +1,8 @@
use crate::{client_document::InsertExt, util::is_newline};
-use lib_ot::core::Attributes;
+use lib_ot::core::AttributeHashMap;
use lib_ot::{
core::{OperationBuilder, OperationIterator, Utf16CodeUnitMetric, NEW_LINE},
- text_delta::{BuildInTextAttributeKey, TextDelta},
+ text_delta::{BuildInTextAttributeKey, TextOperations},
};
pub struct ResetLineFormatOnNewLine {}
@@ -11,7 +11,7 @@ impl InsertExt for ResetLineFormatOnNewLine {
"ResetLineFormatOnNewLine"
}
- fn apply(&self, delta: &TextDelta, replace_len: usize, text: &str, index: usize) -> Option<TextDelta> {
+ fn apply(&self, delta: &TextOperations, replace_len: usize, text: &str, index: usize) -> Option<TextOperations> {
if !is_newline(text) {
return None;
}
@@ -23,7 +23,7 @@ impl InsertExt for ResetLineFormatOnNewLine {
return None;
}
- let mut reset_attribute = Attributes::new();
+ let mut reset_attribute = AttributeHashMap::new();
if next_op
.get_attributes()
.contains_key(BuildInTextAttributeKey::Header.as_ref())
diff --git a/shared-lib/flowy-sync/src/client_document/extensions/mod.rs b/shared-lib/flowy-sync/src/client_document/extensions/mod.rs
index 1933663422..a2cd2dc9d7 100644
--- a/shared-lib/flowy-sync/src/client_document/extensions/mod.rs
+++ b/shared-lib/flowy-sync/src/client_document/extensions/mod.rs
@@ -2,7 +2,7 @@ pub use delete::*;
pub use format::*;
pub use insert::*;
use lib_ot::core::AttributeEntry;
-use lib_ot::{core::Interval, text_delta::TextDelta};
+use lib_ot::{core::Interval, text_delta::TextOperations};
mod delete;
mod format;
@@ -15,15 +15,15 @@ pub type DeleteExtension = Box<dyn DeleteExt + Send + Sync>;
pub trait InsertExt {
fn ext_name(&self) -> &str;
- fn apply(&self, delta: &TextDelta, replace_len: usize, text: &str, index: usize) -> Option<TextDelta>;
+ fn apply(&self, delta: &TextOperations, replace_len: usize, text: &str, index: usize) -> Option<TextOperations>;
}
pub trait FormatExt {
fn ext_name(&self) -> &str;
- fn apply(&self, delta: &TextDelta, interval: Interval, attribute: &AttributeEntry) -> Option<TextDelta>;
+ fn apply(&self, delta: &TextOperations, interval: Interval, attribute: &AttributeEntry) -> Option<TextOperations>;
}
pub trait DeleteExt {
fn ext_name(&self) -> &str;
- fn apply(&self, delta: &TextDelta, interval: Interval) -> Option<TextDelta>;
+ fn apply(&self, delta: &TextOperations, interval: Interval) -> Option<TextOperations>;
}
diff --git a/shared-lib/flowy-sync/src/client_document/history.rs b/shared-lib/flowy-sync/src/client_document/history.rs
index 75ff91d243..4d08a8238d 100644
--- a/shared-lib/flowy-sync/src/client_document/history.rs
+++ b/shared-lib/flowy-sync/src/client_document/history.rs
@@ -1,18 +1,18 @@
-use lib_ot::text_delta::TextDelta;
+use lib_ot::text_delta::TextOperations;
const MAX_UNDOES: usize = 20;
#[derive(Debug, Clone)]
pub struct UndoResult {
- pub delta: TextDelta,
+ pub operations: TextOperations,
}
#[derive(Debug, Clone)]
pub struct History {
#[allow(dead_code)]
cur_undo: usize,
- undoes: Vec<TextDelta>,
- redoes: Vec<TextDelta>,
+ undoes: Vec<TextOperations>,
+ redoes: Vec<TextOperations>,
capacity: usize,
}
@@ -40,15 +40,15 @@ impl History {
!self.redoes.is_empty()
}
- pub fn add_undo(&mut self, delta: TextDelta) {
+ pub fn add_undo(&mut self, delta: TextOperations) {
self.undoes.push(delta);
}
- pub fn add_redo(&mut self, delta: TextDelta) {
+ pub fn add_redo(&mut self, delta: TextOperations) {
self.redoes.push(delta);
}
- pub fn record(&mut self, delta: TextDelta) {
+ pub fn record(&mut self, delta: TextOperations) {
if delta.ops.is_empty() {
return;
}
@@ -61,7 +61,7 @@ impl History {
}
}
- pub fn undo(&mut self) -> Option<TextDelta> {
+ pub fn undo(&mut self) -> Option<TextOperations> {
if !self.can_undo() {
return None;
}
@@ -69,7 +69,7 @@ impl History {
Some(delta)
}
- pub fn redo(&mut self) -> Option<TextDelta> {
+ pub fn redo(&mut self) -> Option<TextOperations> {
if !self.can_redo() {
return None;
}
diff --git a/shared-lib/flowy-sync/src/client_document/mod.rs b/shared-lib/flowy-sync/src/client_document/mod.rs
index c463469c22..7e52b8f9e8 100644
--- a/shared-lib/flowy-sync/src/client_document/mod.rs
+++ b/shared-lib/flowy-sync/src/client_document/mod.rs
@@ -4,7 +4,6 @@ pub use document_pad::*;
pub(crate) use extensions::*;
pub use view::*;
-mod data;
pub mod default;
mod document_pad;
mod extensions;
diff --git a/shared-lib/flowy-sync/src/client_document/view.rs b/shared-lib/flowy-sync/src/client_document/view.rs
index 6646d0f4e2..7c06e36bb8 100644
--- a/shared-lib/flowy-sync/src/client_document/view.rs
+++ b/shared-lib/flowy-sync/src/client_document/view.rs
@@ -3,7 +3,7 @@ use lib_ot::core::AttributeEntry;
use lib_ot::{
core::{trim, Interval},
errors::{ErrorBuilder, OTError, OTErrorCode},
- text_delta::TextDelta,
+ text_delta::TextOperations,
};
pub const RECORD_THRESHOLD: usize = 400; // in milliseconds
@@ -23,24 +23,29 @@ impl ViewExtensions {
}
}
- pub(crate) fn insert(&self, delta: &TextDelta, text: &str, interval: Interval) -> Result<TextDelta, OTError> {
- let mut new_delta = None;
+ pub(crate) fn insert(
+ &self,
+ operations: &TextOperations,
+ text: &str,
+ interval: Interval,
+ ) -> Result<TextOperations, OTError> {
+ let mut new_operations = None;
for ext in &self.insert_exts {
- if let Some(mut delta) = ext.apply(delta, interval.size(), text, interval.start) {
- trim(&mut delta);
- tracing::trace!("[{}] applied, delta: {}", ext.ext_name(), delta);
- new_delta = Some(delta);
+ if let Some(mut operations) = ext.apply(operations, interval.size(), text, interval.start) {
+ trim(&mut operations);
+ tracing::trace!("[{}] applied, delta: {}", ext.ext_name(), operations);
+ new_operations = Some(operations);
break;
}
}
- match new_delta {
+ match new_operations {
None => Err(ErrorBuilder::new(OTErrorCode::ApplyInsertFail).build()),
- Some(new_delta) => Ok(new_delta),
+ Some(new_operations) => Ok(new_operations),
}
}
- pub(crate) fn delete(&self, delta: &TextDelta, interval: Interval) -> Result<TextDelta, OTError> {
+ pub(crate) fn delete(&self, delta: &TextOperations, interval: Interval) -> Result<TextOperations, OTError> {
let mut new_delta = None;
for ext in &self.delete_exts {
if let Some(mut delta) = ext.apply(delta, interval) {
@@ -59,23 +64,23 @@ impl ViewExtensions {
pub(crate) fn format(
&self,
- delta: &TextDelta,
+ operations: &TextOperations,
attribute: AttributeEntry,
interval: Interval,
- ) -> Result<TextDelta, OTError> {
- let mut new_delta = None;
+ ) -> Result<TextOperations, OTError> {
+ let mut new_operations = None;
for ext in &self.format_exts {
- if let Some(mut delta) = ext.apply(delta, interval, &attribute) {
- trim(&mut delta);
- tracing::trace!("[{}] applied, delta: {}", ext.ext_name(), delta);
- new_delta = Some(delta);
+ if let Some(mut operations) = ext.apply(operations, interval, &attribute) {
+ trim(&mut operations);
+ tracing::trace!("[{}] applied, delta: {}", ext.ext_name(), operations);
+ new_operations = Some(operations);
break;
}
}
- match new_delta {
+ match new_operations {
None => Err(ErrorBuilder::new(OTErrorCode::ApplyFormatFail).build()),
- Some(new_delta) => Ok(new_delta),
+ Some(new_operations) => Ok(new_operations),
}
}
}
diff --git a/shared-lib/flowy-sync/src/client_folder/builder.rs b/shared-lib/flowy-sync/src/client_folder/builder.rs
index 6581591c25..972051a462 100644
--- a/shared-lib/flowy-sync/src/client_folder/builder.rs
+++ b/shared-lib/flowy-sync/src/client_folder/builder.rs
@@ -1,13 +1,12 @@
-use crate::entities::folder::FolderDelta;
-use crate::util::make_text_delta_from_revisions;
+use crate::util::make_operations_from_revisions;
use crate::{
- client_folder::{default_folder_delta, FolderPad},
+ client_folder::{default_folder_operations, FolderPad},
entities::revision::Revision,
errors::CollaborateResult,
};
+use crate::server_folder::FolderOperations;
use flowy_folder_data_model::revision::{TrashRevision, WorkspaceRevision};
-
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize)]
@@ -37,11 +36,11 @@ impl FolderPadBuilder {
}
pub(crate) fn build_with_revisions(self, revisions: Vec<Revision>) -> CollaborateResult<FolderPad> {
- let mut folder_delta: FolderDelta = make_text_delta_from_revisions(revisions)?;
- if folder_delta.is_empty() {
- folder_delta = default_folder_delta();
+ let mut operations: FolderOperations = make_operations_from_revisions(revisions)?;
+ if operations.is_empty() {
+ operations = default_folder_operations();
}
- FolderPad::from_delta(folder_delta)
+ FolderPad::from_operations(operations)
}
#[allow(dead_code)]
diff --git a/shared-lib/flowy-sync/src/client_folder/folder_pad.rs b/shared-lib/flowy-sync/src/client_folder/folder_pad.rs
index 964df23fd7..87cb5c603d 100644
--- a/shared-lib/flowy-sync/src/client_folder/folder_pad.rs
+++ b/shared-lib/flowy-sync/src/client_folder/folder_pad.rs
@@ -1,24 +1,23 @@
use crate::errors::internal_error;
+use crate::server_folder::FolderOperations;
use crate::util::cal_diff;
use crate::{
client_folder::builder::FolderPadBuilder,
- entities::{
- folder::FolderDelta,
- revision::{md5, Revision},
- },
+ entities::revision::{md5, Revision},
errors::{CollaborateError, CollaborateResult},
};
use flowy_folder_data_model::revision::{AppRevision, FolderRevision, TrashRevision, ViewRevision, WorkspaceRevision};
use lib_infra::util::move_vec_element;
use lib_ot::core::*;
-
use serde::Deserialize;
use std::sync::Arc;
+pub type FolderOperationsBuilder = DeltaBuilder;
+
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct FolderPad {
folder_rev: FolderRevision,
- delta: FolderDelta,
+ operations: FolderOperations,
}
impl FolderPad {
@@ -33,43 +32,43 @@ impl FolderPad {
pub fn from_folder_rev(folder_rev: FolderRevision) -> CollaborateResult<Self> {
let json = serde_json::to_string(&folder_rev)
.map_err(|e| CollaborateError::internal().context(format!("Serialize to folder json str failed: {}", e)))?;
- let delta = DeltaBuilder::new().insert(&json).build();
+ let operations = FolderOperationsBuilder::new().insert(&json).build();
- Ok(Self { folder_rev, delta })
+ Ok(Self { folder_rev, operations })
}
pub fn from_revisions(revisions: Vec<Revision>) -> CollaborateResult<Self> {
FolderPadBuilder::new().build_with_revisions(revisions)
}
- pub fn from_delta(delta: FolderDelta) -> CollaborateResult<Self> {
+ pub fn from_operations(operations: FolderOperations) -> CollaborateResult<Self> {
// TODO: Reconvert from history if delta.to_str() failed.
- let content = delta.content()?;
+ let content = operations.content()?;
let mut deserializer = serde_json::Deserializer::from_reader(content.as_bytes());
let folder_rev = FolderRevision::deserialize(&mut deserializer).map_err(|e| {
tracing::error!("Deserialize folder from {} failed", content);
- return CollaborateError::internal().context(format!("Deserialize delta to folder failed: {}", e));
+ return CollaborateError::internal().context(format!("Deserialize operations to folder failed: {}", e));
})?;
- Ok(Self { folder_rev, delta })
+ Ok(Self { folder_rev, operations })
}
- pub fn delta(&self) -> &FolderDelta {
- &self.delta
+ pub fn get_operations(&self) -> &FolderOperations {
+ &self.operations
}
- pub fn reset_folder(&mut self, delta: FolderDelta) -> CollaborateResult<String> {
- let folder = FolderPad::from_delta(delta)?;
+ pub fn reset_folder(&mut self, operations: FolderOperations) -> CollaborateResult<String> {
+ let folder = FolderPad::from_operations(operations)?;
self.folder_rev = folder.folder_rev;
- self.delta = folder.delta;
+ self.operations = folder.operations;
Ok(self.md5())
}
- pub fn compose_remote_delta(&mut self, delta: FolderDelta) -> CollaborateResult<String> {
- let composed_delta = self.delta.compose(&delta)?;
- self.reset_folder(composed_delta)
+ pub fn compose_remote_operations(&mut self, operations: FolderOperations) -> CollaborateResult<String> {
+ let composed_operations = self.operations.compose(&operations)?;
+ self.reset_folder(composed_operations)
}
pub fn is_empty(&self) -> bool {
@@ -318,7 +317,7 @@ impl FolderPad {
}
pub fn md5(&self) -> String {
- md5(&self.delta.json_bytes())
+ md5(&self.operations.json_bytes())
}
pub fn to_json(&self) -> CollaborateResult<String> {
@@ -345,9 +344,12 @@ impl FolderPad {
let new = self.to_json()?;
match cal_diff::<EmptyAttributes>(old, new) {
None => Ok(None),
- Some(delta) => {
- self.delta = self.delta.compose(&delta)?;
- Ok(Some(FolderChangeset { delta, md5: self.md5() }))
+ Some(operations) => {
+ self.operations = self.operations.compose(&operations)?;
+ Ok(Some(FolderChangeset {
+ operations,
+ md5: self.md5(),
+ }))
}
}
}
@@ -380,9 +382,12 @@ impl FolderPad {
let new = self.to_json()?;
match cal_diff::<EmptyAttributes>(old, new) {
None => Ok(None),
- Some(delta) => {
- self.delta = self.delta.compose(&delta)?;
- Ok(Some(FolderChangeset { delta, md5: self.md5() }))
+ Some(operations) => {
+ self.operations = self.operations.compose(&operations)?;
+ Ok(Some(FolderChangeset {
+ operations,
+ md5: self.md5(),
+ }))
}
}
}
@@ -428,58 +433,62 @@ impl FolderPad {
}
}
-pub fn default_folder_delta() -> FolderDelta {
- DeltaBuilder::new().insert(r#"{"workspaces":[],"trash":[]}"#).build()
+pub fn default_folder_operations() -> FolderOperations {
+ FolderOperationsBuilder::new()
+ .insert(r#"{"workspaces":[],"trash":[]}"#)
+ .build()
}
-pub fn initial_folder_delta(folder_pad: &FolderPad) -> CollaborateResult<FolderDelta> {
+pub fn initial_folder_operations(folder_pad: &FolderPad) -> CollaborateResult<FolderOperations> {
let json = folder_pad.to_json()?;
- let delta = DeltaBuilder::new().insert(&json).build();
- Ok(delta)
+ let operations = FolderOperationsBuilder::new().insert(&json).build();
+ Ok(operations)
}
impl std::default::Default for FolderPad {
fn default() -> Self {
FolderPad {
folder_rev: FolderRevision::default(),
- delta: default_folder_delta(),
+ operations: default_folder_operations(),
}
}
}
pub struct FolderChangeset {
- pub delta: FolderDelta,
- /// md5: the md5 of the FolderPad's delta after applying the change.
+ pub operations: FolderOperations,
+ /// md5: the md5 of the FolderPad's operations after applying the change.
pub md5: String,
}
#[cfg(test)]
mod tests {
#![allow(clippy::all)]
- use crate::{client_folder::folder_pad::FolderPad, entities::folder::FolderDelta};
+ use crate::client_folder::folder_pad::FolderPad;
use chrono::Utc;
use serde::Deserialize;
+ use crate::client_folder::FolderOperationsBuilder;
+ use crate::server_folder::FolderOperations;
use flowy_folder_data_model::revision::{
AppRevision, FolderRevision, TrashRevision, ViewRevision, WorkspaceRevision,
};
- use lib_ot::core::{Delta, DeltaBuilder, OperationTransform};
+ use lib_ot::core::{DeltaBuilder, OperationTransform};
#[test]
fn folder_add_workspace() {
- let (mut folder, initial_delta, _) = test_folder();
+ let (mut folder, initial_operations, _) = test_folder();
let _time = Utc::now();
let mut workspace_1 = WorkspaceRevision::default();
workspace_1.name = "My first workspace".to_owned();
- let delta_1 = folder.create_workspace(workspace_1).unwrap().unwrap().delta;
+ let operations_1 = folder.create_workspace(workspace_1).unwrap().unwrap().operations;
let mut workspace_2 = WorkspaceRevision::default();
workspace_2.name = "My second workspace".to_owned();
- let delta_2 = folder.create_workspace(workspace_2).unwrap().unwrap().delta;
+ let operations_2 = folder.create_workspace(workspace_2).unwrap().unwrap().operations;
- let folder_from_delta = make_folder_from_delta(initial_delta, vec![delta_1, delta_2]);
- assert_eq!(folder, folder_from_delta);
+ let folder_from_operations = make_folder_from_operations(initial_operations, vec![operations_1, operations_2]);
+ assert_eq!(folder, folder_from_operations);
}
#[test]
@@ -498,35 +507,35 @@ mod tests {
#[test]
fn folder_update_workspace() {
- let (mut folder, initial_delta, workspace) = test_folder();
+ let (mut folder, initial_operation, workspace) = test_folder();
assert_folder_equal(
&folder,
- &make_folder_from_delta(initial_delta.clone(), vec![]),
+ &make_folder_from_operations(initial_operation.clone(), vec![]),
r#"{"workspaces":[{"id":"1","name":"😁 my first workspace","desc":"","apps":[],"modified_time":0,"create_time":0}],"trash":[]}"#,
);
- let delta = folder
+ let operations = folder
.update_workspace(&workspace.id, Some("☺️ rename workspace️".to_string()), None)
.unwrap()
.unwrap()
- .delta;
+ .operations;
- let folder_from_delta = make_folder_from_delta(initial_delta, vec![delta]);
+ let folder_from_operations = make_folder_from_operations(initial_operation, vec![operations]);
assert_folder_equal(
&folder,
- &folder_from_delta,
+ &folder_from_operations,
r#"{"workspaces":[{"id":"1","name":"☺️ rename workspace️","desc":"","apps":[],"modified_time":0,"create_time":0}],"trash":[]}"#,
);
}
#[test]
fn folder_add_app() {
- let (folder, initial_delta, _app) = test_app_folder();
- let folder_from_delta = make_folder_from_delta(initial_delta, vec![]);
- assert_eq!(folder, folder_from_delta);
+ let (folder, initial_operations, _app) = test_app_folder();
+ let folder_from_operations = make_folder_from_operations(initial_operations, vec![]);
+ assert_eq!(folder, folder_from_operations);
assert_folder_equal(
&folder,
- &folder_from_delta,
+ &folder_from_operations,
r#"{
"workspaces": [
{
@@ -556,14 +565,14 @@ mod tests {
#[test]
fn folder_update_app() {
- let (mut folder, initial_delta, app) = test_app_folder();
- let delta = folder
+ let (mut folder, initial_operations, app) = test_app_folder();
+ let operations = folder
.update_app(&app.id, Some("🤪 rename app".to_owned()), None)
.unwrap()
.unwrap()
- .delta;
+ .operations;
- let new_folder = make_folder_from_delta(initial_delta, vec![delta]);
+ let new_folder = make_folder_from_operations(initial_operations, vec![operations]);
assert_folder_equal(
&folder,
&new_folder,
@@ -596,9 +605,9 @@ mod tests {
#[test]
fn folder_delete_app() {
- let (mut folder, initial_delta, app) = test_app_folder();
- let delta = folder.delete_app(&app.id).unwrap().unwrap().delta;
- let new_folder = make_folder_from_delta(initial_delta, vec![delta]);
+ let (mut folder, initial_operations, app) = test_app_folder();
+ let operations = folder.delete_app(&app.id).unwrap().unwrap().operations;
+ let new_folder = make_folder_from_operations(initial_operations, vec![operations]);
assert_folder_equal(
&folder,
&new_folder,
@@ -620,10 +629,10 @@ mod tests {
#[test]
fn folder_add_view() {
- let (folder, initial_delta, _view) = test_view_folder();
+ let (folder, initial_operations, _view) = test_view_folder();
assert_folder_equal(
&folder,
- &make_folder_from_delta(initial_delta, vec![]),
+ &make_folder_from_operations(initial_operations, vec![]),
r#"
{
"workspaces": [
@@ -666,14 +675,14 @@ mod tests {
#[test]
fn folder_update_view() {
- let (mut folder, initial_delta, view) = test_view_folder();
- let delta = folder
+ let (mut folder, initial_operations, view) = test_view_folder();
+ let operations = folder
.update_view(&view.id, Some("😦 rename view".to_owned()), None, 123)
.unwrap()
.unwrap()
- .delta;
+ .operations;
- let new_folder = make_folder_from_delta(initial_delta, vec![delta]);
+ let new_folder = make_folder_from_operations(initial_operations, vec![operations]);
assert_folder_equal(
&folder,
&new_folder,
@@ -718,10 +727,10 @@ mod tests {
#[test]
fn folder_delete_view() {
- let (mut folder, initial_delta, view) = test_view_folder();
- let delta = folder.delete_view(&view.id).unwrap().unwrap().delta;
+ let (mut folder, initial_operations, view) = test_view_folder();
+ let operations = folder.delete_view(&view.id).unwrap().unwrap().operations;
- let new_folder = make_folder_from_delta(initial_delta, vec![delta]);
+ let new_folder = make_folder_from_operations(initial_operations, vec![operations]);
assert_folder_equal(
&folder,
&new_folder,
@@ -754,10 +763,10 @@ mod tests {
#[test]
fn folder_add_trash() {
- let (folder, initial_delta, _trash) = test_trash();
+ let (folder, initial_operations, _trash) = test_trash();
assert_folder_equal(
&folder,
- &make_folder_from_delta(initial_delta, vec![]),
+ &make_folder_from_operations(initial_operations, vec![]),
r#"{
"workspaces": [],
"trash": [
@@ -776,11 +785,11 @@ mod tests {
#[test]
fn folder_delete_trash() {
- let (mut folder, initial_delta, trash) = test_trash();
- let delta = folder.delete_trash(Some(vec![trash.id])).unwrap().unwrap().delta;
+ let (mut folder, initial_operations, trash) = test_trash();
+ let operations = folder.delete_trash(Some(vec![trash.id])).unwrap().unwrap().operations;
assert_folder_equal(
&folder,
- &make_folder_from_delta(initial_delta, vec![delta]),
+ &make_folder_from_operations(initial_operations, vec![operations]),
r#"{
"workspaces": [],
"trash": []
@@ -789,10 +798,10 @@ mod tests {
);
}
- fn test_folder() -> (FolderPad, FolderDelta, WorkspaceRevision) {
+ fn test_folder() -> (FolderPad, FolderOperations, WorkspaceRevision) {
let folder_rev = FolderRevision::default();
let folder_json = serde_json::to_string(&folder_rev).unwrap();
- let mut delta = DeltaBuilder::new().insert(&folder_json).build();
+ let mut operations = FolderOperationsBuilder::new().insert(&folder_json).build();
let mut workspace_rev = WorkspaceRevision::default();
workspace_rev.name = "😁 my first workspace".to_owned();
@@ -800,66 +809,75 @@ mod tests {
let mut folder = FolderPad::from_folder_rev(folder_rev).unwrap();
- delta = delta
- .compose(&folder.create_workspace(workspace_rev.clone()).unwrap().unwrap().delta)
+ operations = operations
+ .compose(
+ &folder
+ .create_workspace(workspace_rev.clone())
+ .unwrap()
+ .unwrap()
+ .operations,
+ )
.unwrap();
- (folder, delta, workspace_rev)
+ (folder, operations, workspace_rev)
}
- fn test_app_folder() -> (FolderPad, FolderDelta, AppRevision) {
- let (mut folder_rev, mut initial_delta, workspace) = test_folder();
+ fn test_app_folder() -> (FolderPad, FolderOperations, AppRevision) {
+ let (mut folder_rev, mut initial_operations, workspace) = test_folder();
let mut app_rev = AppRevision::default();
app_rev.workspace_id = workspace.id;
app_rev.name = "😁 my first app".to_owned();
- initial_delta = initial_delta
- .compose(&folder_rev.create_app(app_rev.clone()).unwrap().unwrap().delta)
+ initial_operations = initial_operations
+ .compose(&folder_rev.create_app(app_rev.clone()).unwrap().unwrap().operations)
.unwrap();
- (folder_rev, initial_delta, app_rev)
+ (folder_rev, initial_operations, app_rev)
}
- fn test_view_folder() -> (FolderPad, FolderDelta, ViewRevision) {
- let (mut folder, mut initial_delta, app) = test_app_folder();
+ fn test_view_folder() -> (FolderPad, FolderOperations, ViewRevision) {
+ let (mut folder, mut initial_operations, app) = test_app_folder();
let mut view_rev = ViewRevision::default();
view_rev.app_id = app.id.clone();
view_rev.name = "🎃 my first view".to_owned();
- initial_delta = initial_delta
- .compose(&folder.create_view(view_rev.clone()).unwrap().unwrap().delta)
+ initial_operations = initial_operations
+ .compose(&folder.create_view(view_rev.clone()).unwrap().unwrap().operations)
.unwrap();
- (folder, initial_delta, view_rev)
+ (folder, initial_operations, view_rev)
}
- fn test_trash() -> (FolderPad, FolderDelta, TrashRevision) {
+ fn test_trash() -> (FolderPad, FolderOperations, TrashRevision) {
let folder_rev = FolderRevision::default();
let folder_json = serde_json::to_string(&folder_rev).unwrap();
- let mut delta = DeltaBuilder::new().insert(&folder_json).build();
+ let mut operations = FolderOperationsBuilder::new().insert(&folder_json).build();
let mut trash_rev = TrashRevision::default();
trash_rev.name = "🚽 my first trash".to_owned();
trash_rev.id = "1".to_owned();
let mut folder = FolderPad::from_folder_rev(folder_rev).unwrap();
- delta = delta
+ operations = operations
.compose(
&folder
.create_trash(vec![trash_rev.clone().into()])
.unwrap()
.unwrap()
- .delta,
+ .operations,
)
.unwrap();
- (folder, delta, trash_rev)
+ (folder, operations, trash_rev)
}
- fn make_folder_from_delta(mut initial_delta: FolderDelta, deltas: Vec<Delta>) -> FolderPad {
- for delta in deltas {
- initial_delta = initial_delta.compose(&delta).unwrap();
+ fn make_folder_from_operations(
+ mut initial_operation: FolderOperations,
+ operations: Vec<FolderOperations>,
+ ) -> FolderPad {
+ for operation in operations {
+ initial_operation = initial_operation.compose(&operation).unwrap();
}
- FolderPad::from_delta(initial_delta).unwrap()
+ FolderPad::from_operations(initial_operation).unwrap()
}
fn assert_folder_equal(old: &FolderPad, new: &FolderPad, expected: &str) {
diff --git a/shared-lib/flowy-sync/src/client_grid/block_revision_pad.rs b/shared-lib/flowy-sync/src/client_grid/block_revision_pad.rs
index 1c655b62ec..36f65837c0 100644
--- a/shared-lib/flowy-sync/src/client_grid/block_revision_pad.rs
+++ b/shared-lib/flowy-sync/src/client_grid/block_revision_pad.rs
@@ -1,18 +1,21 @@
use crate::entities::revision::{md5, RepeatedRevision, Revision};
use crate::errors::{CollaborateError, CollaborateResult};
-use crate::util::{cal_diff, make_text_delta_from_revisions};
+use crate::util::{cal_diff, make_operations_from_revisions};
use flowy_grid_data_model::revision::{
gen_block_id, gen_row_id, CellRevision, GridBlockRevision, RowChangeset, RowRevision,
};
-use lib_ot::core::{Delta, DeltaBuilder, EmptyAttributes, OperationTransform};
+use lib_ot::core::{DeltaBuilder, DeltaOperations, EmptyAttributes, OperationTransform};
use std::borrow::Cow;
use std::collections::HashMap;
use std::sync::Arc;
+pub type GridBlockOperations = DeltaOperations<EmptyAttributes>;
+pub type GridBlockOperationsBuilder = DeltaBuilder;
+
#[derive(Debug, Clone)]
pub struct GridBlockRevisionPad {
block: GridBlockRevision,
- delta: Delta,
+ operations: GridBlockOperations,
}
impl std::ops::Deref for GridBlockRevisionPad {
@@ -42,19 +45,22 @@ impl GridBlockRevisionPad {
}
}
- pub fn from_delta(delta: Delta) -> CollaborateResult<Self> {
- let s = delta.content()?;
+ pub fn from_operations(operations: GridBlockOperations) -> CollaborateResult<Self> {
+ let s = operations.content()?;
let revision: GridBlockRevision = serde_json::from_str(&s).map_err(|e| {
- let msg = format!("Deserialize delta to GridBlockRevision failed: {}", e);
+ let msg = format!("Deserialize operations to GridBlockRevision failed: {}", e);
tracing::error!("{}", s);
CollaborateError::internal().context(msg)
})?;
- Ok(Self { block: revision, delta })
+ Ok(Self {
+ block: revision,
+ operations,
+ })
}
pub fn from_revisions(_grid_id: &str, revisions: Vec<Revision>) -> CollaborateResult<Self> {
- let block_delta: Delta = make_text_delta_from_revisions(revisions)?;
- Self::from_delta(block_delta)
+ let operations: GridBlockOperations = make_operations_from_revisions(revisions)?;
+ Self::from_operations(operations)
}
#[tracing::instrument(level = "trace", skip(self, row), err)]
@@ -202,12 +208,12 @@ impl GridBlockRevisionPad {
let new = self.revision_json()?;
match cal_diff::<EmptyAttributes>(old, new) {
None => Ok(None),
- Some(delta) => {
- tracing::trace!("[GridBlockRevision] Composing delta {}", delta.json_str());
- self.delta = self.delta.compose(&delta)?;
+ Some(operations) => {
+ tracing::trace!("[GridBlockRevision] Composing operations {}", operations.json_str());
+ self.operations = self.operations.compose(&operations)?;
Ok(Some(GridBlockRevisionChangeset {
- delta,
- md5: md5(&self.delta.json_bytes()),
+ operations,
+ md5: md5(&self.operations.json_bytes()),
}))
}
}
@@ -234,25 +240,25 @@ impl GridBlockRevisionPad {
.map_err(|e| CollaborateError::internal().context(format!("serial block to json failed: {}", e)))
}
- pub fn json_str(&self) -> String {
- self.delta.json_str()
+ pub fn operations_json_str(&self) -> String {
+ self.operations.json_str()
}
}
pub struct GridBlockRevisionChangeset {
- pub delta: Delta,
+ pub operations: GridBlockOperations,
/// md5: the md5 of the grid after applying the change.
pub md5: String,
}
-pub fn make_grid_block_delta(block_rev: &GridBlockRevision) -> Delta {
+pub fn make_grid_block_operations(block_rev: &GridBlockRevision) -> GridBlockOperations {
let json = serde_json::to_string(&block_rev).unwrap();
- DeltaBuilder::new().insert(&json).build()
+ GridBlockOperationsBuilder::new().insert(&json).build()
}
pub fn make_grid_block_revisions(user_id: &str, grid_block_meta_data: &GridBlockRevision) -> RepeatedRevision {
- let delta = make_grid_block_delta(grid_block_meta_data);
- let bytes = delta.json_bytes();
+ let operations = make_grid_block_operations(grid_block_meta_data);
+ let bytes = operations.json_bytes();
let revision = Revision::initial_revision(user_id, &grid_block_meta_data.block_id, bytes);
revision.into()
}
@@ -264,19 +270,19 @@ impl std::default::Default for GridBlockRevisionPad {
rows: vec![],
};
- let delta = make_grid_block_delta(&block_revision);
+ let operations = make_grid_block_operations(&block_revision);
GridBlockRevisionPad {
block: block_revision,
- delta,
+ operations,
}
}
}
#[cfg(test)]
mod tests {
- use crate::client_grid::GridBlockRevisionPad;
+ use crate::client_grid::{GridBlockOperations, GridBlockRevisionPad};
use flowy_grid_data_model::revision::{RowChangeset, RowRevision};
- use lib_ot::core::Delta;
+
use std::borrow::Cow;
#[test]
@@ -293,7 +299,7 @@ mod tests {
let change = pad.add_row_rev(row.clone(), None).unwrap().unwrap();
assert_eq!(pad.rows.first().unwrap().as_ref(), &row);
assert_eq!(
- change.delta.json_str(),
+ change.operations.json_str(),
r#"[{"retain":24},{"insert":"{\"id\":\"1\",\"block_id\":\"1\",\"cells\":[],\"height\":0,\"visibility\":false}"},{"retain":2}]"#
);
}
@@ -307,19 +313,19 @@ mod tests {
let change = pad.add_row_rev(row_1.clone(), None).unwrap().unwrap();
assert_eq!(
- change.delta.json_str(),
+ change.operations.json_str(),
r#"[{"retain":24},{"insert":"{\"id\":\"1\",\"block_id\":\"1\",\"cells\":[],\"height\":0,\"visibility\":false}"},{"retain":2}]"#
);
let change = pad.add_row_rev(row_2.clone(), None).unwrap().unwrap();
assert_eq!(
- change.delta.json_str(),
+ change.operations.json_str(),
r#"[{"retain":90},{"insert":",{\"id\":\"2\",\"block_id\":\"1\",\"cells\":[],\"height\":0,\"visibility\":false}"},{"retain":2}]"#
);
let change = pad.add_row_rev(row_3.clone(), Some("2".to_string())).unwrap().unwrap();
assert_eq!(
- change.delta.json_str(),
+ change.operations.json_str(),
r#"[{"retain":157},{"insert":",{\"id\":\"3\",\"block_id\":\"1\",\"cells\":[],\"height\":0,\"visibility\":false}"},{"retain":2}]"#
);
@@ -373,7 +379,7 @@ mod tests {
#[test]
fn block_meta_delete_row() {
let mut pad = test_pad();
- let pre_delta_str = pad.json_str();
+ let pre_json_str = pad.operations_json_str();
let row = RowRevision {
id: "1".to_string(),
block_id: pad.block_id.clone(),
@@ -384,9 +390,12 @@ mod tests {
let _ = pad.add_row_rev(row.clone(), None).unwrap().unwrap();
let change = pad.delete_rows(vec![Cow::Borrowed(&row.id)]).unwrap().unwrap();
- assert_eq!(change.delta.json_str(), r#"[{"retain":24},{"delete":66},{"retain":2}]"#);
+ assert_eq!(
+ change.operations.json_str(),
+ r#"[{"retain":24},{"delete":66},{"retain":2}]"#
+ );
- assert_eq!(pad.json_str(), pre_delta_str);
+ assert_eq!(pad.operations_json_str(), pre_json_str);
}
#[test]
@@ -411,7 +420,7 @@ mod tests {
let change = pad.update_row(changeset).unwrap().unwrap();
assert_eq!(
- change.delta.json_str(),
+ change.operations.json_str(),
r#"[{"retain":69},{"insert":"10"},{"retain":15},{"insert":"tru"},{"delete":4},{"retain":4}]"#
);
@@ -422,7 +431,7 @@ mod tests {
}
fn test_pad() -> GridBlockRevisionPad {
- let delta = Delta::from_json(r#"[{"insert":"{\"block_id\":\"1\",\"rows\":[]}"}]"#).unwrap();
- GridBlockRevisionPad::from_delta(delta).unwrap()
+ let operations = GridBlockOperations::from_json(r#"[{"insert":"{\"block_id\":\"1\",\"rows\":[]}"}]"#).unwrap();
+ GridBlockRevisionPad::from_operations(operations).unwrap()
}
}
diff --git a/shared-lib/flowy-sync/src/client_grid/grid_revision_pad.rs b/shared-lib/flowy-sync/src/client_grid/grid_revision_pad.rs
index 64197716bb..df80521fae 100644
--- a/shared-lib/flowy-sync/src/client_grid/grid_revision_pad.rs
+++ b/shared-lib/flowy-sync/src/client_grid/grid_revision_pad.rs
@@ -1,22 +1,22 @@
use crate::entities::revision::{md5, RepeatedRevision, Revision};
use crate::errors::{internal_error, CollaborateError, CollaborateResult};
-use crate::util::{cal_diff, make_text_delta_from_revisions};
-use bytes::Bytes;
+use crate::util::{cal_diff, make_operations_from_revisions};
+
use flowy_grid_data_model::revision::{
gen_block_id, gen_grid_id, FieldRevision, FieldTypeRevision, GridBlockMetaRevision, GridBlockMetaRevisionChangeset,
GridRevision,
};
use lib_infra::util::move_vec_element;
-use lib_ot::core::{Delta, DeltaBuilder, EmptyAttributes, OperationTransform};
+use lib_ot::core::{DeltaBuilder, DeltaOperations, EmptyAttributes, OperationTransform};
use std::collections::HashMap;
use std::sync::Arc;
-pub type GridRevisionDelta = Delta;
-pub type GridRevisionDeltaBuilder = DeltaBuilder;
+pub type GridOperations = DeltaOperations<EmptyAttributes>;
+pub type GridOperationsBuilder = DeltaBuilder;
pub struct GridRevisionPad {
grid_rev: Arc<GridRevision>,
- delta: GridRevisionDelta,
+ operations: GridOperations,
}
pub trait JsonDeserializer {
@@ -49,23 +49,23 @@ impl GridRevisionPad {
(fields, blocks)
}
- pub fn from_delta(delta: GridRevisionDelta) -> CollaborateResult<Self> {
- let content = delta.content()?;
+ pub fn from_operations(operations: GridOperations) -> CollaborateResult<Self> {
+ let content = operations.content()?;
let grid: GridRevision = serde_json::from_str(&content).map_err(|e| {
- let msg = format!("Deserialize delta to grid failed: {}", e);
+ let msg = format!("Deserialize operations to grid failed: {}", e);
tracing::error!("{}", msg);
CollaborateError::internal().context(msg)
})?;
Ok(Self {
grid_rev: Arc::new(grid),
- delta,
+ operations,
})
}
pub fn from_revisions(revisions: Vec<Revision>) -> CollaborateResult<Self> {
- let grid_delta: GridRevisionDelta = make_text_delta_from_revisions(revisions)?;
- Self::from_delta(grid_delta)
+ let operations: GridOperations = make_operations_from_revisions(revisions)?;
+ Self::from_operations(operations)
}
#[tracing::instrument(level = "debug", skip_all, err)]
@@ -293,18 +293,14 @@ impl GridRevisionPad {
}
pub fn md5(&self) -> String {
- md5(&self.delta.json_bytes())
+ md5(&self.operations.json_bytes())
}
- pub fn delta_str(&self) -> String {
- self.delta.json_str()
+ pub fn operations_json_str(&self) -> String {
+ self.operations.json_str()
}
- pub fn delta_bytes(&self) -> Bytes {
- self.delta.json_bytes()
- }
-
- pub fn fields(&self) -> &[Arc<FieldRevision>] {
+ pub fn get_fields(&self) -> &[Arc<FieldRevision>] {
&self.grid_rev.fields
}
@@ -320,9 +316,12 @@ impl GridRevisionPad {
let new = self.json_str()?;
match cal_diff::<EmptyAttributes>(old, new) {
None => Ok(None),
- Some(delta) => {
- self.delta = self.delta.compose(&delta)?;
- Ok(Some(GridRevisionChangeset { delta, md5: self.md5() }))
+ Some(operations) => {
+ self.operations = self.operations.compose(&operations)?;
+ Ok(Some(GridRevisionChangeset {
+ operations,
+ md5: self.md5(),
+ }))
}
}
}
@@ -377,19 +376,19 @@ pub fn make_grid_rev_json_str(grid_revision: &GridRevision) -> CollaborateResult
}
pub struct GridRevisionChangeset {
- pub delta: GridRevisionDelta,
+ pub operations: GridOperations,
/// md5: the md5 of the grid after applying the change.
pub md5: String,
}
-pub fn make_grid_delta(grid_rev: &GridRevision) -> GridRevisionDelta {
+pub fn make_grid_operations(grid_rev: &GridRevision) -> GridOperations {
let json = serde_json::to_string(&grid_rev).unwrap();
- DeltaBuilder::new().insert(&json).build()
+ GridOperationsBuilder::new().insert(&json).build()
}
pub fn make_grid_revisions(user_id: &str, grid_rev: &GridRevision) -> RepeatedRevision {
- let delta = make_grid_delta(grid_rev);
- let bytes = delta.json_bytes();
+ let operations = make_grid_operations(grid_rev);
+ let bytes = operations.json_bytes();
let revision = Revision::initial_revision(user_id, &grid_rev.grid_id, bytes);
revision.into()
}
@@ -397,10 +396,10 @@ pub fn make_grid_revisions(user_id: &str, grid_rev: &GridRevision) -> RepeatedRe
impl std::default::Default for GridRevisionPad {
fn default() -> Self {
let grid = GridRevision::new(&gen_grid_id());
- let delta = make_grid_delta(&grid);
+ let operations = make_grid_operations(&grid);
GridRevisionPad {
grid_rev: Arc::new(grid),
- delta,
+ operations,
}
}
}
diff --git a/shared-lib/flowy-sync/src/client_grid/view_revision_pad.rs b/shared-lib/flowy-sync/src/client_grid/view_revision_pad.rs
index 11e9d5a07e..46e91734b4 100644
--- a/shared-lib/flowy-sync/src/client_grid/view_revision_pad.rs
+++ b/shared-lib/flowy-sync/src/client_grid/view_revision_pad.rs
@@ -1,17 +1,20 @@
use crate::entities::revision::{md5, Revision};
use crate::errors::{internal_error, CollaborateError, CollaborateResult};
-use crate::util::{cal_diff, make_text_delta_from_revisions};
+use crate::util::{cal_diff, make_operations_from_revisions};
use flowy_grid_data_model::revision::{
FieldRevision, FieldTypeRevision, FilterConfigurationRevision, FilterConfigurationsByFieldId, GridViewRevision,
GroupConfigurationRevision, GroupConfigurationsByFieldId, LayoutRevision,
};
-use lib_ot::core::{Delta, DeltaBuilder, EmptyAttributes, OperationTransform};
+use lib_ot::core::{DeltaBuilder, DeltaOperations, EmptyAttributes, OperationTransform};
use std::sync::Arc;
+pub type GridViewOperations = DeltaOperations<EmptyAttributes>;
+pub type GridViewOperationsBuilder = DeltaBuilder;
+
#[derive(Debug, Clone)]
pub struct GridViewRevisionPad {
view: Arc<GridViewRevision>,
- delta: Delta,
+ operations: GridViewOperations,
}
impl std::ops::Deref for GridViewRevisionPad {
@@ -28,33 +31,33 @@ impl GridViewRevisionPad {
pub fn new(grid_id: String, view_id: String, layout: LayoutRevision) -> Self {
let view = Arc::new(GridViewRevision::new(grid_id, view_id, layout));
let json = serde_json::to_string(&view).unwrap();
- let delta = DeltaBuilder::new().insert(&json).build();
- Self { view, delta }
+ let operations = GridViewOperationsBuilder::new().insert(&json).build();
+ Self { view, operations }
}
- pub fn from_delta(view_id: &str, delta: Delta) -> CollaborateResult<Self> {
- if delta.is_empty() {
+ pub fn from_operations(view_id: &str, operations: GridViewOperations) -> CollaborateResult<Self> {
+ if operations.is_empty() {
return Ok(GridViewRevisionPad::new(
view_id.to_owned(),
view_id.to_owned(),
LayoutRevision::Table,
));
}
- let s = delta.content()?;
+ let s = operations.content()?;
let view: GridViewRevision = serde_json::from_str(&s).map_err(|e| {
- let msg = format!("Deserialize delta to GridViewRevision failed: {}", e);
+ let msg = format!("Deserialize operations to GridViewRevision failed: {}", e);
tracing::error!("parsing json: {}", s);
CollaborateError::internal().context(msg)
})?;
Ok(Self {
view: Arc::new(view),
- delta,
+ operations,
})
}
pub fn from_revisions(view_id: &str, revisions: Vec<Revision>) -> CollaborateResult<Self> {
- let delta: Delta = make_text_delta_from_revisions(revisions)?;
- Self::from_delta(view_id, delta)
+ let operations: GridViewOperations = make_operations_from_revisions(revisions)?;
+ Self::from_operations(view_id, operations)
}
pub fn get_groups_by_field_revs(&self, field_revs: &[Arc<FieldRevision>]) -> Option<GroupConfigurationsByFieldId> {
@@ -183,10 +186,10 @@ impl GridViewRevisionPad {
let new = self.json_str()?;
match cal_diff::<EmptyAttributes>(old, new) {
None => Ok(None),
- Some(delta) => {
- self.delta = self.delta.compose(&delta)?;
- let md5 = md5(&self.delta.json_bytes());
- Ok(Some(GridViewRevisionChangeset { delta, md5 }))
+ Some(operations) => {
+ self.operations = self.operations.compose(&operations)?;
+ let md5 = md5(&self.operations.json_bytes());
+ Ok(Some(GridViewRevisionChangeset { operations, md5 }))
}
}
}
@@ -196,7 +199,7 @@ impl GridViewRevisionPad {
#[derive(Debug)]
pub struct GridViewRevisionChangeset {
- pub delta: Delta,
+ pub operations: GridViewOperations,
pub md5: String,
}
@@ -206,7 +209,7 @@ pub fn make_grid_view_rev_json_str(grid_revision: &GridViewRevision) -> Collabor
Ok(json)
}
-pub fn make_grid_view_delta(grid_view: &GridViewRevision) -> Delta {
+pub fn make_grid_view_operations(grid_view: &GridViewRevision) -> GridViewOperations {
let json = serde_json::to_string(grid_view).unwrap();
- DeltaBuilder::new().insert(&json).build()
+ GridViewOperationsBuilder::new().insert(&json).build()
}
diff --git a/shared-lib/flowy-sync/src/entities/folder.rs b/shared-lib/flowy-sync/src/entities/folder.rs
index bf4cd59e93..1f7ecd0b60 100644
--- a/shared-lib/flowy-sync/src/entities/folder.rs
+++ b/shared-lib/flowy-sync/src/entities/folder.rs
@@ -1,7 +1,4 @@
use flowy_derive::ProtoBuf;
-use lib_ot::core::Delta;
-
-pub type FolderDelta = Delta;
#[derive(ProtoBuf, Default, Debug, Clone, Eq, PartialEq)]
pub struct FolderInfo {
diff --git a/shared-lib/flowy-sync/src/entities/revision.rs b/shared-lib/flowy-sync/src/entities/revision.rs
index 2b7d78ecc8..4f7cc7a148 100644
--- a/shared-lib/flowy-sync/src/entities/revision.rs
+++ b/shared-lib/flowy-sync/src/entities/revision.rs
@@ -1,8 +1,9 @@
use bytes::Bytes;
use flowy_derive::{ProtoBuf, ProtoBuf_Enum};
-use lib_ot::text_delta::TextDelta;
use std::{convert::TryFrom, fmt::Formatter, ops::RangeInclusive};
+pub type RevisionObject = lib_ot::text_delta::TextOperations;
+
#[derive(PartialEq, Eq, Clone, Default, ProtoBuf)]
pub struct Revision {
#[pb(index = 1)]
@@ -12,7 +13,7 @@ pub struct Revision {
pub rev_id: i64,
#[pb(index = 3)]
- pub delta_data: Vec<u8>,
+ pub bytes: Vec<u8>,
#[pb(index = 4)]
pub md5: String,
@@ -47,22 +48,15 @@ impl Revision {
self.rev_id == 0
}
- pub fn initial_revision(user_id: &str, object_id: &str, delta_data: Bytes) -> Self {
- let md5 = md5(&delta_data);
- Self::new(object_id, 0, 0, delta_data, user_id, md5)
+ pub fn initial_revision(user_id: &str, object_id: &str, bytes: Bytes) -> Self {
+ let md5 = md5(&bytes);
+ Self::new(object_id, 0, 0, bytes, user_id, md5)
}
- pub fn new(
- object_id: &str,
- base_rev_id: i64,
- rev_id: i64,
- delta_data: Bytes,
- user_id: &str,
- md5: String,
- ) -> Revision {
+ pub fn new(object_id: &str, base_rev_id: i64, rev_id: i64, bytes: Bytes, user_id: &str, md5: String) -> Revision {
let user_id = user_id.to_owned();
let object_id = object_id.to_owned();
- let delta_data = delta_data.to_vec();
+ let bytes = bytes.to_vec();
let base_rev_id = base_rev_id;
let rev_id = rev_id;
@@ -73,7 +67,7 @@ impl Revision {
Self {
base_rev_id,
rev_id,
- delta_data,
+ bytes,
md5,
object_id,
ty: RevType::DeprecatedLocal,
@@ -87,12 +81,12 @@ impl std::fmt::Debug for Revision {
let _ = f.write_fmt(format_args!("object_id {}, ", self.object_id))?;
let _ = f.write_fmt(format_args!("base_rev_id {}, ", self.base_rev_id))?;
let _ = f.write_fmt(format_args!("rev_id {}, ", self.rev_id))?;
- match TextDelta::from_bytes(&self.delta_data) {
- Ok(delta) => {
- let _ = f.write_fmt(format_args!("delta {:?}", delta.json_str()))?;
+ match RevisionObject::from_bytes(&self.bytes) {
+ Ok(object) => {
+ let _ = f.write_fmt(format_args!("object {:?}", object.json_str()))?;
}
Err(e) => {
- let _ = f.write_fmt(format_args!("delta {:?}", e))?;
+ let _ = f.write_fmt(format_args!("object {:?}", e))?;
}
}
Ok(())
diff --git a/shared-lib/flowy-sync/src/entities/text_block.rs b/shared-lib/flowy-sync/src/entities/text_block.rs
index cca7222bd0..edea62a0e0 100644
--- a/shared-lib/flowy-sync/src/entities/text_block.rs
+++ b/shared-lib/flowy-sync/src/entities/text_block.rs
@@ -3,7 +3,7 @@ use crate::{
errors::CollaborateError,
};
use flowy_derive::ProtoBuf;
-use lib_ot::{errors::OTError, text_delta::TextDelta};
+use lib_ot::{errors::OTError, text_delta::TextOperations};
#[derive(ProtoBuf, Default, Debug, Clone)]
pub struct CreateTextBlockParams {
@@ -30,8 +30,8 @@ pub struct DocumentPB {
}
impl DocumentPB {
- pub fn delta(&self) -> Result<TextDelta, OTError> {
- let delta = TextDelta::from_bytes(&self.text)?;
+ pub fn delta(&self) -> Result<TextOperations, OTError> {
+ let delta = TextOperations::from_bytes(&self.text)?;
Ok(delta)
}
}
@@ -45,7 +45,7 @@ impl std::convert::TryFrom<Revision> for DocumentPB {
.context("Revision's rev_id should be 0 when creating the document"));
}
- let delta = TextDelta::from_bytes(&revision.delta_data)?;
+ let delta = TextOperations::from_bytes(&revision.bytes)?;
let doc_json = delta.json_str();
Ok(DocumentPB {
diff --git a/shared-lib/flowy-sync/src/lib.rs b/shared-lib/flowy-sync/src/lib.rs
index 745d588f7e..b21023c903 100644
--- a/shared-lib/flowy-sync/src/lib.rs
+++ b/shared-lib/flowy-sync/src/lib.rs
@@ -9,4 +9,4 @@ pub mod server_folder;
pub mod synchronizer;
pub mod util;
-pub use lib_ot::text_delta::TextDelta;
+pub use lib_ot::text_delta::TextOperations;
diff --git a/shared-lib/flowy-sync/src/server_document/document_manager.rs b/shared-lib/flowy-sync/src/server_document/document_manager.rs
index 95a25bb6da..786021b0b4 100644
--- a/shared-lib/flowy-sync/src/server_document/document_manager.rs
+++ b/shared-lib/flowy-sync/src/server_document/document_manager.rs
@@ -11,8 +11,8 @@ use async_stream::stream;
use dashmap::DashMap;
use futures::stream::StreamExt;
use lib_infra::future::BoxResultFuture;
-use lib_ot::core::Attributes;
-use lib_ot::text_delta::TextDelta;
+use lib_ot::core::AttributeHashMap;
+use lib_ot::text_delta::TextOperations;
use std::{collections::HashMap, fmt::Debug, sync::Arc};
use tokio::{
sync::{mpsc, oneshot, RwLock},
@@ -199,7 +199,7 @@ impl std::ops::Drop for ServerDocumentManager {
}
}
-type DocumentRevisionSynchronizer = RevisionSynchronizer<Attributes>;
+type DocumentRevisionSynchronizer = RevisionSynchronizer<AttributeHashMap>;
struct OpenDocumentHandler {
doc_id: String,
@@ -213,8 +213,8 @@ impl OpenDocumentHandler {
let (sender, receiver) = mpsc::channel(1000);
let users = DashMap::new();
- let delta = TextDelta::from_bytes(&doc.text)?;
- let sync_object = ServerDocument::from_delta(&doc_id, delta);
+ let operations = TextOperations::from_bytes(&doc.text)?;
+ let sync_object = ServerDocument::from_operations(&doc_id, operations);
let synchronizer = Arc::new(DocumentRevisionSynchronizer::new(doc.rev_id, sync_object, persistence));
let queue = DocumentCommandRunner::new(&doc.block_id, receiver, synchronizer);
diff --git a/shared-lib/flowy-sync/src/server_document/document_pad.rs b/shared-lib/flowy-sync/src/server_document/document_pad.rs
index 7a46a8b432..3a6c54628f 100644
--- a/shared-lib/flowy-sync/src/server_document/document_pad.rs
+++ b/shared-lib/flowy-sync/src/server_document/document_pad.rs
@@ -1,45 +1,49 @@
-use crate::{client_document::InitialDocumentText, errors::CollaborateError, synchronizer::RevisionSyncObject};
-use lib_ot::{core::*, text_delta::TextDelta};
+use crate::synchronizer::RevisionOperations;
+use crate::{client_document::InitialDocumentContent, errors::CollaborateError, synchronizer::RevisionSyncObject};
+use lib_ot::{core::*, text_delta::TextOperations};
pub struct ServerDocument {
- doc_id: String,
- delta: TextDelta,
+ document_id: String,
+ operations: TextOperations,
}
impl ServerDocument {
#[allow(dead_code)]
- pub fn new<C: InitialDocumentText>(doc_id: &str) -> Self {
- Self::from_delta(doc_id, C::initial_delta())
+ pub fn new<C: InitialDocumentContent>(doc_id: &str) -> Self {
+ let operations = TextOperations::from_json(&C::json_str()).unwrap();
+ Self::from_operations(doc_id, operations)
}
- pub fn from_delta(doc_id: &str, delta: TextDelta) -> Self {
- let doc_id = doc_id.to_owned();
- ServerDocument { doc_id, delta }
+ pub fn from_operations(document_id: &str, operations: TextOperations) -> Self {
+ let document_id = document_id.to_owned();
+ ServerDocument {
+ document_id,
+ operations,
+ }
}
}
-impl RevisionSyncObject<Attributes> for ServerDocument {
- fn id(&self) -> &str {
- &self.doc_id
+impl RevisionSyncObject<AttributeHashMap> for ServerDocument {
+ fn object_id(&self) -> &str {
+ &self.document_id
}
- fn compose(&mut self, other: &TextDelta) -> Result<(), CollaborateError> {
- // tracing::trace!("{} compose {}", &self.delta.to_json(), other.to_json());
- let new_delta = self.delta.compose(other)?;
- self.delta = new_delta;
+ fn object_json(&self) -> String {
+ self.operations.json_str()
+ }
+
+ fn compose(&mut self, other: &TextOperations) -> Result<(), CollaborateError> {
+ let operations = self.operations.compose(other)?;
+ self.operations = operations;
Ok(())
}
- fn transform(&self, other: &TextDelta) -> Result<(TextDelta, TextDelta), CollaborateError> {
- let value = self.delta.transform(other)?;
+ fn transform(&self, other: &TextOperations) -> Result<(TextOperations, TextOperations), CollaborateError> {
+ let value = self.operations.transform(other)?;
Ok(value)
}
- fn to_json(&self) -> String {
- self.delta.json_str()
- }
-
- fn set_delta(&mut self, new_delta: Operations<Attributes>) {
- self.delta = new_delta;
+ fn set_operations(&mut self, operations: RevisionOperations<AttributeHashMap>) {
+ self.operations = operations;
}
}
diff --git a/shared-lib/flowy-sync/src/server_folder/folder_manager.rs b/shared-lib/flowy-sync/src/server_folder/folder_manager.rs
index 14e28b9421..43d624028c 100644
--- a/shared-lib/flowy-sync/src/server_folder/folder_manager.rs
+++ b/shared-lib/flowy-sync/src/server_folder/folder_manager.rs
@@ -1,19 +1,16 @@
use crate::entities::revision::{RepeatedRevision, Revision};
+use crate::server_folder::folder_pad::{FolderOperations, FolderRevisionSynchronizer};
use crate::{
- entities::{
- folder::{FolderDelta, FolderInfo},
- ws_data::ServerRevisionWSDataBuilder,
- },
+ entities::{folder::FolderInfo, ws_data::ServerRevisionWSDataBuilder},
errors::{internal_error, CollaborateError, CollaborateResult},
protobuf::ClientRevisionWSData,
server_folder::folder_pad::ServerFolder,
- synchronizer::{RevisionSyncPersistence, RevisionSyncResponse, RevisionSynchronizer, RevisionUser},
+ synchronizer::{RevisionSyncPersistence, RevisionSyncResponse, RevisionUser},
util::rev_id_from_str,
};
use async_stream::stream;
use futures::stream::StreamExt;
use lib_infra::future::BoxResultFuture;
-use lib_ot::core::EmptyAttributes;
use std::{collections::HashMap, fmt::Debug, sync::Arc};
use tokio::{
sync::{mpsc, oneshot, RwLock},
@@ -188,8 +185,6 @@ impl ServerFolderManager {
}
}
-type FolderRevisionSynchronizer = RevisionSynchronizer<EmptyAttributes>;
-
struct OpenFolderHandler {
folder_id: String,
sender: mpsc::Sender<FolderCommand>,
@@ -199,8 +194,8 @@ impl OpenFolderHandler {
fn new(folder_info: FolderInfo, persistence: Arc<dyn FolderCloudPersistence>) -> CollaborateResult<Self> {
let (sender, receiver) = mpsc::channel(1000);
let folder_id = folder_info.folder_id.clone();
- let delta = FolderDelta::from_bytes(&folder_info.text)?;
- let sync_object = ServerFolder::from_delta(&folder_id, delta);
+ let operations = FolderOperations::from_bytes(&folder_info.text)?;
+ let sync_object = ServerFolder::from_operations(&folder_id, operations);
let synchronizer = Arc::new(FolderRevisionSynchronizer::new(
folder_info.rev_id,
sync_object,
diff --git a/shared-lib/flowy-sync/src/server_folder/folder_pad.rs b/shared-lib/flowy-sync/src/server_folder/folder_pad.rs
index 9efa7dd6ed..f192cc7f3d 100644
--- a/shared-lib/flowy-sync/src/server_folder/folder_pad.rs
+++ b/shared-lib/flowy-sync/src/server_folder/folder_pad.rs
@@ -1,41 +1,45 @@
-use crate::{entities::folder::FolderDelta, errors::CollaborateError, synchronizer::RevisionSyncObject};
-use lib_ot::core::{Delta, EmptyAttributes, OperationTransform};
+use crate::synchronizer::{RevisionOperations, RevisionSynchronizer};
+use crate::{errors::CollaborateError, synchronizer::RevisionSyncObject};
+use lib_ot::core::{DeltaOperations, EmptyAttributes, OperationTransform};
+
+pub type FolderRevisionSynchronizer = RevisionSynchronizer<EmptyAttributes>;
+pub type FolderOperations = DeltaOperations<EmptyAttributes>;
pub struct ServerFolder {
folder_id: String,
- delta: FolderDelta,
+ operations: FolderOperations,
}
impl ServerFolder {
- pub fn from_delta(folder_id: &str, delta: FolderDelta) -> Self {
+ pub fn from_operations(folder_id: &str, operations: FolderOperations) -> Self {
Self {
folder_id: folder_id.to_owned(),
- delta,
+ operations,
}
}
}
impl RevisionSyncObject<EmptyAttributes> for ServerFolder {
- fn id(&self) -> &str {
+ fn object_id(&self) -> &str {
&self.folder_id
}
- fn compose(&mut self, other: &Delta) -> Result<(), CollaborateError> {
- let new_delta = self.delta.compose(other)?;
- self.delta = new_delta;
+ fn object_json(&self) -> String {
+ self.operations.json_str()
+ }
+
+ fn compose(&mut self, other: &FolderOperations) -> Result<(), CollaborateError> {
+ let operations = self.operations.compose(other)?;
+ self.operations = operations;
Ok(())
}
- fn transform(&self, other: &Delta) -> Result<(Delta, Delta), CollaborateError> {
- let value = self.delta.transform(other)?;
+ fn transform(&self, other: &FolderOperations) -> Result<(FolderOperations, FolderOperations), CollaborateError> {
+ let value = self.operations.transform(other)?;
Ok(value)
}
- fn to_json(&self) -> String {
- self.delta.json_str()
- }
-
- fn set_delta(&mut self, new_delta: Delta) {
- self.delta = new_delta;
+ fn set_operations(&mut self, operations: RevisionOperations<EmptyAttributes>) {
+ self.operations = operations;
}
}
diff --git a/shared-lib/flowy-sync/src/server_folder/mod.rs b/shared-lib/flowy-sync/src/server_folder/mod.rs
index 309254d1e5..7858b783c6 100644
--- a/shared-lib/flowy-sync/src/server_folder/mod.rs
+++ b/shared-lib/flowy-sync/src/server_folder/mod.rs
@@ -2,3 +2,4 @@ mod folder_manager;
mod folder_pad;
pub use folder_manager::*;
+pub use folder_pad::*;
diff --git a/shared-lib/flowy-sync/src/synchronizer.rs b/shared-lib/flowy-sync/src/synchronizer.rs
index 3c3be82f82..49bfaf5a77 100644
--- a/shared-lib/flowy-sync/src/synchronizer.rs
+++ b/shared-lib/flowy-sync/src/synchronizer.rs
@@ -9,7 +9,7 @@ use crate::{
util::*,
};
use lib_infra::future::BoxResultFuture;
-use lib_ot::core::{OperationAttributes, Operations};
+use lib_ot::core::{DeltaOperations, OperationAttributes};
use parking_lot::RwLock;
use serde::de::DeserializeOwned;
use std::{
@@ -22,6 +22,14 @@ use std::{
time::Duration,
};
+pub type RevisionOperations<Attribute> = DeltaOperations<Attribute>;
+
+pub trait RevisionOperations2<Attribute>: Send + Sync {
+ fn from_bytes<B: AsRef<[u8]>>(bytes: B) -> Result<Self, CollaborateError>
+ where
+ Self: Sized;
+}
+
pub trait RevisionUser: Send + Sync + Debug {
fn user_id(&self) -> String;
fn receive(&self, resp: RevisionSyncResponse);
@@ -43,12 +51,19 @@ pub trait RevisionSyncPersistence: Send + Sync + 'static {
) -> BoxResultFuture<(), CollaborateError>;
}
-pub trait RevisionSyncObject<T: OperationAttributes>: Send + Sync + 'static {
- fn id(&self) -> &str;
- fn compose(&mut self, other: &Operations<T>) -> Result<(), CollaborateError>;
- fn transform(&self, other: &Operations<T>) -> Result<(Operations<T>, Operations<T>), CollaborateError>;
- fn to_json(&self) -> String;
- fn set_delta(&mut self, new_delta: Operations<T>);
+pub trait RevisionSyncObject<Attribute: OperationAttributes>: Send + Sync + 'static {
+ fn object_id(&self) -> &str;
+
+ fn object_json(&self) -> String;
+
+ fn compose(&mut self, other: &RevisionOperations<Attribute>) -> Result<(), CollaborateError>;
+
+ fn transform(
+ &self,
+ other: &RevisionOperations<Attribute>,
+ ) -> Result<(RevisionOperations<Attribute>, RevisionOperations<Attribute>), CollaborateError>;
+
+ fn set_operations(&mut self, operations: RevisionOperations<Attribute>);
}
pub enum RevisionSyncResponse {
@@ -57,25 +72,25 @@ pub enum RevisionSyncResponse {
Ack(ServerRevisionWSData),
}
-pub struct RevisionSynchronizer<T: OperationAttributes> {
+pub struct RevisionSynchronizer<Attribute: OperationAttributes> {
object_id: String,
rev_id: AtomicI64,
- object: Arc<RwLock<dyn RevisionSyncObject<T>>>,
+ object: Arc<RwLock<dyn RevisionSyncObject<Attribute>>>,
persistence: Arc<dyn RevisionSyncPersistence>,
}
-impl<T> RevisionSynchronizer<T>
+impl<Attribute> RevisionSynchronizer<Attribute>
where
- T: OperationAttributes + DeserializeOwned + serde::Serialize + 'static,
+ Attribute: OperationAttributes + DeserializeOwned + serde::Serialize + 'static,
{
- pub fn new<S, P>(rev_id: i64, sync_object: S, persistence: P) -> RevisionSynchronizer<T>
+ pub fn new<S, P>(rev_id: i64, sync_object: S, persistence: P) -> RevisionSynchronizer<Attribute>
where
- S: RevisionSyncObject<T>,
+ S: RevisionSyncObject<Attribute>,
P: RevisionSyncPersistence,
{
let object = Arc::new(RwLock::new(sync_object));
let persistence = Arc::new(persistence);
- let object_id = object.read().id().to_owned();
+ let object_id = object.read().object_id().to_owned();
RevisionSynchronizer {
object_id,
rev_id: AtomicI64::new(rev_id),
@@ -117,7 +132,7 @@ where
}
let _ = self.persistence.save_revisions(repeated_revision).await?;
} else {
- // The server delta is outdated, pull the missing revision from the client.
+ // The server ops is outdated, pull the missing revision from the client.
let range = RevisionRange {
start: server_rev_id,
end: first_revision.rev_id,
@@ -131,9 +146,9 @@ where
tracing::trace!("Applied {} revision rev_id is the same as cur_rev_id", self.object_id);
}
Ordering::Greater => {
- // The client delta is outdated. Transform the client revision delta and then
- // send the prime delta to the client. Client should compose the this prime
- // delta.
+ // The client ops is outdated. Transform the client revision ops and then
+ // send the prime ops to the client. Client should compose the this prime
+ // ops.
let from_rev_id = first_revision.rev_id;
let to_rev_id = server_base_rev_id;
let _ = self.push_revisions_to_user(user, from_rev_id, to_rev_id).await;
@@ -153,9 +168,9 @@ where
}
Ordering::Equal => tracing::trace!("{} is up to date.", object_id),
Ordering::Greater => {
- // The client delta is outdated. Transform the client revision delta and then
- // send the prime delta to the client. Client should compose the this prime
- // delta.
+ // The client ops is outdated. Transform the client revision ops and then
+ // send the prime ops to the client. Client should compose the this prime
+ // ops.
let from_rev_id = client_rev_id;
let to_rev_id = server_rev_id;
tracing::trace!("Push revisions to user");
@@ -171,40 +186,43 @@ where
tracing::Span::current().record("object_id", &object_id.as_str());
let revisions: Vec<Revision> = repeated_revision.clone().into_inner();
let (_, rev_id) = pair_rev_id_from_revision_pbs(&revisions);
- let delta = make_delta_from_revision_pb(revisions)?;
+ let operations = make_operations_from_revisions(revisions)?;
let _ = self.persistence.reset_object(&object_id, repeated_revision).await?;
- self.object.write().set_delta(delta);
+ self.object.write().set_operations(operations);
let _ = self.rev_id.fetch_update(SeqCst, SeqCst, |_e| Some(rev_id));
Ok(())
}
pub fn object_json(&self) -> String {
- self.object.read().to_json()
+ self.object.read().object_json()
}
fn compose_revision(&self, revision: &Revision) -> Result<(), CollaborateError> {
- let delta = Operations::<T>::from_bytes(&revision.delta_data)?;
- let _ = self.compose_delta(delta)?;
+ let operations = RevisionOperations::<Attribute>::from_bytes(&revision.bytes)?;
+ let _ = self.compose_operations(operations)?;
let _ = self.rev_id.fetch_update(SeqCst, SeqCst, |_e| Some(revision.rev_id));
Ok(())
}
#[tracing::instrument(level = "debug", skip(self, revision))]
- fn transform_revision(&self, revision: &RevisionPB) -> Result<(Operations<T>, Operations<T>), CollaborateError> {
- let cli_delta = Operations::<T>::from_bytes(&revision.delta_data)?;
- let result = self.object.read().transform(&cli_delta)?;
+ fn transform_revision(
+ &self,
+ revision: &RevisionPB,
+ ) -> Result<(RevisionOperations<Attribute>, RevisionOperations<Attribute>), CollaborateError> {
+ let client_operations = RevisionOperations::<Attribute>::from_bytes(&revision.bytes)?;
+ let result = self.object.read().transform(&client_operations)?;
Ok(result)
}
- fn compose_delta(&self, delta: Operations<T>) -> Result<(), CollaborateError> {
- if delta.is_empty() {
- log::warn!("Composed delta is empty");
+ fn compose_operations(&self, operations: RevisionOperations<Attribute>) -> Result<(), CollaborateError> {
+ if operations.is_empty() {
+ log::warn!("Composed operations is empty");
}
match self.object.try_write_for(Duration::from_millis(300)) {
None => log::error!("Failed to acquire write lock of object"),
Some(mut write_guard) => {
- let _ = write_guard.compose(&delta)?;
+ let _ = write_guard.compose(&operations)?;
}
}
Ok(())
diff --git a/shared-lib/flowy-sync/src/util.rs b/shared-lib/flowy-sync/src/util.rs
index c3a9a914a5..43c06823fa 100644
--- a/shared-lib/flowy-sync/src/util.rs
+++ b/shared-lib/flowy-sync/src/util.rs
@@ -1,16 +1,17 @@
+use crate::server_folder::FolderOperations;
use crate::{
entities::{
- folder::{FolderDelta, FolderInfo},
+ folder::FolderInfo,
revision::{RepeatedRevision, Revision},
text_block::DocumentPB,
},
errors::{CollaborateError, CollaborateResult},
};
use dissimilar::Chunk;
-use lib_ot::core::{Delta, EmptyAttributes, OTString, OperationAttributes, OperationBuilder};
+use lib_ot::core::{OTString, OperationAttributes, OperationBuilder};
use lib_ot::{
- core::{OperationTransform, Operations, NEW_LINE, WHITESPACE},
- text_delta::TextDelta,
+ core::{DeltaOperations, OperationTransform, NEW_LINE, WHITESPACE},
+ text_delta::TextOperations,
};
use serde::de::DeserializeOwned;
use std::sync::atomic::{AtomicI64, Ordering::SeqCst};
@@ -62,42 +63,24 @@ impl RevIdCounter {
}
#[tracing::instrument(level = "trace", skip(revisions), err)]
-pub fn make_delta_from_revisions<T>(revisions: Vec<Revision>) -> CollaborateResult<Operations<T>>
+pub fn make_operations_from_revisions<T>(revisions: Vec<Revision>) -> CollaborateResult<DeltaOperations<T>>
where
T: OperationAttributes + DeserializeOwned,
{
- let mut delta = Operations::<T>::new();
+ let mut new_operations = DeltaOperations::<T>::new();
for revision in revisions {
- if revision.delta_data.is_empty() {
+ if revision.bytes.is_empty() {
tracing::warn!("revision delta_data is empty");
+ continue;
}
- let revision_delta = Operations::<T>::from_bytes(revision.delta_data).map_err(|e| {
+ let operations = DeltaOperations::<T>::from_bytes(revision.bytes).map_err(|e| {
let err_msg = format!("Deserialize remote revision failed: {:?}", e);
CollaborateError::internal().context(err_msg)
})?;
- delta = delta.compose(&revision_delta)?;
+ new_operations = new_operations.compose(&operations)?;
}
- Ok(delta)
-}
-
-pub fn make_text_delta_from_revisions(revisions: Vec<Revision>) -> CollaborateResult<Delta> {
- make_delta_from_revisions::<EmptyAttributes>(revisions)
-}
-
-pub fn make_delta_from_revision_pb<T>(revisions: Vec<Revision>) -> CollaborateResult<Operations<T>>
-where
- T: OperationAttributes + DeserializeOwned,
-{
- let mut new_delta = Operations::<T>::new();
- for revision in revisions {
- let delta = Operations::<T>::from_bytes(revision.delta_data).map_err(|e| {
- let err_msg = format!("Deserialize remote revision failed: {:?}", e);
- CollaborateError::internal().context(err_msg)
- })?;
- new_delta = new_delta.compose(&delta)?;
- }
- Ok(new_delta)
+ Ok(new_operations)
}
pub fn pair_rev_id_from_revision_pbs(revisions: &[Revision]) -> (i64, i64) {
@@ -140,16 +123,16 @@ pub fn make_folder_from_revisions_pb(
return Ok(None);
}
- let mut folder_delta = FolderDelta::new();
+ let mut folder_delta = FolderOperations::new();
let mut base_rev_id = 0;
let mut rev_id = 0;
for revision in revisions {
base_rev_id = revision.base_rev_id;
rev_id = revision.rev_id;
- if revision.delta_data.is_empty() {
+ if revision.bytes.is_empty() {
tracing::warn!("revision delta_data is empty");
}
- let delta = FolderDelta::from_bytes(revision.delta_data)?;
+ let delta = FolderOperations::from_bytes(revision.bytes)?;
folder_delta = folder_delta.compose(&delta)?;
}
@@ -172,18 +155,18 @@ pub fn make_document_from_revision_pbs(
return Ok(None);
}
- let mut delta = TextDelta::new();
+ let mut delta = TextOperations::new();
let mut base_rev_id = 0;
let mut rev_id = 0;
for revision in revisions {
base_rev_id = revision.base_rev_id;
rev_id = revision.rev_id;
- if revision.delta_data.is_empty() {
+ if revision.bytes.is_empty() {
tracing::warn!("revision delta_data is empty");
}
- let new_delta = TextDelta::from_bytes(revision.delta_data)?;
+ let new_delta = TextOperations::from_bytes(revision.bytes)?;
delta = delta.compose(&new_delta)?;
}
@@ -206,7 +189,7 @@ pub fn rev_id_from_str(s: &str) -> Result<i64, CollaborateError> {
Ok(rev_id)
}
-pub fn cal_diff<T: OperationAttributes>(old: String, new: String) -> Option<Operations<T>> {
+pub fn cal_diff<T: OperationAttributes>(old: String, new: String) -> Option<DeltaOperations<T>> {
let chunks = dissimilar::diff(&old, &new);
let mut delta_builder = OperationBuilder::<T>::new();
for chunk in &chunks {
diff --git a/shared-lib/lib-ot/src/core/attributes/attribute.rs b/shared-lib/lib-ot/src/core/attributes/attribute.rs
index 119be9fcb7..cdbf7c44e1 100644
--- a/shared-lib/lib-ot/src/core/attributes/attribute.rs
+++ b/shared-lib/lib-ot/src/core/attributes/attribute.rs
@@ -5,8 +5,6 @@ use std::collections::HashMap;
use std::fmt;
use std::fmt::Display;
-pub type AttributeMap = HashMap<AttributeKey, AttributeValue>;
-
#[derive(Debug, Clone)]
pub struct AttributeEntry {
pub key: AttributeKey,
@@ -20,37 +18,37 @@ impl AttributeEntry {
}
}
-impl std::convert::From<AttributeEntry> for Attributes {
+impl std::convert::From<AttributeEntry> for AttributeHashMap {
fn from(entry: AttributeEntry) -> Self {
- let mut attributes = Attributes::new();
+ let mut attributes = AttributeHashMap::new();
attributes.insert_entry(entry);
attributes
}
}
#[derive(Default, Clone, Serialize, Deserialize, Eq, PartialEq, Debug)]
-pub struct Attributes(AttributeMap);
+pub struct AttributeHashMap(HashMap<AttributeKey, AttributeValue>);
-impl std::ops::Deref for Attributes {
- type Target = AttributeMap;
+impl std::ops::Deref for AttributeHashMap {
+ type Target = HashMap<AttributeKey, AttributeValue>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
-impl std::ops::DerefMut for Attributes {
+impl std::ops::DerefMut for AttributeHashMap {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
-impl Attributes {
- pub fn new() -> Attributes {
- Attributes(HashMap::new())
+impl AttributeHashMap {
+ pub fn new() -> AttributeHashMap {
+ AttributeHashMap(HashMap::new())
}
- pub fn from_value(attribute_map: AttributeMap) -> Self {
+ pub fn from_value(attribute_map: HashMap<AttributeKey, AttributeValue>) -> Self {
Self(attribute_map)
}
@@ -91,7 +89,7 @@ impl Attributes {
/// Create a new key/value map by constructing new attributes from the other
/// if it's not None and replace the key/value with self key/value.
- pub fn merge(&mut self, other: Option<Attributes>) {
+ pub fn merge(&mut self, other: Option<AttributeHashMap>) {
if other.is_none() {
return;
}
@@ -108,7 +106,7 @@ impl Attributes {
}
}
-impl Display for Attributes {
+impl Display for AttributeHashMap {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
for (key, value) in self.0.iter() {
let _ = f.write_str(&format!("{:?}:{:?}", key, value))?;
@@ -117,21 +115,21 @@ impl Display for Attributes {
}
}
-impl OperationAttributes for Attributes {
+impl OperationAttributes for AttributeHashMap {
fn is_empty(&self) -> bool {
self.is_empty()
}
- fn remove_empty(&mut self) {
+ fn remove(&mut self) {
self.retain(|_, v| v.value.is_some());
}
- fn extend_other(&mut self, other: Self) {
+ fn extend(&mut self, other: Self) {
self.0.extend(other.0);
}
}
-impl OperationTransform for Attributes {
+impl OperationTransform for AttributeHashMap {
fn compose(&self, other: &Self) -> Result<Self, OTError>
where
Self: Sized,
@@ -145,25 +143,27 @@ impl OperationTransform for Attributes {
where
Self: Sized,
{
- let a = self.iter().fold(Attributes::new(), |mut new_attributes, (k, v)| {
+ let a = self.iter().fold(AttributeHashMap::new(), |mut new_attributes, (k, v)| {
if !other.contains_key(k) {
new_attributes.insert(k.clone(), v.clone());
}
new_attributes
});
- let b = other.iter().fold(Attributes::new(), |mut new_attributes, (k, v)| {
- if !self.contains_key(k) {
- new_attributes.insert(k.clone(), v.clone());
- }
- new_attributes
- });
+ let b = other
+ .iter()
+ .fold(AttributeHashMap::new(), |mut new_attributes, (k, v)| {
+ if !self.contains_key(k) {
+ new_attributes.insert(k.clone(), v.clone());
+ }
+ new_attributes
+ });
Ok((a, b))
}
fn invert(&self, other: &Self) -> Self {
- let base_inverted = other.iter().fold(Attributes::new(), |mut attributes, (k, v)| {
+ let base_inverted = other.iter().fold(AttributeHashMap::new(), |mut attributes, (k, v)| {
if other.get(k) != self.get(k) && self.contains_key(k) {
attributes.insert(k.clone(), v.clone());
}
@@ -275,7 +275,7 @@ impl std::convert::From<String> for AttributeValue {
#[derive(Default)]
pub struct AttributeBuilder {
- attributes: Attributes,
+ attributes: AttributeHashMap,
}
impl AttributeBuilder {
@@ -298,7 +298,7 @@ impl AttributeBuilder {
self
}
- pub fn build(self) -> Attributes {
+ pub fn build(self) -> AttributeHashMap {
self.attributes
}
}
diff --git a/shared-lib/lib-ot/src/core/delta/builder.rs b/shared-lib/lib-ot/src/core/delta/builder.rs
index e00cab532e..624be9b287 100644
--- a/shared-lib/lib-ot/src/core/delta/builder.rs
+++ b/shared-lib/lib-ot/src/core/delta/builder.rs
@@ -1,6 +1,6 @@
use crate::core::delta::operation::OperationAttributes;
-use crate::core::delta::{trim, Operations};
-use crate::core::Operation;
+use crate::core::delta::{trim, DeltaOperations};
+use crate::core::DeltaOperation;
/// A builder for creating new [Operations] objects.
///
@@ -17,7 +17,7 @@ use crate::core::Operation;
/// assert_eq!(delta.content().unwrap(), "AppFlowy");
/// ```
pub struct OperationBuilder<T: OperationAttributes> {
- delta: Operations<T>,
+ delta: DeltaOperations<T>,
}
impl<T> std::default::Default for OperationBuilder<T>
@@ -26,7 +26,7 @@ where
{
fn default() -> Self {
Self {
- delta: Operations::new(),
+ delta: DeltaOperations::new(),
}
}
}
@@ -39,7 +39,7 @@ where
OperationBuilder::default()
}
- pub fn from_operations(operations: Vec<Operation<T>>) -> Operations<T> {
+ pub fn from_operations(operations: Vec<DeltaOperation<T>>) -> DeltaOperations<T> {
let mut delta = OperationBuilder::default().build();
operations.into_iter().for_each(|operation| {
delta.add(operation);
@@ -52,10 +52,10 @@ where
/// # Examples
///
/// ```
- /// use lib_ot::text_delta::{BuildInTextAttribute, TextDelta, TextDeltaBuilder};
+ /// use lib_ot::text_delta::{BuildInTextAttribute, TextOperations, TextOperationBuilder};
///
/// let mut attribute = BuildInTextAttribute::Bold(true);
- /// let delta = TextDeltaBuilder::new().retain_with_attributes(7, attribute.into()).build();
+ /// let delta = TextOperationBuilder::new().retain_with_attributes(7, attribute.into()).build();
///
/// assert_eq!(delta.json_str(), r#"[{"retain":7,"attributes":{"bold":true}}]"#);
/// ```
@@ -111,14 +111,14 @@ where
///
/// ```
/// use lib_ot::core::{OperationTransform, DeltaBuilder};
- /// use lib_ot::text_delta::{BuildInTextAttribute, TextDeltaBuilder};
+ /// use lib_ot::text_delta::{BuildInTextAttribute, TextOperationBuilder};
/// let delta = DeltaBuilder::new()
/// .retain(3)
/// .trim()
/// .build();
/// assert_eq!(delta.ops.len(), 0);
///
- /// let delta = TextDeltaBuilder::new()
+ /// let delta = TextOperationBuilder::new()
/// .retain_with_attributes(3, BuildInTextAttribute::Bold(true).into())
/// .trim()
/// .build();
@@ -130,7 +130,7 @@ where
}
/// Builds the `Delta`
- pub fn build(self) -> Operations<T> {
+ pub fn build(self) -> DeltaOperations<T> {
self.delta
}
}
diff --git a/shared-lib/lib-ot/src/core/delta/cursor.rs b/shared-lib/lib-ot/src/core/delta/cursor.rs
index e7e41d80f2..de2ae4304e 100644
--- a/shared-lib/lib-ot/src/core/delta/cursor.rs
+++ b/shared-lib/lib-ot/src/core/delta/cursor.rs
@@ -1,6 +1,6 @@
#![allow(clippy::while_let_on_iterator)]
-use crate::core::delta::operation::{Operation, OperationAttributes};
-use crate::core::delta::Operations;
+use crate::core::delta::operation::{DeltaOperation, OperationAttributes};
+use crate::core::delta::DeltaOperations;
use crate::core::interval::Interval;
use crate::errors::{ErrorBuilder, OTError, OTErrorCode};
use std::{cmp::min, iter::Enumerate, slice::Iter};
@@ -8,13 +8,13 @@ use std::{cmp::min, iter::Enumerate, slice::Iter};
/// A [OperationsCursor] is used to iterate the delta and return the corresponding delta.
#[derive(Debug)]
pub struct OperationsCursor<'a, T: OperationAttributes> {
- pub(crate) delta: &'a Operations<T>,
+ pub(crate) delta: &'a DeltaOperations<T>,
pub(crate) origin_iv: Interval,
pub(crate) consume_iv: Interval,
pub(crate) consume_count: usize,
pub(crate) op_offset: usize,
- iter: Enumerate<Iter<'a, Operation<T>>>,
- next_op: Option<Operation<T>>,
+ iter: Enumerate<Iter<'a, DeltaOperation<T>>>,
+ next_op: Option<DeltaOperation<T>>,
}
impl<'a, T> OperationsCursor<'a, T>
@@ -29,19 +29,19 @@ where
/// # Examples
///
/// ```
- /// use lib_ot::core::{OperationsCursor, OperationIterator, Interval, Operation};
- /// use lib_ot::text_delta::TextDelta;
- /// let mut delta = TextDelta::default();
- /// delta.add(Operation::insert("123"));
- /// delta.add(Operation::insert("4"));
+ /// use lib_ot::core::{OperationsCursor, OperationIterator, Interval, DeltaOperation};
+ /// use lib_ot::text_delta::TextOperations;
+ /// let mut delta = TextOperations::default();
+ /// delta.add(DeltaOperation::insert("123"));
+ /// delta.add(DeltaOperation::insert("4"));
///
/// let mut cursor = OperationsCursor::new(&delta, Interval::new(0, 3));
/// assert_eq!(cursor.next_iv(), Interval::new(0,3));
- /// assert_eq!(cursor.next_with_len(Some(2)).unwrap(), Operation::insert("12"));
- /// assert_eq!(cursor.get_next_op().unwrap(), Operation::insert("3"));
+ /// assert_eq!(cursor.next_with_len(Some(2)).unwrap(), DeltaOperation::insert("12"));
+ /// assert_eq!(cursor.get_next_op().unwrap(), DeltaOperation::insert("3"));
/// assert_eq!(cursor.get_next_op(), None);
/// ```
- pub fn new(delta: &'a Operations<T>, interval: Interval) -> OperationsCursor<'a, T> {
+ pub fn new(delta: &'a DeltaOperations<T>, interval: Interval) -> OperationsCursor<'a, T> {
// debug_assert!(interval.start <= delta.target_len);
let mut cursor = Self {
delta,
@@ -62,12 +62,12 @@ where
}
/// Returns the next operation
- pub fn get_next_op(&mut self) -> Option<Operation<T>> {
+ pub fn get_next_op(&mut self) -> Option<DeltaOperation<T>> {
self.next_with_len(None)
}
/// Returns the reference of the next operation
- pub fn next_op(&self) -> Option<&Operation<T>> {
+ pub fn next_op(&self) -> Option<&DeltaOperation<T>> {
let mut next_op = self.next_op.as_ref();
if next_op.is_none() {
let mut offset = 0;
@@ -87,7 +87,7 @@ where
/// * `expected_len`: Return the next operation with the specified length.
///
///
- pub fn next_with_len(&mut self, expected_len: Option<usize>) -> Option<Operation<T>> {
+ pub fn next_with_len(&mut self, expected_len: Option<usize>) -> Option<DeltaOperation<T>> {
let mut find_op = None;
let holder = self.next_op.clone();
let mut next_op = holder.as_ref();
@@ -182,7 +182,7 @@ where
}
}
-fn find_next<'a, T>(cursor: &mut OperationsCursor<'a, T>) -> Option<&'a Operation<T>>
+fn find_next<'a, T>(cursor: &mut OperationsCursor<'a, T>) -> Option<&'a DeltaOperation<T>>
where
T: OperationAttributes,
{
diff --git a/shared-lib/lib-ot/src/core/delta/iterator.rs b/shared-lib/lib-ot/src/core/delta/iterator.rs
index 9063a67bfd..bd4d3ee55a 100644
--- a/shared-lib/lib-ot/src/core/delta/iterator.rs
+++ b/shared-lib/lib-ot/src/core/delta/iterator.rs
@@ -1,8 +1,8 @@
use super::cursor::*;
-use crate::core::delta::operation::{Operation, OperationAttributes};
-use crate::core::delta::{Operations, NEW_LINE};
+use crate::core::delta::operation::{DeltaOperation, OperationAttributes};
+use crate::core::delta::{DeltaOperations, NEW_LINE};
use crate::core::interval::Interval;
-use crate::core::Attributes;
+use crate::core::AttributeHashMap;
use std::ops::{Deref, DerefMut};
@@ -14,19 +14,19 @@ pub(crate) const MAX_IV_LEN: usize = i32::MAX as usize;
/// You could check [this](https://appflowy.gitbook.io/docs/essential-documentation/contribute-to-appflowy/architecture/backend/delta) out for more information.
///
/// ```
-/// use lib_ot::core::{OperationIterator, Interval, Operation};
-/// use lib_ot::text_delta::TextDelta;
-/// let mut delta = TextDelta::default();
-/// delta.add(Operation::insert("123"));
-/// delta.add(Operation::insert("4"));
+/// use lib_ot::core::{OperationIterator, Interval, DeltaOperation};
+/// use lib_ot::text_delta::TextOperations;
+/// let mut delta = TextOperations::default();
+/// delta.add(DeltaOperation::insert("123"));
+/// delta.add(DeltaOperation::insert("4"));
/// assert_eq!(
/// OperationIterator::from_interval(&delta, Interval::new(0, 2)).ops(),
-/// vec![Operation::insert("12")]
+/// vec![DeltaOperation::insert("12")]
/// );
///
/// assert_eq!(
/// OperationIterator::from_interval(&delta, Interval::new(1, 3)).ops(),
-/// vec![Operation::insert("23")]
+/// vec![DeltaOperation::insert("23")]
/// );
/// ```
pub struct OperationIterator<'a, T: OperationAttributes> {
@@ -37,24 +37,24 @@ impl<'a, T> OperationIterator<'a, T>
where
T: OperationAttributes,
{
- pub fn new(delta: &'a Operations<T>) -> Self {
+ pub fn new(delta: &'a DeltaOperations<T>) -> Self {
let interval = Interval::new(0, MAX_IV_LEN);
Self::from_interval(delta, interval)
}
- pub fn from_offset(delta: &'a Operations<T>, offset: usize) -> Self {
+ pub fn from_offset(delta: &'a DeltaOperations<T>, offset: usize) -> Self {
let interval = Interval::new(0, MAX_IV_LEN);
let mut iter = Self::from_interval(delta, interval);
iter.seek::<Utf16CodeUnitMetric>(offset);
iter
}
- pub fn from_interval(delta: &'a Operations<T>, interval: Interval) -> Self {
+ pub fn from_interval(delta: &'a DeltaOperations<T>, interval: Interval) -> Self {
let cursor = OperationsCursor::new(delta, interval);
Self { cursor }
}
- pub fn ops(&mut self) -> Vec<Operation<T>> {
+ pub fn ops(&mut self) -> Vec<DeltaOperation<T>> {
self.collect::<Vec<_>>()
}
@@ -67,16 +67,16 @@ where
}
}
- pub fn next_op(&mut self) -> Option<Operation<T>> {
+ pub fn next_op(&mut self) -> Option<DeltaOperation<T>> {
self.cursor.get_next_op()
}
- pub fn next_op_with_len(&mut self, len: usize) -> Option<Operation<T>> {
+ pub fn next_op_with_len(&mut self, len: usize) -> Option<DeltaOperation<T>> {
self.cursor.next_with_len(Some(len))
}
// find next op contains NEW_LINE
- pub fn next_op_with_newline(&mut self) -> Option<(Operation<T>, usize)> {
+ pub fn next_op_with_newline(&mut self) -> Option<(DeltaOperation<T>, usize)> {
let mut offset = 0;
while self.has_next() {
if let Some(op) = self.next_op() {
@@ -127,13 +127,13 @@ impl<'a, T> Iterator for OperationIterator<'a, T>
where
T: OperationAttributes,
{
- type Item = Operation<T>;
+ type Item = DeltaOperation<T>;
fn next(&mut self) -> Option<Self::Item> {
self.next_op()
}
}
-pub fn is_empty_line_at_index(delta: &Operations<Attributes>, index: usize) -> bool {
+pub fn is_empty_line_at_index(delta: &DeltaOperations<AttributeHashMap>, index: usize) -> bool {
let mut iter = OperationIterator::new(delta);
let (prev, next) = (iter.next_op_with_len(index), iter.next_op());
if prev.is_none() {
@@ -157,12 +157,12 @@ impl<'a, T> AttributesIter<'a, T>
where
T: OperationAttributes,
{
- pub fn new(delta: &'a Operations<T>) -> Self {
+ pub fn new(delta: &'a DeltaOperations<T>) -> Self {
let interval = Interval::new(0, usize::MAX);
Self::from_interval(delta, interval)
}
- pub fn from_interval(delta: &'a Operations<T>, interval: Interval) -> Self {
+ pub fn from_interval(delta: &'a DeltaOperations<T>, interval: Interval) -> Self {
let delta_iter = OperationIterator::from_interval(delta, interval);
Self { delta_iter }
}
@@ -207,16 +207,16 @@ where
let mut attributes = T::default();
match next_op.unwrap() {
- Operation::<T>::Delete(_n) => {}
- Operation::<T>::Retain(retain) => {
+ DeltaOperation::<T>::Delete(_n) => {}
+ DeltaOperation::<T>::Retain(retain) => {
tracing::trace!("extend retain attributes with {} ", &retain.attributes);
- attributes.extend_other(retain.attributes.clone());
+ attributes.extend(retain.attributes.clone());
length = retain.n;
}
- Operation::<T>::Insert(insert) => {
+ DeltaOperation::<T>::Insert(insert) => {
tracing::trace!("extend insert attributes with {} ", &insert.attributes);
- attributes.extend_other(insert.attributes.clone());
+ attributes.extend(insert.attributes.clone());
length = insert.utf16_size();
}
}
@@ -235,7 +235,7 @@ pub enum OpNewline {
}
impl OpNewline {
- pub fn parse<T: OperationAttributes>(op: &Operation<T>) -> OpNewline {
+ pub fn parse<T: OperationAttributes>(op: &DeltaOperation<T>) -> OpNewline {
let s = op.get_data();
if s == NEW_LINE {
diff --git a/shared-lib/lib-ot/src/core/delta/operation/builder.rs b/shared-lib/lib-ot/src/core/delta/operation/builder.rs
index 864bc39775..bdea0e80ae 100644
--- a/shared-lib/lib-ot/src/core/delta/operation/builder.rs
+++ b/shared-lib/lib-ot/src/core/delta/operation/builder.rs
@@ -1,11 +1,11 @@
-use crate::core::delta::operation::{EmptyAttributes, Operation, OperationAttributes};
+use crate::core::delta::operation::{DeltaOperation, EmptyAttributes, OperationAttributes};
// pub type RichTextOpBuilder = OperationsBuilder<TextAttributes>;
pub type PlainTextOpBuilder = OperationsBuilder<EmptyAttributes>;
#[derive(Default)]
pub struct OperationsBuilder<T: OperationAttributes> {
- operations: Vec<Operation<T>>,
+ operations: Vec<DeltaOperation<T>>,
}
impl<T> OperationsBuilder<T>
@@ -17,35 +17,35 @@ where
}
pub fn retain_with_attributes(mut self, n: usize, attributes: T) -> OperationsBuilder<T> {
- let retain = Operation::retain_with_attributes(n, attributes);
+ let retain = DeltaOperation::retain_with_attributes(n, attributes);
self.operations.push(retain);
self
}
pub fn retain(mut self, n: usize) -> OperationsBuilder<T> {
- let retain = Operation::retain(n);
+ let retain = DeltaOperation::retain(n);
self.operations.push(retain);
self
}
pub fn delete(mut self, n: usize) -> OperationsBuilder<T> {
- self.operations.push(Operation::Delete(n));
+ self.operations.push(DeltaOperation::Delete(n));
self
}
pub fn insert_with_attributes(mut self, s: &str, attributes: T) -> OperationsBuilder<T> {
- let insert = Operation::insert_with_attributes(s, attributes);
+ let insert = DeltaOperation::insert_with_attributes(s, attributes);
self.operations.push(insert);
self
}
pub fn insert(mut self, s: &str) -> OperationsBuilder<T> {
- let insert = Operation::insert(s);
+ let insert = DeltaOperation::insert(s);
self.operations.push(insert);
self
}
- pub fn build(self) -> Vec<Operation<T>> {
+ pub fn build(self) -> Vec<DeltaOperation<T>> {
self.operations
}
}
diff --git a/shared-lib/lib-ot/src/core/delta/operation/operation.rs b/shared-lib/lib-ot/src/core/delta/operation/operation.rs
index 23c15b13c6..19efd022b5 100644
--- a/shared-lib/lib-ot/src/core/delta/operation/operation.rs
+++ b/shared-lib/lib-ot/src/core/delta/operation/operation.rs
@@ -75,17 +75,13 @@ pub trait OperationAttributes: Default + Display + Eq + PartialEq + Clone + Debu
true
}
- /// Remove the empty attribute which value is None.
- fn remove_empty(&mut self) {
- // Do nothing
- }
+ /// Remove the attribute which value is None.
+ fn remove(&mut self) {}
- fn extend_other(&mut self, _other: Self) {
- // Do nothing
- }
+ fn extend(&mut self, _other: Self) {}
}
-/// [Operation] consists of three types.
+/// [DeltaOperation] consists of three types.
/// * Delete
/// * Retain
/// * Insert
@@ -96,13 +92,13 @@ pub trait OperationAttributes: Default + Display + Eq + PartialEq + Clone + Debu
/// to json string. You could check out the operation_serde.rs for more information.
///
#[derive(Debug, Clone, Eq, PartialEq)]
-pub enum Operation<T: OperationAttributes> {
+pub enum DeltaOperation<T: OperationAttributes> {
Delete(usize),
Retain(Retain<T>),
Insert(Insert<T>),
}
-impl<T> Operation<T>
+impl<T> DeltaOperation<T>
where
T: OperationAttributes,
{
@@ -142,25 +138,25 @@ where
/// Return the String if the operation is [Insert] operation, otherwise return the empty string.
pub fn get_data(&self) -> &str {
match self {
- Operation::Delete(_) => "",
- Operation::Retain(_) => "",
- Operation::Insert(insert) => &insert.s,
+ DeltaOperation::Delete(_) => "",
+ DeltaOperation::Retain(_) => "",
+ DeltaOperation::Insert(insert) => &insert.s,
}
}
pub fn get_attributes(&self) -> T {
match self {
- Operation::Delete(_) => T::default(),
- Operation::Retain(retain) => retain.attributes.clone(),
- Operation::Insert(insert) => insert.attributes.clone(),
+ DeltaOperation::Delete(_) => T::default(),
+ DeltaOperation::Retain(retain) => retain.attributes.clone(),
+ DeltaOperation::Insert(insert) => insert.attributes.clone(),
}
}
pub fn set_attributes(&mut self, attributes: T) {
match self {
- Operation::Delete(_) => log::error!("Delete should not contains attributes"),
- Operation::Retain(retain) => retain.attributes = attributes,
- Operation::Insert(insert) => insert.attributes = attributes,
+ DeltaOperation::Delete(_) => log::error!("Delete should not contains attributes"),
+ DeltaOperation::Retain(retain) => retain.attributes = attributes,
+ DeltaOperation::Insert(insert) => insert.attributes = attributes,
}
}
@@ -170,9 +166,9 @@ where
pub fn len(&self) -> usize {
match self {
- Operation::Delete(n) => *n,
- Operation::Retain(r) => r.n,
- Operation::Insert(i) => i.utf16_size(),
+ DeltaOperation::Delete(n) => *n,
+ DeltaOperation::Retain(r) => r.n,
+ DeltaOperation::Insert(i) => i.utf16_size(),
}
}
@@ -181,26 +177,26 @@ where
}
#[allow(dead_code)]
- pub fn split(&self, index: usize) -> (Option<Operation<T>>, Option<Operation<T>>) {
+ pub fn split(&self, index: usize) -> (Option<DeltaOperation<T>>, Option<DeltaOperation<T>>) {
debug_assert!(index < self.len());
let left;
let right;
match self {
- Operation::Delete(n) => {
- left = Some(Operation::<T>::delete(index));
- right = Some(Operation::<T>::delete(*n - index));
+ DeltaOperation::Delete(n) => {
+ left = Some(DeltaOperation::<T>::delete(index));
+ right = Some(DeltaOperation::<T>::delete(*n - index));
}
- Operation::Retain(retain) => {
- left = Some(Operation::<T>::delete(index));
- right = Some(Operation::<T>::delete(retain.n - index));
+ DeltaOperation::Retain(retain) => {
+ left = Some(DeltaOperation::<T>::delete(index));
+ right = Some(DeltaOperation::<T>::delete(retain.n - index));
}
- Operation::Insert(insert) => {
+ DeltaOperation::Insert(insert) => {
let attributes = self.get_attributes();
- left = Some(Operation::<T>::insert_with_attributes(
+ left = Some(DeltaOperation::<T>::insert_with_attributes(
&insert.s[0..index],
attributes.clone(),
));
- right = Some(Operation::<T>::insert_with_attributes(
+ right = Some(DeltaOperation::<T>::insert_with_attributes(
&insert.s[index..insert.utf16_size()],
attributes,
));
@@ -218,27 +214,27 @@ where
/// # Examples
///
/// ```
- /// use lib_ot::core::{Interval, Operation, EmptyAttributes};
- /// let operation = Operation::<EmptyAttributes>::insert("1234");
+ /// use lib_ot::core::{Interval, DeltaOperation, EmptyAttributes};
+ /// let operation = DeltaOperation::<EmptyAttributes>::insert("1234");
///
/// let op1 = operation.shrink(Interval::new(0,3)).unwrap();
- /// assert_eq!(op1 , Operation::insert("123"));
+ /// assert_eq!(op1 , DeltaOperation::insert("123"));
///
/// let op2= operation.shrink(Interval::new(3,4)).unwrap();
- /// assert_eq!(op2, Operation::insert("4"));
+ /// assert_eq!(op2, DeltaOperation::insert("4"));
/// ```
- pub fn shrink(&self, interval: Interval) -> Option<Operation<T>> {
+ pub fn shrink(&self, interval: Interval) -> Option<DeltaOperation<T>> {
let op = match self {
- Operation::Delete(n) => Operation::delete(min(*n, interval.size())),
- Operation::Retain(retain) => {
- Operation::retain_with_attributes(min(retain.n, interval.size()), retain.attributes.clone())
+ DeltaOperation::Delete(n) => DeltaOperation::delete(min(*n, interval.size())),
+ DeltaOperation::Retain(retain) => {
+ DeltaOperation::retain_with_attributes(min(retain.n, interval.size()), retain.attributes.clone())
}
- Operation::Insert(insert) => {
+ DeltaOperation::Insert(insert) => {
if interval.start > insert.utf16_size() {
- Operation::insert("")
+ DeltaOperation::insert("")
} else {
let s = insert.s.sub_str(interval).unwrap_or_else(|| "".to_owned());
- Operation::insert_with_attributes(&s, insert.attributes.clone())
+ DeltaOperation::insert_with_attributes(&s, insert.attributes.clone())
}
}
};
@@ -250,21 +246,21 @@ where
}
pub fn is_delete(&self) -> bool {
- if let Operation::Delete(_) = self {
+ if let DeltaOperation::Delete(_) = self {
return true;
}
false
}
pub fn is_insert(&self) -> bool {
- if let Operation::Insert(_) = self {
+ if let DeltaOperation::Insert(_) = self {
return true;
}
false
}
pub fn is_retain(&self) -> bool {
- if let Operation::Retain(_) = self {
+ if let DeltaOperation::Retain(_) = self {
return true;
}
false
@@ -272,27 +268,27 @@ where
pub fn is_plain(&self) -> bool {
match self {
- Operation::Delete(_) => true,
- Operation::Retain(retain) => retain.is_plain(),
- Operation::Insert(insert) => insert.is_plain(),
+ DeltaOperation::Delete(_) => true,
+ DeltaOperation::Retain(retain) => retain.is_plain(),
+ DeltaOperation::Insert(insert) => insert.is_plain(),
}
}
}
-impl<T> fmt::Display for Operation<T>
+impl<T> fmt::Display for DeltaOperation<T>
where
T: OperationAttributes,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("{")?;
match self {
- Operation::Delete(n) => {
+ DeltaOperation::Delete(n) => {
f.write_fmt(format_args!("delete: {}", n))?;
}
- Operation::Retain(r) => {
+ DeltaOperation::Retain(r) => {
f.write_fmt(format_args!("{}", r))?;
}
- Operation::Insert(i) => {
+ DeltaOperation::Insert(i) => {
f.write_fmt(format_args!("{}", i))?;
}
}
@@ -324,7 +320,7 @@ impl<T> Retain<T>
where
T: OperationAttributes,
{
- pub fn merge_or_new(&mut self, n: usize, attributes: T) -> Option<Operation<T>> {
+ pub fn merge_or_new(&mut self, n: usize, attributes: T) -> Option<DeltaOperation<T>> {
// tracing::trace!(
// "merge_retain_or_new_op: len: {:?}, l: {} - r: {}",
// n,
@@ -335,7 +331,7 @@ where
self.n += n;
None
} else {
- Some(Operation::retain_with_attributes(n, attributes))
+ Some(DeltaOperation::retain_with_attributes(n, attributes))
}
}
@@ -411,12 +407,12 @@ where
self.s.utf16_len()
}
- pub fn merge_or_new_op(&mut self, s: &str, attributes: T) -> Option<Operation<T>> {
+ pub fn merge_or_new_op(&mut self, s: &str, attributes: T) -> Option<DeltaOperation<T>> {
if self.attributes == attributes {
self.s += s;
None
} else {
- Some(Operation::<T>::insert_with_attributes(s, attributes))
+ Some(DeltaOperation::<T>::insert_with_attributes(s, attributes))
}
}
diff --git a/shared-lib/lib-ot/src/core/delta/operation/operation_serde.rs b/shared-lib/lib-ot/src/core/delta/operation/operation_serde.rs
index 73d44578ba..ec00b03800 100644
--- a/shared-lib/lib-ot/src/core/delta/operation/operation_serde.rs
+++ b/shared-lib/lib-ot/src/core/delta/operation/operation_serde.rs
@@ -1,4 +1,4 @@
-use crate::core::delta::operation::{Insert, Operation, OperationAttributes, Retain};
+use crate::core::delta::operation::{DeltaOperation, Insert, OperationAttributes, Retain};
use crate::core::ot_str::OTString;
use serde::{
de,
@@ -8,7 +8,7 @@ use serde::{
};
use std::{fmt, marker::PhantomData};
-impl<T> Serialize for Operation<T>
+impl<T> Serialize for DeltaOperation<T>
where
T: OperationAttributes + Serialize,
{
@@ -17,22 +17,22 @@ where
S: Serializer,
{
match self {
- Operation::Retain(retain) => retain.serialize(serializer),
- Operation::Delete(i) => {
+ DeltaOperation::Retain(retain) => retain.serialize(serializer),
+ DeltaOperation::Delete(i) => {
let mut map = serializer.serialize_map(Some(1))?;
map.serialize_entry("delete", i)?;
map.end()
}
- Operation::Insert(insert) => insert.serialize(serializer),
+ DeltaOperation::Insert(insert) => insert.serialize(serializer),
}
}
}
-impl<'de, T> Deserialize<'de> for Operation<T>
+impl<'de, T> Deserialize<'de> for DeltaOperation<T>
where
T: OperationAttributes + Deserialize<'de>,
{
- fn deserialize<D>(deserializer: D) -> Result<Operation<T>, D::Error>
+ fn deserialize<D>(deserializer: D) -> Result<DeltaOperation<T>, D::Error>
where
D: Deserializer<'de>,
{
@@ -42,7 +42,7 @@ where
where
T: OperationAttributes + Deserialize<'de>,
{
- type Value = Operation<T>;
+ type Value = DeltaOperation<T>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("an integer between -2^64 and 2^63 or a string")
@@ -61,21 +61,21 @@ where
if operation.is_some() {
return Err(de::Error::duplicate_field("operation"));
}
- operation = Some(Operation::<T>::Delete(map.next_value()?));
+ operation = Some(DeltaOperation::<T>::Delete(map.next_value()?));
}
"retain" => {
if operation.is_some() {
return Err(de::Error::duplicate_field("operation"));
}
let i: usize = map.next_value()?;
- operation = Some(Operation::<T>::Retain(i.into()));
+ operation = Some(DeltaOperation::<T>::Retain(i.into()));
}
"insert" => {
if operation.is_some() {
return Err(de::Error::duplicate_field("operation"));
}
let i: String = map.next_value()?;
- operation = Some(Operation::<T>::Insert(i.into()));
+ operation = Some(DeltaOperation::<T>::Insert(i.into()));
}
"attributes" => {
if attributes.is_some() {
diff --git a/shared-lib/lib-ot/src/core/delta/ops.rs b/shared-lib/lib-ot/src/core/delta/ops.rs
index 29e8e0f5ed..df697f845e 100644
--- a/shared-lib/lib-ot/src/core/delta/ops.rs
+++ b/shared-lib/lib-ot/src/core/delta/ops.rs
@@ -1,6 +1,6 @@
use crate::errors::{ErrorBuilder, OTError, OTErrorCode};
-use crate::core::delta::operation::{EmptyAttributes, Operation, OperationAttributes, OperationTransform};
+use crate::core::delta::operation::{DeltaOperation, EmptyAttributes, OperationAttributes, OperationTransform};
use crate::core::delta::{OperationIterator, MAX_IV_LEN};
use crate::core::interval::Interval;
use crate::core::ot_str::OTString;
@@ -15,7 +15,7 @@ use std::{
str::FromStr,
};
-pub type Delta = Operations<EmptyAttributes>;
+pub type Delta = DeltaOperations<EmptyAttributes>;
pub type DeltaBuilder = OperationBuilder<EmptyAttributes>;
/// A [Delta] contains list of operations that consists of 'Retain', 'Delete' and 'Insert' operation.
@@ -28,8 +28,8 @@ pub type DeltaBuilder = OperationBuilder<EmptyAttributes>;
/// a JSON string.
///
#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Operations<T: OperationAttributes> {
- pub ops: Vec<Operation<T>>,
+pub struct DeltaOperations<Attribute: OperationAttributes> {
+ pub ops: Vec<DeltaOperation<Attribute>>,
/// 'Delete' and 'Retain' operation will update the [utf16_base_len]
/// Transforming the other delta, it requires the utf16_base_len must be equal.
@@ -40,7 +40,7 @@ pub struct Operations<T: OperationAttributes> {
pub utf16_target_len: usize,
}
-impl<T> Default for Operations<T>
+impl<T> Default for DeltaOperations<T>
where
T: OperationAttributes,
{
@@ -53,7 +53,7 @@ where
}
}
-impl<T> fmt::Display for Operations<T>
+impl<T> fmt::Display for DeltaOperations<T>
where
T: OperationAttributes,
{
@@ -68,12 +68,12 @@ where
}
}
-impl<T> FromIterator<Operation<T>> for Operations<T>
+impl<T> FromIterator<DeltaOperation<T>> for DeltaOperations<T>
where
T: OperationAttributes,
{
- fn from_iter<I: IntoIterator<Item = Operation<T>>>(ops: I) -> Self {
- let mut operations = Operations::default();
+ fn from_iter<I: IntoIterator<Item = DeltaOperation<T>>>(ops: I) -> Self {
+ let mut operations = DeltaOperations::default();
for op in ops {
operations.add(op);
}
@@ -81,7 +81,7 @@ where
}
}
-impl<T> Operations<T>
+impl<T> DeltaOperations<T>
where
T: OperationAttributes,
{
@@ -99,11 +99,11 @@ where
}
/// Adding an operation. It will be added in sequence.
- pub fn add(&mut self, op: Operation<T>) {
+ pub fn add(&mut self, op: DeltaOperation<T>) {
match op {
- Operation::Delete(i) => self.delete(i),
- Operation::Insert(i) => self.insert(&i.s, i.attributes),
- Operation::Retain(r) => self.retain(r.n, r.attributes),
+ DeltaOperation::Delete(i) => self.delete(i),
+ DeltaOperation::Insert(i) => self.insert(&i.s, i.attributes),
+ DeltaOperation::Retain(r) => self.retain(r.n, r.attributes),
}
}
@@ -113,10 +113,10 @@ where
return;
}
self.utf16_base_len += n as usize;
- if let Some(Operation::Delete(n_last)) = self.ops.last_mut() {
+ if let Some(DeltaOperation::Delete(n_last)) = self.ops.last_mut() {
*n_last += n;
} else {
- self.ops.push(Operation::delete(n));
+ self.ops.push(DeltaOperation::delete(n));
}
}
@@ -129,20 +129,20 @@ where
self.utf16_target_len += s.utf16_len();
let new_last = match self.ops.as_mut_slice() {
- [.., Operation::<T>::Insert(insert)] => {
+ [.., DeltaOperation::<T>::Insert(insert)] => {
//
insert.merge_or_new_op(&s, attributes)
}
- [.., Operation::<T>::Insert(pre_insert), Operation::Delete(_)] => {
+ [.., DeltaOperation::<T>::Insert(pre_insert), DeltaOperation::Delete(_)] => {
//
pre_insert.merge_or_new_op(&s, attributes)
}
- [.., op_last @ Operation::<T>::Delete(_)] => {
+ [.., op_last @ DeltaOperation::<T>::Delete(_)] => {
let new_last = op_last.clone();
- *op_last = Operation::<T>::insert_with_attributes(&s, attributes);
+ *op_last = DeltaOperation::<T>::insert_with_attributes(&s, attributes);
Some(new_last)
}
- _ => Some(Operation::<T>::insert_with_attributes(&s, attributes)),
+ _ => Some(DeltaOperation::<T>::insert_with_attributes(&s, attributes)),
};
match new_last {
@@ -159,12 +159,13 @@ where
self.utf16_base_len += n as usize;
self.utf16_target_len += n as usize;
- if let Some(Operation::<T>::Retain(retain)) = self.ops.last_mut() {
+ if let Some(DeltaOperation::<T>::Retain(retain)) = self.ops.last_mut() {
if let Some(new_op) = retain.merge_or_new(n, attributes) {
self.ops.push(new_op);
}
} else {
- self.ops.push(Operation::<T>::retain_with_attributes(n, attributes));
+ self.ops
+ .push(DeltaOperation::<T>::retain_with_attributes(n, attributes));
}
}
@@ -207,17 +208,17 @@ where
let code_point_iter = &mut applied_str.utf16_iter();
for op in &self.ops {
match &op {
- Operation::Retain(retain) => {
+ DeltaOperation::Retain(retain) => {
for c in code_point_iter.take(retain.n as usize) {
new_s.push_str(str::from_utf8(c.0).unwrap_or(""));
}
}
- Operation::Delete(delete) => {
+ DeltaOperation::Delete(delete) => {
for _ in 0..*delete {
code_point_iter.next();
}
}
- Operation::Insert(insert) => {
+ DeltaOperation::Insert(insert) => {
new_s += &insert.s;
}
}
@@ -249,22 +250,22 @@ where
/// ```
///
pub fn invert_str(&self, inverted_s: &str) -> Self {
- let mut inverted = Operations::default();
+ let mut inverted = DeltaOperations::default();
let inverted_s: OTString = inverted_s.into();
let code_point_iter = &mut inverted_s.utf16_iter();
for op in &self.ops {
match &op {
- Operation::Retain(retain) => {
+ DeltaOperation::Retain(retain) => {
inverted.retain(retain.n, T::default());
for _ in 0..retain.n {
code_point_iter.next();
}
}
- Operation::Insert(insert) => {
+ DeltaOperation::Insert(insert) => {
inverted.delete(insert.utf16_size());
}
- Operation::Delete(delete) => {
+ DeltaOperation::Delete(delete) => {
let bytes = code_point_iter
.take(*delete as usize)
.into_iter()
@@ -280,7 +281,7 @@ where
/// Return true if the delta doesn't contain any [Insert] or [Delete] operations.
pub fn is_noop(&self) -> bool {
- matches!(self.ops.as_slice(), [] | [Operation::Retain(_)])
+ matches!(self.ops.as_slice(), [] | [DeltaOperation::Retain(_)])
}
pub fn is_empty(&self) -> bool {
@@ -292,7 +293,7 @@ where
}
}
-impl<T> OperationTransform for Operations<T>
+impl<T> OperationTransform for DeltaOperations<T>
where
T: OperationAttributes,
{
@@ -300,7 +301,7 @@ where
where
Self: Sized,
{
- let mut new_delta = Operations::default();
+ let mut new_delta = DeltaOperations::default();
let mut iter = OperationIterator::new(self);
let mut other_iter = OperationIterator::new(other);
@@ -322,25 +323,25 @@ where
let op = iter
.next_op_with_len(length)
- .unwrap_or_else(|| Operation::retain(length));
+ .unwrap_or_else(|| DeltaOperation::retain(length));
let other_op = other_iter
.next_op_with_len(length)
- .unwrap_or_else(|| Operation::retain(length));
+ .unwrap_or_else(|| DeltaOperation::retain(length));
// debug_assert_eq!(op.len(), other_op.len(), "Composing delta failed,");
match (&op, &other_op) {
- (Operation::Retain(retain), Operation::Retain(other_retain)) => {
+ (DeltaOperation::Retain(retain), DeltaOperation::Retain(other_retain)) => {
let composed_attrs = retain.attributes.compose(&other_retain.attributes)?;
- new_delta.add(Operation::retain_with_attributes(retain.n, composed_attrs))
+ new_delta.add(DeltaOperation::retain_with_attributes(retain.n, composed_attrs))
}
- (Operation::Insert(insert), Operation::Retain(other_retain)) => {
+ (DeltaOperation::Insert(insert), DeltaOperation::Retain(other_retain)) => {
let mut composed_attrs = insert.attributes.compose(&other_retain.attributes)?;
- composed_attrs.remove_empty();
- new_delta.add(Operation::insert_with_attributes(op.get_data(), composed_attrs))
+ composed_attrs.remove();
+ new_delta.add(DeltaOperation::insert_with_attributes(op.get_data(), composed_attrs))
}
- (Operation::Retain(_), Operation::Delete(_)) => {
+ (DeltaOperation::Retain(_), DeltaOperation::Delete(_)) => {
new_delta.add(other_op);
}
(a, b) => {
@@ -366,8 +367,8 @@ where
.build());
}
- let mut a_prime = Operations::default();
- let mut b_prime = Operations::default();
+ let mut a_prime = DeltaOperations::default();
+ let mut b_prime = DeltaOperations::default();
let mut ops1 = self.ops.iter().cloned();
let mut ops2 = other.ops.iter().cloned();
@@ -377,13 +378,13 @@ where
loop {
match (&next_op1, &next_op2) {
(None, None) => break,
- (Some(Operation::Insert(insert)), _) => {
+ (Some(DeltaOperation::Insert(insert)), _) => {
// let composed_attrs = transform_attributes(&next_op1, &next_op2, true);
a_prime.insert(&insert.s, insert.attributes.clone());
b_prime.retain(insert.utf16_size(), insert.attributes.clone());
next_op1 = ops1.next();
}
- (_, Some(Operation::Insert(o_insert))) => {
+ (_, Some(DeltaOperation::Insert(o_insert))) => {
let composed_attrs = transform_op_attribute(&next_op1, &next_op2)?;
a_prime.retain(o_insert.utf16_size(), composed_attrs.clone());
b_prime.insert(&o_insert.s, composed_attrs);
@@ -395,13 +396,13 @@ where
(_, None) => {
return Err(ErrorBuilder::new(OTErrorCode::IncompatibleLength).build());
}
- (Some(Operation::Retain(retain)), Some(Operation::Retain(o_retain))) => {
+ (Some(DeltaOperation::Retain(retain)), Some(DeltaOperation::Retain(o_retain))) => {
let composed_attrs = transform_op_attribute(&next_op1, &next_op2)?;
match retain.cmp(o_retain) {
Ordering::Less => {
a_prime.retain(retain.n, composed_attrs.clone());
b_prime.retain(retain.n, composed_attrs.clone());
- next_op2 = Some(Operation::retain(o_retain.n - retain.n));
+ next_op2 = Some(DeltaOperation::retain(o_retain.n - retain.n));
next_op1 = ops1.next();
}
Ordering::Equal => {
@@ -413,14 +414,14 @@ where
Ordering::Greater => {
a_prime.retain(o_retain.n, composed_attrs.clone());
b_prime.retain(o_retain.n, composed_attrs.clone());
- next_op1 = Some(Operation::retain(retain.n - o_retain.n));
+ next_op1 = Some(DeltaOperation::retain(retain.n - o_retain.n));
next_op2 = ops2.next();
}
};
}
- (Some(Operation::Delete(i)), Some(Operation::Delete(j))) => match i.cmp(j) {
+ (Some(DeltaOperation::Delete(i)), Some(DeltaOperation::Delete(j))) => match i.cmp(j) {
Ordering::Less => {
- next_op2 = Some(Operation::delete(*j - *i));
+ next_op2 = Some(DeltaOperation::delete(*j - *i));
next_op1 = ops1.next();
}
Ordering::Equal => {
@@ -428,15 +429,15 @@ where
next_op2 = ops2.next();
}
Ordering::Greater => {
- next_op1 = Some(Operation::delete(*i - *j));
+ next_op1 = Some(DeltaOperation::delete(*i - *j));
next_op2 = ops2.next();
}
},
- (Some(Operation::Delete(i)), Some(Operation::Retain(o_retain))) => {
+ (Some(DeltaOperation::Delete(i)), Some(DeltaOperation::Retain(o_retain))) => {
match i.cmp(o_retain) {
Ordering::Less => {
a_prime.delete(*i);
- next_op2 = Some(Operation::retain(o_retain.n - *i));
+ next_op2 = Some(DeltaOperation::retain(o_retain.n - *i));
next_op1 = ops1.next();
}
Ordering::Equal => {
@@ -446,16 +447,16 @@ where
}
Ordering::Greater => {
a_prime.delete(o_retain.n);
- next_op1 = Some(Operation::delete(*i - o_retain.n));
+ next_op1 = Some(DeltaOperation::delete(*i - o_retain.n));
next_op2 = ops2.next();
}
};
}
- (Some(Operation::Retain(retain)), Some(Operation::Delete(j))) => {
+ (Some(DeltaOperation::Retain(retain)), Some(DeltaOperation::Delete(j))) => {
match retain.cmp(j) {
Ordering::Less => {
b_prime.delete(retain.n);
- next_op2 = Some(Operation::delete(*j - retain.n));
+ next_op2 = Some(DeltaOperation::delete(*j - retain.n));
next_op1 = ops1.next();
}
Ordering::Equal => {
@@ -465,7 +466,7 @@ where
}
Ordering::Greater => {
b_prime.delete(*j);
- next_op1 = Some(Operation::retain(retain.n - *j));
+ next_op1 = Some(DeltaOperation::retain(retain.n - *j));
next_op2 = ops2.next();
}
};
@@ -476,16 +477,16 @@ where
}
fn invert(&self, other: &Self) -> Self {
- let mut inverted = Operations::default();
+ let mut inverted = DeltaOperations::default();
let mut index = 0;
for op in &self.ops {
let len: usize = op.len() as usize;
match op {
- Operation::Delete(n) => {
+ DeltaOperation::Delete(n) => {
invert_other(&mut inverted, other, op, index, index + *n);
index += len;
}
- Operation::Retain(_) => {
+ DeltaOperation::Retain(_) => {
match op.has_attribute() {
true => invert_other(&mut inverted, other, op, index, index + len),
false => {
@@ -496,7 +497,7 @@ where
}
index += len;
}
- Operation::Insert(_) => {
+ DeltaOperation::Insert(_) => {
// tracing::trace!("invert insert: {} by delete {}", op, len);
inverted.delete(len as usize);
}
@@ -507,7 +508,7 @@ where
}
/// Removes trailing retain operation with empty attributes, if present.
-pub fn trim<T>(delta: &mut Operations<T>)
+pub fn trim<T>(delta: &mut DeltaOperations<T>)
where
T: OperationAttributes,
{
@@ -519,20 +520,20 @@ where
}
fn invert_other<T: OperationAttributes>(
- base: &mut Operations<T>,
- other: &Operations<T>,
- operation: &Operation<T>,
+ base: &mut DeltaOperations<T>,
+ other: &DeltaOperations<T>,
+ operation: &DeltaOperation<T>,
start: usize,
end: usize,
) {
tracing::trace!("invert op: {} [{}:{}]", operation, start, end);
let other_ops = OperationIterator::from_interval(other, Interval::new(start, end)).ops();
other_ops.into_iter().for_each(|other_op| match operation {
- Operation::Delete(_n) => {
+ DeltaOperation::Delete(_n) => {
// tracing::trace!("invert delete: {} by add {}", n, other_op);
base.add(other_op);
}
- Operation::Retain(_retain) => {
+ DeltaOperation::Retain(_retain) => {
tracing::trace!(
"invert attributes: {:?}, {:?}",
operation.get_attributes(),
@@ -541,15 +542,15 @@ fn invert_other<T: OperationAttributes>(
let inverted_attrs = operation.get_attributes().invert(&other_op.get_attributes());
base.retain(other_op.len(), inverted_attrs);
}
- Operation::Insert(_) => {
+ DeltaOperation::Insert(_) => {
log::error!("Impossible to here. Insert operation should be treated as delete")
}
});
}
fn transform_op_attribute<T: OperationAttributes>(
- left: &Option<Operation<T>>,
- right: &Option<Operation<T>>,
+ left: &Option<DeltaOperation<T>>,
+ right: &Option<DeltaOperation<T>>,
) -> Result<T, OTError> {
if left.is_none() {
if right.is_none() {
@@ -563,7 +564,7 @@ fn transform_op_attribute<T: OperationAttributes>(
Ok(left.transform(&right)?.0)
}
-impl<T> Operations<T>
+impl<T> DeltaOperations<T>
where
T: OperationAttributes + DeserializeOwned,
{
@@ -571,11 +572,11 @@ where
///
/// ```
/// use lib_ot::core::OperationBuilder;
- /// use lib_ot::text_delta::{TextDelta};
+ /// use lib_ot::text_delta::{TextOperations};
/// let json = r#"[
/// {"retain":7,"attributes":{"bold":null}}
/// ]"#;
- /// let delta = TextDelta::from_json(json).unwrap();
+ /// let delta = TextOperations::from_json(json).unwrap();
/// assert_eq!(delta.json_str(), r#"[{"retain":7,"attributes":{"bold":null}}]"#);
/// ```
pub fn from_json(json: &str) -> Result<Self, OTError> {
@@ -595,7 +596,7 @@ where
}
}
-impl<T> Operations<T>
+impl<T> DeltaOperations<T>
where
T: OperationAttributes + serde::Serialize,
{
@@ -616,36 +617,36 @@ where
}
}
-impl<T> FromStr for Operations<T>
+impl<T> FromStr for DeltaOperations<T>
where
T: OperationAttributes,
{
type Err = ();
- fn from_str(s: &str) -> Result<Operations<T>, Self::Err> {
- let mut delta = Operations::with_capacity(1);
- delta.add(Operation::Insert(s.into()));
+ fn from_str(s: &str) -> Result<DeltaOperations<T>, Self::Err> {
+ let mut delta = DeltaOperations::with_capacity(1);
+ delta.add(DeltaOperation::Insert(s.into()));
Ok(delta)
}
}
-impl<T> std::convert::TryFrom<Vec<u8>> for Operations<T>
+impl<T> std::convert::TryFrom<Vec<u8>> for DeltaOperations<T>
where
T: OperationAttributes + DeserializeOwned,
{
type Error = OTError;
fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
- Operations::from_bytes(bytes)
+ DeltaOperations::from_bytes(bytes)
}
}
-impl<T> std::convert::TryFrom<Bytes> for Operations<T>
+impl<T> std::convert::TryFrom<Bytes> for DeltaOperations<T>
where
T: OperationAttributes + DeserializeOwned,
{
type Error = OTError;
fn try_from(bytes: Bytes) -> Result<Self, Self::Error> {
- Operations::from_bytes(&bytes)
+ DeltaOperations::from_bytes(&bytes)
}
}
diff --git a/shared-lib/lib-ot/src/core/delta/ops_serde.rs b/shared-lib/lib-ot/src/core/delta/ops_serde.rs
index f467fafa2f..a29b32926f 100644
--- a/shared-lib/lib-ot/src/core/delta/ops_serde.rs
+++ b/shared-lib/lib-ot/src/core/delta/ops_serde.rs
@@ -1,5 +1,5 @@
use crate::core::delta::operation::OperationAttributes;
-use crate::core::delta::Operations;
+use crate::core::delta::DeltaOperations;
use serde::{
de::{SeqAccess, Visitor},
ser::SerializeSeq,
@@ -7,7 +7,7 @@ use serde::{
};
use std::{fmt, marker::PhantomData};
-impl<T> Serialize for Operations<T>
+impl<T> Serialize for DeltaOperations<T>
where
T: OperationAttributes + Serialize,
{
@@ -23,11 +23,11 @@ where
}
}
-impl<'de, T> Deserialize<'de> for Operations<T>
+impl<'de, T> Deserialize<'de> for DeltaOperations<T>
where
T: OperationAttributes + Deserialize<'de>,
{
- fn deserialize<D>(deserializer: D) -> Result<Operations<T>, D::Error>
+ fn deserialize<D>(deserializer: D) -> Result<DeltaOperations<T>, D::Error>
where
D: Deserializer<'de>,
{
@@ -37,7 +37,7 @@ where
where
T: OperationAttributes + Deserialize<'de>,
{
- type Value = Operations<T>;
+ type Value = DeltaOperations<T>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("a sequence")
@@ -48,7 +48,7 @@ where
where
A: SeqAccess<'de>,
{
- let mut o = Operations::default();
+ let mut o = DeltaOperations::default();
while let Some(op) = seq.next_element()? {
o.add(op);
}
diff --git a/shared-lib/lib-ot/src/core/node_tree/node.rs b/shared-lib/lib-ot/src/core/node_tree/node.rs
index 908cfa3f18..557078f9f6 100644
--- a/shared-lib/lib-ot/src/core/node_tree/node.rs
+++ b/shared-lib/lib-ot/src/core/node_tree/node.rs
@@ -1,9 +1,9 @@
use super::node_serde::*;
-use crate::core::attributes::{AttributeKey, AttributeValue, Attributes};
+use crate::core::attributes::{AttributeHashMap, AttributeKey, AttributeValue};
use crate::core::NodeBody::Delta;
use crate::core::OperationTransform;
use crate::errors::OTError;
-use crate::text_delta::TextDelta;
+use crate::text_delta::TextOperations;
use serde::{Deserialize, Serialize};
#[derive(Default, Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
@@ -11,9 +11,9 @@ pub struct NodeData {
#[serde(rename = "type")]
pub node_type: String,
- #[serde(skip_serializing_if = "Attributes::is_empty")]
+ #[serde(skip_serializing_if = "AttributeHashMap::is_empty")]
#[serde(default)]
- pub attributes: Attributes,
+ pub attributes: AttributeHashMap,
#[serde(serialize_with = "serialize_body")]
#[serde(deserialize_with = "deserialize_body")]
@@ -94,7 +94,7 @@ impl NodeDataBuilder {
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NodeBody {
Empty,
- Delta(TextDelta),
+ Delta(TextOperations),
}
impl std::default::Default for NodeBody {
@@ -159,7 +159,10 @@ impl OperationTransform for NodeBody {
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum NodeBodyChangeset {
- Delta { delta: TextDelta, inverted: TextDelta },
+ Delta {
+ delta: TextOperations,
+ inverted: TextOperations,
+ },
}
impl NodeBodyChangeset {
@@ -179,14 +182,14 @@ impl NodeBodyChangeset {
pub struct Node {
pub node_type: String,
pub body: NodeBody,
- pub attributes: Attributes,
+ pub attributes: AttributeHashMap,
}
impl Node {
pub fn new(node_type: &str) -> Node {
Node {
node_type: node_type.into(),
- attributes: Attributes::new(),
+ attributes: AttributeHashMap::new(),
body: NodeBody::Empty,
}
}
diff --git a/shared-lib/lib-ot/src/core/node_tree/node_serde.rs b/shared-lib/lib-ot/src/core/node_tree/node_serde.rs
index d1c2f74df1..71c8f64b45 100644
--- a/shared-lib/lib-ot/src/core/node_tree/node_serde.rs
+++ b/shared-lib/lib-ot/src/core/node_tree/node_serde.rs
@@ -1,5 +1,5 @@
use super::NodeBody;
-use crate::text_delta::TextDelta;
+use crate::text_delta::TextOperations;
use serde::de::{self, MapAccess, Visitor};
use serde::ser::SerializeMap;
use serde::{Deserializer, Serializer};
@@ -37,7 +37,7 @@ where
where
A: de::SeqAccess<'de>,
{
- let mut delta = TextDelta::default();
+ let mut delta = TextOperations::default();
while let Some(op) = seq.next_element()? {
delta.add(op);
}
@@ -49,7 +49,7 @@ where
where
V: MapAccess<'de>,
{
- let mut delta: Option<TextDelta> = None;
+ let mut delta: Option<TextOperations> = None;
while let Some(key) = map.next_key()? {
match key {
"delta" => {
diff --git a/shared-lib/lib-ot/src/core/node_tree/operation.rs b/shared-lib/lib-ot/src/core/node_tree/operation.rs
index cdd2b99c7b..324cf73a6e 100644
--- a/shared-lib/lib-ot/src/core/node_tree/operation.rs
+++ b/shared-lib/lib-ot/src/core/node_tree/operation.rs
@@ -1,4 +1,4 @@
-use crate::core::attributes::Attributes;
+use crate::core::attributes::AttributeHashMap;
use crate::core::{NodeBodyChangeset, NodeData, Path};
use crate::errors::OTError;
use serde::{Deserialize, Serialize};
@@ -13,8 +13,8 @@ pub enum NodeOperation {
#[serde(rename = "update-attribute")]
UpdateAttributes {
path: Path,
- new: Attributes,
- old: Attributes,
+ new: AttributeHashMap,
+ old: AttributeHashMap,
},
#[serde(rename = "update-body")]
@@ -121,11 +121,11 @@ impl NodeOperation {
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
-pub struct NodeOperationList {
+pub struct NodeOperations {
operations: Vec<Rc<NodeOperation>>,
}
-impl NodeOperationList {
+impl NodeOperations {
pub fn into_inner(self) -> Vec<Rc<NodeOperation>> {
self.operations
}
@@ -135,7 +135,7 @@ impl NodeOperationList {
}
}
-impl std::ops::Deref for NodeOperationList {
+impl std::ops::Deref for NodeOperations {
type Target = Vec<Rc<NodeOperation>>;
fn deref(&self) -> &Self::Target {
@@ -143,19 +143,19 @@ impl std::ops::Deref for NodeOperationList {
}
}
-impl std::ops::DerefMut for NodeOperationList {
+impl std::ops::DerefMut for NodeOperations {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.operations
}
}
-impl std::convert::From<Vec<NodeOperation>> for NodeOperationList {
+impl std::convert::From<Vec<NodeOperation>> for NodeOperations {
fn from(operations: Vec<NodeOperation>) -> Self {
Self::new(operations)
}
}
-impl NodeOperationList {
+impl NodeOperations {
pub fn new(operations: Vec<NodeOperation>) -> Self {
Self {
operations: operations.into_iter().map(Rc::new).collect(),
diff --git a/shared-lib/lib-ot/src/core/node_tree/operation_serde.rs b/shared-lib/lib-ot/src/core/node_tree/operation_serde.rs
index 439066b75b..d6dc2c49b7 100644
--- a/shared-lib/lib-ot/src/core/node_tree/operation_serde.rs
+++ b/shared-lib/lib-ot/src/core/node_tree/operation_serde.rs
@@ -1,5 +1,5 @@
use crate::core::{NodeBodyChangeset, Path};
-use crate::text_delta::TextDelta;
+use crate::text_delta::TextOperations;
use serde::de::{self, MapAccess, Visitor};
use serde::ser::SerializeMap;
use serde::{Deserializer, Serializer};
@@ -88,8 +88,8 @@ where
#[allow(dead_code)]
struct DeltaBodyChangeset<E> {
- delta: Option<TextDelta>,
- inverted: Option<TextDelta>,
+ delta: Option<TextOperations>,
+ inverted: Option<TextOperations>,
error: PhantomData<E>,
}
diff --git a/shared-lib/lib-ot/src/core/node_tree/transaction.rs b/shared-lib/lib-ot/src/core/node_tree/transaction.rs
index 1f855698cf..e6cf72e59e 100644
--- a/shared-lib/lib-ot/src/core/node_tree/transaction.rs
+++ b/shared-lib/lib-ot/src/core/node_tree/transaction.rs
@@ -1,14 +1,14 @@
-use crate::core::attributes::Attributes;
+use crate::core::attributes::AttributeHashMap;
use crate::core::{NodeData, NodeOperation, NodeTree, Path};
use crate::errors::OTError;
use indextree::NodeId;
use std::rc::Rc;
-use super::{NodeBodyChangeset, NodeOperationList};
+use super::{NodeBodyChangeset, NodeOperations};
#[derive(Debug, Clone, Default)]
pub struct Transaction {
- operations: NodeOperationList,
+ operations: NodeOperations,
}
impl Transaction {
@@ -16,7 +16,7 @@ impl Transaction {
Self::default()
}
- pub fn from_operations<T: Into<NodeOperationList>>(operations: T) -> Self {
+ pub fn from_operations<T: Into<NodeOperations>>(operations: T) -> Self {
Self {
operations: operations.into(),
}
@@ -66,14 +66,14 @@ impl std::ops::DerefMut for Transaction {
pub struct TransactionBuilder<'a> {
node_tree: &'a NodeTree,
- operations: NodeOperationList,
+ operations: NodeOperations,
}
impl<'a> TransactionBuilder<'a> {
pub fn new(node_tree: &'a NodeTree) -> TransactionBuilder {
TransactionBuilder {
node_tree,
- operations: NodeOperationList::default(),
+ operations: NodeOperations::default(),
}
}
@@ -132,10 +132,10 @@ impl<'a> TransactionBuilder<'a> {
self.insert_nodes_at_path(path, vec![node])
}
- pub fn update_attributes_at_path(mut self, path: &Path, attributes: Attributes) -> Self {
+ pub fn update_attributes_at_path(mut self, path: &Path, attributes: AttributeHashMap) -> Self {
match self.node_tree.get_node_at_path(path) {
Some(node) => {
- let mut old_attributes = Attributes::new();
+ let mut old_attributes = AttributeHashMap::new();
for key in attributes.keys() {
let old_attrs = &node.attributes;
if let Some(value) = old_attrs.get(key.as_str()) {
diff --git a/shared-lib/lib-ot/src/core/node_tree/tree.rs b/shared-lib/lib-ot/src/core/node_tree/tree.rs
index fde8ccf20c..50a3e50226 100644
--- a/shared-lib/lib-ot/src/core/node_tree/tree.rs
+++ b/shared-lib/lib-ot/src/core/node_tree/tree.rs
@@ -1,10 +1,10 @@
-use crate::core::attributes::Attributes;
+use crate::core::attributes::AttributeHashMap;
use crate::core::{Node, NodeBodyChangeset, NodeData, NodeOperation, OperationTransform, Path, Transaction};
use crate::errors::{ErrorBuilder, OTError, OTErrorCode};
use indextree::{Arena, Children, FollowingSiblings, NodeId};
use std::rc::Rc;
-use super::NodeOperationList;
+use super::NodeOperations;
///
pub struct NodeTree {
@@ -26,11 +26,11 @@ impl NodeTree {
}
pub fn from_bytes(root_name: &str, bytes: Vec<u8>) -> Result<Self, OTError> {
- let operations = NodeOperationList::from_bytes(bytes)?;
+ let operations = NodeOperations::from_bytes(bytes)?;
Self::from_operations(root_name, operations)
}
- pub fn from_operations(root_name: &str, operations: NodeOperationList) -> Result<Self, OTError> {
+ pub fn from_operations(root_name: &str, operations: NodeOperations) -> Result<Self, OTError> {
let mut node_tree = NodeTree::new(root_name);
for operation in operations.into_inner().into_iter() {
let _ = node_tree.apply_op(operation)?;
@@ -252,9 +252,9 @@ impl NodeTree {
}
}
- fn update_attributes(&mut self, path: &Path, attributes: Attributes) -> Result<(), OTError> {
+ fn update_attributes(&mut self, path: &Path, attributes: AttributeHashMap) -> Result<(), OTError> {
self.mut_node_at_path(path, |node| {
- let new_attributes = Attributes::compose(&node.attributes, &attributes)?;
+ let new_attributes = AttributeHashMap::compose(&node.attributes, &attributes)?;
node.attributes = new_attributes;
Ok(())
})
diff --git a/shared-lib/lib-ot/src/text_delta/attributes.rs b/shared-lib/lib-ot/src/text_delta/attributes.rs
index 388f492bdf..b695d8a805 100644
--- a/shared-lib/lib-ot/src/text_delta/attributes.rs
+++ b/shared-lib/lib-ot/src/text_delta/attributes.rs
@@ -1,5 +1,5 @@
#![allow(non_snake_case)]
-use crate::core::{AttributeEntry, AttributeKey, Attributes};
+use crate::core::{AttributeEntry, AttributeHashMap, AttributeKey};
use crate::text_delta::TextOperation;
use crate::{inline_attribute_entry, inline_list_attribute_entry};
use lazy_static::lazy_static;
@@ -8,11 +8,11 @@ use std::{collections::HashSet, iter::FromIterator};
use strum_macros::{AsRefStr, Display, EnumString};
#[inline(always)]
-pub fn empty_attributes() -> Attributes {
- Attributes::default()
+pub fn empty_attributes() -> AttributeHashMap {
+ AttributeHashMap::default()
}
-pub fn attributes_except_header(op: &TextOperation) -> Attributes {
+pub fn attributes_except_header(op: &TextOperation) -> AttributeHashMap {
let mut attributes = op.get_attributes();
attributes.remove_key(BuildInTextAttributeKey::Header);
attributes
diff --git a/shared-lib/lib-ot/src/text_delta/delta.rs b/shared-lib/lib-ot/src/text_delta/delta.rs
index e8eb3c3fd8..fc5cb4e150 100644
--- a/shared-lib/lib-ot/src/text_delta/delta.rs
+++ b/shared-lib/lib-ot/src/text_delta/delta.rs
@@ -1,5 +1,10 @@
-use crate::core::{Attributes, Operation, OperationBuilder, Operations};
+use crate::core::{AttributeHashMap, DeltaOperation, DeltaOperations, OperationBuilder, OperationTransform};
+use std::fmt::Debug;
-pub type TextDelta = Operations<Attributes>;
-pub type TextDeltaBuilder = OperationBuilder<Attributes>;
-pub type TextOperation = Operation<Attributes>;
+pub type TextOperations = DeltaOperations<AttributeHashMap>;
+pub type TextOperationBuilder = OperationBuilder<AttributeHashMap>;
+pub type TextOperation = DeltaOperation<AttributeHashMap>;
+
+// pub trait TextOperation2: Default + Debug + OperationTransform {}
+//
+// impl TextOperation2 for TextOperations {}
diff --git a/shared-lib/lib-ot/tests/node/editor_test.rs b/shared-lib/lib-ot/tests/node/editor_test.rs
index abd294ecc0..1695b015c0 100644
--- a/shared-lib/lib-ot/tests/node/editor_test.rs
+++ b/shared-lib/lib-ot/tests/node/editor_test.rs
@@ -2,7 +2,7 @@ use super::script::{NodeScript::*, *};
use lib_ot::core::AttributeBuilder;
use lib_ot::{
core::{NodeData, Path},
- text_delta::TextDeltaBuilder,
+ text_delta::TextOperationBuilder,
};
#[test]
@@ -11,7 +11,7 @@ fn editor_deserialize_node_test() {
let node: NodeData = serde_json::from_str(EXAMPLE_JSON).unwrap();
let path: Path = 0.into();
- let expected_delta = TextDeltaBuilder::new()
+ let expected_delta = TextOperationBuilder::new()
.insert("👋 ")
.insert_with_attributes(
"Welcome to ",
diff --git a/shared-lib/lib-ot/tests/node/operation_test.rs b/shared-lib/lib-ot/tests/node/operation_test.rs
index a0be952afb..114b2abb01 100644
--- a/shared-lib/lib-ot/tests/node/operation_test.rs
+++ b/shared-lib/lib-ot/tests/node/operation_test.rs
@@ -3,7 +3,7 @@ use crate::node::script::NodeTest;
use lib_ot::core::{AttributeBuilder, Node};
use lib_ot::{
core::{NodeBodyChangeset, NodeData, NodeDataBuilder, NodeOperation, Path},
- text_delta::TextDeltaBuilder,
+ text_delta::TextOperationBuilder,
};
#[test]
@@ -48,7 +48,7 @@ fn operation_update_node_attributes_serde_test() {
#[test]
fn operation_update_node_body_serialize_test() {
- let delta = TextDeltaBuilder::new().insert("AppFlowy...").build();
+ let delta = TextOperationBuilder::new().insert("AppFlowy...").build();
let inverted = delta.invert_str("");
let changeset = NodeBodyChangeset::Delta { delta, inverted };
let insert = NodeOperation::UpdateBody {
diff --git a/shared-lib/lib-ot/tests/node/script.rs b/shared-lib/lib-ot/tests/node/script.rs
index 678138e183..7c27763bc7 100644
--- a/shared-lib/lib-ot/tests/node/script.rs
+++ b/shared-lib/lib-ot/tests/node/script.rs
@@ -1,8 +1,8 @@
use lib_ot::core::{Node, Transaction};
use lib_ot::{
- core::attributes::Attributes,
+ core::attributes::AttributeHashMap,
core::{NodeBody, NodeBodyChangeset, NodeData, NodeTree, Path, TransactionBuilder},
- text_delta::TextDelta,
+ text_delta::TextOperations,
};
use std::collections::HashMap;
@@ -14,7 +14,7 @@ pub enum NodeScript {
},
UpdateAttributes {
path: Path,
- attributes: Attributes,
+ attributes: AttributeHashMap,
},
UpdateBody {
path: Path,
@@ -38,7 +38,7 @@ pub enum NodeScript {
},
AssertNodeDelta {
path: Path,
- expected: TextDelta,
+ expected: TextOperations,
},
}
diff --git a/shared-lib/lib-ot/tests/node/tree_test.rs b/shared-lib/lib-ot/tests/node/tree_test.rs
index c1f1532385..98f9ee00ed 100644
--- a/shared-lib/lib-ot/tests/node/tree_test.rs
+++ b/shared-lib/lib-ot/tests/node/tree_test.rs
@@ -4,7 +4,7 @@ use lib_ot::core::NodeBody;
use lib_ot::core::NodeBodyChangeset;
use lib_ot::core::OperationTransform;
use lib_ot::core::{NodeData, NodeDataBuilder, Path};
-use lib_ot::text_delta::TextDeltaBuilder;
+use lib_ot::text_delta::TextOperationBuilder;
#[test]
fn node_insert_test() {
@@ -293,8 +293,8 @@ fn node_update_body_test() {
let path: Path = 0.into();
let s = "Hello".to_owned();
- let init_delta = TextDeltaBuilder::new().insert(&s).build();
- let delta = TextDeltaBuilder::new().retain(s.len()).insert(" AppFlowy").build();
+ let init_delta = TextOperationBuilder::new().insert(&s).build();
+ let delta = TextOperationBuilder::new().retain(s.len()).insert(" AppFlowy").build();
let inverted = delta.invert(&init_delta);
let expected = init_delta.compose(&delta).unwrap();