Mirrored_Repos/AppFlowy
1
0
Fork 0
mirror of https://github.com/AppFlowy-IO/AppFlowy.git synced 2024-08-30 18:12:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: refactor delta attributes

Browse Source
This commit is contained in:
appflowy 2022-09-13 11:38:19 +08:00
parent c552e958ce
commit c991473259
42 changed files with 591 additions and 1016 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
frontend/rust-lib/Cargo.lock generated
View File

@ -1172,6 +1172,7 @@ dependencies = [
"strum_macros",
"tokio",
"tracing",
"tracing-subscriber",
"unicode-segmentation",
"url",
]

8
frontend/rust-lib/flowy-revision/src/conflict_resolve.rs
View File

@ -9,8 +9,8 @@ use flowy_sync::{
util::make_delta_from_revisions,
};
use lib_infra::future::BoxResultFuture;
use lib_ot::core::{EmptyAttributes, OperationAttributes, Operations};
use lib_ot::text_delta::TextAttributes;
use lib_ot::core::{Attributes, EmptyAttributes, OperationAttributes, Operations};
use serde::de::DeserializeOwned;
use std::{convert::TryFrom, sync::Arc};
@ -30,7 +30,7 @@ pub trait ConflictRevisionSink: Send + Sync + 'static {
fn ack(&self, rev_id: String, ty: ServerRevisionWSDataType) -> BoxResultFuture<(), FlowyError>;
}
pub type RichTextConflictController = ConflictController<TextAttributes>;
pub type RichTextConflictController = ConflictController<Attributes>;
pub type PlainTextConflictController = ConflictController<EmptyAttributes>;
pub struct ConflictController<T>
@ -175,7 +175,7 @@ where
}
}
pub type RichTextTransformDeltas = TransformDeltas<TextAttributes>;
pub type RichTextTransformDeltas = TransformDeltas<Attributes>;
pub struct TransformDeltas<T>
where

2
frontend/rust-lib/flowy-text-block/Cargo.toml
View File

@ -26,6 +26,7 @@ unicode-segmentation = "1.8"
log = "0.4.14"
tokio = {version = "1", features = ["sync"]}
tracing = { version = "0.1", features = ["log"] }
bytes = { version = "1.1" }
strum = "0.21"
strum_macros = "0.21"
@ -42,6 +43,7 @@ futures = "0.3.15"
flowy-test = { path = "../flowy-test" }
flowy-text-block = { path = "../flowy-text-block", features = ["flowy_unit_test"]}
derive_more = {version = "0.99", features = ["display"]}
tracing-subscriber = "0.2.0"
color-eyre = { version = "0.5", default-features = false }
criterion = "0.3"

5
frontend/rust-lib/flowy-text-block/src/editor.rs
View File

@ -13,9 +13,10 @@ use flowy_sync::{
errors::CollaborateResult,
util::make_delta_from_revisions,
};
use lib_ot::core::AttributeEntry;
use lib_ot::{
core::{Interval, Operation},
text_delta::{TextAttribute, TextDelta},
text_delta::TextDelta,
};
use lib_ws::WSConnectState;
use std::sync::Arc;
@ -85,7 +86,7 @@ impl TextBlockEditor {
Ok(())
}
pub async fn format(&self, interval: Interval, attribute: TextAttribute) -> Result<(), FlowyError> {
pub async fn format(&self, interval: Interval, attribute: AttributeEntry) -> Result<(), FlowyError> {
let (ret, rx) = oneshot::channel::<CollaborateResult<()>>();
let msg = EditorCommand::Format {
interval,

7
frontend/rust-lib/flowy-text-block/src/queue.rs
View File

@ -11,9 +11,10 @@ use flowy_sync::{
errors::CollaborateError,
};
use futures::stream::StreamExt;
use lib_ot::core::{AttributeEntry, Attributes};
use lib_ot::{
core::{Interval, OperationTransform},
text_delta::{TextAttribute, TextAttributes, TextDelta},
text_delta::TextDelta,
};
use std::sync::Arc;
use tokio::sync::{oneshot, RwLock};
@ -194,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::<TextAttributes>(revisions)?;
let delta = make_delta_from_revisions::<Attributes>(revisions)?;
Ok(delta.json_bytes())
}
}
@ -229,7 +230,7 @@ pub(crate) enum EditorCommand {
},
Format {
interval: Interval,
attribute: TextAttribute,
attribute: AttributeEntry,
ret: Ret<()>,
},
Replace {

5
frontend/rust-lib/flowy-text-block/src/web_socket.rs
View File

@ -10,7 +10,8 @@ use flowy_sync::{
errors::CollaborateResult,
};
use lib_infra::future::{BoxResultFuture, FutureResult};
use lib_ot::text_delta::TextAttributes;
use lib_ot::core::Attributes;
use lib_ot::text_delta::TextDelta;
use lib_ws::WSConnectState;
use std::{sync::Arc, time::Duration};
@ -111,7 +112,7 @@ struct TextBlockConflictResolver {
edit_cmd_tx: EditorCommandSender,
}
impl ConflictResolver<TextAttributes> for TextBlockConflictResolver {
impl ConflictResolver<Attributes> for TextBlockConflictResolver {
fn compose_delta(&self, delta: TextDelta) -> BoxResultFuture<DeltaMD5, FlowyError> {
let tx = self.edit_cmd_tx.clone();
Box::pin(async move {

176
frontend/rust-lib/flowy-text-block/tests/editor/attribute_test.rs
View File

@ -1,6 +1,6 @@
#![cfg_attr(rustfmt, rustfmt::skip)]
use crate::editor::{TestBuilder, TestOp::*};
use flowy_sync::client_document::{NewlineDoc, PlainDoc};
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;
@ -14,12 +14,12 @@ fn attributes_bold_added() {
0,
r#"[
{"insert":"123"},
{"insert":"45","attributes":{"bold":"true"}},
{"insert":"45","attributes":{"bold":true}},
{"insert":"6"}
]"#,
),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
@ -27,11 +27,11 @@ fn attributes_bold_added_and_invert_all() {
let ops = vec![
Insert(0, "123", 0),
Bold(0, Interval::new(0, 3), true),
AssertDocJson(0, r#"[{"insert":"123","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"123","attributes":{"bold":true}}]"#),
Bold(0, Interval::new(0, 3), false),
AssertDocJson(0, r#"[{"insert":"123"}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
@ -39,11 +39,11 @@ fn attributes_bold_added_and_invert_partial_suffix() {
let ops = vec![
Insert(0, "1234", 0),
Bold(0, Interval::new(0, 4), true),
AssertDocJson(0, r#"[{"insert":"1234","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"1234","attributes":{"bold":true}}]"#),
Bold(0, Interval::new(2, 4), false),
AssertDocJson(0, r#"[{"insert":"12","attributes":{"bold":"true"}},{"insert":"34"}]"#),
AssertDocJson(0, r#"[{"insert":"12","attributes":{"bold":true}},{"insert":"34"}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
@ -51,13 +51,13 @@ fn attributes_bold_added_and_invert_partial_suffix2() {
let ops = vec![
Insert(0, "1234", 0),
Bold(0, Interval::new(0, 4), true),
AssertDocJson(0, r#"[{"insert":"1234","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"1234","attributes":{"bold":true}}]"#),
Bold(0, Interval::new(2, 4), false),
AssertDocJson(0, r#"[{"insert":"12","attributes":{"bold":"true"}},{"insert":"34"}]"#),
AssertDocJson(0, r#"[{"insert":"12","attributes":{"bold":true}},{"insert":"34"}]"#),
Bold(0, Interval::new(2, 4), true),
AssertDocJson(0, r#"[{"insert":"1234","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"1234","attributes":{"bold":true}}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
@ -67,22 +67,22 @@ fn attributes_bold_added_with_new_line() {
Bold(0, Interval::new(0, 6), true),
AssertDocJson(
0,
r#"[{"insert":"123456","attributes":{"bold":"true"}},{"insert":"\n"}]"#,
r#"[{"insert":"123456","attributes":{"bold":true}},{"insert":"\n"}]"#,
),
Insert(0, "\n", 3),
AssertDocJson(
0,
r#"[{"insert":"123","attributes":{"bold":"true"}},{"insert":"\n"},{"insert":"456","attributes":{"bold":"true"}},{"insert":"\n"}]"#,
r#"[{"insert":"123","attributes":{"bold":true}},{"insert":"\n"},{"insert":"456","attributes":{"bold":true}},{"insert":"\n"}]"#,
),
Insert(0, "\n", 4),
AssertDocJson(
0,
r#"[{"insert":"123","attributes":{"bold":"true"}},{"insert":"\n\n"},{"insert":"456","attributes":{"bold":"true"}},{"insert":"\n"}]"#,
r#"[{"insert":"123","attributes":{"bold":true}},{"insert":"\n\n"},{"insert":"456","attributes":{"bold":true}},{"insert":"\n"}]"#,
),
Insert(0, "a", 4),
AssertDocJson(
0,
r#"[{"insert":"123","attributes":{"bold":"true"}},{"insert":"\na\n"},{"insert":"456","attributes":{"bold":"true"}},{"insert":"\n"}]"#,
r#"[{"insert":"123","attributes":{"bold":true}},{"insert":"\na\n"},{"insert":"456","attributes":{"bold":true}},{"insert":"\n"}]"#,
),
];
TestBuilder::new().run_scripts::<NewlineDoc>(ops);
@ -93,11 +93,11 @@ fn attributes_bold_added_and_invert_partial_prefix() {
let ops = vec![
Insert(0, "1234", 0),
Bold(0, Interval::new(0, 4), true),
AssertDocJson(0, r#"[{"insert":"1234","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"1234","attributes":{"bold":true}}]"#),
Bold(0, Interval::new(0, 2), false),
AssertDocJson(0, r#"[{"insert":"12"},{"insert":"34","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"12"},{"insert":"34","attributes":{"bold":true}}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
@ -105,11 +105,11 @@ fn attributes_bold_added_consecutive() {
let ops = vec![
Insert(0, "1234", 0),
Bold(0, Interval::new(0, 1), true),
AssertDocJson(0, r#"[{"insert":"1","attributes":{"bold":"true"}},{"insert":"234"}]"#),
AssertDocJson(0, r#"[{"insert":"1","attributes":{"bold":true}},{"insert":"234"}]"#),
Bold(0, Interval::new(1, 2), true),
AssertDocJson(0, r#"[{"insert":"12","attributes":{"bold":"true"}},{"insert":"34"}]"#),
AssertDocJson(0, r#"[{"insert":"12","attributes":{"bold":true}},{"insert":"34"}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
@ -120,12 +120,12 @@ fn attributes_bold_added_italic() {
Italic(0, Interval::new(0, 4), true),
AssertDocJson(
0,
r#"[{"insert":"1234","attributes":{"italic":"true","bold":"true"}},{"insert":"\n"}]"#,
r#"[{"insert":"1234","attributes":{"italic":true,"bold":true}},{"insert":"\n"}]"#,
),
Insert(0, "5678", 4),
AssertDocJson(
0,
r#"[{"insert":"12345678","attributes":{"bold":"true","italic":"true"}},{"insert":"\n"}]"#,
r#"[{"insert":"12345678","attributes":{"bold":true,"italic":true}},{"insert":"\n"}]"#,
),
];
TestBuilder::new().run_scripts::<NewlineDoc>(ops);
@ -136,27 +136,27 @@ fn attributes_bold_added_italic2() {
let ops = vec![
Insert(0, "123456", 0),
Bold(0, Interval::new(0, 6), true),
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":true}}]"#),
Italic(0, Interval::new(0, 2), true),
AssertDocJson(
0,
r#"[
{"insert":"12","attributes":{"italic":"true","bold":"true"}},
{"insert":"3456","attributes":{"bold":"true"}}]
{"insert":"12","attributes":{"italic":true,"bold":true}},
{"insert":"3456","attributes":{"bold":true}}]
"#,
),
Italic(0, Interval::new(4, 6), true),
AssertDocJson(
0,
r#"[
{"insert":"12","attributes":{"italic":"true","bold":"true"}},
{"insert":"34","attributes":{"bold":"true"}},
{"insert":"56","attributes":{"italic":"true","bold":"true"}}]
{"insert":"12","attributes":{"italic":true,"bold":true}},
{"insert":"34","attributes":{"bold":true}},
{"insert":"56","attributes":{"italic":true,"bold":true}}]
"#,
),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
@ -168,16 +168,16 @@ fn attributes_bold_added_italic3() {
AssertDocJson(
0,
r#"[
{"insert":"12","attributes":{"bold":"true","italic":"true"}},
{"insert":"345","attributes":{"bold":"true"}},{"insert":"6789"}]
{"insert":"12","attributes":{"bold":true,"italic":true}},
{"insert":"345","attributes":{"bold":true}},{"insert":"6789"}]
"#,
),
Italic(0, Interval::new(2, 4), true),
AssertDocJson(
0,
r#"[
{"insert":"1234","attributes":{"bold":"true","italic":"true"}},
{"insert":"5","attributes":{"bold":"true"}},
{"insert":"1234","attributes":{"bold":true,"italic":true}},
{"insert":"5","attributes":{"bold":true}},
{"insert":"6789"}]
"#,
),
@ -185,15 +185,15 @@ fn attributes_bold_added_italic3() {
AssertDocJson(
0,
r#"[
{"insert":"1234","attributes":{"bold":"true","italic":"true"}},
{"insert":"5","attributes":{"bold":"true"}},
{"insert":"1234","attributes":{"bold":true,"italic":true}},
{"insert":"5","attributes":{"bold":true}},
{"insert":"67"},
{"insert":"89","attributes":{"bold":"true"}}]
{"insert":"89","attributes":{"bold":true}}]
"#,
),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
@ -205,57 +205,57 @@ fn attributes_bold_added_italic_delete() {
AssertDocJson(
0,
r#"[
{"insert":"12","attributes":{"italic":"true","bold":"true"}},
{"insert":"345","attributes":{"bold":"true"}},{"insert":"6789"}]
{"insert":"12","attributes":{"italic":true,"bold":true}},
{"insert":"345","attributes":{"bold":true}},{"insert":"6789"}]
"#,
),
Italic(0, Interval::new(2, 4), true),
AssertDocJson(
0,
r#"[
{"insert":"1234","attributes":{"bold":"true","italic":"true"}}
,{"insert":"5","attributes":{"bold":"true"}},{"insert":"6789"}]"#,
{"insert":"1234","attributes":{"bold":true,"italic":true}}
,{"insert":"5","attributes":{"bold":true}},{"insert":"6789"}]"#,
),
Bold(0, Interval::new(7, 9), true),
AssertDocJson(
0,
r#"[
{"insert":"1234","attributes":{"bold":"true","italic":"true"}},
{"insert":"5","attributes":{"bold":"true"}},{"insert":"67"},
{"insert":"89","attributes":{"bold":"true"}}]
{"insert":"1234","attributes":{"bold":true,"italic":true}},
{"insert":"5","attributes":{"bold":true}},{"insert":"67"},
{"insert":"89","attributes":{"bold":true}}]
"#,
),
Delete(0, Interval::new(0, 5)),
AssertDocJson(0, r#"[{"insert":"67"},{"insert":"89","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"67"},{"insert":"89","attributes":{"bold":true}}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
fn attributes_merge_inserted_text_with_same_attribute() {
let ops = vec![
InsertBold(0, "123", Interval::new(0, 3)),
AssertDocJson(0, r#"[{"insert":"123","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"123","attributes":{"bold":true}}]"#),
InsertBold(0, "456", Interval::new(3, 6)),
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":true}}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
fn attributes_compose_attr_attributes_with_attr_attributes_test() {
let ops = vec![
InsertBold(0, "123456", Interval::new(0, 6)),
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":true}}]"#),
InsertBold(1, "7", Interval::new(0, 1)),
AssertDocJson(1, r#"[{"insert":"7","attributes":{"bold":"true"}}]"#),
AssertDocJson(1, r#"[{"insert":"7","attributes":{"bold":true}}]"#),
Transform(0, 1),
AssertDocJson(0, r#"[{"insert":"1234567","attributes":{"bold":"true"}}]"#),
AssertDocJson(1, r#"[{"insert":"1234567","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"1234567","attributes":{"bold":true}}]"#),
AssertDocJson(1, r#"[{"insert":"1234567","attributes":{"bold":true}}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
@ -268,113 +268,113 @@ fn attributes_compose_attr_attributes_with_attr_attributes_test2() {
AssertDocJson(
0,
r#"[
{"insert":"12","attributes":{"bold":"true","italic":"true"}},
{"insert":"34","attributes":{"bold":"true"}},
{"insert":"56","attributes":{"italic":"true","bold":"true"}}]
{"insert":"12","attributes":{"bold":true,"italic":true}},
{"insert":"34","attributes":{"bold":true}},
{"insert":"56","attributes":{"italic":true,"bold":true}}]
"#,
),
InsertBold(1, "7", Interval::new(0, 1)),
AssertDocJson(1, r#"[{"insert":"7","attributes":{"bold":"true"}}]"#),
AssertDocJson(1, r#"[{"insert":"7","attributes":{"bold":true}}]"#),
Transform(0, 1),
AssertDocJson(
0,
r#"[
{"insert":"12","attributes":{"italic":"true","bold":"true"}},
{"insert":"34","attributes":{"bold":"true"}},
{"insert":"56","attributes":{"italic":"true","bold":"true"}},
{"insert":"7","attributes":{"bold":"true"}}]
{"insert":"12","attributes":{"italic":true,"bold":true}},
{"insert":"34","attributes":{"bold":true}},
{"insert":"56","attributes":{"italic":true,"bold":true}},
{"insert":"7","attributes":{"bold":true}}]
"#,
),
AssertDocJson(
1,
r#"[
{"insert":"12","attributes":{"italic":"true","bold":"true"}},
{"insert":"34","attributes":{"bold":"true"}},
{"insert":"56","attributes":{"italic":"true","bold":"true"}},
{"insert":"7","attributes":{"bold":"true"}}]
{"insert":"12","attributes":{"italic":true,"bold":true}},
{"insert":"34","attributes":{"bold":true}},
{"insert":"56","attributes":{"italic":true,"bold":true}},
{"insert":"7","attributes":{"bold":true}}]
"#,
),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
fn attributes_compose_attr_attributes_with_no_attr_attributes_test() {
let expected = r#"[{"insert":"123456","attributes":{"bold":"true"}},{"insert":"7"}]"#;
let expected = r#"[{"insert":"123456","attributes":{"bold":true}},{"insert":"7"}]"#;
let ops = vec![
InsertBold(0, "123456", Interval::new(0, 6)),
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":true}}]"#),
Insert(1, "7", 0),
AssertDocJson(1, r#"[{"insert":"7"}]"#),
Transform(0, 1),
AssertDocJson(0, expected),
AssertDocJson(1, expected),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
fn attributes_replace_heading() {
let ops = vec![
InsertBold(0, "123456", Interval::new(0, 6)),
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":true}}]"#),
Delete(0, Interval::new(0, 2)),
AssertDocJson(0, r#"[{"insert":"3456","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"3456","attributes":{"bold":true}}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
fn attributes_replace_trailing() {
let ops = vec![
InsertBold(0, "123456", Interval::new(0, 6)),
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":true}}]"#),
Delete(0, Interval::new(5, 6)),
AssertDocJson(0, r#"[{"insert":"12345","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"12345","attributes":{"bold":true}}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
fn attributes_replace_middle() {
let ops = vec![
InsertBold(0, "123456", Interval::new(0, 6)),
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":true}}]"#),
Delete(0, Interval::new(0, 2)),
AssertDocJson(0, r#"[{"insert":"3456","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"3456","attributes":{"bold":true}}]"#),
Delete(0, Interval::new(2, 4)),
AssertDocJson(0, r#"[{"insert":"34","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"34","attributes":{"bold":true}}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
fn attributes_replace_all() {
let ops = vec![
InsertBold(0, "123456", Interval::new(0, 6)),
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":true}}]"#),
Delete(0, Interval::new(0, 6)),
AssertDocJson(0, r#"[]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
fn attributes_replace_with_text() {
let ops = vec![
InsertBold(0, "123456", Interval::new(0, 6)),
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":true}}]"#),
Replace(0, Interval::new(0, 3), "ab"),
AssertDocJson(0, r#"[{"insert":"ab"},{"insert":"456","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"ab"},{"insert":"456","attributes":{"bold":true}}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
@ -472,7 +472,7 @@ fn attributes_link_format_with_bold() {
AssertDocJson(
0,
r#"[
{"insert":"123","attributes":{"bold":"true","link":"https://appflowy.io"}},
{"insert":"123","attributes":{"bold":true,"link":"https://appflowy.io"}},
{"insert":"456","attributes":{"link":"https://appflowy.io"}},
{"insert":"\n"}]
"#,

27
frontend/rust-lib/flowy-text-block/tests/editor/mod.rs
View File

@ -8,13 +8,11 @@ use derive_more::Display;
use flowy_sync::client_document::{ClientDocument, InitialDocumentText};
use lib_ot::{
core::*,
text_delta::{TextAttribute, TextAttributes, TextDelta},
text_delta::{BuildInTextAttribute, TextDelta},
};
use rand::{prelude::*, Rng as WrappedRng};
use std::{sync::Once, time::Duration};
const LEVEL: &str = "info";
#[derive(Clone, Debug, Display)]
pub enum TestOp {
#[display(fmt = "Insert")]
@ -92,7 +90,8 @@ impl TestBuilder {
static INIT: Once = Once::new();
INIT.call_once(|| {
let _ = color_eyre::install();
std::env::set_var("RUST_LOG", LEVEL);
// let subscriber = FmtSubscriber::builder().with_max_level(Level::INFO).finish();
// tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");
});
Self {
@ -127,11 +126,11 @@ impl TestBuilder {
TestOp::InsertBold(delta_i, s, iv) => {
let document = &mut self.documents[*delta_i];
document.insert(iv.start, s).unwrap();
document.format(*iv, TextAttribute::Bold(true)).unwrap();
document.format(*iv, BuildInTextAttribute::Bold(true)).unwrap();
}
TestOp::Bold(delta_i, iv, enable) => {
let document = &mut self.documents[*delta_i];
let attribute = TextAttribute::Bold(*enable);
let attribute = BuildInTextAttribute::Bold(*enable);
let delta = document.format(*iv, attribute).unwrap();
tracing::trace!("Bold delta: {}", delta.json_str());
self.deltas.insert(*delta_i, Some(delta));
@ -139,8 +138,8 @@ impl TestBuilder {
TestOp::Italic(delta_i, iv, enable) => {
let document = &mut self.documents[*delta_i];
let attribute = match *enable {
true => TextAttribute::Italic(true),
false => TextAttribute::Italic(false),
true => BuildInTextAttribute::Italic(true),
false => BuildInTextAttribute::Italic(false),
};
let delta = document.format(*iv, attribute).unwrap();
tracing::trace!("Italic delta: {}", delta.json_str());
@ -148,21 +147,21 @@ impl TestBuilder {
}
TestOp::Header(delta_i, iv, level) => {
let document = &mut self.documents[*delta_i];
let attribute = TextAttribute::Header(*level);
let attribute = BuildInTextAttribute::Header(*level);
let delta = document.format(*iv, attribute).unwrap();
tracing::trace!("Header delta: {}", delta.json_str());
self.deltas.insert(*delta_i, Some(delta));
}
TestOp::Link(delta_i, iv, link) => {
let document = &mut self.documents[*delta_i];
let attribute = TextAttribute::Link(link.to_owned());
let attribute = BuildInTextAttribute::Link(link.to_owned());
let delta = document.format(*iv, attribute).unwrap();
tracing::trace!("Link delta: {}", delta.json_str());
self.deltas.insert(*delta_i, Some(delta));
}
TestOp::Bullet(delta_i, iv, enable) => {
let document = &mut self.documents[*delta_i];
let attribute = TextAttribute::Bullet(*enable);
let attribute = BuildInTextAttribute::Bullet(*enable);
let delta = document.format(*iv, attribute).unwrap();
tracing::debug!("Bullet delta: {}", delta.json_str());
@ -313,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), TextAttributes::default());
delta.insert(&self.gen_string(i), Attributes::default());
}
f if f < 0.4 => {
delta.delete(i);
}
_ => {
delta.retain(i, TextAttributes::default());
delta.retain(i, Attributes::default());
}
}
}
if self.0.gen_range(0.0..1.0) < 0.3 {
delta.insert(&("1".to_owned() + &self.gen_string(10)), TextAttributes::default());
delta.insert(&("1".to_owned() + &self.gen_string(10)), Attributes::default());
}
delta
}

145
frontend/rust-lib/flowy-text-block/tests/editor/op_test.rs
View File

@ -1,12 +1,8 @@
#![allow(clippy::all)]
use crate::editor::{Rng, TestBuilder, TestOp::*};
use flowy_sync::client_document::{NewlineDoc, PlainDoc};
use flowy_sync::client_document::{EmptyDoc, NewlineDoc};
use lib_ot::text_delta::TextDeltaBuilder;
use lib_ot::{
core::Interval,
core::*,
text_delta::{TextAttribute, TextAttributes, TextDelta, TextDeltaAttributeBuilder},
};
use lib_ot::{core::Interval, core::*, text_delta::TextDelta};
#[test]
fn attributes_insert_text() {
@ -15,7 +11,7 @@ fn attributes_insert_text() {
Insert(0, "456", 3),
AssertDocJson(0, r#"[{"insert":"123456"}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
@ -25,7 +21,7 @@ fn attributes_insert_text_at_head() {
Insert(0, "456", 0),
AssertDocJson(0, r#"[{"insert":"456123"}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
@ -35,7 +31,7 @@ fn attributes_insert_text_at_middle() {
Insert(0, "456", 1),
AssertDocJson(0, r#"[{"insert":"145623"}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
@ -206,9 +202,9 @@ fn delta_utf16_code_unit_seek() {
#[test]
fn delta_utf16_code_unit_seek_with_attributes() {
let mut delta = TextDelta::default();
let attributes = TextDeltaAttributeBuilder::new()
.add_attr(TextAttribute::Bold(true))
.add_attr(TextAttribute::Italic(true))
let attributes = AttributeBuilder::new()
.insert("bold", true)
.insert("italic", true)
.build();
delta.add(Operation::insert_with_attributes("1234", attributes.clone()));
@ -304,13 +300,13 @@ fn lengths() {
let mut delta = TextDelta::default();
assert_eq!(delta.utf16_base_len, 0);
assert_eq!(delta.utf16_target_len, 0);
delta.retain(5, TextAttributes::default());
delta.retain(5, Attributes::default());
assert_eq!(delta.utf16_base_len, 5);
assert_eq!(delta.utf16_target_len, 5);
delta.insert("abc", TextAttributes::default());
delta.insert("abc", Attributes::default());
assert_eq!(delta.utf16_base_len, 5);
assert_eq!(delta.utf16_target_len, 8);
delta.retain(2, TextAttributes::default());
delta.retain(2, Attributes::default());
assert_eq!(delta.utf16_base_len, 7);
assert_eq!(delta.utf16_target_len, 10);
delta.delete(2);
@ -320,10 +316,10 @@ fn lengths() {
#[test]
fn sequence() {
let mut delta = TextDelta::default();
delta.retain(5, TextAttributes::default());
delta.retain(0, TextAttributes::default());
delta.insert("appflowy", TextAttributes::default());
delta.insert("", TextAttributes::default());
delta.retain(5, Attributes::default());
delta.retain(0, Attributes::default());
delta.insert("appflowy", Attributes::default());
delta.insert("", Attributes::default());
delta.delete(3);
delta.delete(0);
assert_eq!(delta.ops.len(), 3);
@ -353,15 +349,15 @@ fn apply_test() {
#[test]
fn base_len_test() {
let mut delta_a = TextDelta::default();
delta_a.insert("a", TextAttributes::default());
delta_a.insert("b", TextAttributes::default());
delta_a.insert("c", TextAttributes::default());
delta_a.insert("a", Attributes::default());
delta_a.insert("b", Attributes::default());
delta_a.insert("c", Attributes::default());
let s = "hello world,".to_owned();
delta_a.delete(s.len());
let after_a = delta_a.apply(&s).unwrap();
delta_a.insert("d", TextAttributes::default());
delta_a.insert("d", Attributes::default());
assert_eq!("abc", &after_a);
}
@ -392,8 +388,8 @@ fn invert_test() {
#[test]
fn empty_ops() {
let mut delta = TextDelta::default();
delta.retain(0, TextAttributes::default());
delta.insert("", TextAttributes::default());
delta.retain(0, Attributes::default());
delta.insert("", Attributes::default());
delta.delete(0);
assert_eq!(delta.ops.len(), 0);
}
@ -401,33 +397,33 @@ fn empty_ops() {
fn eq() {
let mut delta_a = TextDelta::default();
delta_a.delete(1);
delta_a.insert("lo", TextAttributes::default());
delta_a.retain(2, TextAttributes::default());
delta_a.retain(3, TextAttributes::default());
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_b.delete(1);
delta_b.insert("l", TextAttributes::default());
delta_b.insert("o", TextAttributes::default());
delta_b.retain(5, TextAttributes::default());
delta_b.insert("l", Attributes::default());
delta_b.insert("o", Attributes::default());
delta_b.retain(5, Attributes::default());
assert_eq!(delta_a, delta_b);
delta_a.delete(1);
delta_b.retain(1, TextAttributes::default());
delta_b.retain(1, Attributes::default());
assert_ne!(delta_a, delta_b);
}
#[test]
fn ops_merging() {
let mut delta = TextDelta::default();
assert_eq!(delta.ops.len(), 0);
delta.retain(2, TextAttributes::default());
delta.retain(2, Attributes::default());
assert_eq!(delta.ops.len(), 1);
assert_eq!(delta.ops.last(), Some(&Operation::retain(2)));
delta.retain(3, TextAttributes::default());
delta.retain(3, Attributes::default());
assert_eq!(delta.ops.len(), 1);
assert_eq!(delta.ops.last(), Some(&Operation::retain(5)));
delta.insert("abc", TextAttributes::default());
delta.insert("abc", Attributes::default());
assert_eq!(delta.ops.len(), 2);
assert_eq!(delta.ops.last(), Some(&Operation::insert("abc")));
delta.insert("xyz", TextAttributes::default());
delta.insert("xyz", Attributes::default());
assert_eq!(delta.ops.len(), 2);
assert_eq!(delta.ops.last(), Some(&Operation::insert("abcxyz")));
delta.delete(1);
@ -442,11 +438,11 @@ fn ops_merging() {
fn is_noop() {
let mut delta = TextDelta::default();
assert!(delta.is_noop());
delta.retain(5, TextAttributes::default());
delta.retain(5, Attributes::default());
assert!(delta.is_noop());
delta.retain(3, TextAttributes::default());
delta.retain(3, Attributes::default());
assert!(delta.is_noop());
delta.insert("lorem", TextAttributes::default());
delta.insert("lorem", Attributes::default());
assert!(!delta.is_noop());
}
#[test]
@ -490,18 +486,13 @@ fn transform_random_delta() {
fn transform_with_two_delta() {
let mut a = TextDelta::default();
let mut a_s = String::new();
a.insert(
"123",
TextDeltaAttributeBuilder::new()
.add_attr(TextAttribute::Bold(true))
.build(),
);
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_s = String::new();
b.insert("456", TextAttributes::default());
b.insert("456", Attributes::default());
b_s = b.apply(&b_s).unwrap();
assert_eq!(&b_s, "456");
@ -537,7 +528,7 @@ fn transform_two_plain_delta() {
AssertDocJson(0, r#"[{"insert":"123456"}]"#),
AssertDocJson(1, r#"[{"insert":"123456"}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
@ -551,7 +542,7 @@ fn transform_two_plain_delta2() {
AssertDocJson(0, r#"[{"insert":"123456"}]"#),
AssertDocJson(1, r#"[{"insert":"123456"}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
@ -569,7 +560,7 @@ fn transform_two_non_seq_delta() {
AssertDocJson(0, r#"[{"insert":"123456"}]"#),
AssertDocJson(1, r#"[{"insert":"123456789"}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
@ -584,7 +575,7 @@ fn transform_two_conflict_non_seq_delta() {
AssertDocJson(0, r#"[{"insert":"123456"}]"#),
AssertDocJson(1, r#"[{"insert":"12378456"}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
@ -611,7 +602,7 @@ fn delta_invert_no_attribute_delta2() {
Invert(0, 1),
AssertDocJson(0, r#"[{"insert":"123"}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
@ -619,12 +610,12 @@ fn delta_invert_attribute_delta_with_no_attribute_delta() {
let ops = vec![
Insert(0, "123", 0),
Bold(0, Interval::new(0, 3), true),
AssertDocJson(0, r#"[{"insert":"123","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"123","attributes":{"bold":true}}]"#),
Insert(1, "4567", 0),
Invert(0, 1),
AssertDocJson(0, r#"[{"insert":"123","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"123","attributes":{"bold":true}}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
@ -636,16 +627,16 @@ fn delta_invert_attribute_delta_with_no_attribute_delta2() {
AssertDocJson(
0,
r#"[
{"insert":"123456","attributes":{"bold":"true"}}]
{"insert":"123456","attributes":{"bold":true}}]
"#,
),
Italic(0, Interval::new(2, 4), true),
AssertDocJson(
0,
r#"[
{"insert":"12","attributes":{"bold":"true"}},
{"insert":"34","attributes":{"bold":"true","italic":"true"}},
{"insert":"56","attributes":{"bold":"true"}}
{"insert":"12","attributes":{"bold":true}},
{"insert":"34","attributes":{"bold":true,"italic":true}},
{"insert":"56","attributes":{"bold":true}}
]"#,
),
Insert(1, "abc", 0),
@ -653,13 +644,13 @@ fn delta_invert_attribute_delta_with_no_attribute_delta2() {
AssertDocJson(
0,
r#"[
{"insert":"12","attributes":{"bold":"true"}},
{"insert":"34","attributes":{"bold":"true","italic":"true"}},
{"insert":"56","attributes":{"bold":"true"}}
{"insert":"12","attributes":{"bold":true}},
{"insert":"34","attributes":{"bold":true,"italic":true}},
{"insert":"56","attributes":{"bold":true}}
]"#,
),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
@ -668,11 +659,11 @@ fn delta_invert_no_attribute_delta_with_attribute_delta() {
Insert(0, "123", 0),
Insert(1, "4567", 0),
Bold(1, Interval::new(0, 3), true),
AssertDocJson(1, r#"[{"insert":"456","attributes":{"bold":"true"}},{"insert":"7"}]"#),
AssertDocJson(1, r#"[{"insert":"456","attributes":{"bold":true}},{"insert":"7"}]"#),
Invert(0, 1),
AssertDocJson(0, r#"[{"insert":"123"}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
@ -686,12 +677,12 @@ fn delta_invert_no_attribute_delta_with_attribute_delta2() {
Italic(1, Interval::new(1, 3), true),
AssertDocJson(
1,
r#"[{"insert":"a","attributes":{"bold":"true"}},{"insert":"bc","attributes":{"bold":"true","italic":"true"}},{"insert":"d","attributes":{"bold":"true"}}]"#,
r#"[{"insert":"a","attributes":{"bold":true}},{"insert":"bc","attributes":{"bold":true,"italic":true}},{"insert":"d","attributes":{"bold":true}}]"#,
),
Invert(0, 1),
AssertDocJson(0, r#"[{"insert":"123"}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
@ -700,14 +691,14 @@ fn delta_invert_attribute_delta_with_attribute_delta() {
Insert(0, "123", 0),
Bold(0, Interval::new(0, 3), true),
Insert(0, "456", 3),
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":"true"}}]"#),
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":true}}]"#),
Italic(0, Interval::new(2, 4), true),
AssertDocJson(
0,
r#"[
{"insert":"12","attributes":{"bold":"true"}},
{"insert":"34","attributes":{"bold":"true","italic":"true"}},
{"insert":"56","attributes":{"bold":"true"}}
{"insert":"12","attributes":{"bold":true}},
{"insert":"34","attributes":{"bold":true,"italic":true}},
{"insert":"56","attributes":{"bold":true}}
]"#,
),
Insert(1, "abc", 0),
@ -717,22 +708,22 @@ fn delta_invert_attribute_delta_with_attribute_delta() {
AssertDocJson(
1,
r#"[
{"insert":"a","attributes":{"bold":"true"}},
{"insert":"bc","attributes":{"bold":"true","italic":"true"}},
{"insert":"d","attributes":{"bold":"true"}}
{"insert":"a","attributes":{"bold":true}},
{"insert":"bc","attributes":{"bold":true,"italic":true}},
{"insert":"d","attributes":{"bold":true}}
]"#,
),
Invert(0, 1),
AssertDocJson(
0,
r#"[
{"insert":"12","attributes":{"bold":"true"}},
{"insert":"34","attributes":{"bold":"true","italic":"true"}},
{"insert":"56","attributes":{"bold":"true"}}
{"insert":"12","attributes":{"bold":true}},
{"insert":"34","attributes":{"bold":true,"italic":true}},
{"insert":"56","attributes":{"bold":true}}
]"#,
),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]

50
frontend/rust-lib/flowy-text-block/tests/editor/serde_test.rs
View File

@ -1,21 +1,21 @@
use flowy_sync::client_document::{ClientDocument, PlainDoc};
use lib_ot::text_delta::RichTextOperation;
use flowy_sync::client_document::{ClientDocument, EmptyDoc};
use lib_ot::text_delta::TextOperation;
use lib_ot::{
core::*,
text_delta::{TextAttribute, TextAttributeValue, TextDelta, TextDeltaAttributeBuilder},
text_delta::{BuildInTextAttribute, TextDelta},
};
#[test]
fn operation_insert_serialize_test() {
let attributes = TextDeltaAttributeBuilder::new()
.add_attr(TextAttribute::Bold(true))
.add_attr(TextAttribute::Italic(true))
let attributes = AttributeBuilder::new()
.insert("bold", true)
.insert("italic", true)
.build();
let operation = Operation::insert_with_attributes("123", attributes);
let json = serde_json::to_string(&operation).unwrap();
eprintln!("{}", json);
let insert_op: RichTextOperation = serde_json::from_str(&json).unwrap();
let insert_op: TextOperation = serde_json::from_str(&json).unwrap();
assert_eq!(insert_op, operation);
}
@ -24,23 +24,23 @@ fn operation_retain_serialize_test() {
let operation = Operation::Retain(12.into());
let json = serde_json::to_string(&operation).unwrap();
eprintln!("{}", json);
let insert_op: RichTextOperation = serde_json::from_str(&json).unwrap();
let insert_op: TextOperation = serde_json::from_str(&json).unwrap();
assert_eq!(insert_op, operation);
}
#[test]
fn operation_delete_serialize_test() {
let operation = RichTextOperation::Delete(2);
let operation = TextOperation::Delete(2);
let json = serde_json::to_string(&operation).unwrap();
let insert_op: RichTextOperation = serde_json::from_str(&json).unwrap();
let insert_op: TextOperation = serde_json::from_str(&json).unwrap();
assert_eq!(insert_op, operation);
}
#[test]
fn attributes_serialize_test() {
let attributes = TextDeltaAttributeBuilder::new()
.add_attr(TextAttribute::Bold(true))
.add_attr(TextAttribute::Italic(true))
let attributes = AttributeBuilder::new()
.insert_entry(BuildInTextAttribute::Bold(true))
.insert_entry(BuildInTextAttribute::Italic(true))
.build();
let retain = Operation::insert_with_attributes("123", attributes);
@ -52,9 +52,9 @@ fn attributes_serialize_test() {
fn delta_serialize_multi_attribute_test() {
let mut delta = Operations::default();
let attributes = TextDeltaAttributeBuilder::new()
.add_attr(TextAttribute::Bold(true))
.add_attr(TextAttribute::Italic(true))
let attributes = AttributeBuilder::new()
.insert_entry(BuildInTextAttribute::Bold(true))
.insert_entry(BuildInTextAttribute::Italic(true))
.build();
let retain = Operation::insert_with_attributes("123", attributes);
@ -74,7 +74,7 @@ fn delta_deserialize_test() {
let json = r#"[
{"retain":2,"attributes":{"italic":true}},
{"retain":2,"attributes":{"italic":123}},
{"retain":2,"attributes":{"italic":"true","bold":"true"}},
{"retain":2,"attributes":{"italic":true,"bold":true}},
{"retain":2,"attributes":{"italic":true,"bold":true}}
]"#;
let delta = TextDelta::from_json(json).unwrap();
@ -88,26 +88,20 @@ fn delta_deserialize_null_test() {
]"#;
let delta1 = TextDelta::from_json(json).unwrap();
let mut attribute = TextAttribute::Bold(true);
attribute.value = TextAttributeValue(None);
let mut attribute = BuildInTextAttribute::Bold(true);
attribute.remove_value();
let delta2 = OperationBuilder::new()
.retain_with_attributes(7, attribute.into())
.build();
assert_eq!(delta2.json_str(), r#"[{"retain":7,"attributes":{"bold":""}}]"#);
assert_eq!(delta2.json_str(), r#"[{"retain":7,"attributes":{"bold":null}}]"#);
assert_eq!(delta1, delta2);
}
#[test]
fn delta_serde_null_test() {
let mut attribute = TextAttribute::Bold(true);
attribute.value = TextAttributeValue(None);
assert_eq!(attribute.to_json(), r#"{"bold":""}"#);
}
#[test]
fn document_insert_serde_test() {
let mut document = ClientDocument::new::<PlainDoc>();
let mut document = ClientDocument::new::<EmptyDoc>();
document.insert(0, "\n").unwrap();
document.insert(0, "123").unwrap();
let json = document.delta_str();

22
frontend/rust-lib/flowy-text-block/tests/editor/undo_redo_test.rs
View File

@ -1,5 +1,5 @@
use crate::editor::{TestBuilder, TestOp::*};
use flowy_sync::client_document::{NewlineDoc, PlainDoc, RECORD_THRESHOLD};
use flowy_sync::client_document::{EmptyDoc, NewlineDoc, RECORD_THRESHOLD};
use lib_ot::core::{Interval, NEW_LINE, WHITESPACE};
#[test]
@ -85,7 +85,7 @@ fn history_bold_redo() {
Undo(0),
AssertDocJson(0, r#"[{"insert":"\n"}]"#),
Redo(0),
AssertDocJson(0, r#" [{"insert":"123","attributes":{"bold":"true"}},{"insert":"\n"}]"#),
AssertDocJson(0, r#" [{"insert":"123","attributes":{"bold":true}},{"insert":"\n"}]"#),
];
TestBuilder::new().run_scripts::<NewlineDoc>(ops);
}
@ -99,7 +99,7 @@ fn history_bold_redo_with_lagging() {
Undo(0),
AssertDocJson(0, r#"[{"insert":"123\n"}]"#),
Redo(0),
AssertDocJson(0, r#"[{"insert":"123","attributes":{"bold":"true"}},{"insert":"\n"}]"#),
AssertDocJson(0, r#"[{"insert":"123","attributes":{"bold":true}},{"insert":"\n"}]"#),
];
TestBuilder::new().run_scripts::<NewlineDoc>(ops);
}
@ -115,7 +115,7 @@ fn history_delete_undo() {
Undo(0),
AssertDocJson(0, r#"[{"insert":"123"}]"#),
];
TestBuilder::new().run_scripts::<PlainDoc>(ops);
TestBuilder::new().run_scripts::<EmptyDoc>(ops);
}
#[test]
@ -127,7 +127,7 @@ fn history_delete_undo_2() {
AssertDocJson(
0,
r#"[
{"insert":"23","attributes":{"bold":"true"}},
{"insert":"23","attributes":{"bold":true}},
{"insert":"\n"}]
"#,
),
@ -148,7 +148,7 @@ fn history_delete_undo_with_lagging() {
AssertDocJson(
0,
r#"[
{"insert":"23","attributes":{"bold":"true"}},
{"insert":"23","attributes":{"bold":true}},
{"insert":"\n"}]
"#,
),
@ -156,7 +156,7 @@ fn history_delete_undo_with_lagging() {
AssertDocJson(
0,
r#"[
{"insert":"123","attributes":{"bold":"true"}},
{"insert":"123","attributes":{"bold":true}},
{"insert":"\n"}]
"#,
),
@ -188,7 +188,7 @@ fn history_replace_undo() {
0,
r#"[
{"insert":"ab"},
{"insert":"3","attributes":{"bold":"true"}},{"insert":"\n"}]
{"insert":"3","attributes":{"bold":true}},{"insert":"\n"}]
"#,
),
Undo(0),
@ -209,11 +209,11 @@ fn history_replace_undo_with_lagging() {
0,
r#"[
{"insert":"ab"},
{"insert":"3","attributes":{"bold":"true"}},{"insert":"\n"}]
{"insert":"3","attributes":{"bold":true}},{"insert":"\n"}]
"#,
),
Undo(0),
AssertDocJson(0, r#"[{"insert":"123","attributes":{"bold":"true"}},{"insert":"\n"}]"#),
AssertDocJson(0, r#"[{"insert":"123","attributes":{"bold":true}},{"insert":"\n"}]"#),
];
TestBuilder::new().run_scripts::<NewlineDoc>(ops);
}
@ -230,7 +230,7 @@ fn history_replace_redo() {
0,
r#"[
{"insert":"ab"},
{"insert":"3","attributes":{"bold":"true"}},{"insert":"\n"}]
{"insert":"3","attributes":{"bold":true}},{"insert":"\n"}]
"#,
),
];

13
shared-lib/flowy-sync/src/client_document/document_pad.rs
View File

@ -7,18 +7,15 @@ use crate::{
errors::CollaborateError,
};
use bytes::Bytes;
use lib_ot::{
core::*,
text_delta::{TextAttribute, TextDelta},
};
use lib_ot::{core::*, text_delta::TextDelta};
use tokio::sync::mpsc;
pub trait InitialDocumentText {
fn initial_delta() -> TextDelta;
}
pub struct PlainDoc();
impl InitialDocumentText for PlainDoc {
pub struct EmptyDoc();
impl InitialDocumentText for EmptyDoc {
fn initial_delta() -> TextDelta {
TextDelta::new()
}
@ -141,9 +138,9 @@ impl ClientDocument {
Ok(delete)
}
pub fn format(&mut self, interval: Interval, attribute: TextAttribute) -> Result<TextDelta, CollaborateError> {
pub fn format(&mut self, interval: Interval, attribute: AttributeEntry) -> Result<TextDelta, CollaborateError> {
let _ = validate_interval(&self.delta, &interval)?;
tracing::trace!("format {} with {}", interval, attribute);
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)

8
shared-lib/flowy-sync/src/client_document/extensions/delete/preserve_line_format_merge.rs
View File

@ -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::{plain_attributes, TextDelta},
text_delta::{empty_attributes, TextDelta},
};
pub struct PreserveLineFormatOnMerge {}
@ -37,18 +37,18 @@ impl DeleteExt for PreserveLineFormatOnMerge {
//
match op.get_data().find(NEW_LINE) {
None => {
new_delta.retain(op.len(), plain_attributes());
new_delta.retain(op.len(), empty_attributes());
continue;
}
Some(line_break) => {
let mut attributes = op.get_attributes();
attributes.mark_all_as_removed_except(None);
attributes.remove_all_value();
if newline_op.has_attribute() {
attributes.extend_other(newline_op.get_attributes());
}
new_delta.retain(line_break, plain_attributes());
new_delta.retain(line_break, empty_attributes());
new_delta.retain(1, attributes);
break;
}

14
shared-lib/flowy-sync/src/client_document/extensions/format/resolve_block_format.rs
View File

@ -1,6 +1,8 @@
use lib_ot::core::AttributeEntry;
use lib_ot::text_delta::is_block;
use lib_ot::{
core::{Interval, OperationBuilder, OperationIterator},
text_delta::{plain_attributes, AttributeScope, TextAttribute, TextDelta},
text_delta::{empty_attributes, AttributeScope, TextDelta},
};
use crate::{
@ -14,8 +16,8 @@ impl FormatExt for ResolveBlockFormat {
"ResolveBlockFormat"
}
fn apply(&self, delta: &TextDelta, interval: Interval, attribute: &TextAttribute) -> Option<TextDelta> {
if attribute.scope != AttributeScope::Block {
fn apply(&self, delta: &TextDelta, interval: Interval, attribute: &AttributeEntry) -> Option<TextDelta> {
if !is_block(&attribute.key) {
return None;
}
@ -26,7 +28,7 @@ impl FormatExt for ResolveBlockFormat {
while start < end && iter.has_next() {
let next_op = iter.next_op_with_len(end - start).unwrap();
match find_newline(next_op.get_data()) {
None => new_delta.retain(next_op.len(), plain_attributes()),
None => new_delta.retain(next_op.len(), empty_attributes()),
Some(_) => {
let tmp_delta = line_break(&next_op, attribute, AttributeScope::Block);
new_delta.extend(tmp_delta);
@ -40,9 +42,9 @@ impl FormatExt for ResolveBlockFormat {
let op = iter.next_op().expect("Unexpected None, iter.has_next() must return op");
match find_newline(op.get_data()) {
None => new_delta.retain(op.len(), plain_attributes()),
None => new_delta.retain(op.len(), empty_attributes()),
Some(line_break) => {
new_delta.retain(line_break, plain_attributes());
new_delta.retain(line_break, empty_attributes());
new_delta.retain(1, attribute.clone().into());
break;
}

8
shared-lib/flowy-sync/src/client_document/extensions/format/resolve_inline_format.rs
View File

@ -1,6 +1,8 @@
use lib_ot::core::AttributeEntry;
use lib_ot::text_delta::is_inline;
use lib_ot::{
core::{Interval, OperationBuilder, OperationIterator},
text_delta::{AttributeScope, TextAttribute, TextDelta},
text_delta::{AttributeScope, TextDelta},
};
use crate::{
@ -14,8 +16,8 @@ impl FormatExt for ResolveInlineFormat {
"ResolveInlineFormat"
}
fn apply(&self, delta: &TextDelta, interval: Interval, attribute: &TextAttribute) -> Option<TextDelta> {
if attribute.scope != AttributeScope::Inline {
fn apply(&self, delta: &TextDelta, interval: Interval, attribute: &AttributeEntry) -> Option<TextDelta> {
if !is_inline(&attribute.key) {
return None;
}
let mut new_delta = OperationBuilder::new().retain(interval.start).build();

11
shared-lib/flowy-sync/src/client_document/extensions/helper.rs
View File

@ -1,7 +1,8 @@
use crate::util::find_newline;
use lib_ot::text_delta::{plain_attributes, AttributeScope, RichTextOperation, TextAttribute, TextDelta};
use lib_ot::core::AttributeEntry;
use lib_ot::text_delta::{empty_attributes, AttributeScope, TextDelta, TextOperation};
pub(crate) fn line_break(op: &RichTextOperation, attribute: &TextAttribute, scope: AttributeScope) -> TextDelta {
pub(crate) fn line_break(op: &TextOperation, attribute: &AttributeEntry, scope: AttributeScope) -> TextDelta {
let mut new_delta = TextDelta::new();
let mut start = 0;
let end = op.len();
@ -11,10 +12,10 @@ pub(crate) fn line_break(op: &RichTextOperation, attribute: &TextAttribute, scop
match scope {
AttributeScope::Inline => {
new_delta.retain(line_break - start, attribute.clone().into());
new_delta.retain(1, plain_attributes());
new_delta.retain(1, empty_attributes());
}
AttributeScope::Block => {
new_delta.retain(line_break - start, plain_attributes());
new_delta.retain(line_break - start, empty_attributes());
new_delta.retain(1, attribute.clone().into());
}
_ => {
@ -29,7 +30,7 @@ pub(crate) fn line_break(op: &RichTextOperation, attribute: &TextAttribute, scop
if start < end {
match scope {
AttributeScope::Inline => new_delta.retain(end - start, attribute.clone().into()),
AttributeScope::Block => new_delta.retain(end - start, plain_attributes()),
AttributeScope::Block => new_delta.retain(end - start, empty_attributes()),
_ => log::error!("Unsupported parser line break for {:?}", scope),
}
}

4
shared-lib/flowy-sync/src/client_document/extensions/insert/auto_exit_block.rs
View File

@ -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, TextAttributeKey, TextDelta};
use lib_ot::text_delta::{attributes_except_header, BuildInTextAttributeKey, TextDelta};
pub struct AutoExitBlock {}
@ -42,7 +42,7 @@ impl InsertExt for AutoExitBlock {
}
}
attributes.mark_all_as_removed_except(Some(TextAttributeKey::Header));
attributes.retain_values(&[BuildInTextAttributeKey::Header.as_ref()]);
Some(
OperationBuilder::new()

9
shared-lib/flowy-sync/src/client_document/extensions/insert/auto_format.rs
View File

@ -1,7 +1,8 @@
use crate::{client_document::InsertExt, util::is_whitespace};
use lib_ot::core::Attributes;
use lib_ot::{
core::{count_utf16_code_units, OperationBuilder, OperationIterator},
text_delta::{plain_attributes, TextAttribute, TextAttributes, TextDelta},
text_delta::{empty_attributes, BuildInTextAttribute, TextDelta},
};
use std::cmp::min;
use url::Url;
@ -36,7 +37,7 @@ impl InsertExt for AutoFormatExt {
});
let next_attributes = match iter.next_op() {
None => plain_attributes(),
None => empty_attributes(),
Some(op) => op.get_attributes(),
};
@ -60,9 +61,9 @@ pub enum AutoFormatter {
}
impl AutoFormatter {
pub fn to_attributes(&self) -> TextAttributes {
pub fn to_attributes(&self) -> Attributes {
match self {
AutoFormatter::Url(url) => TextAttribute::Link(url.as_str()).into(),
AutoFormatter::Url(url) => BuildInTextAttribute::Link(url.as_str()).into(),
}
}

10
shared-lib/flowy-sync/src/client_document/extensions/insert/default_insert.rs
View File

@ -1,7 +1,8 @@
use crate::client_document::InsertExt;
use lib_ot::core::Attributes;
use lib_ot::{
core::{OperationAttributes, OperationBuilder, OperationIterator, NEW_LINE},
text_delta::{TextAttributeKey, TextAttributes, TextDelta},
text_delta::{BuildInTextAttributeKey, TextDelta},
};
pub struct DefaultInsertAttribute {}
@ -12,7 +13,7 @@ impl InsertExt for DefaultInsertAttribute {
fn apply(&self, delta: &TextDelta, replace_len: usize, text: &str, index: usize) -> Option<TextDelta> {
let iter = OperationIterator::new(delta);
let mut attributes = TextAttributes::new();
let mut attributes = Attributes::new();
// Enable each line split by "\n" remains the block attributes. for example:
// insert "\n" to "123456" at index 3
@ -23,7 +24,10 @@ impl InsertExt for DefaultInsertAttribute {
match iter.last() {
None => {}
Some(op) => {
if op.get_attributes().contains_key(&TextAttributeKey::Header) {
if op
.get_attributes()
.contains_key(BuildInTextAttributeKey::Header.as_ref())
{
attributes.extend_other(op.get_attributes());
}
}

17
shared-lib/flowy-sync/src/client_document/extensions/insert/preserve_block_format.rs
View File

@ -1,9 +1,8 @@
use crate::{client_document::InsertExt, util::is_newline};
use lib_ot::core::Attributes;
use lib_ot::{
core::{OperationBuilder, OperationIterator, NEW_LINE},
text_delta::{
attributes_except_header, plain_attributes, TextAttribute, TextAttributeKey, TextAttributes, TextDelta,
},
text_delta::{attributes_except_header, empty_attributes, BuildInTextAttributeKey, TextDelta},
};
pub struct PreserveBlockFormatOnInsert {}
@ -27,16 +26,16 @@ impl InsertExt for PreserveBlockFormatOnInsert {
return None;
}
let mut reset_attribute = TextAttributes::new();
if newline_attributes.contains_key(&TextAttributeKey::Header) {
reset_attribute.add(TextAttribute::Header(1));
let mut reset_attribute = Attributes::new();
if newline_attributes.contains_key(BuildInTextAttributeKey::Header.as_ref()) {
reset_attribute.insert(BuildInTextAttributeKey::Header, 1);
}
let lines: Vec<_> = text.split(NEW_LINE).collect();
let mut new_delta = OperationBuilder::new().retain(index + replace_len).build();
lines.iter().enumerate().for_each(|(i, line)| {
if !line.is_empty() {
new_delta.insert(line, plain_attributes());
new_delta.insert(line, empty_attributes());
}
if i == 0 {
@ -48,9 +47,9 @@ impl InsertExt for PreserveBlockFormatOnInsert {
}
});
if !reset_attribute.is_empty() {
new_delta.retain(offset, plain_attributes());
new_delta.retain(offset, empty_attributes());
let len = newline_op.get_data().find(NEW_LINE).unwrap();
new_delta.retain(len, plain_attributes());
new_delta.retain(len, empty_attributes());
new_delta.retain(1, reset_attribute);
}

12
shared-lib/flowy-sync/src/client_document/extensions/insert/preserve_inline_format.rs
View File

@ -4,7 +4,7 @@ use crate::{
};
use lib_ot::{
core::{OpNewline, OperationBuilder, OperationIterator, NEW_LINE},
text_delta::{plain_attributes, TextAttributeKey, TextDelta},
text_delta::{empty_attributes, BuildInTextAttributeKey, TextDelta},
};
pub struct PreserveInlineFormat {}
@ -25,7 +25,7 @@ impl InsertExt for PreserveInlineFormat {
}
let mut attributes = prev.get_attributes();
if attributes.is_empty() || !attributes.contains_key(&TextAttributeKey::Link) {
if attributes.is_empty() || !attributes.contains_key(BuildInTextAttributeKey::Link.as_ref()) {
return Some(
OperationBuilder::new()
.retain(index + replace_len)
@ -36,10 +36,10 @@ impl InsertExt for PreserveInlineFormat {
let next = iter.next_op();
match &next {
None => attributes = plain_attributes(),
None => attributes = empty_attributes(),
Some(next) => {
if OpNewline::parse(next).is_equal() {
attributes = plain_attributes();
attributes = empty_attributes();
}
}
}
@ -77,11 +77,11 @@ impl InsertExt for PreserveLineFormatOnSplit {
}
let mut new_delta = TextDelta::new();
new_delta.retain(index + replace_len, plain_attributes());
new_delta.retain(index + replace_len, empty_attributes());
if newline_status.is_contain() {
debug_assert!(!next.has_attribute());
new_delta.insert(NEW_LINE, plain_attributes());
new_delta.insert(NEW_LINE, empty_attributes());
return Some(new_delta);
}

12
shared-lib/flowy-sync/src/client_document/extensions/insert/reset_format_on_new_line.rs
View File

@ -1,7 +1,8 @@
use crate::{client_document::InsertExt, util::is_newline};
use lib_ot::core::Attributes;
use lib_ot::{
core::{OperationBuilder, OperationIterator, Utf16CodeUnitMetric, NEW_LINE},
text_delta::{TextAttributeKey, TextAttributes, TextDelta},
text_delta::{BuildInTextAttributeKey, TextDelta},
};
pub struct ResetLineFormatOnNewLine {}
@ -22,9 +23,12 @@ impl InsertExt for ResetLineFormatOnNewLine {
return None;
}
let mut reset_attribute = TextAttributes::new();
if next_op.get_attributes().contains_key(&TextAttributeKey::Header) {
reset_attribute.delete(&TextAttributeKey::Header);
let mut reset_attribute = Attributes::new();
if next_op
.get_attributes()
.contains_key(BuildInTextAttributeKey::Header.as_ref())
{
reset_attribute.remove_value(BuildInTextAttributeKey::Header);
}
let len = index + replace_len;

8
shared-lib/flowy-sync/src/client_document/extensions/mod.rs
View File

@ -1,10 +1,8 @@
pub use delete::*;
pub use format::*;
pub use insert::*;
use lib_ot::{
core::Interval,
text_delta::{TextAttribute, TextDelta},
};
use lib_ot::core::AttributeEntry;
use lib_ot::{core::Interval, text_delta::TextDelta};
mod delete;
mod format;
@ -22,7 +20,7 @@ pub trait InsertExt {
pub trait FormatExt {
fn ext_name(&self) -> &str;
fn apply(&self, delta: &TextDelta, interval: Interval, attribute: &TextAttribute) -> Option<TextDelta>;
fn apply(&self, delta: &TextDelta, interval: Interval, attribute: &AttributeEntry) -> Option<TextDelta>;
}
pub trait DeleteExt {

11
shared-lib/flowy-sync/src/client_document/view.rs
View File

@ -1,8 +1,9 @@
use crate::client_document::*;
use lib_ot::core::AttributeEntry;
use lib_ot::{
core::{trim, Interval},
errors::{ErrorBuilder, OTError, OTErrorCode},
text_delta::{TextAttribute, TextDelta},
text_delta::TextDelta,
};
pub const RECORD_THRESHOLD: usize = 400; // in milliseconds
@ -27,7 +28,7 @@ impl ViewExtensions {
for ext in &self.insert_exts {
if let Some(mut delta) = ext.apply(delta, interval.size(), text, interval.start) {
trim(&mut delta);
tracing::debug!("[{} extension]: process: {}", ext.ext_name(), delta);
tracing::trace!("[{}] applied, delta: {}", ext.ext_name(), delta);
new_delta = Some(delta);
break;
}
@ -44,7 +45,7 @@ impl ViewExtensions {
for ext in &self.delete_exts {
if let Some(mut delta) = ext.apply(delta, interval) {
trim(&mut delta);
tracing::trace!("[{}]: applied, delta: {}", ext.ext_name(), delta);
tracing::trace!("[{}] applied, delta: {}", ext.ext_name(), delta);
new_delta = Some(delta);
break;
}
@ -59,14 +60,14 @@ impl ViewExtensions {
pub(crate) fn format(
&self,
delta: &TextDelta,
attribute: TextAttribute,
attribute: AttributeEntry,
interval: Interval,
) -> Result<TextDelta, OTError> {
let mut new_delta = 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);
tracing::trace!("[{}] applied, delta: {}", ext.ext_name(), delta);
new_delta = Some(delta);
break;
}

5
shared-lib/flowy-sync/src/server_document/document_manager.rs
View File

@ -11,7 +11,8 @@ use async_stream::stream;
use dashmap::DashMap;
use futures::stream::StreamExt;
use lib_infra::future::BoxResultFuture;
use lib_ot::text_delta::{TextAttributes, TextDelta};
use lib_ot::core::Attributes;
use lib_ot::text_delta::TextDelta;
use std::{collections::HashMap, fmt::Debug, sync::Arc};
use tokio::{
sync::{mpsc, oneshot, RwLock},
@ -198,7 +199,7 @@ impl std::ops::Drop for ServerDocumentManager {
}
}
type DocumentRevisionSynchronizer = RevisionSynchronizer<TextAttributes>;
type DocumentRevisionSynchronizer = RevisionSynchronizer<Attributes>;
struct OpenDocumentHandler {
doc_id: String,

9
shared-lib/flowy-sync/src/server_document/document_pad.rs
View File

@ -1,8 +1,5 @@
use crate::{client_document::InitialDocumentText, errors::CollaborateError, synchronizer::RevisionSyncObject};
use lib_ot::{
core::*,
text_delta::{TextAttributes, TextDelta},
};
use lib_ot::{core::*, text_delta::TextDelta};
pub struct ServerDocument {
doc_id: String,
@ -21,7 +18,7 @@ impl ServerDocument {
}
}
impl RevisionSyncObject<TextAttributes> for ServerDocument {
impl RevisionSyncObject<Attributes> for ServerDocument {
fn id(&self) -> &str {
&self.doc_id
}
@ -42,7 +39,7 @@ impl RevisionSyncObject<TextAttributes> for ServerDocument {
self.delta.json_str()
}
fn set_delta(&mut self, new_delta: Operations<TextAttributes>) {
fn set_delta(&mut self, new_delta: Operations<Attributes>) {
self.delta = new_delta;
}
}

71
shared-lib/lib-ot/src/codec/markdown/markdown_encoder.rs
View File

@ -1,6 +1,8 @@
use crate::core::{OperationIterator, Operations};
use crate::text_delta::{is_block, TextAttributeKey, TextAttributeValue, TextAttributes};
use crate::core::{AttributeKey, AttributeValue, Attributes, OperationIterator, Operations};
use crate::text_delta::{is_block, TextAttributeKey};
use std::collections::HashMap;
use std::str::FromStr;
use strum_macros::EnumString;
const LINEFEEDASCIICODE: i32 = 0x0A;
@ -98,14 +100,14 @@ mod tests {
}
struct Attribute {
key: TextAttributeKey,
value: TextAttributeValue,
key: AttributeKey,
value: AttributeValue,
}
pub fn markdown_encoder(delta: &Operations<TextAttributes>) -> String {
pub fn markdown_encoder(delta: &Operations<Attributes>) -> String {
let mut markdown_buffer = String::new();
let mut line_buffer = String::new();
let mut current_inline_style = TextAttributes::default();
let mut current_inline_style = Attributes::default();
let mut current_block_lines: Vec<String> = Vec::new();
let mut iterator = OperationIterator::new(delta);
let mut current_block_style: Option<Attribute> = None;
@ -137,23 +139,20 @@ pub fn markdown_encoder(delta: &Operations<TextAttributes>) -> String {
markdown_buffer
}
fn handle_inline(
current_inline_style: &mut TextAttributes,
buffer: &mut String,
mut text: String,
attributes: TextAttributes,
) {
let mut marked_for_removal: HashMap<TextAttributeKey, TextAttributeValue> = HashMap::new();
fn handle_inline(current_inline_style: &mut Attributes, buffer: &mut String, mut text: String, attributes: Attributes) {
let mut marked_for_removal: HashMap<AttributeKey, AttributeValue> = HashMap::new();
for key in current_inline_style
.clone()
.keys()
.collect::<Vec<&TextAttributeKey>>()
.collect::<Vec<&AttributeKey>>()
.into_iter()
.rev()
{
if is_block(key) {
continue;
if let Some(attribute) = TextAttributeKey::from_str(key) {
if is_block(&attribute) {
continue;
}
}
if attributes.contains_key(key) {
@ -161,7 +160,7 @@ fn handle_inline(
}
let padding = trim_right(buffer);
write_attribute(buffer, key, current_inline_style.get(key).unwrap(), true);
write_attribute(buffer, key, current_inline_style.get(key.as_ref()).unwrap(), true);
if !padding.is_empty() {
buffer.push_str(&padding)
}
@ -175,8 +174,10 @@ fn handle_inline(
}
for (key, value) in attributes.iter() {
if is_block(key) {
continue;
if let Some(attribute) = TextAttributeKey::from_str(key) {
if is_block(&attribute) {
continue;
}
}
if current_inline_style.contains_key(key) {
continue;
@ -205,7 +206,8 @@ fn trim_right(buffer: &mut String) -> String {
" ".repeat(text.len() - result.len())
}
fn write_attribute(buffer: &mut String, key: &TextAttributeKey, value: &TextAttributeValue, close: bool) {
fn write_attribute(buffer: &mut String, key: &AttributeKey, value: &AttributeValue, close: bool) {
let key = TextAttributeKey::from_str(key);
match key {
TextAttributeKey::Bold => buffer.push_str("**"),
TextAttributeKey::Italic => buffer.push('_'),
@ -247,10 +249,10 @@ fn handle_line(
buffer: &mut String,
markdown_buffer: &mut String,
data: String,
attributes: TextAttributes,
attributes: Attributes,
current_block_style: &mut Option<Attribute>,
current_block_lines: &mut Vec<String>,
current_inline_style: &mut TextAttributes,
current_inline_style: &mut Attributes,
) {
let mut span = String::new();
for c in data.chars() {
@ -258,14 +260,15 @@ fn handle_line(
if !span.is_empty() {
handle_inline(current_inline_style, buffer, span.clone(), attributes.clone());
}
handle_inline(
current_inline_style,
buffer,
String::from(""),
TextAttributes::default(),
);
handle_inline(current_inline_style, buffer, String::from(""), Attributes::default());
let line_block_key = attributes.keys().find(|key| is_block(*key));
let line_block_key = attributes.keys().find(|key| {
if let Some(attribute) = TextAttributeKey::from_str(key) {
is_block(&attribute)
} else {
false
}
});
match (line_block_key, &current_block_style) {
(Some(line_block_key), Some(current_block_style))
@ -321,7 +324,7 @@ fn handle_block(
markdown_buffer.push_str(&current_block_lines.join("\n"));
markdown_buffer.push('\n');
}
Some(block_style) if block_style.key == TextAttributeKey::CodeBlock => {
Some(block_style) if block_style.key == AttributeKey::CodeBlock => {
write_attribute(markdown_buffer, &block_style.key, &block_style.value, false);
markdown_buffer.push_str(&current_block_lines.join("\n"));
write_attribute(markdown_buffer, &block_style.key, &block_style.value, true);
@ -342,9 +345,9 @@ fn write_block_tag(buffer: &mut String, block: &Attribute, close: bool) {
return;
}
if block.key == TextAttributeKey::BlockQuote {
if block.key == AttributeKey::BlockQuote {
buffer.push_str("> ");
} else if block.key == TextAttributeKey::List {
} else if block.key == AttributeKey::List {
if block.value.0.as_ref().unwrap().eq("bullet") {
buffer.push_str("* ");
} else if block.value.0.as_ref().unwrap().eq("checked") {
@ -356,14 +359,14 @@ fn write_block_tag(buffer: &mut String, block: &Attribute, close: bool) {
} else {
buffer.push_str("* ");
}
} else if block.key == TextAttributeKey::Header {
} else if block.key == AttributeKey::Header {
if block.value.0.as_ref().unwrap().eq("1") {
buffer.push_str("# ");
} else if block.value.0.as_ref().unwrap().eq("2") {
buffer.push_str("## ");
} else if block.value.0.as_ref().unwrap().eq("3") {
buffer.push_str("### ");
} else if block.key == TextAttributeKey::List {
} else if block.key == AttributeKey::List {
}
}
}

2
shared-lib/lib-ot/src/codec/markdown/mod.rs
View File

@ -1 +1 @@
pub mod markdown_encoder;
// pub mod markdown_encoder;

150
shared-lib/lib-ot/src/core/attributes/attribute.rs
View File

@ -1,10 +1,33 @@
use crate::core::OperationTransform;
use crate::core::{OperationAttributes, OperationTransform};
use crate::errors::OTError;
use serde::{Deserialize, Serialize};
use serde_repr::*;
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,
pub value: AttributeValue,
}
impl AttributeEntry {
pub fn remove_value(&mut self) {
self.value.ty = None;
self.value.value = None;
}
}
impl std::convert::From<AttributeEntry> for Attributes {
fn from(entry: AttributeEntry) -> Self {
let mut attributes = Attributes::new();
attributes.insert_entry(entry);
attributes
}
}
#[derive(Default, Clone, Serialize, Deserialize, Eq, PartialEq, Debug)]
pub struct Attributes(AttributeMap);
@ -35,12 +58,76 @@ impl Attributes {
self.0.insert(key.to_string(), value.into());
}
pub fn insert_entry(&mut self, entry: AttributeEntry) {
self.insert(entry.key, entry.value)
}
/// Set the key's value to None
pub fn remove_value<K: AsRef<str>>(&mut self, key: K) {
// if let Some(mut_value) = self.0.get_mut(key.as_ref()) {
// mut_value.value = None;
// }
self.insert(key.as_ref().to_string(), AttributeValue::none());
}
/// Set all key's value to None
pub fn remove_all_value(&mut self) {
self.0.iter_mut().for_each(|(_, v)| {
*v = AttributeValue::none();
})
}
pub fn retain_values(&mut self, retain_keys: &[&str]) {
self.0.iter_mut().for_each(|(k, v)| {
if !retain_keys.contains(&k.as_str()) {
*v = AttributeValue::none();
}
})
}
pub fn remove_key<K: AsRef<str>>(&mut self, key: K) {
self.0.remove(key.as_ref());
}
/// 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>) {
if other.is_none() {
return;
}
let mut new_attributes = other.unwrap().0;
self.0.iter().for_each(|(k, v)| {
new_attributes.insert(k.clone(), v.clone());
});
self.0 = new_attributes;
}
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
}
pub fn delete<K: ToString>(&mut self, key: K) {
self.insert(key.to_string(), AttributeValue::empty());
impl Display for Attributes {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
for (key, value) in self.0.iter() {
let _ = f.write_str(&format!("{:?}:{:?}", key, value))?;
}
Ok(())
}
}
impl OperationAttributes for Attributes {
fn is_empty(&self) -> bool {
self.is_empty()
}
fn remove_empty(&mut self) {
self.retain(|_, v| v.value.is_some());
}
fn extend_other(&mut self, other: Self) {
self.0.extend(other.0);
}
}
@ -85,7 +172,7 @@ impl OperationTransform for Attributes {
self.iter().fold(base_inverted, |mut attributes, (k, _)| {
if other.get(k) != self.get(k) && !other.contains_key(k) {
attributes.delete(k);
attributes.remove_value(k);
}
attributes
})
@ -94,8 +181,7 @@ impl OperationTransform for Attributes {
pub type AttributeKey = String;
#[derive(Eq, PartialEq, Hash, Debug, Clone, Serialize_repr, Deserialize_repr)]
#[repr(u8)]
#[derive(Eq, PartialEq, Hash, Debug, Clone)]
pub enum ValueType {
IntType = 0,
FloatType = 1,
@ -105,41 +191,40 @@ pub enum ValueType {
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct AttributeValue {
pub ty: ValueType,
pub ty: Option<ValueType>,
pub value: Option<String>,
}
impl AttributeValue {
pub fn empty() -> Self {
Self {
ty: ValueType::StrType,
value: None,
}
pub fn none() -> Self {
Self { ty: None, value: None }
}
pub fn from_int(val: usize) -> Self {
let value = if val > 0_usize { Some(val.to_string()) } else { None };
Self {
ty: ValueType::IntType,
value: Some(val.to_string()),
ty: Some(ValueType::IntType),
value,
}
}
pub fn from_float(val: f64) -> Self {
Self {
ty: ValueType::FloatType,
ty: Some(ValueType::FloatType),
value: Some(val.to_string()),
}
}
pub fn from_bool(val: bool) -> Self {
let value = if val { Some(val.to_string()) } else { None };
Self {
ty: ValueType::BoolType,
value: Some(val.to_string()),
ty: Some(ValueType::BoolType),
value,
}
}
pub fn from_string(s: &str) -> Self {
let value = if s.is_empty() { None } else { Some(s.to_string()) };
Self {
ty: ValueType::StrType,
ty: Some(ValueType::StrType),
value,
}
}
@ -170,6 +255,24 @@ impl std::convert::From<bool> for AttributeValue {
}
}
impl std::convert::From<usize> for AttributeValue {
fn from(value: usize) -> Self {
AttributeValue::from_int(value)
}
}
impl std::convert::From<&str> for AttributeValue {
fn from(value: &str) -> Self {
AttributeValue::from_string(value)
}
}
impl std::convert::From<String> for AttributeValue {
fn from(value: String) -> Self {
AttributeValue::from_string(&value)
}
}
#[derive(Default)]
pub struct AttributeBuilder {
attributes: Attributes,
@ -185,8 +288,13 @@ impl AttributeBuilder {
self
}
pub fn delete<K: ToString>(mut self, key: K) -> Self {
self.attributes.delete(key);
pub fn insert_entry(mut self, entry: AttributeEntry) -> Self {
self.attributes.insert_entry(entry);
self
}
pub fn delete<K: AsRef<str>>(mut self, key: K) -> Self {
self.attributes.remove_value(key);
self
}

59
shared-lib/lib-ot/src/core/attributes/attribute_serde.rs
View File

@ -1,4 +1,5 @@
use crate::core::attributes::AttributeValue;
use serde::{
de::{self, MapAccess, Visitor},
Deserialize, Deserializer, Serialize, Serializer,
@ -10,36 +11,38 @@ impl Serialize for AttributeValue {
where
S: Serializer,
{
match self.ty {
super::ValueType::IntType => {
//
if let Some(value) = self.int_value() {
serializer.serialize_i64(value)
} else {
serializer.serialize_none()
match &self.ty {
None => serializer.serialize_none(),
Some(ty) => match ty {
super::ValueType::IntType => {
if let Some(value) = self.int_value() {
serializer.serialize_i64(value)
} else {
serializer.serialize_none()
}
}
}
super::ValueType::FloatType => {
if let Some(value) = self.float_value() {
serializer.serialize_f64(value)
} else {
serializer.serialize_none()
super::ValueType::FloatType => {
if let Some(value) = self.float_value() {
serializer.serialize_f64(value)
} else {
serializer.serialize_none()
}
}
}
super::ValueType::StrType => {
if let Some(value) = self.str_value() {
serializer.serialize_str(&value)
} else {
serializer.serialize_none()
super::ValueType::StrType => {
if let Some(value) = self.str_value() {
serializer.serialize_str(&value)
} else {
serializer.serialize_none()
}
}
}
super::ValueType::BoolType => {
if let Some(value) = self.bool_value() {
serializer.serialize_bool(value)
} else {
serializer.serialize_none()
super::ValueType::BoolType => {
if let Some(value) = self.bool_value() {
serializer.serialize_bool(value)
} else {
serializer.serialize_none()
}
}
}
},
}
}
}
@ -130,7 +133,7 @@ impl<'de> Deserialize<'de> for AttributeValue {
where
E: de::Error,
{
Ok(AttributeValue::empty())
Ok(AttributeValue::none())
}
fn visit_unit<E>(self) -> Result<Self::Value, E>
@ -138,7 +141,7 @@ impl<'de> Deserialize<'de> for AttributeValue {
E: de::Error,
{
// the value that contains null will be processed here.
Ok(AttributeValue::empty())
Ok(AttributeValue::none())
}
fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>

8
shared-lib/lib-ot/src/core/delta/builder.rs
View File

@ -52,9 +52,9 @@ where
/// # Examples
///
/// ```
/// use lib_ot::text_delta::{TextAttribute, TextDelta, TextDeltaBuilder};
/// use lib_ot::text_delta::{BuildInTextAttribute, TextDelta, TextDeltaBuilder};
///
/// let mut attribute = TextAttribute::Bold(true);
/// let mut attribute = BuildInTextAttribute::Bold(true);
/// let delta = TextDeltaBuilder::new().retain_with_attributes(7, attribute.into()).build();
///
/// assert_eq!(delta.json_str(), r#"[{"retain":7,"attributes":{"bold":true}}]"#);
@ -111,7 +111,7 @@ where
///
/// ```
/// use lib_ot::core::{OperationTransform, DeltaBuilder};
/// use lib_ot::text_delta::{TextAttribute, TextDeltaBuilder};
/// use lib_ot::text_delta::{BuildInTextAttribute, TextDeltaBuilder};
/// let delta = DeltaBuilder::new()
/// .retain(3)
/// .trim()
@ -119,7 +119,7 @@ where
/// assert_eq!(delta.ops.len(), 0);
///
/// let delta = TextDeltaBuilder::new()
/// .retain_with_attributes(3, TextAttribute::Bold(true).into())
/// .retain_with_attributes(3, BuildInTextAttribute::Bold(true).into())
/// .trim()
/// .build();
/// assert_eq!(delta.ops.len(), 1);

5
shared-lib/lib-ot/src/core/delta/iterator.rs
View File

@ -2,7 +2,8 @@ use super::cursor::*;
use crate::core::delta::operation::{Operation, OperationAttributes};
use crate::core::delta::{Operations, NEW_LINE};
use crate::core::interval::Interval;
use crate::text_delta::TextAttributes;
use crate::core::Attributes;
use std::ops::{Deref, DerefMut};
pub(crate) const MAX_IV_LEN: usize = i32::MAX as usize;
@ -132,7 +133,7 @@ where
}
}
pub fn is_empty_line_at_index(delta: &Operations<TextAttributes>, index: usize) -> bool {
pub fn is_empty_line_at_index(delta: &Operations<Attributes>, 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() {

3
shared-lib/lib-ot/src/core/delta/operation/builder.rs
View File

@ -1,7 +1,6 @@
use crate::core::delta::operation::{EmptyAttributes, Operation, OperationAttributes};
use crate::text_delta::TextAttributes;
pub type RichTextOpBuilder = OperationsBuilder<TextAttributes>;
// pub type RichTextOpBuilder = OperationsBuilder<TextAttributes>;
pub type PlainTextOpBuilder = OperationsBuilder<EmptyAttributes>;
#[derive(Default)]

2
shared-lib/lib-ot/src/core/delta/ops.rs
View File

@ -576,7 +576,7 @@ where
/// {"retain":7,"attributes":{"bold":null}}
/// ]"#;
/// let delta = TextDelta::from_json(json).unwrap();
/// assert_eq!(delta.json_str(), r#"[{"retain":7,"attributes":{"bold":""}}]"#);
/// assert_eq!(delta.json_str(), r#"[{"retain":7,"attributes":{"bold":null}}]"#);
/// ```
pub fn from_json(json: &str) -> Result<Self, OTError> {
let delta = serde_json::from_str(json).map_err(|e| {

30
shared-lib/lib-ot/src/text_delta/attribute_builder.rs
View File

@ -1,30 +0,0 @@
#![allow(non_snake_case)]
#![allow(clippy::derivable_impls)]
use crate::text_delta::{TextAttribute, TextAttributes};
pub struct TextDeltaAttributeBuilder {
inner: TextAttributes,
}
impl std::default::Default for TextDeltaAttributeBuilder {
fn default() -> Self {
Self {
inner: TextAttributes::default(),
}
}
}
impl TextDeltaAttributeBuilder {
pub fn new() -> Self {
TextDeltaAttributeBuilder::default()
}
pub fn add_attr(mut self, attribute: TextAttribute) -> Self {
self.inner.add(attribute);
self
}
pub fn build(self) -> TextAttributes {
self.inner
}
}

375
shared-lib/lib-ot/src/text_delta/attributes.rs
View File

@ -1,253 +1,58 @@
#![allow(non_snake_case)]
use crate::core::{Operation, OperationAttributes, OperationTransform};
use crate::{block_attribute, errors::OTError, ignore_attribute, inline_attribute, list_attribute};
use crate::core::{AttributeEntry, AttributeKey, Attributes};
use crate::text_delta::TextOperation;
use crate::{inline_attribute_entry, inline_list_attribute_entry};
use lazy_static::lazy_static;
use std::{
collections::{HashMap, HashSet},
fmt,
fmt::Formatter,
iter::FromIterator,
};
use strum_macros::Display;
pub type RichTextOperation = Operation<TextAttributes>;
impl RichTextOperation {
pub fn contain_attribute(&self, attribute: &TextAttribute) -> bool {
self.get_attributes().contains_key(&attribute.key)
}
}
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct TextAttributes {
pub(crate) inner: HashMap<TextAttributeKey, TextAttributeValue>,
}
impl std::default::Default for TextAttributes {
fn default() -> Self {
Self {
inner: HashMap::with_capacity(0),
}
}
}
impl fmt::Display for TextAttributes {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_fmt(format_args!("{:?}", self.inner))
}
}
use std::str::FromStr;
use std::{collections::HashSet, iter::FromIterator};
use strum_macros::{AsRefStr, Display, EnumString};
#[inline(always)]
pub fn plain_attributes() -> TextAttributes {
TextAttributes::default()
pub fn empty_attributes() -> Attributes {
Attributes::default()
}
impl TextAttributes {
pub fn new() -> Self {
TextAttributes { inner: HashMap::new() }
}
pub fn is_empty(&self) -> bool {
self.inner.is_empty()
}
pub fn add(&mut self, attribute: TextAttribute) {
let TextAttribute { key, value, scope: _ } = attribute;
self.inner.insert(key, value);
}
pub fn insert(&mut self, key: TextAttributeKey, value: TextAttributeValue) {
self.inner.insert(key, value);
}
pub fn delete(&mut self, key: &TextAttributeKey) {
self.inner.insert(key.clone(), TextAttributeValue(None));
}
pub fn mark_all_as_removed_except(&mut self, attribute: Option<TextAttributeKey>) {
match attribute {
None => {
self.inner.iter_mut().for_each(|(_k, v)| v.0 = None);
}
Some(attribute) => {
self.inner.iter_mut().for_each(|(k, v)| {
if k != &attribute {
v.0 = None;
}
});
}
}
}
pub fn remove(&mut self, key: TextAttributeKey) {
self.inner.retain(|k, _| k != &key);
}
// Update inner 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<TextAttributes>) {
if other.is_none() {
return;
}
let mut new_attributes = other.unwrap().inner;
self.inner.iter().for_each(|(k, v)| {
new_attributes.insert(k.clone(), v.clone());
});
self.inner = new_attributes;
}
}
impl OperationAttributes for TextAttributes {
fn is_empty(&self) -> bool {
self.inner.is_empty()
}
fn remove_empty(&mut self) {
self.inner.retain(|_, v| v.0.is_some());
}
fn extend_other(&mut self, other: Self) {
self.inner.extend(other.inner);
}
}
impl OperationTransform for TextAttributes {
fn compose(&self, other: &Self) -> Result<Self, OTError>
where
Self: Sized,
{
let mut attributes = self.clone();
attributes.extend_other(other.clone());
Ok(attributes)
}
fn transform(&self, other: &Self) -> Result<(Self, Self), OTError>
where
Self: Sized,
{
let a = self.iter().fold(TextAttributes::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(TextAttributes::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(TextAttributes::new(), |mut attributes, (k, v)| {
if other.get(k) != self.get(k) && self.contains_key(k) {
attributes.insert(k.clone(), v.clone());
}
attributes
});
let inverted = self.iter().fold(base_inverted, |mut attributes, (k, _)| {
if other.get(k) != self.get(k) && !other.contains_key(k) {
attributes.delete(k);
}
attributes
});
inverted
}
}
impl std::ops::Deref for TextAttributes {
type Target = HashMap<TextAttributeKey, TextAttributeValue>;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl std::ops::DerefMut for TextAttributes {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.inner
}
}
pub fn attributes_except_header(op: &RichTextOperation) -> TextAttributes {
pub fn attributes_except_header(op: &TextOperation) -> Attributes {
let mut attributes = op.get_attributes();
attributes.remove(TextAttributeKey::Header);
attributes.remove_key(BuildInTextAttributeKey::Header);
attributes
}
#[derive(Debug, Clone)]
pub struct TextAttribute {
pub key: TextAttributeKey,
pub value: TextAttributeValue,
pub scope: AttributeScope,
}
pub struct BuildInTextAttribute();
impl TextAttribute {
// inline
inline_attribute!(Bold, bool);
inline_attribute!(Italic, bool);
inline_attribute!(Underline, bool);
inline_attribute!(StrikeThrough, bool);
inline_attribute!(Link, &str);
inline_attribute!(Color, String);
inline_attribute!(Font, usize);
inline_attribute!(Size, usize);
inline_attribute!(Background, String);
inline_attribute!(InlineCode, bool);
impl BuildInTextAttribute {
inline_attribute_entry!(Bold, bool);
inline_attribute_entry!(Italic, bool);
inline_attribute_entry!(Underline, bool);
inline_attribute_entry!(StrikeThrough, bool);
inline_attribute_entry!(Link, &str);
inline_attribute_entry!(Color, String);
inline_attribute_entry!(Font, usize);
inline_attribute_entry!(Size, usize);
inline_attribute_entry!(Background, String);
inline_attribute_entry!(InlineCode, bool);
// block
block_attribute!(Header, usize);
block_attribute!(Indent, usize);
block_attribute!(Align, String);
block_attribute!(List, &str);
block_attribute!(CodeBlock, bool);
block_attribute!(BlockQuote, bool);
inline_attribute_entry!(Header, usize);
inline_attribute_entry!(Indent, usize);
inline_attribute_entry!(Align, String);
inline_attribute_entry!(List, &str);
inline_attribute_entry!(CodeBlock, bool);
inline_attribute_entry!(BlockQuote, bool);
// ignore
ignore_attribute!(Width, usize);
ignore_attribute!(Height, usize);
inline_attribute_entry!(Width, usize);
inline_attribute_entry!(Height, usize);
// List extension
list_attribute!(Bullet, "bullet");
list_attribute!(Ordered, "ordered");
list_attribute!(Checked, "checked");
list_attribute!(UnChecked, "unchecked");
pub fn to_json(&self) -> String {
match serde_json::to_string(self) {
Ok(json) => json,
Err(e) => {
log::error!("Attribute serialize to str failed: {}", e);
"".to_owned()
}
}
}
inline_list_attribute_entry!(Bullet, "bullet");
inline_list_attribute_entry!(Ordered, "ordered");
inline_list_attribute_entry!(Checked, "checked");
inline_list_attribute_entry!(UnChecked, "unchecked");
}
impl fmt::Display for TextAttribute {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
let s = format!("{:?}:{:?} {:?}", self.key, self.value.0, self.scope);
f.write_str(&s)
}
}
impl std::convert::From<TextAttribute> for TextAttributes {
fn from(attr: TextAttribute) -> Self {
let mut attributes = TextAttributes::new();
attributes.add(attr);
attributes
}
}
#[derive(Clone, Debug, Display, Hash, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
// #[serde(rename_all = "snake_case")]
pub enum TextAttributeKey {
#[derive(Clone, Debug, Display, Hash, Eq, PartialEq, serde::Serialize, serde::Deserialize, AsRefStr, EnumString)]
#[strum(serialize_all = "snake_case")]
pub enum BuildInTextAttributeKey {
#[serde(rename = "bold")]
Bold,
#[serde(rename = "italic")]
@ -286,91 +91,45 @@ pub enum TextAttributeKey {
Header,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct TextAttributeValue(pub Option<String>);
impl std::convert::From<&usize> for TextAttributeValue {
fn from(val: &usize) -> Self {
TextAttributeValue::from(*val)
pub fn is_block(k: &AttributeKey) -> bool {
if let Ok(key) = BuildInTextAttributeKey::from_str(k) {
BLOCK_KEYS.contains(&key)
} else {
false
}
}
impl std::convert::From<usize> for TextAttributeValue {
fn from(val: usize) -> Self {
if val > 0_usize {
TextAttributeValue(Some(format!("{}", val)))
} else {
TextAttributeValue(None)
}
pub fn is_inline(k: &AttributeKey) -> bool {
if let Ok(key) = BuildInTextAttributeKey::from_str(k) {
INLINE_KEYS.contains(&key)
} else {
false
}
}
impl std::convert::From<&str> for TextAttributeValue {
fn from(val: &str) -> Self {
val.to_owned().into()
}
}
impl std::convert::From<String> for TextAttributeValue {
fn from(val: String) -> Self {
if val.is_empty() {
TextAttributeValue(None)
} else {
TextAttributeValue(Some(val))
}
}
}
impl std::convert::From<&bool> for TextAttributeValue {
fn from(val: &bool) -> Self {
TextAttributeValue::from(*val)
}
}
impl std::convert::From<bool> for TextAttributeValue {
fn from(val: bool) -> Self {
let val = match val {
true => Some("true".to_owned()),
false => None,
};
TextAttributeValue(val)
}
}
pub fn is_block_except_header(k: &TextAttributeKey) -> bool {
if k == &TextAttributeKey::Header {
return false;
}
BLOCK_KEYS.contains(k)
}
pub fn is_block(k: &TextAttributeKey) -> bool {
BLOCK_KEYS.contains(k)
}
lazy_static! {
static ref BLOCK_KEYS: HashSet<TextAttributeKey> = HashSet::from_iter(vec![
TextAttributeKey::Header,
TextAttributeKey::Indent,
TextAttributeKey::Align,
TextAttributeKey::CodeBlock,
TextAttributeKey::List,
TextAttributeKey::BlockQuote,
static ref BLOCK_KEYS: HashSet<BuildInTextAttributeKey> = HashSet::from_iter(vec![
BuildInTextAttributeKey::Header,
BuildInTextAttributeKey::Indent,
BuildInTextAttributeKey::Align,
BuildInTextAttributeKey::CodeBlock,
BuildInTextAttributeKey::List,
BuildInTextAttributeKey::BlockQuote,
]);
static ref INLINE_KEYS: HashSet<TextAttributeKey> = HashSet::from_iter(vec![
TextAttributeKey::Bold,
TextAttributeKey::Italic,
TextAttributeKey::Underline,
TextAttributeKey::StrikeThrough,
TextAttributeKey::Link,
TextAttributeKey::Color,
TextAttributeKey::Font,
TextAttributeKey::Size,
TextAttributeKey::Background,
TextAttributeKey::InlineCode,
static ref INLINE_KEYS: HashSet<BuildInTextAttributeKey> = HashSet::from_iter(vec![
BuildInTextAttributeKey::Bold,
BuildInTextAttributeKey::Italic,
BuildInTextAttributeKey::Underline,
BuildInTextAttributeKey::StrikeThrough,
BuildInTextAttributeKey::Link,
BuildInTextAttributeKey::Color,
BuildInTextAttributeKey::Font,
BuildInTextAttributeKey::Size,
BuildInTextAttributeKey::Background,
BuildInTextAttributeKey::InlineCode,
]);
static ref INGORE_KEYS: HashSet<TextAttributeKey> =
HashSet::from_iter(vec![TextAttributeKey::Width, TextAttributeKey::Height,]);
static ref INGORE_KEYS: HashSet<BuildInTextAttributeKey> =
HashSet::from_iter(vec![BuildInTextAttributeKey::Width, BuildInTextAttributeKey::Height,]);
}
#[derive(Debug, PartialEq, Eq, Clone)]

231
shared-lib/lib-ot/src/text_delta/attributes_serde.rs
View File

@ -1,231 +0,0 @@
#[rustfmt::skip]
use crate::text_delta::{TextAttribute, TextAttributeKey, TextAttributes, TextAttributeValue};
use serde::{
de,
de::{MapAccess, Visitor},
ser::SerializeMap,
Deserialize, Deserializer, Serialize, Serializer,
};
use std::fmt;
impl Serialize for TextAttribute {
fn serialize<S>(&self, serializer: S) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where
S: Serializer,
{
let mut map = serializer.serialize_map(Some(1))?;
let _ = serial_attribute(&mut map, &self.key, &self.value)?;
map.end()
}
}
impl Serialize for TextAttributes {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
if self.is_empty() {
return serializer.serialize_none();
}
let mut map = serializer.serialize_map(Some(self.inner.len()))?;
for (k, v) in &self.inner {
let _ = serial_attribute(&mut map, k, v)?;
}
map.end()
}
}
fn serial_attribute<S, E>(map_serializer: &mut S, key: &TextAttributeKey, value: &TextAttributeValue) -> Result<(), E>
where
S: SerializeMap,
E: From<<S as SerializeMap>::Error>,
{
if let Some(v) = &value.0 {
match key {
TextAttributeKey::Bold
| TextAttributeKey::Italic
| TextAttributeKey::Underline
| TextAttributeKey::StrikeThrough
| TextAttributeKey::CodeBlock
| TextAttributeKey::InlineCode
| TextAttributeKey::BlockQuote => match &v.parse::<bool>() {
Ok(value) => map_serializer.serialize_entry(&key, value)?,
Err(e) => log::error!("Serial {:?} failed. {:?}", &key, e),
},
TextAttributeKey::Font
| TextAttributeKey::Size
| TextAttributeKey::Header
| TextAttributeKey::Indent
| TextAttributeKey::Width
| TextAttributeKey::Height => match &v.parse::<i32>() {
Ok(value) => map_serializer.serialize_entry(&key, value)?,
Err(e) => log::error!("Serial {:?} failed. {:?}", &key, e),
},
TextAttributeKey::Link
| TextAttributeKey::Color
| TextAttributeKey::Background
| TextAttributeKey::Align
| TextAttributeKey::List => {
map_serializer.serialize_entry(&key, v)?;
}
}
} else {
map_serializer.serialize_entry(&key, "")?;
}
Ok(())
}
impl<'de> Deserialize<'de> for TextAttributes {
fn deserialize<D>(deserializer: D) -> Result<TextAttributes, D::Error>
where
D: Deserializer<'de>,
{
struct AttributesVisitor;
impl<'de> Visitor<'de> for AttributesVisitor {
type Value = TextAttributes;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("Expect map")
}
fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
where
A: MapAccess<'de>,
{
let mut attributes = TextAttributes::new();
while let Some(key) = map.next_key::<TextAttributeKey>()? {
let value = map.next_value::<TextAttributeValue>()?;
attributes.insert(key, value);
}
Ok(attributes)
}
}
deserializer.deserialize_map(AttributesVisitor {})
}
}
impl Serialize for TextAttributeValue {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match &self.0 {
None => serializer.serialize_none(),
Some(val) => serializer.serialize_str(val),
}
}
}
impl<'de> Deserialize<'de> for TextAttributeValue {
fn deserialize<D>(deserializer: D) -> Result<TextAttributeValue, D::Error>
where
D: Deserializer<'de>,
{
struct AttributeValueVisitor;
impl<'de> Visitor<'de> for AttributeValueVisitor {
type Value = TextAttributeValue;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("bool, usize or string")
}
fn visit_bool<E>(self, value: bool) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(value.into())
}
fn visit_i8<E>(self, value: i8) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(TextAttributeValue(Some(format!("{}", value))))
}
fn visit_i16<E>(self, value: i16) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(TextAttributeValue(Some(format!("{}", value))))
}
fn visit_i32<E>(self, value: i32) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(TextAttributeValue(Some(format!("{}", value))))
}
fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(TextAttributeValue(Some(format!("{}", value))))
}
fn visit_u8<E>(self, value: u8) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(TextAttributeValue(Some(format!("{}", value))))
}
fn visit_u16<E>(self, value: u16) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(TextAttributeValue(Some(format!("{}", value))))
}
fn visit_u32<E>(self, value: u32) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(TextAttributeValue(Some(format!("{}", value))))
}
fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(TextAttributeValue(Some(format!("{}", value))))
}
fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(s.into())
}
fn visit_none<E>(self) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(TextAttributeValue(None))
}
fn visit_unit<E>(self) -> Result<Self::Value, E>
where
E: de::Error,
{
// the value that contains null will be processed here.
Ok(TextAttributeValue(None))
}
fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
where
A: MapAccess<'de>,
{
// https://github.com/serde-rs/json/issues/505
let mut map = map;
let value = map.next_value::<TextAttributeValue>()?;
Ok(value)
}
}
deserializer.deserialize_any(AttributeValueVisitor)
}
}

9
shared-lib/lib-ot/src/text_delta/delta.rs
View File

@ -1,5 +1,6 @@
use crate::core::{OperationBuilder, Operations};
use crate::text_delta::TextAttributes;
use crate::core::{Attributes, Operation, OperationBuilder, Operations};
pub type TextDelta = Operations<TextAttributes>;
pub type TextDeltaBuilder = OperationBuilder<TextAttributes>;
pub type TextDelta = Operations<Attributes>;
pub type TextDeltaBuilder = OperationBuilder<Attributes>;
pub type TextOperation = Operation<Attributes>;

45
shared-lib/lib-ot/src/text_delta/macros.rs
View File

@ -1,62 +1,33 @@
#[macro_export]
macro_rules! inline_attribute {
macro_rules! inline_attribute_entry {
(
$key: ident,
$value: ty
) => {
pub fn $key(value: $value) -> Self {
Self {
key: TextAttributeKey::$key,
pub fn $key(value: $value) -> crate::core::AttributeEntry {
AttributeEntry {
key: BuildInTextAttributeKey::$key.as_ref().to_string(),
value: value.into(),
scope: AttributeScope::Inline,
}
}
};
}
#[macro_export]
macro_rules! block_attribute {
(
$key: ident,
$value: ty
) => {
pub fn $key(value: $value) -> Self {
Self {
key: TextAttributeKey::$key,
value: value.into(),
scope: AttributeScope::Block,
}
}
};
}
#[macro_export]
macro_rules! list_attribute {
macro_rules! inline_list_attribute_entry {
(
$key: ident,
$value: expr
) => {
pub fn $key(b: bool) -> Self {
pub fn $key(b: bool) -> crate::core::AttributeEntry {
let value = match b {
true => $value,
false => "",
};
TextAttribute::List(value)
}
};
}
#[macro_export]
macro_rules! ignore_attribute {
(
$key: ident,
$value: ident
) => {
pub fn $key(value: $value) -> Self {
Self {
key: TextAttributeKey::$key,
AttributeEntry {
key: BuildInTextAttributeKey::List.as_ref().to_string(),
value: value.into(),
scope: AttributeScope::Ignore,
}
}
};

3
shared-lib/lib-ot/src/text_delta/mod.rs
View File

@ -1,11 +1,8 @@
mod attribute_builder;
mod attributes;
mod attributes_serde;
#[macro_use]
mod macros;
mod delta;
pub use attribute_builder::*;
pub use attributes::*;
pub use delta::*;

13
shared-lib/lib-ot/tests/node/editor_test.rs
View File

@ -1,7 +1,8 @@
use super::script::{NodeScript::*, *};
use lib_ot::core::AttributeBuilder;
use lib_ot::{
core::{NodeData, Path},
text_delta::{TextAttribute, TextDeltaAttributeBuilder, TextDeltaBuilder},
text_delta::TextDeltaBuilder,
};
#[test]
@ -14,15 +15,11 @@ fn editor_deserialize_node_test() {
.insert("👋 ")
.insert_with_attributes(
"Welcome to ",
TextDeltaAttributeBuilder::new()
.add_attr(TextAttribute::Bold(true))
.build(),
AttributeBuilder::new().insert("href", "appflowy.io").build(),
)
.insert_with_attributes(
"AppFlowy Editor",
TextDeltaAttributeBuilder::new()
.add_attr(TextAttribute::Italic(true))
.build(),
AttributeBuilder::new().insert("italic", true).build(),
)
.build();
@ -81,7 +78,7 @@ const EXAMPLE_JSON: &str = r#"
{
"insert": "Welcome to ",
"attributes": {
"bold": true
"href": "appflowy.io"
}
},
{

2
shared-lib/lib-ot/tests/node/operation_test.rs
View File

@ -41,7 +41,7 @@ fn operation_update_node_attributes_serde_test() {
assert_eq!(
result,
r#"{"op":"update","path":[0,1],"attributes":{"bold":true},"oldAttributes":{"bold":false}}"#
r#"{"op":"update","path":[0,1],"attributes":{"bold":true},"oldAttributes":{"bold":null}}"#
);
}