...

Author: chanced

GO_LICENSE

@@ -1,6 +1,7 @@
 package jsonpointer
 
 import (
+	"fmt"
 	"reflect"
 )
 
@@ -12,22 +13,12 @@ func Assign(dst interface{}, ptr JSONPointer, value interface{}) error {
 	if err := ptr.Validate(); err != nil {
 		return err
 	}
-
-	//  not sure whether or not to delete this. Leaving it out for now.
-	//
-	// if ptr == TopLevel {
-	// 	return &ptrError{
-	// 		err: ErrEmptyJSONPointer,
-	// 		typ: reflect.TypeOf(src),
-	// 	}
-	// }
-
 	if value == nil {
 		return Delete(dst, ptr)
 	}
 	dv := reflect.ValueOf(dst)
 	s := newState(ptr, Assigning)
-	defer s.Done()
+	defer s.Release()
 	if dv.Kind() != reflect.Ptr || dv.IsNil() {
 		return &ptrError{
 			state: *s,
@@ -36,16 +27,21 @@ func Assign(dst interface{}, ptr JSONPointer, value interface{}) error {
 		}
 	}
 
-	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()
+	cpy := dv
+	dv = dv.Elem()
+	switch dv.Type().Kind() {
+	case reflect.Ptr:
+		if dv.IsNil() {
+			dv = reflect.New(dv.Type().Elem())
+		}
+	case reflect.Slice:
+		if dv.Type().AssignableTo(typeByteSlice) {
+			fmt.Println("is byte slice")
 		}
 	}
-	res, err := s.assign(dv, reflect.ValueOf(value))
-	tmp.Elem().Set(res)
+	dp := reflect.New(dv.Type())
+	dp.Elem().Set(dv)
+	res, err := s.assign(dp, reflect.ValueOf(value))
+	cpy.Elem().Set(res.Elem())
 	return err
 }

assign.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/chanced/jsonpointer"
+	"github.com/sanity-io/litter"
 	"github.com/stretchr/testify/require"
 )
 
@@ -62,7 +63,7 @@ func TestAssign(t *testing.T) {
 	}
 
 	for i, test := range tests {
-		fmt.Printf("=== RUN TestAssign#%d, pointer %s\n", i+1, test.ptr)
+		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)
@@ -73,3 +74,67 @@ func TestAssign(t *testing.T) {
 		fmt.Printf("--- PASS TestAssign #%d, pointer %s\n", i, test.ptr)
 	}
 }
+
+func TestAssignAny(t *testing.T) {
+	assert := require.New(t)
+
+	m := map[string]interface{}{}
+	tests := []struct {
+		ptr   jsonpointer.JSONPointer
+		value interface{}
+		err   error
+		run   func(v interface{})
+	}{
+		{"/nested/str", "strval", nil, func(val interface{}) {
+			assert.Contains(m, "nested")
+			assert.Contains(m["nested"], "str")
+			m := m["nested"].(map[string]interface{})
+			assert.Equal(val, m["str"])
+		}},
+		{"/nestedptr/str", "x", nil, func(val interface{}) {
+			assert.Contains(m, "nestedptr")
+			assert.Contains(m["nestedptr"], "str")
+			n := m["nestedptr"].(map[string]interface{})
+			assert.Equal(n["str"], "x")
+		}},
+		{"/nested/array/0/entry/value", "entry value", nil, func(v interface{}) {
+			litter.Dump(m)
+			a := m["nested"].(map[string]interface{})["array"].([]interface{})
+			assert.Len(a, 1)
+			mv := a[0].(map[string]interface{})
+			assert.Contains(mv, "entry")
+			e := mv["entry"].(map[string]interface{})
+			assert.Contains(e, "value")
+			assert.Equal(v, e["value"])
+		}},
+
+		{"/nested/intarray/0", int(1), nil, func(v interface{}) {
+		}},
+		{"/nested/anon/value", "val", nil, func(v interface{}) {
+		}},
+		{"/nested/strslice/-", "val", nil, func(v interface{}) {
+		}},
+		{"/nested/strslice/-", "val2", nil, func(v interface{}) {
+		}},
+		{"/nested/custommap/key", "val", nil, func(v interface{}) {
+		}},
+		{"/nested/embedded/value", "embed-val", nil, func(v interface{}) {
+		}},
+		{"/nested/yield/value", "yielded value", nil, func(v interface{}) {
+		}},
+		{"/nested/interface/private/value", uint(3), nil, func(v interface{}) {
+		}},
+	}
+
+	for i, test := range tests {
+		fmt.Printf("=== RUN TestAssignAny #%d, pointer %s\n", i, test.ptr)
+		err := jsonpointer.Assign(&m, test.ptr, test.value)
+		if test.err != nil {
+			assert.ErrorIs(err, test.err)
+		} else {
+			assert.NoError(err)
+			test.run(test.value)
+		}
+		fmt.Printf("--- PASS TestAssign #%d, pointer %s\n", i, test.ptr)
+	}
+}

assign_test.go

@@ -5,5 +5,10 @@ type Deleter interface {
 }
 
 func Delete(src interface{}, ptr JSONPointer) error {
-	panic("not impl")
+	if err := ptr.Validate(); err != nil {
+		return err
+	}
+	s := newState(ptr, Deleting)
+	defer s.Release()
+	panic("not done with Delete")
 }

delete.go

@@ -246,7 +246,7 @@ type valueError struct {
 }
 
 func (e *valueError) Error() string {
-	return e.ptrError.Error() + " " + e.valuetype.String() + " for " + e.typ.String()
+	return fmt.Sprintf("%v (%v) for reference \"%v\"; expected %v", e.ptrError.err, e.valuetype, e.ptr, e.typ)
 }
 
 func (e *valueError) ValueType() reflect.Type {
@@ -293,7 +293,7 @@ func (e *indexError) Index() int {
 
 func (e *indexError) Error() string {
 	if errors.Is(e.err, ErrOutOfRange) {
-		return fmt.Sprintf("%v; expected index to be less than next (%d) but is (%d)", ErrOutOfRange, e.maxIndex, e.index)
+		return fmt.Sprintf("%v; expected index to be equal to or less than next (%d) but is (%d)", ErrOutOfRange, e.maxIndex, e.index)
 	}
 	return fmt.Sprintf("%v for index %d of %d", e.err.Error(), e.index, e.maxIndex)
 }

errors.go

@@ -12,7 +12,7 @@ func Resolve(src interface{}, ptr JSONPointer, dst interface{}) error {
 	}
 	dv := reflect.ValueOf(dst)
 	s := newState(ptr, Resolving)
-	defer s.Done()
+	defer s.Release()
 	if dv.Kind() != reflect.Ptr || dv.IsNil() {
 		return &ptrError{
 			state: *s,