wip

Author: chanced

assign.go

@@ -1,12 +1,14 @@
 package jsonpointer
 
-import "reflect"
+import (
+	"reflect"
+)
 
 type Assigner interface {
 	AssignByJSONPointer(ptr *JSONPointer, value interface{}) error
 }
 
-func Assign(ptr JSONPointer, src interface{}, value interface{}) error {
+func Assign(dst interface{}, ptr JSONPointer, value interface{}) error {
 	if err := ptr.Validate(); err != nil {
 		return err
 	}
@@ -21,19 +23,29 @@ func Assign(ptr JSONPointer, src interface{}, value interface{}) error {
 	// }
 
 	if value == nil {
-		return Delete(src, ptr)
+		return Delete(dst, ptr)
 	}
-	sv := reflect.ValueOf(src)
+	dv := reflect.ValueOf(dst)
 	s := newState(ptr, Assigning)
 	defer s.Done()
-	if sv.Kind() != reflect.Ptr || sv.IsNil() {
+	if dv.Kind() != reflect.Ptr || dv.IsNil() {
 		return &ptrError{
 			state: *s,
 			err:   ErrNonPointer,
-			typ:   sv.Type(),
+			typ:   dv.Type(),
 		}
 	}
-	// TODO: Handle bytes / reader
-	_, err := s.assign(sv, reflect.ValueOf(value))
+
+	var tmp reflect.Value
+	if dv.Type().Elem().Kind() == reflect.Ptr {
+		tmp = dv
+		if dv.Elem().IsNil() {
+			dv = reflect.New(dv.Type().Elem().Elem())
+		} else {
+			dv = dv.Elem()
+		}
+	}
+	res, err := s.assign(dv, reflect.ValueOf(value))
+	tmp.Elem().Set(res)
 	return err
 }

assign_test.go

@@ -11,52 +11,65 @@ import (
 func TestAssign(t *testing.T) {
 	assert := require.New(t)
 
-	r := Root{}
+	var r *Root
 
 	tests := []struct {
 		ptr   jsonpointer.JSONPointer
 		value interface{}
 		err   error
 		run   func(v interface{})
 	}{
-		{"/nested/str", "strval", nil, func(val interface{}) {
-			assert.Equal(val, r.Nested.String)
-		}},
-		{"/nestedptr/str", "x", nil, func(val interface{}) {
-			assert.Equal(val, r.NestedPtr.String)
-		}},
-		{"/nested/entrymap/keyval/name", "entry-name", nil, func(v interface{}) {
-			assert.Contains(r.Nested.EntryMap, "keyval")
-			assert.Equal("entry-name", r.Nested.EntryMap["keyval"].Name)
-		}},
-		{"/nested/strarray/1", "strval", nil, func(v interface{}) {
-			assert.Equal(v, r.Nested.StrArray[1])
-		}},
-		{"/nested/intarray/1", int(1), nil, func(v interface{}) {
-			assert.Equal(v, r.Nested.IntArray[1])
-		}},
-		{"/nested/anon/value", "val", nil, func(v interface{}) {
-			assert.Equal(v, r.Nested.AnonStruct.Value)
-		}},
-		{"/nested/strslice/-", "val", nil, func(v interface{}) {
-			assert.Len(r.Nested.StrSlice, 1)
-			assert.Equal(v, r.Nested.StrSlice[0])
-		}},
-		{"/nested/strslice/-", "val2", nil, func(v interface{}) {
-			assert.Len(r.Nested.StrSlice, 2)
-			assert.Equal(v, r.Nested.StrSlice[1])
+		// {"/nested/str", "strval", nil, func(val interface{}) {
+		// 	assert.Equal(val, r.Nested.String)
+		// }},
+		// {"/nestedptr/str", "x", nil, func(val interface{}) {
+		// 	assert.Equal(val, r.NestedPtr.String)
+		// }},
+		// {"/nested/entrymap/keyval/name", "entry-name", nil, func(v interface{}) {
+		// 	assert.Contains(r.Nested.EntryMap, "keyval")
+		// 	assert.Equal("entry-name", r.Nested.EntryMap["keyval"].Name)
+		// }},
+		// {"/nested/strarray/1", "strval", nil, func(v interface{}) {
+		// 	assert.Equal(v, r.Nested.StrArray[1])
+		// }},
+		// {"/nested/intarray/1", int(1), nil, func(v interface{}) {
+		// 	assert.Equal(v, r.Nested.IntArray[1])
+		// }},
+		// {"/nested/anon/value", "val", nil, func(v interface{}) {
+		// 	assert.Equal(v, r.Nested.AnonStruct.Value)
+		// }},
+		// {"/nested/strslice/-", "val", nil, func(v interface{}) {
+		// 	assert.Len(r.Nested.StrSlice, 1)
+		// 	assert.Equal(v, r.Nested.StrSlice[0])
+		// }},
+		// {"/nested/strslice/-", "val2", nil, func(v interface{}) {
+		// 	assert.Len(r.Nested.StrSlice, 2)
+		// 	assert.Equal(v, r.Nested.StrSlice[1])
+		// }},
+		// {"/nested/custommap/key", "val", nil, func(v interface{}) {
+		// 	assert.Len(r.Nested.CustomMap, 1)
+		// 	assert.Contains(r.Nested.CustomMap, Key{"key"})
+		// }},
+		// {"/nested/embedded/value", "embed-val", nil, func(v interface{}) {
+		// 	assert.Equal(v, r.Nested.Embedded.Value)
+		// }},
+		// {"/nested/yield/value", "yielded value", nil, func(v interface{}) {
+		// 	assert.Equal(v, r.Nested.Yield.Value)
+		// }},
+		{"/nested/interface/private/value", uint(3), nil, func(v interface{}) {
+			assert.Equal(v, r.Nested.InterContainer.Value())
 		}},
 	}
 
 	for i, test := range tests {
-		fmt.Printf("=== test %d, pointer %s\n", i, test.ptr)
-		err := jsonpointer.Assign(test.ptr, &r, test.value)
+		fmt.Printf("=== RUN TestAssign#%d, pointer %s\n", i+1, test.ptr)
+		err := jsonpointer.Assign(&r, test.ptr, test.value)
 		if test.err != nil {
 			assert.ErrorIs(err, test.err)
 		} else {
 			assert.NoError(err)
 			test.run(test.value)
 		}
-		fmt.Println("\tPASS")
+		fmt.Printf("--- PASS TestAssign #%d, pointer %s\n", i, test.ptr)
 	}
 }

errors.go

@@ -59,8 +59,7 @@ var (
 	//
 	ErrNilInterface = errors.New("jsonpointer: can not assign due to nil interface")
 
-	// ErrMalformedIndex indicates a syntax error in the index or a slice or an
-	// array.
+	// ErrMalformedIndex indicates a syntax error in the index or a slice or an array.
 	ErrMalformedIndex = errors.New("jsonpointer: malformed slice/array index")
 )
 
@@ -102,9 +101,9 @@ type ptrError struct {
 func (e *ptrError) Error() string {
 	t, ok := e.Token()
 	if ok {
-		return fmt.Sprintf(`"%v for token "%s" in reference "%v"`, e.err.Error(), t, e.ptr)
+		return fmt.Sprintf(`%v for token "%s" in reference "%v"`, e.err.Error(), t, e.ptr)
 	}
-	return fmt.Sprintf(`"%v" for reference "%v"`, e.err.Error(), e.ptr)
+	return fmt.Sprintf(`%v for reference "%v"`, e.err.Error(), e.ptr)
 }
 
 // Unwrap returns the underlying error.

resolve_test.go

@@ -55,7 +55,7 @@ func TestResolveField(t *testing.T) {
 	}
 
 	for i, test := range tests {
-		fmt.Printf("=== test %d, pointer %s", i, test.ptr)
+		fmt.Printf("=== RUN TestResolveField #%d, pointer %s\n", i, test.ptr)
 		var val interface{}
 		err := jsonpointer.Resolve(r, test.ptr, &val)
 		if test.expectederr != nil {
@@ -64,7 +64,7 @@ func TestResolveField(t *testing.T) {
 			assert.NoError(err)
 		}
 		assert.Equal(test.expectedval, val)
-		fmt.Printf("\n\tPASS\n")
+		fmt.Printf("---PASS\n")
 	}
 }