wip

Author: chanced

assign_test.go

@@ -98,7 +98,6 @@ func TestAssignAny(t *testing.T) {
 			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{})
@@ -109,12 +108,19 @@ func TestAssignAny(t *testing.T) {
 		}},
 
 		{"/nested/intarray/0", int(1), nil, func(v interface{}) {
-		}},
-		{"/nested/anon/value", "val", nil, func(v interface{}) {
+			a := m["nested"].(map[string]interface{})["intarray"].([]interface{})
+			assert.Len(a, 1)
+			assert.Equal(v, a[0])
 		}},
 		{"/nested/strslice/-", "val", nil, func(v interface{}) {
+			a := m["nested"].(map[string]interface{})["strslice"].([]interface{})
+			assert.Len(a, 1)
+			assert.Equal(v, a[0])
 		}},
 		{"/nested/strslice/-", "val2", nil, func(v interface{}) {
+			a := m["nested"].(map[string]interface{})["strslice"].([]interface{})
+			assert.Len(a, 2)
+			assert.Equal(v, a[1])
 		}},
 		{"/nested/custommap/key", "val", nil, func(v interface{}) {
 		}},
@@ -137,4 +143,5 @@ func TestAssignAny(t *testing.T) {
 		}
 		fmt.Printf("--- PASS TestAssign #%d, pointer %s\n", i, test.ptr)
 	}
+	litter.Dump(m)
 }

state.go

@@ -45,7 +45,7 @@ type state struct {
 }
 
 func (s *state) Release() {
-	statePool.Put(&s)
+	statePool.Put(s)
 }
 
 func (s state) Operation() Operation {
@@ -271,82 +271,80 @@ func (s *state) assign(dst reflect.Value, val reflect.Value) (reflect.Value, err
 		return reflect.Value{}, fmt.Errorf("unexpected end of JSON pointer %v", cur)
 	}
 	// new dst
-	var nd reflect.Value
-	nd, err = s.resolveNext(dst, t)
+	var rn reflect.Value
+	rn, err = s.resolveNext(dst, t)
 	if err != nil {
-		return nd, err
+		return rn, err
 	}
 
 	shouldSet := false
-	switch nd.Kind() {
+	switch rn.Kind() {
 	case reflect.Interface:
-		if !nd.IsNil() && nd.Type() == typeAny {
-			nd = nd.Elem()
+		if !rn.IsNil() && rn.Type() == typeAny {
+			rn = rn.Elem()
 		}
 	case reflect.Ptr:
-		if nd.IsNil() {
-			nd.Set(reflect.New(nd.Type().Elem()))
+		if rn.IsNil() {
+			rn.Set(reflect.New(rn.Type().Elem()))
 		}
 	case reflect.Map:
-		if nd.IsNil() {
-			nd.Set(reflect.MakeMap(nd.Type()))
+		if rn.IsNil() {
+			rn.Set(reflect.MakeMap(rn.Type()))
 		}
 	case reflect.Slice:
-		if nd.IsNil() {
-			nd.Set(reflect.MakeSlice(nd.Type(), 0, 1))
+		if rn.IsNil() {
+			rn.Set(reflect.MakeSlice(rn.Type(), 0, 1))
 		}
 	case reflect.Invalid:
 		switch dst.Type().Elem().Kind() {
-		case reflect.Map:
+		case reflect.Map, reflect.Slice:
 			shouldSet = true
-			nd = reflect.Zero(dst.Type().Elem().Elem())
-			if nd.Kind() == reflect.Ptr && nd.IsNil() {
-				nd = reflect.New(nd.Type().Elem())
+			rn = reflect.Zero(dst.Type().Elem().Elem())
+			if rn.Kind() == reflect.Ptr && rn.IsNil() {
+				rn = reflect.New(rn.Type().Elem())
 				// so this works
-			} else if nd.Type() == typeAny && nd.IsNil() {
-				fmt.Printf("\ttoken: %v\n\t\tcurrent: %v\n\t\troot: %v\n", t, s.current, s.current.IsRoot())
-				switch {
-				case s.current.IsRoot():
-					nd = reflect.Zero(val.Type())
-				case t.IsIndexable():
-					nd = reflect.MakeSlice(typeAnySlice, 0, 1)
-				default:
-					nd = reflect.MakeMap(typeAnyMap)
+			} else if rn.Type() == typeAny && rn.IsNil() {
+				nt, ok := s.current.NextToken()
+				if !ok {
+					rn = reflect.Zero(val.Type())
+				} else {
+					if _, err = nt.Index(0); err == nil {
+						rn = reflect.MakeSlice(typeAnySlice, 0, 1)
+					} else {
+						rn = reflect.MakeMap(typeAnyMap)
+					}
 				}
 			}
-		case reflect.Slice:
-			shouldSet = true
-			if err != nil {
-				return reflect.Value{}, newError(err, *s, dst.Type())
-			}
-			nd = reflect.Zero(dst.Type().Elem().Elem())
-			if nd.Kind() == reflect.Ptr && nd.IsNil() {
-				nd = reflect.New(nd.Type().Elem())
-			}
 		case reflect.Interface:
-			if nd.Type() == typeAny {
-				switch {
-				case s.current.IsRoot():
-					nd = reflect.Zero(val.Type())
-				case t.IsIndexable():
-					nd = reflect.MakeSlice(typeAnySlice, 0, 1)
-				default:
-					nd = reflect.MakeMap(typeAnyMap)
+			_, nt, ok := s.current.Next()
+			if !ok {
+				panic("pointer is not ok")
+			}
+			if rn.Type() == typeAny {
+				if s.current.IsRoot() {
+					rn = reflect.Zero(val.Type())
+				} else {
+					if _, err = nt.Index(0); err == nil {
+						rn = reflect.MakeSlice(typeAnySlice, 0, 1)
+					} else {
+						rn = reflect.MakeMap(typeAnyMap)
+					}
 				}
 			}
 		default:
 			return reflect.Value{}, newError(ErrUnreachable, *s, dst.Type())
 		}
 	}
-	if nd.CanAddr() {
-		nd = nd.Addr()
+
+	if rn.CanAddr() {
+		rn = rn.Addr()
 	} else {
-		pv := reflect.New(nd.Type())
-		pv.Elem().Set(nd)
-		nd = pv
+		pv := reflect.New(rn.Type())
+		pv.Elem().Set(rn)
+		rn = pv
 	}
 	var nv reflect.Value
-	nv, err = s.assign(nd, val)
+	nv, err = s.assign(rn, val)
 
 	s.current = s.current.Prepend(t)
 	if err != nil {
@@ -385,16 +383,16 @@ func (s *state) assign(dst reflect.Value, val reflect.Value) (reflect.Value, err
 			s.current = cur
 		}
 	}
-	nd, err = s.assignValue(nd, nv.Elem())
+	rn, err = s.assignValue(rn, nv.Elem())
 	if err != nil {
-		return nd, err
+		return rn, err
 	}
 	if shouldSet {
 		switch dst.Elem().Kind() {
 		case reflect.Map:
-			s.setMapIndex(dst.Elem(), t, nd.Elem())
+			s.setMapIndex(dst.Elem(), t, rn.Elem())
 		case reflect.Slice:
-			s.setSliceIndex(dst.Elem(), t, nd.Elem())
+			s.setSliceIndex(dst.Elem(), t, rn.Elem())
 		}
 	}
 	return dst, nil

token.go

@@ -31,16 +31,6 @@ func (t Token) Uint64() (uint64, error) {
 	return strconv.ParseUint(t.String(), 10, 64)
 }
 
-func (t Token) IsIndexable() bool {
-	if t == "-" {
-		return true
-	}
-	if i, err := t.Int(); err == nil {
-		return i >= 0
-	}
-	return false
-}
-
 func (t Token) Int() (int, error) {
 	return strconv.Atoi(t.String())
 }

token_test.go

@@ -1,7 +1,6 @@
 package jsonpointer_test
 
 import (
-	"fmt"
 	"testing"
 
 	"github.com/chanced/jsonpointer"
@@ -46,23 +45,23 @@ func TestTokenString(t *testing.T) {
 	assert.Equal("~/", token.String())
 }
 
-func TestTokenIsIndexable(t *testing.T) {
-	assert := require.New(t)
-	tests := []struct {
-		token    jsonpointer.Token
-		expected bool
-	}{
-		{"1", true},
-		{"-1", false},
-		{"-", true},
-		{"0", true},
-		{"c", false},
-		{"", false},
-	}
+// func TestTokenIsIndexable(t *testing.T) {
+// 	assert := require.New(t)
+// 	tests := []struct {
+// 		token    jsonpointer.Token
+// 		expected bool
+// 	}{
+// 		{"1", true},
+// 		{"-1", false},
+// 		{"-", true},
+// 		{"0", true},
+// 		{"c", false},
+// 		{"", false},
+// 	}
 
-	for i, t := range tests {
-		fmt.Println("=== TestTokenIsIndexable #", i, "token:", t.token)
-		assert.Equal(t.expected, t.token.IsIndexable(), "test %d", i)
-		fmt.Println("--- PASS TestTokenIsIndexable #", i)
-	}
-}
+// 	for i, t := range tests {
+// 		fmt.Println("=== TestTokenIsIndexable #", i, "token:", t.token)
+// 		assert.Equal(t.expected, t.token.IsIndexable(), "test %d", i)
+// 		fmt.Println("--- PASS TestTokenIsIndexable #", i)
+// 	}
+// }