wip

Author: chanced

assign_test.go

@@ -1,21 +1,16 @@
 package jsonpointer_test
 
 import (
-	"fmt"
 	"testing"
 
 	"github.com/chanced/jsonpointer"
 	"github.com/stretchr/testify/require"
 )
 
-func TestAssignStructField(t *testing.T) {
+func TestAssign(t *testing.T) {
 	assert := require.New(t)
 
-	r := Root{
-		Nested: Nested{
-			String: "",
-		},
-	}
+	r := Root{}
 
 	tests := []struct {
 		ptr   jsonpointer.JSONPointer
@@ -25,11 +20,13 @@ func TestAssignStructField(t *testing.T) {
 	}{
 		{"/nested/str", "strval", nil, func(val interface{}) {
 			assert.Equal(val, r.Nested.String)
-			fmt.Println(r.Nested.String)
 		}},
 		{"/nestedptr/str", "x", nil, func(val interface{}) {
 			assert.Equal(val, r.NestedPtr.String)
-			fmt.Println(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)
 		}},
 	}
 
@@ -43,20 +40,3 @@ func TestAssignStructField(t *testing.T) {
 		}
 	}
 }
-
-func TestAssignMapValue(t *testing.T) {
-	// assert := require.New(t)
-	// m := make(map[string]structentry)
-	// ptr := JSONPointer("/foo")
-	// assign := newAssignState(ptr)
-	// val := structentry{Name: "fooval"}
-	// err := assign.setMapIndex(
-	// 	ptr,
-	// 	reflect.TypeOf(m),
-	// 	reflect.ValueOf(m),
-	// 	reflect.ValueOf(val),
-	// )
-	// assert.NoError(err)
-	// assert.Contains(m, "foo")
-	// assert.Equal(val, m["foo"])
-}

errors.go

@@ -13,27 +13,51 @@ var (
 	//
 	// This error is returned by JSONPointer.Validate() which is called by
 	// Resolve, Assign, and Delete.
+	//
 	ErrMalformedToken = fmt.Errorf(`jsonpointer: reference must be empty or start with a "/"`)
+
 	// ErrNonPointer indicates a non-pointer value was passed to Assign.
+	//
 	ErrNonPointer = errors.New("jsonpointer: dst must be a pointer")
+
 	// ErrUnexportedField indicates the given path is not reachable due to being
 	// an unexported field.
+	//
 	ErrUnexportedField = errors.New("jsonpointer: unexported field")
+
 	// ErrInvalidKeyType indicates the key type is not supported.
 	//
 	// Custom key types must implement encoding.TextUnmarshaler
+	//
 	ErrInvalidKeyType = errors.New("jsonpointer: invalid key type")
+
 	// ErrNotAssignable indicates the type of the value is not assignable to the
 	// provided path.
+	//
 	ErrNotAssignable = errors.New("jsonpointer: invalid value type")
+
 	// ErrNotFound indicates a JSONPointer is not reachable from the root object
 	// (e.g. a nil pointer, missing map key).
+	//
 	ErrNotFound = errors.New(`jsonpointer: value not found`)
+
 	// ErrOutOfRange indicates an index is out of range for an array or slice
+	//
 	ErrOutOfRange = errors.New("jsonpointer: index out of range")
-	// ErrUnreachable indicates a reference is not reachable. This occurs
-	// when a primitive leaf node is reached and the reference is not empty.
+
+	// ErrUnreachable indicates a reference is not reachable. This occurs when
+	// resolving and a primitive (string, number, or bool) leaf node is reached
+	// and the reference is not empty.
+	//
 	ErrUnreachable = fmt.Errorf("%w due to being unreachable", ErrNotFound)
+
+	// ErrNilInterface is returned when assigning and a nil interface is
+	// reached.
+	//
+	// To solve this, the node containing the interface should implement
+	// jsonpoint.Resolver and return a non-nil implemention of the interface.
+	//
+	ErrNilInterface = errors.New("jsonpointer: can not assign due to nil interface")
 )
 
 // Error is a base error type returned from Resolve, Assign, and Delete.
@@ -282,3 +306,22 @@ func (e *indexError) AsIndexError(err error) (IndexError, bool) {
 func (e *indexError) Unwrap() error {
 	return e.err
 }
+
+type nilInterfaceError struct {
+	ptrError
+}
+
+func newNilInterfaceError(s state, typ reflect.Type) *nilInterfaceError {
+	return &nilInterfaceError{
+		ptrError: ptrError{
+			state: s,
+			err:   ErrNilInterface,
+			typ:   typ,
+		},
+	}
+}
+
+func (e *nilInterfaceError) Error() string {
+	t, _ := e.Token()
+	return fmt.Sprintf("jsonpointer: can not assign token \"%s\" of \"%s\" because %v is nil and can not be instantiated.", t, e.ptr, e.typ)
+}

state.go

@@ -9,8 +9,6 @@ import (
 	"reflect"
 	"sort"
 	"sync"
-
-	"github.com/sanity-io/litter"
 )
 
 var (
@@ -252,7 +250,6 @@ func (s *state) assign(dst reflect.Value, value reflect.Value) (reflect.Value, e
 	// TODO: deref the current pointer and use that instead
 	if s.current.IsRoot() {
 		_, err := s.assignValue(dst, value)
-		fmt.Printf("--------------\nROOT\n\"%v\" => %v\n--------------\n", t, dst.Type())
 		return dst, err
 	}
 
@@ -264,18 +261,29 @@ func (s *state) assign(dst reflect.Value, value reflect.Value) (reflect.Value, e
 	// can i just overwrite src?
 	var nd reflect.Value
 	nd, err = s.resolveNext(dst, t)
-	fmt.Printf("resolved: \"%v\" => %v\n", t, nd.Type())
 	if err != nil {
 		return nd, err
 	}
 
 	shouldSet := false
+	switch nd.Kind() {
+	case reflect.Ptr:
+		if nd.IsNil() {
+			nd.Set(reflect.New(nd.Type().Elem()))
+		}
+	case reflect.Interface:
+		if nd.IsNil() {
+			return nd, newError(ErrUnreachable, *s, nd.Type())
+		}
+	}
+
 	if !nd.IsValid() {
-		switch dst.Kind() {
+		switch dst.Elem().Kind() {
 		case reflect.Map, reflect.Slice:
 			shouldSet = true
 			nd = reflect.Zero(dst.Type().Elem())
 		default:
+			fmt.Println(dst.Type())
 			// TODO: figure out which other types would be invalid and remove this panic
 			panic("resolving an invalid value which is not an entry on a map/slice is not done")
 		}
@@ -291,41 +299,26 @@ func (s *state) assign(dst reflect.Value, value reflect.Value) (reflect.Value, e
 		nd = pv
 	}
 
-	fmt.Printf("new dst: \"%v\" => %v\n", t, nd.Type())
-	fmt.Printf("cur dst: \"%v\" => %v\n", t, dst.Type())
 	_ = shouldSet
+
 	var nv reflect.Value
 	nv, err = s.assign(nd, value)
-
-	fmt.Printf("Prepending \"%v\" to \"%s\"\n", s.current, t)
 	s.current = s.current.Prepend(t)
-	fmt.Printf("new val: \"%v\" => %v\n", t, nv.Type())
+
 	if err != nil {
 		return dst, err
 	}
-
-	fmt.Printf("calling assignValue(%v, %v) with current = %v, token = %v\n", nd.Type(), nv.Elem().Type(), s.current, t)
-	fmt.Printf("val: %v\n", value.Type())
-	fmt.Printf("dst: %v\n", dst.Type())
 	nd, err = s.assignValue(nd, nv.Elem())
 	if err != nil {
 		return nd, err
 	}
-
-	fmt.Printf("--------------\n\"%v\" => %v\n--------------\n", t, nd.Type())
 	return dst, nil
 }
 
 func (s *state) assignValue(dst reflect.Value, v reflect.Value) (reflect.Value, error) {
 	var err error
 	cur := s.current
-	fmt.Println("\nassignValue:")
-	fmt.Printf("current:  \"%s\"", cur)
-	fmt.Printf("\ndst:      %v", dst.Elem().Type())
-	fmt.Printf("\nvalue:    %v\n\n", v.Type())
-	fmt.Printf("---------------\nASSIGN VALUE:  ")
-	litter.Dump(v.Interface())
-	fmt.Println("---------------")
+
 	if dst.Type().Implements(typeAssigner) {
 		err = dst.Interface().(Assigner).AssignByJSONPointer(&cur, v)
 		if err != nil {