chore: update documentation about how the iterator/FlowyStr/Operation work

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

@@ -40,7 +40,7 @@ fn attributes_insert_text_at_middle() {
 
 #[test]
 fn delta_get_ops_in_interval_1() {
-    let operations = OperationBuilder::new().insert("123", None).insert("4", None).build();
+    let operations = OperationsBuilder::new().insert("123").insert("4").build();
     let delta = RichTextDeltaBuilder::from_operations(operations);
 
     let mut iterator = DeltaIterator::from_interval(&delta, Interval::new(0, 4));
@@ -50,10 +50,10 @@ fn delta_get_ops_in_interval_1() {
 #[test]
 fn delta_get_ops_in_interval_2() {
     let mut delta = RichTextDelta::default();
-    let insert_a = OperationBuilder::insert("123").build();
-    let insert_b = OperationBuilder::insert("4").build();
-    let insert_c = OperationBuilder::insert("5").build();
-    let retain_a = OperationBuilder::retain(3).build();
+    let insert_a = Operation::insert("123");
+    let insert_b = Operation::insert("4");
+    let insert_c = Operation::insert("5");
+    let retain_a = Operation::retain(3);
 
     delta.add(insert_a.clone());
     delta.add(retain_a.clone());
@@ -62,12 +62,12 @@ fn delta_get_ops_in_interval_2() {
 
     assert_eq!(
         DeltaIterator::from_interval(&delta, Interval::new(0, 2)).ops(),
-        vec![OperationBuilder::insert("12").build()]
+        vec![Operation::insert("12")]
     );
 
     assert_eq!(
         DeltaIterator::from_interval(&delta, Interval::new(1, 3)).ops(),
-        vec![OperationBuilder::insert("23").build()]
+        vec![Operation::insert("23")]
     );
 
     assert_eq!(
@@ -77,7 +77,7 @@ fn delta_get_ops_in_interval_2() {
 
     assert_eq!(
         DeltaIterator::from_interval(&delta, Interval::new(0, 4)).ops(),
-        vec![insert_a.clone(), OperationBuilder::retain(1).build()]
+        vec![insert_a.clone(), Operation::retain(1)]
     );
 
     assert_eq!(
@@ -94,20 +94,20 @@ fn delta_get_ops_in_interval_2() {
 #[test]
 fn delta_get_ops_in_interval_3() {
     let mut delta = RichTextDelta::default();
-    let insert_a = OperationBuilder::insert("123456").build();
+    let insert_a = Operation::insert("123456");
     delta.add(insert_a.clone());
     assert_eq!(
         DeltaIterator::from_interval(&delta, Interval::new(3, 5)).ops(),
-        vec![OperationBuilder::insert("45").build()]
+        vec![Operation::insert("45")]
     );
 }
 
 #[test]
 fn delta_get_ops_in_interval_4() {
     let mut delta = RichTextDelta::default();
-    let insert_a = OperationBuilder::insert("12").build();
-    let insert_b = OperationBuilder::insert("34").build();
-    let insert_c = OperationBuilder::insert("56").build();
+    let insert_a = Operation::insert("12");
+    let insert_b = Operation::insert("34");
+    let insert_c = Operation::insert("56");
 
     delta.ops.push(insert_a.clone());
     delta.ops.push(insert_b.clone());
@@ -128,73 +128,64 @@ fn delta_get_ops_in_interval_4() {
 
     assert_eq!(
         DeltaIterator::from_interval(&delta, Interval::new(2, 5)).ops(),
-        vec![
-            OperationBuilder::insert("34").build(),
-            OperationBuilder::insert("5").build()
-        ]
+        vec![Operation::insert("34"), Operation::insert("5")]
     );
 }
 
 #[test]
 fn delta_get_ops_in_interval_5() {
     let mut delta = RichTextDelta::default();
-    let insert_a = OperationBuilder::insert("123456").build();
-    let insert_b = OperationBuilder::insert("789").build();
+    let insert_a = Operation::insert("123456");
+    let insert_b = Operation::insert("789");
     delta.ops.push(insert_a.clone());
     delta.ops.push(insert_b.clone());
     assert_eq!(
         DeltaIterator::from_interval(&delta, Interval::new(4, 8)).ops(),
-        vec![
-            OperationBuilder::insert("56").build(),
-            OperationBuilder::insert("78").build()
-        ]
+        vec![Operation::insert("56"), Operation::insert("78")]
     );
 
     // assert_eq!(
     //     DeltaIter::from_interval(&delta, Interval::new(8, 9)).ops(),
-    //     vec![Builder::insert("9").build()]
+    //     vec![Builder::insert("9")]
     // );
 }
 
 #[test]
 fn delta_get_ops_in_interval_6() {
     let mut delta = RichTextDelta::default();
-    let insert_a = OperationBuilder::insert("12345678").build();
+    let insert_a = Operation::insert("12345678");
     delta.add(insert_a.clone());
     assert_eq!(
         DeltaIterator::from_interval(&delta, Interval::new(4, 6)).ops(),
-        vec![OperationBuilder::insert("56").build()]
+        vec![Operation::insert("56")]
     );
 }
 
 #[test]
 fn delta_get_ops_in_interval_7() {
     let mut delta = RichTextDelta::default();
-    let insert_a = OperationBuilder::insert("12345").build();
-    let retain_a = OperationBuilder::retain(3).build();
+    let insert_a = Operation::insert("12345");
+    let retain_a = Operation::retain(3);
 
     delta.add(insert_a.clone());
     delta.add(retain_a.clone());
 
     let mut iter_1 = DeltaIterator::from_offset(&delta, 2);
-    assert_eq!(iter_1.next_op().unwrap(), OperationBuilder::insert("345").build());
-    assert_eq!(iter_1.next_op().unwrap(), OperationBuilder::retain(3).build());
+    assert_eq!(iter_1.next_op().unwrap(), Operation::insert("345"));
+    assert_eq!(iter_1.next_op().unwrap(), Operation::retain(3));
 
     let mut iter_2 = DeltaIterator::new(&delta);
-    assert_eq!(
-        iter_2.next_op_with_len(2).unwrap(),
-        OperationBuilder::insert("12").build()
-    );
-    assert_eq!(iter_2.next_op().unwrap(), OperationBuilder::insert("345").build());
+    assert_eq!(iter_2.next_op_with_len(2).unwrap(), Operation::insert("12"));
+    assert_eq!(iter_2.next_op().unwrap(), Operation::insert("345"));
 
-    assert_eq!(iter_2.next_op().unwrap(), OperationBuilder::retain(3).build());
+    assert_eq!(iter_2.next_op().unwrap(), Operation::retain(3));
 }
 
 #[test]
 fn delta_op_seek() {
     let mut delta = RichTextDelta::default();
-    let insert_a = OperationBuilder::insert("12345").build();
-    let retain_a = OperationBuilder::retain(3).build();
+    let insert_a = Operation::insert("12345");
+    let retain_a = Operation::retain(3);
     delta.add(insert_a.clone());
     delta.add(retain_a.clone());
     let mut iter = DeltaIterator::new(&delta);
@@ -205,14 +196,11 @@ fn delta_op_seek() {
 #[test]
 fn delta_utf16_code_unit_seek() {
     let mut delta = RichTextDelta::default();
-    delta.add(OperationBuilder::insert("12345").build());
+    delta.add(Operation::insert("12345"));
 
     let mut iter = DeltaIterator::new(&delta);
     iter.seek::<Utf16CodeUnitMetric>(3);
-    assert_eq!(
-        iter.next_op_with_len(2).unwrap(),
-        OperationBuilder::insert("45").build()
-    );
+    assert_eq!(iter.next_op_with_len(2).unwrap(), Operation::insert("45"));
 }
 
 #[test]
@@ -223,91 +211,76 @@ fn delta_utf16_code_unit_seek_with_attributes() {
         .add_attr(RichTextAttribute::Italic(true))
         .build();
 
-    delta.add(OperationBuilder::insert("1234").attributes(attributes.clone()).build());
-    delta.add(OperationBuilder::insert("\n").build());
+    delta.add(Operation::insert_with_attributes("1234", attributes.clone()));
+    delta.add(Operation::insert("\n"));
 
     let mut iter = DeltaIterator::new(&delta);
     iter.seek::<Utf16CodeUnitMetric>(0);
 
     assert_eq!(
         iter.next_op_with_len(4).unwrap(),
-        OperationBuilder::insert("1234").attributes(attributes).build(),
+        Operation::insert_with_attributes("1234", attributes),
     );
 }
 
 #[test]
 fn delta_next_op_len() {
     let mut delta = RichTextDelta::default();
-    delta.add(OperationBuilder::insert("12345").build());
+    delta.add(Operation::insert("12345"));
     let mut iter = DeltaIterator::new(&delta);
-    assert_eq!(
-        iter.next_op_with_len(2).unwrap(),
-        OperationBuilder::insert("12").build()
-    );
-    assert_eq!(
-        iter.next_op_with_len(2).unwrap(),
-        OperationBuilder::insert("34").build()
-    );
-    assert_eq!(iter.next_op_with_len(2).unwrap(), OperationBuilder::insert("5").build());
+    assert_eq!(iter.next_op_with_len(2).unwrap(), Operation::insert("12"));
+    assert_eq!(iter.next_op_with_len(2).unwrap(), Operation::insert("34"));
+    assert_eq!(iter.next_op_with_len(2).unwrap(), Operation::insert("5"));
     assert_eq!(iter.next_op_with_len(1), None);
 }
 
 #[test]
 fn delta_next_op_len_with_chinese() {
     let mut delta = RichTextDelta::default();
-    delta.add(OperationBuilder::insert("你好").build());
+    delta.add(Operation::insert("你好"));
 
     let mut iter = DeltaIterator::new(&delta);
     assert_eq!(iter.next_op_len().unwrap(), 2);
-    assert_eq!(
-        iter.next_op_with_len(2).unwrap(),
-        OperationBuilder::insert("你好").build()
-    );
+    assert_eq!(iter.next_op_with_len(2).unwrap(), Operation::insert("你好"));
 }
 
 #[test]
 fn delta_next_op_len_with_english() {
     let mut delta = RichTextDelta::default();
-    delta.add(OperationBuilder::insert("ab").build());
+    delta.add(Operation::insert("ab"));
     let mut iter = DeltaIterator::new(&delta);
     assert_eq!(iter.next_op_len().unwrap(), 2);
-    assert_eq!(
-        iter.next_op_with_len(2).unwrap(),
-        OperationBuilder::insert("ab").build()
-    );
+    assert_eq!(iter.next_op_with_len(2).unwrap(), Operation::insert("ab"));
 }
 
 #[test]
 fn delta_next_op_len_after_seek() {
     let mut delta = RichTextDelta::default();
-    delta.add(OperationBuilder::insert("12345").build());
+    delta.add(Operation::insert("12345"));
     let mut iter = DeltaIterator::new(&delta);
     assert_eq!(iter.next_op_len().unwrap(), 5);
     iter.seek::<Utf16CodeUnitMetric>(3);
     assert_eq!(iter.next_op_len().unwrap(), 2);
-    assert_eq!(iter.next_op_with_len(1).unwrap(), OperationBuilder::insert("4").build());
+    assert_eq!(iter.next_op_with_len(1).unwrap(), Operation::insert("4"));
     assert_eq!(iter.next_op_len().unwrap(), 1);
-    assert_eq!(iter.next_op().unwrap(), OperationBuilder::insert("5").build());
+    assert_eq!(iter.next_op().unwrap(), Operation::insert("5"));
 }
 
 #[test]
 fn delta_next_op_len_none() {
     let mut delta = RichTextDelta::default();
-    delta.add(OperationBuilder::insert("12345").build());
+    delta.add(Operation::insert("12345"));
     let mut iter = DeltaIterator::new(&delta);
 
     assert_eq!(iter.next_op_len().unwrap(), 5);
-    assert_eq!(
-        iter.next_op_with_len(5).unwrap(),
-        OperationBuilder::insert("12345").build()
-    );
+    assert_eq!(iter.next_op_with_len(5).unwrap(), Operation::insert("12345"));
     assert_eq!(iter.next_op_len(), None);
 }
 
 #[test]
 fn delta_next_op_with_len_zero() {
     let mut delta = RichTextDelta::default();
-    delta.add(OperationBuilder::insert("12345").build());
+    delta.add(Operation::insert("12345"));
     let mut iter = DeltaIterator::new(&delta);
     assert_eq!(iter.next_op_with_len(0), None,);
     assert_eq!(iter.next_op_len().unwrap(), 5);
@@ -316,14 +289,14 @@ fn delta_next_op_with_len_zero() {
 #[test]
 fn delta_next_op_with_len_cross_op_return_last() {
     let mut delta = RichTextDelta::default();
-    delta.add(OperationBuilder::insert("12345").build());
-    delta.add(OperationBuilder::retain(1).build());
-    delta.add(OperationBuilder::insert("678").build());
+    delta.add(Operation::insert("12345"));
+    delta.add(Operation::retain(1));
+    delta.add(Operation::insert("678"));
 
     let mut iter = DeltaIterator::new(&delta);
     iter.seek::<Utf16CodeUnitMetric>(4);
     assert_eq!(iter.next_op_len().unwrap(), 1);
-    assert_eq!(iter.next_op_with_len(2).unwrap(), OperationBuilder::retain(1).build());
+    assert_eq!(iter.next_op_with_len(2).unwrap(), Operation::retain(1));
 }
 
 #[test]
@@ -450,22 +423,22 @@ fn ops_merging() {
     assert_eq!(delta.ops.len(), 0);
     delta.retain(2, RichTextAttributes::default());
     assert_eq!(delta.ops.len(), 1);
-    assert_eq!(delta.ops.last(), Some(&OperationBuilder::retain(2).build()));
+    assert_eq!(delta.ops.last(), Some(&Operation::retain(2)));
     delta.retain(3, RichTextAttributes::default());
     assert_eq!(delta.ops.len(), 1);
-    assert_eq!(delta.ops.last(), Some(&OperationBuilder::retain(5).build()));
+    assert_eq!(delta.ops.last(), Some(&Operation::retain(5)));
     delta.insert("abc", RichTextAttributes::default());
     assert_eq!(delta.ops.len(), 2);
-    assert_eq!(delta.ops.last(), Some(&OperationBuilder::insert("abc").build()));
+    assert_eq!(delta.ops.last(), Some(&Operation::insert("abc")));
     delta.insert("xyz", RichTextAttributes::default());
     assert_eq!(delta.ops.len(), 2);
-    assert_eq!(delta.ops.last(), Some(&OperationBuilder::insert("abcxyz").build()));
+    assert_eq!(delta.ops.last(), Some(&Operation::insert("abcxyz")));
     delta.delete(1);
     assert_eq!(delta.ops.len(), 3);
-    assert_eq!(delta.ops.last(), Some(&OperationBuilder::delete(1).build()));
+    assert_eq!(delta.ops.last(), Some(&Operation::delete(1)));
     delta.delete(1);
     assert_eq!(delta.ops.len(), 3);
-    assert_eq!(delta.ops.last(), Some(&OperationBuilder::delete(2).build()));
+    assert_eq!(delta.ops.last(), Some(&Operation::delete(2)));
 }
 
 #[test]
@@ -618,11 +591,11 @@ fn transform_two_conflict_non_seq_delta() {
 #[test]
 fn delta_invert_no_attribute_delta() {
     let mut delta = RichTextDelta::default();
-    delta.add(OperationBuilder::insert("123").build());
+    delta.add(Operation::insert("123"));
 
     let mut change = RichTextDelta::default();
-    change.add(OperationBuilder::retain(3).build());
-    change.add(OperationBuilder::insert("456").build());
+    change.add(Operation::retain(3));
+    change.add(Operation::insert("456"));
     let undo = change.invert(&delta);
 
     let new_delta = delta.compose(&change).unwrap();

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

@@ -11,7 +11,7 @@ fn operation_insert_serialize_test() {
         .add_attr(RichTextAttribute::Bold(true))
         .add_attr(RichTextAttribute::Italic(true))
         .build();
-    let operation = OperationBuilder::insert("123").attributes(attributes).build();
+    let operation = Operation::insert_with_attributes("123", attributes);
     let json = serde_json::to_string(&operation).unwrap();
     eprintln!("{}", json);
 
@@ -42,7 +42,7 @@ fn attributes_serialize_test() {
         .add_attr(RichTextAttribute::Bold(true))
         .add_attr(RichTextAttribute::Italic(true))
         .build();
-    let retain = OperationBuilder::insert("123").attributes(attributes).build();
+    let retain = Operation::insert_with_attributes("123", attributes);
 
     let json = serde_json::to_string(&retain).unwrap();
     eprintln!("{}", json);
@@ -56,7 +56,7 @@ fn delta_serialize_multi_attribute_test() {
         .add_attr(RichTextAttribute::Bold(true))
         .add_attr(RichTextAttribute::Italic(true))
         .build();
-    let retain = OperationBuilder::insert("123").attributes(attributes).build();
+    let retain = Operation::insert_with_attributes("123", attributes);
 
     delta.add(retain);
     delta.add(Operation::Retain(5.into()));

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

@@ -29,11 +29,11 @@ where
     /// # Examples
     ///
     /// ```
-    /// use lib_ot::core::{DeltaIterator, Interval, OperationBuilder};
+    /// use lib_ot::core::{DeltaIterator, Interval, Operation};
     /// use lib_ot::rich_text::RichTextDelta;
     /// let mut delta = RichTextDelta::default();   
-    /// let op_1 = OperationBuilder::insert("123").build();    
-    /// let op_2 = OperationBuilder::insert("4").build();
+    /// let op_1 = Operation::insert("123");    
+    /// let op_2 = Operation::insert("4");
     /// delta.add(op_1.clone());
     /// delta.add(op_2.clone());
     /// assert_eq!(DeltaIterator::from_interval(&delta, Interval::new(0, 3)).ops(), vec![op_1.clone()]);

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

@@ -3,7 +3,7 @@ use crate::errors::{ErrorBuilder, OTError, OTErrorCode};
 use crate::core::delta::{DeltaIterator, MAX_IV_LEN};
 use crate::core::flowy_str::FlowyStr;
 use crate::core::interval::Interval;
-use crate::core::operation::{Attributes, Operation, OperationBuilder, OperationTransform, PhantomAttributes};
+use crate::core::operation::{Attributes, Operation, OperationTransform, PhantomAttributes};
 use bytes::Bytes;
 use serde::de::DeserializeOwned;
 use std::{
@@ -112,7 +112,7 @@ where
         if let Some(Operation::Delete(n_last)) = self.ops.last_mut() {
             *n_last += n;
         } else {
-            self.ops.push(OperationBuilder::delete(n).build());
+            self.ops.push(Operation::delete(n));
         }
     }
 
@@ -135,10 +135,10 @@ where
             }
             [.., op_last @ Operation::<T>::Delete(_)] => {
                 let new_last = op_last.clone();
-                *op_last = OperationBuilder::<T>::insert(&s).attributes(attributes).build();
+                *op_last = Operation::<T>::insert_with_attributes(&s, attributes);
                 Some(new_last)
             }
-            _ => Some(OperationBuilder::<T>::insert(&s).attributes(attributes).build()),
+            _ => Some(Operation::<T>::insert_with_attributes(&s, attributes)),
         };
 
         match new_last {
@@ -160,8 +160,7 @@ where
                 self.ops.push(new_op);
             }
         } else {
-            self.ops
-                .push(OperationBuilder::<T>::retain(n).attributes(attributes).build());
+            self.ops.push(Operation::<T>::retain_with_attributes(n, attributes));
         }
     }
 
@@ -319,10 +318,10 @@ where
 
             let op = iter
                 .next_op_with_len(length)
-                .unwrap_or_else(|| OperationBuilder::retain(length).build());
+                .unwrap_or_else(|| Operation::retain(length));
             let other_op = other_iter
                 .next_op_with_len(length)
-                .unwrap_or_else(|| OperationBuilder::retain(length).build());
+                .unwrap_or_else(|| Operation::retain(length));
 
             // debug_assert_eq!(op.len(), other_op.len(), "Composing delta failed,");
 
@@ -330,16 +329,12 @@ where
                 (Operation::Retain(retain), Operation::Retain(other_retain)) => {
                     let composed_attrs = retain.attributes.compose(&other_retain.attributes)?;
 
-                    new_delta.add(OperationBuilder::retain(retain.n).attributes(composed_attrs).build())
+                    new_delta.add(Operation::retain_with_attributes(retain.n, composed_attrs))
                 }
                 (Operation::Insert(insert), Operation::Retain(other_retain)) => {
                     let mut composed_attrs = insert.attributes.compose(&other_retain.attributes)?;
                     composed_attrs.remove_empty();
-                    new_delta.add(
-                        OperationBuilder::insert(op.get_data())
-                            .attributes(composed_attrs)
-                            .build(),
-                    )
+                    new_delta.add(Operation::insert_with_attributes(op.get_data(), composed_attrs))
                 }
                 (Operation::Retain(_), Operation::Delete(_)) => {
                     new_delta.add(other_op);
@@ -402,7 +397,7 @@ where
                         Ordering::Less => {
                             a_prime.retain(retain.n, composed_attrs.clone());
                             b_prime.retain(retain.n, composed_attrs.clone());
-                            next_op2 = Some(OperationBuilder::retain(o_retain.n - retain.n).build());
+                            next_op2 = Some(Operation::retain(o_retain.n - retain.n));
                             next_op1 = ops1.next();
                         }
                         Ordering::Equal => {
@@ -414,14 +409,14 @@ where
                         Ordering::Greater => {
                             a_prime.retain(o_retain.n, composed_attrs.clone());
                             b_prime.retain(o_retain.n, composed_attrs.clone());
-                            next_op1 = Some(OperationBuilder::retain(retain.n - o_retain.n).build());
+                            next_op1 = Some(Operation::retain(retain.n - o_retain.n));
                             next_op2 = ops2.next();
                         }
                     };
                 }
                 (Some(Operation::Delete(i)), Some(Operation::Delete(j))) => match i.cmp(j) {
                     Ordering::Less => {
-                        next_op2 = Some(OperationBuilder::delete(*j - *i).build());
+                        next_op2 = Some(Operation::delete(*j - *i));
                         next_op1 = ops1.next();
                     }
                     Ordering::Equal => {
@@ -429,7 +424,7 @@ where
                         next_op2 = ops2.next();
                     }
                     Ordering::Greater => {
-                        next_op1 = Some(OperationBuilder::delete(*i - *j).build());
+                        next_op1 = Some(Operation::delete(*i - *j));
                         next_op2 = ops2.next();
                     }
                 },
@@ -437,7 +432,7 @@ where
                     match i.cmp(o_retain) {
                         Ordering::Less => {
                             a_prime.delete(*i);
-                            next_op2 = Some(OperationBuilder::retain(o_retain.n - *i).build());
+                            next_op2 = Some(Operation::retain(o_retain.n - *i));
                             next_op1 = ops1.next();
                         }
                         Ordering::Equal => {
@@ -447,7 +442,7 @@ where
                         }
                         Ordering::Greater => {
                             a_prime.delete(o_retain.n);
-                            next_op1 = Some(OperationBuilder::delete(*i - o_retain.n).build());
+                            next_op1 = Some(Operation::delete(*i - o_retain.n));
                             next_op2 = ops2.next();
                         }
                     };
@@ -456,7 +451,7 @@ where
                     match retain.cmp(j) {
                         Ordering::Less => {
                             b_prime.delete(retain.n);
-                            next_op2 = Some(OperationBuilder::delete(*j - retain.n).build());
+                            next_op2 = Some(Operation::delete(*j - retain.n));
                             next_op1 = ops1.next();
                         }
                         Ordering::Equal => {
@@ -466,7 +461,7 @@ where
                         }
                         Ordering::Greater => {
                             b_prime.delete(*j);
-                            next_op1 = Some(OperationBuilder::retain(retain.n - *j).build());
+                            next_op1 = Some(Operation::retain(retain.n - *j));
                             next_op2 = ops2.next();
                         }
                     };

shared-lib/lib-ot/src/core/flowy_str.rs

@@ -30,6 +30,22 @@ impl FlowyStr {
         Utf16CodeUnitIterator::new(self)
     }
 
+    /// Return a new string with the given [Interval]
+    /// # Examples
+    ///
+    /// ```
+    /// use lib_ot::core::{FlowyStr, Interval};
+    /// let s: FlowyStr = "你好\n😁".into();
+    /// assert_eq!(s.utf16_len(), 5);
+    /// let output1 = s.sub_str(Interval::new(0, 2)).unwrap();
+    /// assert_eq!(output1, "你好");
+    ///
+    /// let output2 = s.sub_str(Interval::new(2, 3)).unwrap();
+    /// assert_eq!(output2, "\n");
+    ///
+    /// let output3 = s.sub_str(Interval::new(3, 5)).unwrap();
+    /// assert_eq!(output3, "😁");
+    /// ```
     pub fn sub_str(&self, interval: Interval) -> Option<String> {
         let mut iter = Utf16CodeUnitIterator::new(self);
         let mut buf = vec![];
@@ -49,8 +65,28 @@ impl FlowyStr {
         }
     }
 
+    /// Return a new string with the given [Interval]
+    /// # Examples
+    ///
+    /// ```
+    /// use lib_ot::core::FlowyStr;
+    /// let s: FlowyStr = "👋😁👋".into();    ///
+    /// let mut iter = s.utf16_code_point_iter();
+    /// assert_eq!(iter.next().unwrap(), "👋".to_string());
+    /// assert_eq!(iter.next().unwrap(), "😁".to_string());
+    /// assert_eq!(iter.next().unwrap(), "👋".to_string());
+    /// assert_eq!(iter.next(), None);
+    ///
+    /// let s: FlowyStr = "👋12ab一二👋".into();    ///
+    /// let mut iter = s.utf16_code_point_iter();
+    /// assert_eq!(iter.next().unwrap(), "👋".to_string());
+    /// assert_eq!(iter.next().unwrap(), "1".to_string());
+    /// assert_eq!(iter.next().unwrap(), "2".to_string());
+    ///
+    /// assert_eq!(iter.skip(FlowyStr::from("ab一二").utf16_len()).next().unwrap(), "👋".to_string());
+    /// ```
     #[allow(dead_code)]
-    fn utf16_code_point_iter(&self) -> FlowyUtf16CodePointIterator {
+    pub fn utf16_code_point_iter(&self) -> FlowyUtf16CodePointIterator {
         FlowyUtf16CodePointIterator::new(self, 0)
     }
 }
@@ -264,20 +300,6 @@ mod tests {
         assert_eq!(output, "👋");
     }
 
-    #[test]
-    fn flowy_str_sub_str_in_chinese() {
-        let s: FlowyStr = "你好\n😁".into();
-        let size = s.utf16_len();
-        assert_eq!(size, 5);
-
-        let output1 = s.sub_str(Interval::new(0, 2)).unwrap();
-        let output2 = s.sub_str(Interval::new(2, 3)).unwrap();
-        let output3 = s.sub_str(Interval::new(3, 5)).unwrap();
-        assert_eq!(output1, "你好");
-        assert_eq!(output2, "\n");
-        assert_eq!(output3, "😁");
-    }
-
     #[test]
     fn flowy_str_sub_str_in_chinese2() {
         let s: FlowyStr = "😁 \n".into();
@@ -300,16 +322,6 @@ mod tests {
         assert_eq!(output, "ab");
     }
 
-    #[test]
-    fn flowy_str_utf16_code_point_iter_test1() {
-        let s: FlowyStr = "👋😁👋".into();
-        let mut iter = s.utf16_code_point_iter();
-        assert_eq!(iter.next().unwrap(), "👋".to_string());
-        assert_eq!(iter.next().unwrap(), "😁".to_string());
-        assert_eq!(iter.next().unwrap(), "👋".to_string());
-        assert_eq!(iter.next(), None);
-    }
-
     #[test]
     fn flowy_str_utf16_code_point_iter_test2() {
         let s: FlowyStr = "👋😁👋".into();

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

@@ -1,51 +1,47 @@
 use crate::core::operation::{Attributes, Operation, PhantomAttributes};
 use crate::rich_text::RichTextAttributes;
 
-pub type RichTextOpBuilder = OperationBuilder<RichTextAttributes>;
-pub type PlainTextOpBuilder = OperationBuilder<PhantomAttributes>;
+pub type RichTextOpBuilder = OperationsBuilder<RichTextAttributes>;
+pub type PlainTextOpBuilder = OperationsBuilder<PhantomAttributes>;
 
-pub struct OperationBuilder<T: Attributes> {
+pub struct OperationsBuilder<T: Attributes> {
     operations: Vec<Operation<T>>,
 }
 
-impl<T> OperationBuilder<T>
+impl<T> OperationsBuilder<T>
 where
     T: Attributes,
 {
-    pub fn new() -> OperationBuilder<T> {
-        OperationBuilder { operations: vec![] }
+    pub fn new() -> OperationsBuilder<T> {
+        OperationsBuilder { operations: vec![] }
     }
 
-    pub fn retain(mut self, n: usize) -> OperationBuilder<T> {
-        let mut retain = Operation::Retain(n.into());
+    pub fn retain_with_attributes(mut self, n: usize, attributes: T) -> OperationsBuilder<T> {
+        let retain = Operation::retain_with_attributes(n.into(), attributes);
+        self.operations.push(retain);
+        self
+    }
 
-        if let Some(attributes) = attributes {
-            if let Operation::Retain(r) = &mut retain {
-                r.attributes = attributes;
-            }
-        }
+    pub fn retain(mut self, n: usize) -> OperationsBuilder<T> {
+        let retain = Operation::retain(n.into());
         self.operations.push(retain);
         self
     }
 
-    pub fn delete(mut self, n: usize) -> OperationBuilder<T> {
+    pub fn delete(mut self, n: usize) -> OperationsBuilder<T> {
         self.operations.push(Operation::Delete(n));
         self
     }
 
-    pub fn insert(mut self, s: &str, attributes: Option<T>) -> OperationBuilder<T> {
-        let mut insert = Operation::Insert(s.into());
-        if let Some(attributes) = attributes {
-            if let Operation::Retain(i) = &mut insert {
-                i.attributes = attributes;
-            }
-        }
+    pub fn insert_with_attributes(mut self, s: &str, attributes: T) -> OperationsBuilder<T> {
+        let insert = Operation::insert_with_attributes(s.into(), attributes);
         self.operations.push(insert);
         self
     }
 
-    pub fn attributes(mut self, attrs: T) -> OperationBuilder<T> {
-        self.attrs = attrs;
+    pub fn insert(mut self, s: &str) -> OperationsBuilder<T> {
+        let insert = Operation::insert(s.into());
+        self.operations.push(insert);
         self
     }
 

shared-lib/lib-ot/src/core/operation/operation.rs

@@ -1,6 +1,5 @@
 use crate::core::flowy_str::FlowyStr;
 use crate::core::interval::Interval;
-use crate::core::operation::OperationBuilder;
 use crate::errors::OTError;
 use serde::{Deserialize, Serialize, __private::Formatter};
 use std::fmt::Display;
@@ -105,6 +104,40 @@ impl<T> Operation<T>
 where
     T: Attributes,
 {
+    pub fn delete(n: usize) -> Self {
+        Self::Delete(n)
+    }
+
+    /// Create a [Retain] operation with the given attributes
+    pub fn retain_with_attributes(n: usize, attributes: T) -> Self {
+        Self::Retain(Retain { n, attributes })
+    }
+
+    /// Create a [Retain] operation without attributes
+    pub fn retain(n: usize) -> Self {
+        Self::Retain(Retain {
+            n,
+            attributes: T::default(),
+        })
+    }
+
+    /// Create a [Insert] operation with the given attributes
+    pub fn insert_with_attributes(s: &str, attributes: T) -> Self {
+        Self::Insert(Insert {
+            s: FlowyStr::from(s),
+            attributes,
+        })
+    }
+
+    /// Create a [Insert] operation without attributes
+    pub fn insert(s: &str) -> Self {
+        Self::Insert(Insert {
+            s: FlowyStr::from(s),
+            attributes: T::default(),
+        })
+    }
+
+    /// Return the String if the operation is [Insert] operation, otherwise return the empty string.
     pub fn get_data(&self) -> &str {
         match self {
             Operation::Delete(_) => "",
@@ -152,45 +185,58 @@ where
         let right;
         match self {
             Operation::Delete(n) => {
-                left = Some(OperationBuilder::<T>::delete(index).build());
-                right = Some(OperationBuilder::<T>::delete(*n - index).build());
+                left = Some(Operation::<T>::delete(index));
+                right = Some(Operation::<T>::delete(*n - index));
             }
             Operation::Retain(retain) => {
-                left = Some(OperationBuilder::<T>::delete(index).build());
-                right = Some(OperationBuilder::<T>::delete(retain.n - index).build());
+                left = Some(Operation::<T>::delete(index));
+                right = Some(Operation::<T>::delete(retain.n - index));
             }
             Operation::Insert(insert) => {
                 let attributes = self.get_attributes();
-                left = Some(
-                    OperationBuilder::<T>::insert(&insert.s[0..index])
-                        .attributes(attributes.clone())
-                        .build(),
-                );
-                right = Some(
-                    OperationBuilder::<T>::insert(&insert.s[index..insert.utf16_size()])
-                        .attributes(attributes)
-                        .build(),
-                );
+                left = Some(Operation::<T>::insert_with_attributes(
+                    &insert.s[0..index],
+                    attributes.clone(),
+                ));
+                right = Some(Operation::<T>::insert_with_attributes(
+                    &insert.s[index..insert.utf16_size()],
+                    attributes,
+                ));
             }
         }
 
         (left, right)
     }
 
+    /// Returns an operation with the specified width.
+    /// # Arguments
+    ///
+    /// * `interval`: Specify the shrink width of the operation.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use lib_ot::core::{Interval, Operation, PhantomAttributes};
+    /// let operation = Operation::<PhantomAttributes>::insert("1234");
+    ///
+    /// let op1 = operation.shrink(Interval::new(0,3)).unwrap();
+    /// assert_eq!(op1 , Operation::insert("123"));
+    ///
+    /// let op2= operation.shrink(Interval::new(3,4)).unwrap();
+    /// assert_eq!(op2, Operation::insert("4"));
+    /// ```
     pub fn shrink(&self, interval: Interval) -> Option<Operation<T>> {
         let op = match self {
-            Operation::Delete(n) => OperationBuilder::delete(min(*n, interval.size())).build(),
-            Operation::Retain(retain) => OperationBuilder::retain(min(retain.n, interval.size()))
-                .attributes(retain.attributes.clone())
-                .build(),
+            Operation::Delete(n) => Operation::delete(min(*n, interval.size())),
+            Operation::Retain(retain) => {
+                Operation::retain_with_attributes(min(retain.n, interval.size()), retain.attributes.clone())
+            }
             Operation::Insert(insert) => {
                 if interval.start > insert.utf16_size() {
-                    OperationBuilder::insert("").build()
+                    Operation::insert("")
                 } else {
                     let s = insert.s.sub_str(interval).unwrap_or_else(|| "".to_owned());
-                    OperationBuilder::insert(&s)
-                        .attributes(insert.attributes.clone())
-                        .build()
+                    Operation::insert_with_attributes(&s, insert.attributes.clone())
                 }
             }
         };
@@ -287,7 +333,7 @@ where
             self.n += n;
             None
         } else {
-            Some(OperationBuilder::retain(n).attributes(attributes).build())
+            Some(Operation::retain_with_attributes(n, attributes))
         }
     }
 
@@ -368,7 +414,7 @@ where
             self.s += s;
             None
         } else {
-            Some(OperationBuilder::<T>::insert(s).attributes(attributes).build())
+            Some(Operation::<T>::insert_with_attributes(s, attributes))
         }
     }