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

generic lib-ot

Browse Source
This commit is contained in:
appflowy
2021-12-07 10:39:01 +08:00
parent 8457682092
commit 2f413a8e67
44 changed files with 1023 additions and 586 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
frontend/rust-lib/flowy-document/tests/editor/attribute_test.rs
View File

@ -1,7 +1,7 @@
#![cfg_attr(rustfmt, rustfmt::skip)]
use crate::editor::{TestBuilder, TestOp::*};
use flowy_document_infra::core::{FlowyDoc, PlainDoc};
use lib_ot::core::{Delta, Interval, OperationTransformable, NEW_LINE, WHITESPACE, FlowyStr};
use lib_ot::core::{Interval, OperationTransformable, NEW_LINE, WHITESPACE, FlowyStr, RichTextDelta};
use unicode_segmentation::UnicodeSegmentation;
#[test]
@ -760,12 +760,12 @@ fn attributes_preserve_list_format_on_merge() {
#[test]
fn delta_compose() {
let mut delta = Delta::from_json(r#"[{"insert":"\n"}]"#).unwrap();
let mut delta = RichTextDelta::from_json(r#"[{"insert":"\n"}]"#).unwrap();
let deltas = vec![
Delta::from_json(r#"[{"retain":1,"attributes":{"list":"unchecked"}}]"#).unwrap(),
Delta::from_json(r#"[{"insert":"a"}]"#).unwrap(),
Delta::from_json(r#"[{"retain":1},{"insert":"\n","attributes":{"list":"unchecked"}}]"#).unwrap(),
Delta::from_json(r#"[{"retain":2},{"retain":1,"attributes":{"list":""}}]"#).unwrap(),
RichTextDelta::from_json(r#"[{"retain":1,"attributes":{"list":"unchecked"}}]"#).unwrap(),
RichTextDelta::from_json(r#"[{"insert":"a"}]"#).unwrap(),
RichTextDelta::from_json(r#"[{"retain":1},{"insert":"\n","attributes":{"list":"unchecked"}}]"#).unwrap(),
RichTextDelta::from_json(r#"[{"retain":2},{"retain":1,"attributes":{"list":""}}]"#).unwrap(),
];
for d in deltas {

36
frontend/rust-lib/flowy-document/tests/editor/mod.rs
View File

@ -80,8 +80,8 @@ pub enum TestOp {
pub struct TestBuilder {
documents: Vec<Document>,
deltas: Vec<Option<Delta>>,
primes: Vec<Option<Delta>>,
deltas: Vec<Option<RichTextDelta>>,
primes: Vec<Option<RichTextDelta>>,
}
impl TestBuilder {
@ -125,11 +125,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, Attribute::Bold(true)).unwrap();
document.format(*iv, RichTextAttribute::Bold(true)).unwrap();
},
TestOp::Bold(delta_i, iv, enable) => {
let document = &mut self.documents[*delta_i];
let attribute = Attribute::Bold(*enable);
let attribute = RichTextAttribute::Bold(*enable);
let delta = document.format(*iv, attribute).unwrap();
tracing::trace!("Bold delta: {}", delta.to_json());
self.deltas.insert(*delta_i, Some(delta));
@ -137,8 +137,8 @@ impl TestBuilder {
TestOp::Italic(delta_i, iv, enable) => {
let document = &mut self.documents[*delta_i];
let attribute = match *enable {
true => Attribute::Italic(true),
false => Attribute::Italic(false),
true => RichTextAttribute::Italic(true),
false => RichTextAttribute::Italic(false),
};
let delta = document.format(*iv, attribute).unwrap();
tracing::trace!("Italic delta: {}", delta.to_json());
@ -146,21 +146,21 @@ impl TestBuilder {
},
TestOp::Header(delta_i, iv, level) => {
let document = &mut self.documents[*delta_i];
let attribute = Attribute::Header(*level);
let attribute = RichTextAttribute::Header(*level);
let delta = document.format(*iv, attribute).unwrap();
tracing::trace!("Header delta: {}", delta.to_json());
self.deltas.insert(*delta_i, Some(delta));
},
TestOp::Link(delta_i, iv, link) => {
let document = &mut self.documents[*delta_i];
let attribute = Attribute::Link(link.to_owned());
let attribute = RichTextAttribute::Link(link.to_owned());
let delta = document.format(*iv, attribute).unwrap();
tracing::trace!("Link delta: {}", delta.to_json());
self.deltas.insert(*delta_i, Some(delta));
},
TestOp::Bullet(delta_i, iv, enable) => {
let document = &mut self.documents[*delta_i];
let attribute = Attribute::Bullet(*enable);
let attribute = RichTextAttribute::Bullet(*enable);
let delta = document.format(*iv, attribute).unwrap();
tracing::debug!("Bullet delta: {}", delta.to_json());
@ -225,8 +225,8 @@ impl TestBuilder {
TestOp::AssertDocJson(delta_i, expected) => {
let delta_json = self.documents[*delta_i].to_json();
let expected_delta: Delta = serde_json::from_str(expected).unwrap();
let target_delta: Delta = serde_json::from_str(&delta_json).unwrap();
let expected_delta: RichTextDelta = serde_json::from_str(expected).unwrap();
let target_delta: RichTextDelta = serde_json::from_str(&delta_json).unwrap();
if expected_delta != target_delta {
log::error!("✅ expect: {}", expected,);
@ -237,8 +237,8 @@ impl TestBuilder {
TestOp::AssertPrimeJson(doc_i, expected) => {
let prime_json = self.primes[*doc_i].as_ref().unwrap().to_json();
let expected_prime: Delta = serde_json::from_str(expected).unwrap();
let target_prime: Delta = serde_json::from_str(&prime_json).unwrap();
let expected_prime: RichTextDelta = serde_json::from_str(expected).unwrap();
let target_prime: RichTextDelta = serde_json::from_str(&prime_json).unwrap();
if expected_prime != target_prime {
log::error!("✅ expect prime: {}", expected,);
@ -292,8 +292,8 @@ impl Rng {
.collect()
}
pub fn gen_delta(&mut self, s: &str) -> Delta {
let mut delta = Delta::default();
pub fn gen_delta(&mut self, s: &str) -> RichTextDelta {
let mut delta = RichTextDelta::default();
loop {
let left = s.chars().count() - delta.base_len;
if left == 0 {
@ -306,18 +306,18 @@ impl Rng {
};
match self.0.gen_range(0.0, 1.0) {
f if f < 0.2 => {
delta.insert(&self.gen_string(i), Attributes::default());
delta.insert(&self.gen_string(i), RichTextAttributes::default());
},
f if f < 0.4 => {
delta.delete(i);
},
_ => {
delta.retain(i, Attributes::default());
delta.retain(i, RichTextAttributes::default());
},
}
}
if self.0.gen_range(0.0, 1.0) < 0.3 {
delta.insert(&("1".to_owned() + &self.gen_string(10)), Attributes::default());
delta.insert(&("1".to_owned() + &self.gen_string(10)), RichTextAttributes::default());
}
delta
}

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

@ -35,7 +35,7 @@ fn attributes_insert_text_at_middle() {
#[test]
fn delta_get_ops_in_interval_1() {
let mut delta = Delta::default();
let mut delta = RichTextDelta::default();
let insert_a = OpBuilder::insert("123").build();
let insert_b = OpBuilder::insert("4").build();
@ -48,7 +48,7 @@ fn delta_get_ops_in_interval_1() {
#[test]
fn delta_get_ops_in_interval_2() {
let mut delta = Delta::default();
let mut delta = RichTextDelta::default();
let insert_a = OpBuilder::insert("123").build();
let insert_b = OpBuilder::insert("4").build();
let insert_c = OpBuilder::insert("5").build();
@ -92,7 +92,7 @@ fn delta_get_ops_in_interval_2() {
#[test]
fn delta_get_ops_in_interval_3() {
let mut delta = Delta::default();
let mut delta = RichTextDelta::default();
let insert_a = OpBuilder::insert("123456").build();
delta.add(insert_a.clone());
assert_eq!(
@ -103,7 +103,7 @@ fn delta_get_ops_in_interval_3() {
#[test]
fn delta_get_ops_in_interval_4() {
let mut delta = Delta::default();
let mut delta = RichTextDelta::default();
let insert_a = OpBuilder::insert("12").build();
let insert_b = OpBuilder::insert("34").build();
let insert_c = OpBuilder::insert("56").build();
@ -133,7 +133,7 @@ fn delta_get_ops_in_interval_4() {
#[test]
fn delta_get_ops_in_interval_5() {
let mut delta = Delta::default();
let mut delta = RichTextDelta::default();
let insert_a = OpBuilder::insert("123456").build();
let insert_b = OpBuilder::insert("789").build();
delta.ops.push(insert_a.clone());
@ -151,7 +151,7 @@ fn delta_get_ops_in_interval_5() {
#[test]
fn delta_get_ops_in_interval_6() {
let mut delta = Delta::default();
let mut delta = RichTextDelta::default();
let insert_a = OpBuilder::insert("12345678").build();
delta.add(insert_a.clone());
assert_eq!(
@ -162,7 +162,7 @@ fn delta_get_ops_in_interval_6() {
#[test]
fn delta_get_ops_in_interval_7() {
let mut delta = Delta::default();
let mut delta = RichTextDelta::default();
let insert_a = OpBuilder::insert("12345").build();
let retain_a = OpBuilder::retain(3).build();
@ -182,7 +182,7 @@ fn delta_get_ops_in_interval_7() {
#[test]
fn delta_seek_1() {
let mut delta = Delta::default();
let mut delta = RichTextDelta::default();
let insert_a = OpBuilder::insert("12345").build();
let retain_a = OpBuilder::retain(3).build();
delta.add(insert_a.clone());
@ -194,7 +194,7 @@ fn delta_seek_1() {
#[test]
fn delta_seek_2() {
let mut delta = Delta::default();
let mut delta = RichTextDelta::default();
delta.add(OpBuilder::insert("12345").build());
let mut iter = DeltaIter::new(&delta);
@ -203,7 +203,7 @@ fn delta_seek_2() {
#[test]
fn delta_seek_3() {
let mut delta = Delta::default();
let mut delta = RichTextDelta::default();
delta.add(OpBuilder::insert("12345").build());
let mut iter = DeltaIter::new(&delta);
@ -218,7 +218,7 @@ fn delta_seek_3() {
#[test]
fn delta_seek_4() {
let mut delta = Delta::default();
let mut delta = RichTextDelta::default();
delta.add(OpBuilder::insert("12345").build());
let mut iter = DeltaIter::new(&delta);
@ -228,10 +228,10 @@ fn delta_seek_4() {
#[test]
fn delta_seek_5() {
let mut delta = Delta::default();
let mut delta = RichTextDelta::default();
let attributes = AttributeBuilder::new()
.add_attr(Attribute::Bold(true))
.add_attr(Attribute::Italic(true))
.add_attr(RichTextAttribute::Bold(true))
.add_attr(RichTextAttribute::Italic(true))
.build();
delta.add(OpBuilder::insert("1234").attributes(attributes.clone()).build());
@ -248,7 +248,7 @@ fn delta_seek_5() {
#[test]
fn delta_next_op_len_test() {
let mut delta = Delta::default();
let mut delta = RichTextDelta::default();
delta.add(OpBuilder::insert("12345").build());
let mut iter = DeltaIter::new(&delta);
@ -261,7 +261,7 @@ fn delta_next_op_len_test() {
#[test]
fn delta_next_op_len_test2() {
let mut delta = Delta::default();
let mut delta = RichTextDelta::default();
delta.add(OpBuilder::insert("12345").build());
let mut iter = DeltaIter::new(&delta);
@ -272,7 +272,7 @@ fn delta_next_op_len_test2() {
#[test]
fn delta_next_op_with_len_zero() {
let mut delta = Delta::default();
let mut delta = RichTextDelta::default();
delta.add(OpBuilder::insert("12345").build());
let mut iter = DeltaIter::new(&delta);
assert_eq!(iter.next_op_with_len(0), None,);
@ -281,7 +281,7 @@ fn delta_next_op_with_len_zero() {
#[test]
fn delta_next_op_with_len_cross_op_return_last() {
let mut delta = Delta::default();
let mut delta = RichTextDelta::default();
delta.add(OpBuilder::insert("12345").build());
delta.add(OpBuilder::retain(1).build());
delta.add(OpBuilder::insert("678").build());
@ -294,16 +294,16 @@ fn delta_next_op_with_len_cross_op_return_last() {
#[test]
fn lengths() {
let mut delta = Delta::default();
let mut delta = RichTextDelta::default();
assert_eq!(delta.base_len, 0);
assert_eq!(delta.target_len, 0);
delta.retain(5, Attributes::default());
delta.retain(5, RichTextAttributes::default());
assert_eq!(delta.base_len, 5);
assert_eq!(delta.target_len, 5);
delta.insert("abc", Attributes::default());
delta.insert("abc", RichTextAttributes::default());
assert_eq!(delta.base_len, 5);
assert_eq!(delta.target_len, 8);
delta.retain(2, Attributes::default());
delta.retain(2, RichTextAttributes::default());
assert_eq!(delta.base_len, 7);
assert_eq!(delta.target_len, 10);
delta.delete(2);
@ -312,11 +312,11 @@ fn lengths() {
}
#[test]
fn sequence() {
let mut delta = Delta::default();
delta.retain(5, Attributes::default());
delta.retain(0, Attributes::default());
delta.insert("appflowy", Attributes::default());
delta.insert("", Attributes::default());
let mut delta = RichTextDelta::default();
delta.retain(5, RichTextAttributes::default());
delta.retain(0, RichTextAttributes::default());
delta.insert("appflowy", RichTextAttributes::default());
delta.insert("", RichTextAttributes::default());
delta.delete(3);
delta.delete(0);
assert_eq!(delta.ops.len(), 3);
@ -335,12 +335,12 @@ fn apply_1000() {
#[test]
fn apply() {
let s = "hello world,".to_owned();
let mut delta_a = Delta::default();
delta_a.insert(&s, Attributes::default());
let mut delta_a = RichTextDelta::default();
delta_a.insert(&s, RichTextAttributes::default());
let mut delta_b = Delta::default();
delta_b.retain(s.len(), Attributes::default());
delta_b.insert("appflowy", Attributes::default());
let mut delta_b = RichTextDelta::default();
delta_b.retain(s.len(), RichTextAttributes::default());
delta_b.insert("appflowy", RichTextAttributes::default());
let after_a = delta_a.apply("").unwrap();
let after_b = delta_b.apply(&after_a).unwrap();
@ -349,16 +349,16 @@ fn apply() {
#[test]
fn base_len_test() {
let mut delta_a = Delta::default();
delta_a.insert("a", Attributes::default());
delta_a.insert("b", Attributes::default());
delta_a.insert("c", Attributes::default());
let mut delta_a = RichTextDelta::default();
delta_a.insert("a", RichTextAttributes::default());
delta_a.insert("b", RichTextAttributes::default());
delta_a.insert("c", RichTextAttributes::default());
let s = "hello world,".to_owned();
delta_a.delete(s.len());
let after_a = delta_a.apply(&s).unwrap();
delta_a.insert("d", Attributes::default());
delta_a.insert("d", RichTextAttributes::default());
assert_eq!("abc", &after_a);
}
@ -377,43 +377,43 @@ fn invert() {
#[test]
fn empty_ops() {
let mut delta = Delta::default();
delta.retain(0, Attributes::default());
delta.insert("", Attributes::default());
let mut delta = RichTextDelta::default();
delta.retain(0, RichTextAttributes::default());
delta.insert("", RichTextAttributes::default());
delta.delete(0);
assert_eq!(delta.ops.len(), 0);
}
#[test]
fn eq() {
let mut delta_a = Delta::default();
let mut delta_a = RichTextDelta::default();
delta_a.delete(1);
delta_a.insert("lo", Attributes::default());
delta_a.retain(2, Attributes::default());
delta_a.retain(3, Attributes::default());
let mut delta_b = Delta::default();
delta_a.insert("lo", RichTextAttributes::default());
delta_a.retain(2, RichTextAttributes::default());
delta_a.retain(3, RichTextAttributes::default());
let mut delta_b = RichTextDelta::default();
delta_b.delete(1);
delta_b.insert("l", Attributes::default());
delta_b.insert("o", Attributes::default());
delta_b.retain(5, Attributes::default());
delta_b.insert("l", RichTextAttributes::default());
delta_b.insert("o", RichTextAttributes::default());
delta_b.retain(5, RichTextAttributes::default());
assert_eq!(delta_a, delta_b);
delta_a.delete(1);
delta_b.retain(1, Attributes::default());
delta_b.retain(1, RichTextAttributes::default());
assert_ne!(delta_a, delta_b);
}
#[test]
fn ops_merging() {
let mut delta = Delta::default();
let mut delta = RichTextDelta::default();
assert_eq!(delta.ops.len(), 0);
delta.retain(2, Attributes::default());
delta.retain(2, RichTextAttributes::default());
assert_eq!(delta.ops.len(), 1);
assert_eq!(delta.ops.last(), Some(&OpBuilder::retain(2).build()));
delta.retain(3, Attributes::default());
delta.retain(3, RichTextAttributes::default());
assert_eq!(delta.ops.len(), 1);
assert_eq!(delta.ops.last(), Some(&OpBuilder::retain(5).build()));
delta.insert("abc", Attributes::default());
delta.insert("abc", RichTextAttributes::default());
assert_eq!(delta.ops.len(), 2);
assert_eq!(delta.ops.last(), Some(&OpBuilder::insert("abc").build()));
delta.insert("xyz", Attributes::default());
delta.insert("xyz", RichTextAttributes::default());
assert_eq!(delta.ops.len(), 2);
assert_eq!(delta.ops.last(), Some(&OpBuilder::insert("abcxyz").build()));
delta.delete(1);
@ -425,13 +425,13 @@ fn ops_merging() {
}
#[test]
fn is_noop() {
let mut delta = Delta::default();
let mut delta = RichTextDelta::default();
assert!(delta.is_noop());
delta.retain(5, Attributes::default());
delta.retain(5, RichTextAttributes::default());
assert!(delta.is_noop());
delta.retain(3, Attributes::default());
delta.retain(3, RichTextAttributes::default());
assert!(delta.is_noop());
delta.insert("lorem", Attributes::default());
delta.insert("lorem", RichTextAttributes::default());
assert!(!delta.is_noop());
}
#[test]
@ -473,15 +473,18 @@ fn transform_random_delta() {
#[test]
fn transform_with_two_delta_test() {
let mut a = Delta::default();
let mut a = RichTextDelta::default();
let mut a_s = String::new();
a.insert("123", AttributeBuilder::new().add_attr(Attribute::Bold(true)).build());
a.insert(
"123",
AttributeBuilder::new().add_attr(RichTextAttribute::Bold(true)).build(),
);
a_s = a.apply(&a_s).unwrap();
assert_eq!(&a_s, "123");
let mut b = Delta::default();
let mut b = RichTextDelta::default();
let mut b_s = String::new();
b.insert("456", Attributes::default());
b.insert("456", RichTextAttributes::default());
b_s = b.apply(&b_s).unwrap();
assert_eq!(&b_s, "456");
@ -569,10 +572,10 @@ fn transform_two_conflict_non_seq_delta() {
#[test]
fn delta_invert_no_attribute_delta() {
let mut delta = Delta::default();
let mut delta = RichTextDelta::default();
delta.add(OpBuilder::insert("123").build());
let mut change = Delta::default();
let mut change = RichTextDelta::default();
change.add(OpBuilder::retain(3).build());
change.add(OpBuilder::insert("456").build());
let undo = change.invert(&delta);

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

@ -4,14 +4,14 @@ use lib_ot::core::*;
#[test]
fn operation_insert_serialize_test() {
let attributes = AttributeBuilder::new()
.add_attr(Attribute::Bold(true))
.add_attr(Attribute::Italic(true))
.add_attr(RichTextAttribute::Bold(true))
.add_attr(RichTextAttribute::Italic(true))
.build();
let operation = OpBuilder::insert("123").attributes(attributes).build();
let json = serde_json::to_string(&operation).unwrap();
eprintln!("{}", json);
let insert_op: Operation = serde_json::from_str(&json).unwrap();
let insert_op: RichTextOperation = serde_json::from_str(&json).unwrap();
assert_eq!(insert_op, operation);
}
@ -20,23 +20,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: Operation = serde_json::from_str(&json).unwrap();
let insert_op: RichTextOperation = serde_json::from_str(&json).unwrap();
assert_eq!(insert_op, operation);
}
#[test]
fn operation_delete_serialize_test() {
let operation = Operation::Delete(2);
let operation = RichTextOperation::Delete(2);
let json = serde_json::to_string(&operation).unwrap();
let insert_op: Operation = serde_json::from_str(&json).unwrap();
let insert_op: RichTextOperation = serde_json::from_str(&json).unwrap();
assert_eq!(insert_op, operation);
}
#[test]
fn attributes_serialize_test() {
let attributes = AttributeBuilder::new()
.add_attr(Attribute::Bold(true))
.add_attr(Attribute::Italic(true))
.add_attr(RichTextAttribute::Bold(true))
.add_attr(RichTextAttribute::Italic(true))
.build();
let retain = OpBuilder::insert("123").attributes(attributes).build();
@ -49,8 +49,8 @@ fn delta_serialize_multi_attribute_test() {
let mut delta = Delta::default();
let attributes = AttributeBuilder::new()
.add_attr(Attribute::Bold(true))
.add_attr(Attribute::Italic(true))
.add_attr(RichTextAttribute::Bold(true))
.add_attr(RichTextAttribute::Italic(true))
.build();
let retain = OpBuilder::insert("123").attributes(attributes).build();
@ -73,7 +73,7 @@ fn delta_deserialize_test() {
{"retain":2,"attributes":{"italic":"true","bold":"true"}},
{"retain":2,"attributes":{"italic":true,"bold":true}}
]"#;
let delta = Delta::from_json(json).unwrap();
let delta = RichTextDelta::from_json(json).unwrap();
eprintln!("{}", delta);
}
@ -82,10 +82,10 @@ fn delta_deserialize_null_test() {
let json = r#"[
{"retain":7,"attributes":{"bold":null}}
]"#;
let delta1 = Delta::from_json(json).unwrap();
let delta1 = RichTextDelta::from_json(json).unwrap();
let mut attribute = Attribute::Bold(true);
attribute.value = AttributeValue(None);
let mut attribute = RichTextAttribute::Bold(true);
attribute.value = RichTextAttributeValue(None);
let delta2 = DeltaBuilder::new().retain_with_attributes(7, attribute.into()).build();
assert_eq!(delta2.to_json(), r#"[{"retain":7,"attributes":{"bold":""}}]"#);
@ -94,8 +94,8 @@ fn delta_deserialize_null_test() {
#[test]
fn delta_serde_null_test() {
let mut attribute = Attribute::Bold(true);
attribute.value = AttributeValue(None);
let mut attribute = RichTextAttribute::Bold(true);
attribute.value = RichTextAttributeValue(None);
assert_eq!(attribute.to_json(), r#"{"bold":""}"#);
}