Better set json with jsonizer / *json (#11)

Thomas Charlot · web-flow · commit bb56859aa956 · 2021-01-26T14:54:27.000+01:00
diff --git a/go.sum b/go.sum
@@ -5,10 +5,9 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/json.go b/json.go
@@ -12,6 +12,11 @@ type Json struct {
 	data interface{}
 }
 
+// A Jsonizer can converts to a json
+type Jsonizer interface {
+	JSON() *Json
+}
+
 // New creates an empty object Json, ie {}
 func New() *Json {
 	return &Json{
@@ -239,20 +244,46 @@ func (j *Json) Has(path string) bool {
 
 // Set sets the value at path of object. If a portion of path doesn't exist, it's created.
 // Arrays are created for missing index properties while objects are created for all other missing properties
-func (j *Json) Set(path string, value ...interface{}) bool {
+func (j *Json) Set(path string, value interface{}) bool {
 	keys := createPath(path)
 	lastIndex := len(keys) - 1
 
 	// Pick value
 	var newValue interface{}
-	lv := len(value)
-
-	if lv == 0 {
-		newValue = nil
-	} else if lv == 1 {
-		newValue = value[0]
-	} else {
-		newValue = value
+
+	switch cv := value.(type) {
+	case Jsonizer:
+		if jsub := cv.JSON(); jsub != nil {
+			newValue = jsub.data
+		}
+
+	case *Json:
+		newValue = cv.data
+
+	case []*Json:
+		datas := make([]interface{}, 0, len(cv))
+		for _, item := range cv {
+			datas = append(datas, item.data)
+		}
+		newValue = datas
+
+	case []interface{}:
+		newValue = cv
+
+	default:
+		rv := reflect.ValueOf(value)
+		kind := rv.Kind()
+
+		if kind == reflect.Array || kind == reflect.Slice {
+			l := rv.Len()
+			datas := make([]interface{}, l)
+			for i := 0; i < l; i++ {
+				datas[i] = rv.Index(i).Interface()
+			}
+			newValue = datas
+		} else {
+			newValue = value
+		}
 	}
 
 	if lastIndex == -1 {
@@ -281,16 +312,10 @@ func (j *Json) Set(path string, value ...interface{}) bool {
 		if a := curr.AsArray(); a != nil {
 			// Must be an int
 			idx, e := strconv.Atoi(k)
-			if e != nil || idx < 0 {
+			if e != nil || idx < 0 || idx >= len(a) {
 				return false
 			}
 
-			if idx >= len(a) {
-				for q := len(a); q <= idx; q++ {
-					a = append(a, nil)
-				}
-			}
-
 			// Assign value
 			if i == lastIndex {
 				a[idx] = newValue
@@ -318,15 +343,6 @@ func (j *Json) Set(path string, value ...interface{}) bool {
 	return false
 }
 
-// SetJSON to sets a json or an array of json to path
-func (j *Json) SetJSON(path string, json ...*Json) bool {
-	var d []interface{}
-	for _, o := range json {
-		d = append(d, o.data)
-	}
-	return j.Set(path, d...)
-}
-
 // Unset deletes the value
 func (j *Json) Unset(path string) bool {
 	keys := createPath(path)
@@ -380,7 +396,7 @@ func (j *Json) Rewrite(oldPath string, newPath string) bool {
 // Returns the new parent or nilJson if error
 func (j *Json) Wrap(path string) *Json {
 	wrap := New()
-	if !wrap.Set(path, j.data) {
+	if !wrap.Set(path, j) {
 		return Nil()
 	}
 	return wrap
diff --git a/json_test.go b/json_test.go
@@ -2,6 +2,7 @@ package jsonmap_test
 
 import (
 	"encoding/json"
+	"fmt"
 	"sort"
 	"testing"
 
@@ -25,6 +26,19 @@ const jsonTest = `
 }
 `
 
+type Person struct {
+	FirstName string
+	Name      string
+	Age       int
+}
+
+func (p *Person) JSON() *jsonmap.Json {
+	j := jsonmap.New()
+	j.Set("name", fmt.Sprintf("%s %s", p.FirstName, p.Name))
+	j.Set("age", p.Age)
+	return j
+}
+
 func TestNewJson(t *testing.T) {
 	j := jsonmap.New()
 	assert.False(t, j.IsNil())
@@ -116,42 +130,102 @@ func TestGetPath(t *testing.T) {
 }
 
 func TestSet(t *testing.T) {
-	j := jsonmap.New()
-	assert.True(t, j.Set("", 3.14))
-	assert.Equal(t, 3.14, j.AsFloat())
-
-	// Collision test => try to sets object on value
-	assert.True(t, j.Set("hello", "world"))
-	assert.Equal(t, "world", j.Get("hello").AsString())
-
-	// Can reinject new value
-	assert.True(t, j.Set("", "3.14"))
-	assert.Equal(t, "3.14", j.AsString())
-
-	// Create auto map
-	j = jsonmap.New()
-	assert.True(t, j.Set("hello", "world"))
-	assert.Equal(t, "world", j.Get("hello").AsString())
-	assert.True(t, j.Set("the.number.pi.is", 3.14))
-	assert.Equal(t, 3.14, j.Get("the.number.pi.is").AsFloat())
-
-	// Can sets array
-	j = jsonmap.FromString(jsonTest)
-	assert.Equal(t, int64(2), j.Get("array[1]").AsInt())
-	assert.True(t, j.Set("array[1]", 3.14))
-	assert.Equal(t, 3.14, j.Get("array[1]").AsFloat())
-	assert.Equal(t, "b", j.Get("object.sub[1].1").AsString())
-	assert.True(t, j.Set("object.sub[1].1", 3.14))
-	assert.Equal(t, 3.14, j.Get("object.sub[1].1").AsFloat())
+	t.Run("can set root path", func(t *testing.T) {
+		j := jsonmap.New()
+		assert.True(t, j.Set("", 3.14))
+		assert.JSONEq(t, "3.14", j.Stringify())
+		assert.Equal(t, 3.14, j.AsFloat())
+	})
+
+	t.Run("can replace a value by an object", func(t *testing.T) {
+		j := jsonmap.New()
+		assert.True(t, j.Set("", 3.14))
+		assert.True(t, j.Set("hello", "world"))
+		assert.JSONEq(t, `{ "hello": "world" }`, j.Stringify())
+	})
+
+	t.Run("can replace an object by a value", func(t *testing.T) {
+		j := jsonmap.New()
+		assert.True(t, j.Set("hello", "world"))
+		assert.True(t, j.Set("", 3.14))
+		assert.JSONEq(t, "3.14", j.Stringify())
+	})
+
+	t.Run("can create sub path", func(t *testing.T) {
+		j := jsonmap.New()
+		assert.True(t, j.Set("hello", "world"))
+		assert.True(t, j.Set("the.number.pi.is", 3.14))
+		assert.JSONEq(t, `{ "hello": "world", "the": { "number": { "pi": { "is": 3.14 }}}}`, j.Stringify())
+	})
+
+	t.Run("can create path with escape '.'", func(t *testing.T) {
+		j := jsonmap.New()
+		assert.True(t, j.Set("test\\.machin", 45))
+		assert.True(t, j.Set("choux\\.machin.truc", "bidule"))
+		assert.True(t, j.Set("choux.machin\\.truc", "bidule"))
+		assert.JSONEq(t, `{ "test.machin": 45, "choux.machin": { "truc": "bidule" }, "choux": { "machin.truc": "bidule" }}`, j.Stringify())
+	})
 
-	// can create auto array
-	assert.True(t, j.Set("hello", 1, 2, 3, 4, 5))
-	assert.Subset(t, []int{1, 2, 3, 4, 5}, j.Get("hello").AsArray())
+	t.Run("can set array", func(t *testing.T) {
+		j := jsonmap.New()
+		assert.True(t, j.Set("items", []int{1, 2, 3, 4, 5}))
+		assert.JSONEq(t, `{ "items": [1, 2, 3, 4, 5] }`, j.Stringify())
 
-	assert.True(t, j.Set("test\\.machin", 45))
-	assert.Equal(t, int64(45), j.Get("test\\.machin").AsInt())
-	assert.True(t, j.Set("choux\\.machin.truc", "bidule"))
-	assert.Equal(t, "bidule", j.Get("choux\\.machin.truc").AsString())
+		assert.True(t, j.Set("items[2]", 3.14))
+		assert.JSONEq(t, `{ "items": [1, 2, 3.14, 4, 5] }`, j.Stringify())
+
+		assert.True(t, j.Set("items[3]", &Person{FirstName: "Thomas", Name: "CHARLOT", Age: 36}))
+		assert.JSONEq(t, `{ "items": [1, 2, 3.14, {"name": "Thomas CHARLOT", "age": 36 }, 5] }`, j.Stringify())
+
+		assert.True(t, j.Set("items[3].age", 37))
+		assert.JSONEq(t, `{ "items": [1, 2, 3.14, {"name": "Thomas CHARLOT", "age": 37 }, 5] }`, j.Stringify())
+
+		assert.False(t, j.Set("items[7]", 11))
+		assert.JSONEq(t, `{ "items": [1, 2, 3.14, {"name": "Thomas CHARLOT", "age": 37 }, 5] }`, j.Stringify())
+	})
+
+	t.Run("can set nil", func(t *testing.T) {
+		j := jsonmap.New()
+		assert.True(t, j.Set("nil", nil))
+		assert.JSONEq(t, `{ "nil": null }`, j.Stringify())
+	})
+
+	t.Run("can set a sub json", func(t *testing.T) {
+		j := jsonmap.New()
+		sub := jsonmap.New()
+		assert.True(t, sub.Set("pi", 3.14))
+		assert.True(t, j.Set("wrapped", sub))
+		assert.JSONEq(t, `{ "wrapped": { "pi": 3.14 }}`, j.Stringify())
+	})
+
+	t.Run("can set a json array", func(t *testing.T) {
+		j := jsonmap.New()
+		items := []*jsonmap.Json{
+			jsonmap.FromString(`{ "string": "hello" }`),
+			jsonmap.FromString(`{ "bool": true }`),
+			jsonmap.FromString(`{ "number": 3.14 }`),
+			jsonmap.FromString(`{ "array": [1,2,3,4,5] }`),
+			jsonmap.FromString(`{ "object": { "a": 4, "1": "a" }}`),
+			jsonmap.Nil(),
+		}
+
+		assert.True(t, j.Set("items", items))
+		assert.JSONEq(t,
+			`{ "items": [{ "string": "hello" }, { "bool": true }, { "number": 3.14 }, { "array": [1,2,3,4,5] }, { "object": { "a": 4, "1": "a" }}, null ]}`,
+			j.Stringify(),
+		)
+	})
+
+	t.Run("can set a jsonizer", func(t *testing.T) {
+		j := jsonmap.New()
+		person := &Person{FirstName: "Thomas", Name: "CHARLOT", Age: 36}
+		assert.True(t, j.Set("person", person))
+		assert.JSONEq(t,
+			`{ "person": { "name": "Thomas CHARLOT", "age": 36 }}`,
+			j.Stringify(),
+		)
+
+	})
 }
 
 func TestWrap(t *testing.T) {
diff --git a/jsonizer.go b/jsonizer.go
