Implement Tree.RemoveStyle

api/converter/from_pb.go

@@ -511,6 +511,16 @@ func fromTreeStyle(pbTreeStyle *api.Operation_TreeStyle) (*operations.TreeStyle,
 		return nil, err
 	}
 
+	if len(pbTreeStyle.AttributesToRemove) > 0 {
+		return operations.NewTreeStyleRemove(
+			parentCreatedAt,
+			from,
+			to,
+			pbTreeStyle.AttributesToRemove,
+			executedAt,
+		), nil
+	}
+
 	return operations.NewTreeStyle(
 		parentCreatedAt,
 		from,

api/converter/to_pb.go

@@ -364,11 +364,12 @@ func toTreeEdit(e *operations.TreeEdit) (*api.Operation_TreeEdit_, error) {
 func toTreeStyle(style *operations.TreeStyle) (*api.Operation_TreeStyle_, error) {
 	return &api.Operation_TreeStyle_{
 		TreeStyle: &api.Operation_TreeStyle{
-			ParentCreatedAt: ToTimeTicket(style.ParentCreatedAt()),
-			From:            toTreePos(style.FromPos()),
-			To:              toTreePos(style.ToPos()),
-			Attributes:      style.Attributes(),
-			ExecutedAt:      ToTimeTicket(style.ExecutedAt()),
+			ParentCreatedAt:    ToTimeTicket(style.ParentCreatedAt()),
+			From:               toTreePos(style.FromPos()),
+			To:                 toTreePos(style.ToPos()),
+			Attributes:         style.Attributes(),
+			ExecutedAt:         ToTimeTicket(style.ExecutedAt()),
+			AttributesToRemove: style.AttributesToRemove(),
 		},
 	}, nil
 }

api/yorkie/v1/resources.proto

@@ -133,6 +133,7 @@ message Operation {
     TreePos to = 3;
     map<string, string> attributes = 4;
     TimeTicket executed_at = 5;
+    repeated string attributes_to_remove = 6;
   }
 
   oneof body {

pkg/document/crdt/tree.go

@@ -876,6 +876,34 @@ func (t *Tree) Style(from, to *TreePos, attributes map[string]string, editedAt *
 	return nil
 }
 
+// RemoveStyle removes the given attributes of the given range.
+func (t *Tree) RemoveStyle(from, to *TreePos, attributesToRemove []string, editedAt *time.Ticket) error {
+	// 01. split text nodes at the given range if needed.
+	fromParent, fromLeft, err := t.FindTreeNodesWithSplitText(from, editedAt)
+	if err != nil {
+		return err
+	}
+	toParent, toLeft, err := t.FindTreeNodesWithSplitText(to, editedAt)
+	if err != nil {
+		return err
+	}
+
+	err = t.traverseInPosRange(fromParent, fromLeft, toParent, toLeft,
+		func(token index.TreeToken[*TreeNode], _ bool) {
+			node := token.Node
+			if !node.IsRemoved() && !node.IsText() && len(attributesToRemove) > 0 && node.Attrs != nil {
+				for _, value := range attributesToRemove {
+					node.Attrs.Remove(value, editedAt)
+				}
+			}
+		})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
 // FindTreeNodesWithSplitText finds TreeNode of the given crdt.TreePos and
 // splits the text node if the position is in the middle of the text node.
 // crdt.TreePos is a position in the CRDT perspective. This is different

pkg/document/json/tree.go

@@ -198,6 +198,10 @@ func (t *Tree) Style(fromIdx, toIdx int, attributes map[string]string) bool {
 		panic("from should be less than or equal to to")
 	}
 
+	if len(attributes) == 0 {
+		return true
+	}
+
 	fromPos, err := t.Tree.FindPos(fromIdx)
 	if err != nil {
 		panic(err)
@@ -223,6 +227,41 @@ func (t *Tree) Style(fromIdx, toIdx int, attributes map[string]string) bool {
 	return true
 }
 
+// RemoveStyle sets the attributes to the elements of the given range.
+func (t *Tree) RemoveStyle(fromIdx, toIdx int, attributesToRemove []string) bool {
+	if fromIdx > toIdx {
+		panic("from should be less than or equal to to")
+	}
+
+	if len(attributesToRemove) == 0 {
+		return true
+	}
+
+	fromPos, err := t.Tree.FindPos(fromIdx)
+	if err != nil {
+		panic(err)
+	}
+	toPos, err := t.Tree.FindPos(toIdx)
+	if err != nil {
+		panic(err)
+	}
+
+	ticket := t.context.IssueTimeTicket()
+	if err := t.Tree.RemoveStyle(fromPos, toPos, attributesToRemove, ticket); err != nil {
+		panic(err)
+	}
+
+	t.context.Push(operations.NewTreeStyleRemove(
+		t.CreatedAt(),
+		fromPos,
+		toPos,
+		attributesToRemove,
+		ticket,
+	))
+
+	return true
+}
+
 // Len returns the length of this tree.
 func (t *Tree) Len() int {
 	return t.IndexTree.Root().Len()

pkg/document/operations/tree_style.go

@@ -32,9 +32,12 @@ type TreeStyle struct {
 	// toPos represents the end point of the editing range.
 	to *crdt.TreePos
 
-	// attributes represents the tree style.
+	// attributes represents the tree style to be added.
 	attributes map[string]string
 
+	// attributesToRemove represents the tree style to be removed.
+	attributesToRemove []string
+
 	// executedAt is the time the operation was executed.
 	executedAt *time.Ticket
 }
@@ -48,11 +51,30 @@ func NewTreeStyle(
 	executedAt *time.Ticket,
 ) *TreeStyle {
 	return &TreeStyle{
-		parentCreatedAt: parentCreatedAt,
-		from:            from,
-		to:              to,
-		attributes:      attributes,
-		executedAt:      executedAt,
+		parentCreatedAt:    parentCreatedAt,
+		from:               from,
+		to:                 to,
+		attributes:         attributes,
+		attributesToRemove: []string{},
+		executedAt:         executedAt,
+	}
+}
+
+// NewTreeStyleRemove creates a new instance of TreeStyle.
+func NewTreeStyleRemove(
+	parentCreatedAt *time.Ticket,
+	from *crdt.TreePos,
+	to *crdt.TreePos,
+	attributesToRemove []string,
+	executedAt *time.Ticket,
+) *TreeStyle {
+	return &TreeStyle{
+		parentCreatedAt:    parentCreatedAt,
+		from:               from,
+		to:                 to,
+		attributes:         map[string]string{},
+		attributesToRemove: attributesToRemove,
+		executedAt:         executedAt,
 	}
 }
 
@@ -64,7 +86,11 @@ func (e *TreeStyle) Execute(root *crdt.Root) error {
 		return ErrNotApplicableDataType
 	}
 
-	return obj.Style(e.from, e.to, e.attributes, e.executedAt)
+	if len(e.attributes) > 0 {
+		return obj.Style(e.from, e.to, e.attributes, e.executedAt)
+	}
+
+	return obj.RemoveStyle(e.from, e.to, e.attributesToRemove, e.executedAt)
 }
 
 // FromPos returns the start point of the editing range.
@@ -96,3 +122,8 @@ func (e *TreeStyle) ParentCreatedAt() *time.Ticket {
 func (e *TreeStyle) Attributes() map[string]string {
 	return e.attributes
 }
+
+// AttributesToRemove returns the content of Style.
+func (e *TreeStyle) AttributesToRemove() []string {
+	return e.attributesToRemove
+}

test/integration/tree_test.go

@@ -734,6 +734,118 @@ func TestTree(t *testing.T) {
 		assert.Equal(t, `{"type":"root","children":[{"type":"p","children":[{"type":"text","value":"ab"}],"attributes":{"bold":"true"}},{"type":"p","children":[{"type":"text","value":"cd"}],"attributes":{"italic":"true"}}]}`, d2.Root().GetTree("t").Marshal())
 	})
 
+	t.Run("remove attributes test", func(t *testing.T) {
+		ctx := context.Background()
+		d1 := document.New(helper.TestDocKey(t))
+		assert.NoError(t, c1.Attach(ctx, d1))
+
+		assert.NoError(t, d1.Update(func(root *json.Object, p *presence.Presence) error {
+			root.SetNewTree("t", &json.TreeNode{
+				Type: "root",
+				Children: []json.TreeNode{
+					{Type: "p", Children: []json.TreeNode{{Type: "text", Value: "ab"}}},
+					{Type: "p", Attributes: map[string]string{"italic": "true"}, Children: []json.TreeNode{{Type: "text", Value: "cd"}}},
+				},
+			})
+			return nil
+		}))
+		assert.NoError(t, c1.Sync(ctx))
+		assert.Equal(t, `<root><p>ab</p><p italic="true">cd</p></root>`, d1.Root().GetTree("t").ToXML())
+
+		assert.NoError(t, d1.Update(func(root *json.Object, p *presence.Presence) error {
+			root.GetTree("t").RemoveStyle(4, 8, []string{"italic"})
+			return nil
+		}))
+
+		assert.NoError(t, c1.Sync(ctx))
+		d2 := document.New(helper.TestDocKey(t))
+		assert.NoError(t, c2.Attach(ctx, d2))
+
+		assert.Equal(t, `<root><p>ab</p><p>cd</p></root>`, d1.Root().GetTree("t").ToXML())
+		assert.Equal(t, `<root><p>ab</p><p>cd</p></root>`, d2.Root().GetTree("t").ToXML())
+
+		assert.Equal(t, `{"type":"root","children":[{"type":"p","children":[{"type":"text","value":"ab"}]},{"type":"p","children":[{"type":"text","value":"cd"}]}]}`, d1.Root().GetTree("t").Marshal())
+		assert.Equal(t, `{"type":"root","children":[{"type":"p","children":[{"type":"text","value":"ab"}]},{"type":"p","children":[{"type":"text","value":"cd"}]}]}`, d2.Root().GetTree("t").Marshal())
+
+		// remove not exist style
+		assert.NoError(t, d1.Update(func(root *json.Object, p *presence.Presence) error {
+			root.GetTree("t").RemoveStyle(4, 8, []string{"bold"})
+			return nil
+		}))
+
+		assert.NoError(t, c1.Sync(ctx))
+		assert.NoError(t, c2.Sync(ctx))
+
+		assert.Equal(t, `<root><p>ab</p><p>cd</p></root>`, d1.Root().GetTree("t").ToXML())
+		assert.Equal(t, `<root><p>ab</p><p>cd</p></root>`, d2.Root().GetTree("t").ToXML())
+
+		assert.Equal(t, `{"type":"root","children":[{"type":"p","children":[{"type":"text","value":"ab"}]},{"type":"p","children":[{"type":"text","value":"cd"}]}]}`, d1.Root().GetTree("t").Marshal())
+		assert.Equal(t, `{"type":"root","children":[{"type":"p","children":[{"type":"text","value":"ab"}]},{"type":"p","children":[{"type":"text","value":"cd"}]}]}`, d2.Root().GetTree("t").Marshal())
+	})
+
+	t.Run("set/remove style without any attributes", func(t *testing.T) {
+		ctx := context.Background()
+		d1 := document.New(helper.TestDocKey(t))
+		assert.NoError(t, c1.Attach(ctx, d1))
+
+		assert.NoError(t, d1.Update(func(root *json.Object, p *presence.Presence) error {
+			root.SetNewTree("t", &json.TreeNode{
+				Type: "root",
+				Children: []json.TreeNode{
+					{Type: "p", Children: []json.TreeNode{{Type: "text", Value: "ab"}}},
+					{Type: "p", Attributes: map[string]string{"italic": "true"}, Children: []json.TreeNode{{Type: "text", Value: "cd"}}},
+				},
+			})
+			return nil
+		}))
+		assert.NoError(t, c1.Sync(ctx))
+		assert.Equal(t, `<root><p>ab</p><p italic="true">cd</p></root>`, d1.Root().GetTree("t").ToXML())
+
+		assert.NoError(t, d1.Update(func(root *json.Object, p *presence.Presence) error {
+			// NOTE(sejongk): 0, 4 -> 0,1 / 3,4
+			root.GetTree("t").Style(0, 4, map[string]string{})
+			return nil
+		}))
+
+		assert.NoError(t, c1.Sync(ctx))
+		d2 := document.New(helper.TestDocKey(t))
+		assert.NoError(t, c2.Attach(ctx, d2))
+
+		assert.Equal(t, `<root><p>ab</p><p italic="true">cd</p></root>`, d1.Root().GetTree("t").ToXML())
+		assert.Equal(t, `<root><p>ab</p><p italic="true">cd</p></root>`, d2.Root().GetTree("t").ToXML())
+
+		assert.Equal(t, `{"type":"root","children":[{"type":"p","children":[{"type":"text","value":"ab"}]},{"type":"p","children":[{"type":"text","value":"cd"}],"attributes":{"italic":"true"}}]}`, d1.Root().GetTree("t").Marshal())
+		assert.Equal(t, `{"type":"root","children":[{"type":"p","children":[{"type":"text","value":"ab"}]},{"type":"p","children":[{"type":"text","value":"cd"}],"attributes":{"italic":"true"}}]}`, d2.Root().GetTree("t").Marshal())
+
+		assert.NoError(t, d1.Update(func(root *json.Object, p *presence.Presence) error {
+			root.GetTree("t").RemoveStyle(4, 8, []string{"italic"})
+			return nil
+		}))
+
+		assert.NoError(t, c1.Sync(ctx))
+		assert.NoError(t, c2.Sync(ctx))
+
+		assert.Equal(t, `<root><p>ab</p><p>cd</p></root>`, d1.Root().GetTree("t").ToXML())
+		assert.Equal(t, `<root><p>ab</p><p>cd</p></root>`, d2.Root().GetTree("t").ToXML())
+
+		assert.Equal(t, `{"type":"root","children":[{"type":"p","children":[{"type":"text","value":"ab"}]},{"type":"p","children":[{"type":"text","value":"cd"}]}]}`, d1.Root().GetTree("t").Marshal())
+		assert.Equal(t, `{"type":"root","children":[{"type":"p","children":[{"type":"text","value":"ab"}]},{"type":"p","children":[{"type":"text","value":"cd"}]}]}`, d2.Root().GetTree("t").Marshal())
+
+		assert.NoError(t, d1.Update(func(root *json.Object, p *presence.Presence) error {
+			root.GetTree("t").RemoveStyle(4, 8, []string{})
+			return nil
+		}))
+
+		assert.NoError(t, c1.Sync(ctx))
+		assert.NoError(t, c2.Sync(ctx))
+
+		assert.Equal(t, `<root><p>ab</p><p>cd</p></root>`, d1.Root().GetTree("t").ToXML())
+		assert.Equal(t, `<root><p>ab</p><p>cd</p></root>`, d2.Root().GetTree("t").ToXML())
+
+		assert.Equal(t, `{"type":"root","children":[{"type":"p","children":[{"type":"text","value":"ab"}]},{"type":"p","children":[{"type":"text","value":"cd"}]}]}`, d1.Root().GetTree("t").Marshal())
+		assert.Equal(t, `{"type":"root","children":[{"type":"p","children":[{"type":"text","value":"ab"}]},{"type":"p","children":[{"type":"text","value":"cd"}]}]}`, d2.Root().GetTree("t").Marshal())
+	})
+
 	// Concurrent editing, overlapping range test
 	t.Run("concurrently delete overlapping elements test", func(t *testing.T) {
 		ctx := context.Background()