Apply the comment

1. integrate text, counter, tree type interface
2. decouple the build json from buildCRDTElement
3. fix duplicated deregister
4. relevant testcode update

pkg/document/crdt/root.go

@@ -91,12 +91,14 @@ func (r *Root) RegisterElement(element Element) {
 }
 
 // DeregisterElement deregister the given element from hash tables.
-func (r *Root) DeregisterElement(element Element) {
+func (r *Root) DeregisterElement(element Element) int {
+	count := 0
 
 	deregisterElementInternal := func(elem Element) {
 		createdAt := elem.CreatedAt().Key()
 		delete(r.elementMapByCreatedAt, createdAt)
 		delete(r.removedElementPairMapByCreatedAt, createdAt)
+		count++
 	}
 
 	deregisterElementInternal(element)
@@ -111,6 +113,7 @@ func (r *Root) DeregisterElement(element Element) {
 		}
 	}
 
+	return count
 }
 
 // RegisterRemovedElementPair register the given element pair to hash table.
@@ -145,7 +148,7 @@ func (r *Root) GarbageCollect(ticket *time.Ticket) (int, error) {
 				return 0, err
 			}
 
-			count += r.garbageCollect(pair.elem)
+			count += r.DeregisterElement(pair.elem)
 		}
 	}
 
@@ -200,23 +203,3 @@ func (r *Root) GarbageLen() int {
 
 	return count
 }
-
-func (r *Root) garbageCollect(elem Element) int {
-	count := 0
-
-	callback := func(elem Element, parent Container) bool {
-		r.DeregisterElement(elem)
-		count++
-		return false
-	}
-
-	callback(elem, nil)
-	switch elem := elem.(type) {
-	case *Object:
-		elem.Descendants(callback)
-	case *Array:
-		elem.Descendants(callback)
-	}
-
-	return count
-}

pkg/document/json/counter.go

@@ -28,9 +28,25 @@ import (
 // it is used when the user manipulates the counter from the outside.
 type Counter struct {
 	*crdt.Counter
-	context *change.Context
+	context   *change.Context
+	valueType crdt.CounterType
+	value     interface{}
 }
 
+// CreateCounter creates a new instance of Counter without context, crdt.Counter
+func CreateCounter(t crdt.CounterType, n interface{}) *Counter {
+	return &Counter{
+		valueType: t,
+		value:     n,
+	}
+}
+
+// InitializeCounter initializes Counter instance.
+// func (p *Counter) InitializeCounter(ctx *change.Context, counter *crdt.Counter) {
+// 	p.Counter = counter
+// 	p.context = ctx
+// }
+
 // NewCounter create Counter instance.
 func NewCounter(ctx *change.Context, counter *crdt.Counter) *Counter {
 	if !counter.IsNumericType() {
@@ -42,20 +58,6 @@ func NewCounter(ctx *change.Context, counter *crdt.Counter) *Counter {
 	}
 }
 
-// TempCounter is a transmission object for creating a counter inside.
-type TempCounter struct {
-	valueType crdt.CounterType
-	value     interface{}
-}
-
-// NewTempCounter creates a new instance of TempCounter.
-func NewTempCounter(t crdt.CounterType, n interface{}) *TempCounter {
-	return &TempCounter{
-		valueType: t,
-		value:     n,
-	}
-}
-
 // Increase adds an increase operations.
 // Only numeric types are allowed as operand values, excluding
 // uint64 and uintptr.

pkg/document/json/json.go

@@ -44,6 +44,25 @@ func toOriginal(elem crdt.Element) crdt.Element {
 	panic("unsupported type")
 }
 
+func toElement(ctx *change.Context, elem crdt.Element) crdt.Element {
+	switch elem := elem.(type) {
+	case *crdt.Object:
+		return NewObject(ctx, elem)
+	case *crdt.Array:
+		return NewArray(ctx, elem)
+	case *crdt.Text:
+		return NewText(ctx, elem)
+	case *crdt.Counter:
+		return NewCounter(ctx, elem)
+	case *crdt.Tree:
+		return NewTree(ctx, elem)
+	case *crdt.Primitive:
+		return elem
+	}
+
+	panic("unsupported type")
+}
+
 func buildCRDTElement(
 	context *change.Context,
 	value interface{},
@@ -59,53 +78,42 @@ func buildCRDTElement(
 		return primitive
 
 	case *TreeNode:
-
-		return NewTree(context, crdt.NewTree(buildRoot(context, elem, ticket), ticket))
-
+		return crdt.NewTree(buildRoot(context, elem, ticket), ticket)
 	case *Text:
-		return NewText(context, crdt.NewText(crdt.NewRGATreeSplit(crdt.InitialTextNode()), ticket))
-	case *TempCounter:
+		return crdt.NewText(crdt.NewRGATreeSplit(crdt.InitialTextNode()), ticket)
+	case *Counter:
 		switch elem.valueType {
 		case crdt.IntegerCnt:
 			counter, err := crdt.NewCounter(crdt.IntegerCnt, elem.value, ticket)
 			if err != nil {
 				panic(err)
 			}
-			return NewCounter(
-				context,
-				counter,
-			)
+			return counter
 		case crdt.LongCnt:
 			counter, err := crdt.NewCounter(crdt.LongCnt, elem.value, ticket)
 			if err != nil {
 				panic(err)
 			}
-			return NewCounter(
-				context,
-				counter,
-			)
+			return counter
 		default:
-			panic("unsupported type")
+			panic("unsupported counter type ")
 		}
 
 	case []interface{}:
-		array := NewArray(context, crdt.NewArray(crdt.NewRGATreeList(), ticket))
+		array := crdt.NewArray(crdt.NewRGATreeList(), ticket)
 		for _, v := range elem {
 			ticket := context.IssueTimeTicket()
 			value := buildCRDTElement(context, v, ticket)
-			value = toOriginal(value)
 			if err := array.InsertAfter(array.LastCreatedAt(), value); err != nil {
 				panic(err)
 			}
-			array.context.RegisterElement(value)
 		}
 		return array
 	case map[string]interface{}:
-		obj := NewObject(context, crdt.NewObject(crdt.NewElementRHT(), ticket))
+		obj := crdt.NewObject(crdt.NewElementRHT(), ticket)
 		members := buildObjectMember(context, elem)
 
 		for key, value := range members {
-			value = toOriginal(value)
 			_ = obj.Set(key, value)
 		}
 

pkg/document/json/object.go

@@ -56,7 +56,7 @@ func (p *Object) SetNewObject(kv ...interface{}) *Object {
 		k := kv[0].(string)
 		v := p.setInternal(k, func(ticket *time.Ticket) crdt.Element {
 			json := kv[1].(map[string]interface{})
-			return buildCRDTElement(p.context, json, ticket)
+			return toElement(p.context, buildCRDTElement(p.context, json, ticket))
 		})
 
 		return v.(*Object)

pkg/document/json/text.go

@@ -37,6 +37,11 @@ func NewText(ctx *change.Context, text *crdt.Text) *Text {
 	}
 }
 
+// CreateText creates a new instance of Text for json literal.
+func CreateText() *Text {
+	return NewText(nil, nil)
+}
+
 // CreateRange creates a range from the given positions.
 func (p *Text) CreateRange(from, to int) (*crdt.RGATreeSplitNodePos, *crdt.RGATreeSplitNodePos) {
 	fromPos, toPos, err := p.Text.CreateRange(from, to)

pkg/document/json/tree.go

@@ -77,6 +77,11 @@ func NewTree(ctx *change.Context, tree *crdt.Tree) *Tree {
 	}
 }
 
+// CreateTree creates a new instance of Tree for json literal.
+func CreateTree(root *TreeNode) *TreeNode {
+	return root
+}
+
 // validateTextNode make sure that text node have non-empty string value
 func validateTextNode(treeNode TreeNode) error {
 	if len(treeNode.Value) == 0 {

test/integration/object_test.go

@@ -181,8 +181,8 @@ func TestObject(t *testing.T) {
 				"obj": map[string]interface{}{ // 2 : object, double
 					"key3": 42.2,
 				},
-				"cnt": json.NewTempCounter(crdt.LongCnt, 0), // 1
-				"txt": json.NewText(nil, nil),               // 1
+				"cnt": json.CreateCounter(crdt.LongCnt, 0), // 1
+				"txt": json.NewText(nil, nil),              // 1
 			}
 			root.SetNewObject("shape", data)
 			root.GetObject("shape").SetString("key", "changed") // 1 tombstone
@@ -228,11 +228,11 @@ func TestObject(t *testing.T) {
 
 		assert.NoError(t, err)
 
-		assert.Equal(t, d1.GarbageLen(), 11)
-		assert.Equal(t, d1.GarbageCollect(time.MaxTicket), 11)
+		assert.Equal(t, 11, d1.GarbageLen())
+		assert.Equal(t, 11, d1.GarbageCollect(time.MaxTicket))
 
-		assert.Equal(t, d2.GarbageLen(), 11)
-		assert.Equal(t, d2.GarbageCollect(time.MaxTicket), 11)
+		assert.Equal(t, 11, d2.GarbageLen())
+		assert.Equal(t, 11, d2.GarbageCollect(time.MaxTicket))
 
 	})
 
@@ -250,7 +250,7 @@ func TestObject(t *testing.T) {
 		err = d1.Update(func(root *json.Object, p *presence.Presence) error {
 
 			data := map[string]interface{}{
-				"tree": &json.TreeNode{
+				"tree": json.CreateTree(&json.TreeNode{
 					Type: "doc",
 					Children: []json.TreeNode{{
 						Type:     "p",
@@ -265,7 +265,7 @@ func TestObject(t *testing.T) {
 						Type:     "bp",
 						Children: []json.TreeNode{{Type: "text", Value: "gh"}},
 					}},
-				},
+				}),
 			}
 
 			root.SetNewObject("shape", data)
@@ -288,8 +288,8 @@ func TestObject(t *testing.T) {
 		})
 		assert.NoError(t, err)
 
-		assert.Equal(t, d1.GarbageLen(), 2)
-		assert.Equal(t, d1.GarbageCollect(time.MaxTicket), 2)
+		assert.Equal(t, 2, d1.GarbageLen())
+		assert.Equal(t, 2, d1.GarbageCollect(time.MaxTicket))
 	})
 
 	t.Run("Nested object sync test", func(t *testing.T) {
@@ -346,12 +346,12 @@ func TestObject(t *testing.T) {
 		err = c1.Sync(ctx)
 		assert.NoError(t, err)
 
-		assert.Equal(t, d1.GarbageLen(), 1)
-		assert.Equal(t, d1.GarbageCollect(time.MaxTicket), 1)
+		assert.Equal(t, 1, d1.GarbageLen())
+		assert.Equal(t, 1, d1.GarbageCollect(time.MaxTicket))
 
 	})
 
-	t.Run("nested object set/delete", func(t *testing.T) {
+	t.Run("Nested object set/delete test", func(t *testing.T) {
 		ctx := context.Background()
 		d1 := document.New(helper.TestDocKey(t))
 		err := c1.Attach(ctx, d1)
@@ -384,7 +384,7 @@ func TestObject(t *testing.T) {
 		syncClientsThenAssertEqual(t, []clientAndDocPair{{c1, d1}, {c2, d2}})
 	})
 
-	t.Run("nested object nil type", func(t *testing.T) {
+	t.Run("Nested object nil type test", func(t *testing.T) {
 		ctx := context.Background()
 		d1 := document.New(helper.TestDocKey(t))
 		err := c1.Attach(ctx, d1)
@@ -399,7 +399,64 @@ func TestObject(t *testing.T) {
 		})
 
 		assert.NoError(t, err)
-		assert.Equal(t, d1.Marshal(), `{"obj":{"emptry":null}}`)
+		assert.Equal(t, `{"obj":{"emptry":null}}`, d1.Marshal())
+	})
+
+	t.Run("Nested object array type test", func(t *testing.T) {
+		ctx := context.Background()
+		d1 := document.New(helper.TestDocKey(t))
+		err := c1.Attach(ctx, d1)
+		assert.NoError(t, err)
+
+		err = d1.Update(func(root *json.Object, p *presence.Presence) error {
+			json := map[string]interface{}{
+				"array": []interface{}{1, 2, 3},
+			}
+			root.SetNewObject("obj", json)
+			root.GetObject("obj").GetArray("array").AddInteger(4, 5)
+			return nil
+		})
+
+		assert.NoError(t, err)
+		assert.Equal(t, `{"obj":{"array":[1,2,3,4,5]}}`, d1.Marshal())
+	})
+
+	t.Run("Nested object counter type test", func(t *testing.T) {
+		ctx := context.Background()
+		d1 := document.New(helper.TestDocKey(t))
+		err := c1.Attach(ctx, d1)
+		assert.NoError(t, err)
+
+		err = d1.Update(func(root *json.Object, p *presence.Presence) error {
+			json := map[string]interface{}{
+				"counter": json.CreateCounter(crdt.LongCnt, 0),
+			}
+			root.SetNewObject("obj", json)
+			root.GetObject("obj").GetCounter("counter").Increase(3)
+			return nil
+		})
+
+		assert.NoError(t, err)
+		assert.Equal(t, `{"obj":{"counter":3}}`, d1.Marshal())
+	})
+
+	t.Run("Nested object text type test", func(t *testing.T) {
+		ctx := context.Background()
+		d1 := document.New(helper.TestDocKey(t))
+		err := c1.Attach(ctx, d1)
+		assert.NoError(t, err)
+
+		err = d1.Update(func(root *json.Object, p *presence.Presence) error {
+			json := map[string]interface{}{
+				"text": json.CreateText(),
+			}
+			root.SetNewObject("obj", json)
+			root.GetObject("obj").GetText("text").Edit(0, 0, "ABCD")
+			return nil
+		})
+
+		assert.NoError(t, err)
+		assert.Equal(t, `{"obj":{"text":[{"val":"ABCD"}]}}`, d1.Marshal())
 	})
 
 }