wip

Author: chanced

README.md

@@ -1,3 +1 @@
 # jsonpointer
-
-wip

errors.go

@@ -28,9 +28,9 @@ var (
 	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: token path not found`)
-	// ErrOutOfBounds indicates an index is out of bounds for an array or slice
-	ErrOutOfBounds = errors.New("jsonpointer: index out of bounds")
+	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")
 	// ErrInvalidReference indicates a reference is not reachable. This occurs
 	// when a primitive leaf node is reached and the reference is not empty.
 	ErrInvalidReference = errors.New("jsonpointer: bad reference")
@@ -72,14 +72,24 @@ type ptrError struct {
 }
 
 func (e *ptrError) Error() string {
-	return e.err.Error()
+	t, ok := e.Token()
+	fmt.Println("e.current", e.current)
+	fmt.Println("TOKEN ERROR", t, ok)
+	if ok {
+		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)
 }
 
 // Unwrap returns the underlying error.
 func (e *ptrError) Unwrap() error {
 	return e.err
 }
 
+func (e *ptrError) updateState(s *state) {
+	e.state = *s
+}
+
 // JSONPointer returns the initial JSONPointer.
 func (e *ptrError) JSONPointer() JSONPointer {
 	return e.ptr
@@ -217,3 +227,60 @@ func (e *valueError) Error() string {
 func (e *valueError) ValueType() reflect.Type {
 	return e.valuetype
 }
+
+func updateErrorState(err error, s *state) {
+	if e, ok := err.(interface{ updateState(s *state) }); ok {
+		e.updateState(s)
+	}
+}
+
+// IndexError indicates an error occurred with regards to an index of a slice or
+// array. The error may be wrapped in an Error if it is returned from an operation on a
+// JSON Pointer.
+//
+// err.Index() will return -1 if:
+//
+// - the source or destination is an array, token is equal to "-",
+// and the array does not have a zero value.
+//
+// - the token can not be parsed as an int
+//
+type IndexError interface {
+	MaxIndex() int
+	Index() int
+	Error() string
+	Unwrap() error
+}
+
+type indexError struct {
+	err      error
+	maxIndex int
+	index    int
+}
+
+func (e *indexError) MaxIndex() int {
+	return e.maxIndex
+}
+
+func (e *indexError) Index() int {
+	return e.index
+}
+
+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 for index %d of %d", e.err.Error(), e.index, e.maxIndex)
+}
+
+// AsIndexError is a convenience function which calls calls errors.As, returning
+// err as an IndexError and true or nil and false if err can not be assigned to
+// an IndexError
+func (e *indexError) AsIndexError(err error) (IndexError, bool) {
+	var ie IndexError
+	return ie, errors.As(err, &ie)
+}
+
+func (e *indexError) Unwrap() error {
+	return e.err
+}

jsonpointer.go

@@ -70,18 +70,33 @@ func (p JSONPointer) String() string {
 	return string(p)
 }
 
-// AppendString encodes and appends token to value of p and returns the new
+// Append appends token to the end of reference p and returns the new JSONPointer.
+//
+// Note: token is not encoded. Use p.AppendString to encode and append the
+// token.
+func (p JSONPointer) Append(token Token) JSONPointer {
+	return p + "/" + token.ptr()
+}
+
+// AppendString encodes and appends token to the value of p and returns the new
 // JSONPointer.
 func (p JSONPointer) AppendString(token string) JSONPointer {
 	return p.Append(Token(encoder.Replace(token)))
 }
 
-// Append appends token to valuœe of p and returns the new JSONPointer.
+// Preppend prepends token to the beginning of the value of p and returns the
+// resulting JSONPointer.
 //
-// Note: token is not encoded. Use p.AppendString to encode and append the
+// Note: token is not encoded. Use p.PrependString to encode and prepend the
 // token.
-func (p JSONPointer) Append(token Token) JSONPointer {
-	return JSONPointer(p + "/" + token.ptr())
+func (p JSONPointer) Prepend(token Token) JSONPointer {
+	return "/" + token.ptr() + p
+}
+
+// PrependString encodes and prepends token to the value of p and returns the new
+// JSONPointer.
+func (p JSONPointer) PrependString(token string) JSONPointer {
+	return p.Prepend(Token(encoder.Replace(token)))
 }
 
 func (p JSONPointer) Validate() error {

resolve_test.go

@@ -7,22 +7,22 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestResolve(t *testing.T) {
+func TestResolveField(t *testing.T) {
 	assert := require.New(t)
 	floatv := float64(3.4)
 	fl := &floatv
 
 	r1 := Root{
 		Nested: Nested{
-			String:   "string",
+			String:   "strval",
 			FloatPtr: fl,
 		},
 	}
 	var err error
 	var sr string
-	err = jsonpointer.Resolve(r1, "/nested/str", &sr)
+	err = jsonpointer.Resolve(r1, "/nested/string", &sr)
 	assert.NoError(err)
-	assert.Equal("str", sr)
+	assert.Equal("strval", sr)
 
 	var floatres *float64
 	err = jsonpointer.Resolve(r1, "/nested/floatptr", &floatres)
@@ -33,3 +33,59 @@ func TestResolve(t *testing.T) {
 	err = jsonpointer.Resolve(r1, "/nested/floatptr", &floatptrvalue)
 	assert.ErrorIs(err, jsonpointer.ErrNotAssignable)
 }
+
+func TestResolveMapIndex(t *testing.T) {
+	assert := require.New(t)
+
+	r := Root{
+		Nested: Nested{
+			EntryMap: map[string]*Entry{
+				"foo": {
+					Name:  "bar",
+					Value: 34.34,
+				},
+			},
+		},
+	}
+	var s string
+	err := jsonpointer.Resolve(r, "/nested/entrymap/foo/name", &s)
+	assert.Equal("bar", s)
+	assert.NoError(err)
+}
+
+func TestResolveBadMapKey(t *testing.T) {
+	assert := require.New(t)
+	var s string
+	r := Root{
+		Nested: Nested{
+			EntryMap: map[string]*Entry{},
+		},
+	}
+
+	if err, ok := jsonpointer.AsError(jsonpointer.Resolve(r, "/nested/entrymap/x/name", &s)); ok {
+		t, ok := err.Token()
+		assert.True(ok)
+		assert.Equal("x", t.String())
+	} else {
+		assert.Fail("expected jsonpointer.Error")
+	}
+}
+
+func TestResolveArray(t *testing.T) {
+	assert := require.New(t)
+	r := Root{
+		Nested: Nested{
+			StrArray: [3]string{"foo", "bar", "baz"},
+			IntArray: [3]int{30, 31, 32},
+		},
+	}
+
+	var s string
+	err := jsonpointer.Resolve(r, "/nested/strarray/1", &s)
+	assert.NoError(err)
+	assert.Equal("bar", s)
+
+	var i int
+	err = jsonpointer.Resolve(r, "/nested/intarray/1", &i)
+	assert.ErrorIs(err, jsonpointer.ErrNotAssignable)
+}