renames JSONPointer to Pointer. Creates type Alias for JSONPointer

Author: chanced

assign.go

@@ -25,7 +25,7 @@ import (
 // resolution is needed, the type should also implement Resolver.
 //
 type Assigner interface {
-	AssignByJSONPointer(ptr *JSONPointer, value interface{}) error
+	AssignByJSONPointer(ptr *Pointer, value interface{}) error
 }
 
 // Assign performs an assignment of value to the target dst specified by the
@@ -38,7 +38,7 @@ type Assigner interface {
 // If a type in the path implements Assigner, AssignByJSONPointer will be called
 // with the updated value pertinent to that path.
 //
-func Assign(dst interface{}, ptr JSONPointer, value interface{}) error {
+func Assign(dst interface{}, ptr Pointer, value interface{}) error {
 	if value == nil {
 		return Delete(dst, ptr)
 	}

assign_test.go

@@ -29,7 +29,7 @@ func TestAssign(t *testing.T) {
 	var r *Root
 
 	tests := []struct {
-		ptr   jsonpointer.JSONPointer
+		ptr   jsonpointer.Pointer
 		value interface{}
 		run   func(v interface{}, err error)
 	}{
@@ -121,7 +121,7 @@ func TestAssignAny(t *testing.T) {
 
 	m := map[string]interface{}{}
 	tests := []struct {
-		ptr   jsonpointer.JSONPointer
+		ptr   jsonpointer.Pointer
 		value interface{}
 		err   error
 		run   func(v interface{})
@@ -183,7 +183,7 @@ func TestAssignJSON(t *testing.T) {
 	_ = assert
 
 	tests := []struct {
-		ptr   jsonpointer.JSONPointer
+		ptr   jsonpointer.Pointer
 		json  string
 		value interface{}
 		run   func(v Root, err error)

delete.go

@@ -18,14 +18,14 @@ import "reflect"
 // Deleter is an interface that is implemented by any type which can delete a
 // value by JSON pointer.
 type Deleter interface {
-	DeleteByJSONPointer(ptr *JSONPointer) error
+	DeleteByJSONPointer(ptr *Pointer) error
 }
 
 // Delete deletes the value at the given JSON pointer from src.
 //
 // If any part of the path is unreachable, the Delete function is
 // considered a success as the value is not present to delete.
-func Delete(src interface{}, ptr JSONPointer) error {
+func Delete(src interface{}, ptr Pointer) error {
 	dv := reflect.ValueOf(src)
 	s := newState(ptr, Deleting)
 	defer s.Release()

delete_test.go

@@ -26,7 +26,7 @@ func TestDelete(t *testing.T) {
 	assert := require.New(t)
 
 	tests := []struct {
-		ptr  jsonpointer.JSONPointer
+		ptr  jsonpointer.Pointer
 		root Root
 		run  func(r Root, err error)
 	}{
@@ -58,7 +58,7 @@ func TestDeleteJSON(t *testing.T) {
 	assert := require.New(t)
 
 	tests := []struct {
-		ptr  jsonpointer.JSONPointer
+		ptr  jsonpointer.Pointer
 		root Root
 		run  func(r Root, err error)
 	}{

errors.go

@@ -85,8 +85,8 @@ var (
 // Error is a base error type returned from Resolve, Assign, and Delete.
 type Error interface {
 	error
-	JSONPointer() JSONPointer
-	CurrentJSONPointer() JSONPointer
+	JSONPointer() Pointer
+	CurrentJSONPointer() Pointer
 	Token() (Token, bool)
 	Operation() Operation
 	Unwrap() error
@@ -135,7 +135,7 @@ func (e *ptrError) updateState(s state) {
 }
 
 // JSONPointer returns the initial JSONPointer.
-func (e *ptrError) JSONPointer() JSONPointer {
+func (e *ptrError) JSONPointer() Pointer {
 	return e.ptr
 }
 

jsonpointer.go

@@ -36,7 +36,7 @@ var (
 
 const (
 	// Root is a top-level JSONPointer, indicated by an empty string.
-	Root JSONPointer = ""
+	Root Pointer = ""
 )
 
 // New encodes and returns the token + tokens into a JSONPointer.
@@ -49,15 +49,15 @@ const (
 //  jsonpointer.New("/") => "/~1"
 //  jsonpointer.New("~") => "/~0"
 //
-func New(tokens ...string) JSONPointer {
+func New(tokens ...string) Pointer {
 	return NewFromStrings(tokens)
 }
 
 // NewFromStrings encodes and returns the tokens into a JSONPointer.
 //
 // Examples:
 //  jsonpointer.NewFromStrings([]string{"foo", "bar", "baz"}) => "/foo/bar/baz"
-func NewFromStrings(tokens []string) JSONPointer {
+func NewFromStrings(tokens []string) Pointer {
 	b := &strings.Builder{}
 	b.Grow(len(tokens))
 	if len(tokens) == 0 {
@@ -70,31 +70,35 @@ func NewFromStrings(tokens []string) JSONPointer {
 			panic(err)
 		}
 	}
-	return JSONPointer(b.String())
+	return Pointer(b.String())
 }
 
-// A JSONPointer is a Unicode string containing a sequence of zero or more
+// Alias for Pointer
+// Deprecated in favor of Pointer
+type JSONPointer = Pointer
+
+// A Pointer is a Unicode string containing a sequence of zero or more
 // reference tokens, each prefixed by a '/' character.
 //
 // See [rfc 6901 for more information](https://datatracker.ietf.org/doc/html/rfc6901).
 //
-type JSONPointer string
+type Pointer string
 
-func (p JSONPointer) String() string {
+func (p Pointer) String() string {
 	return string(p)
 }
 
 // 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 {
+func (p Pointer) Append(token Token) Pointer {
 	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 {
+func (p Pointer) AppendString(token string) Pointer {
 	return p.Append(Token(encoder.Replace(token)))
 }
 
@@ -103,13 +107,13 @@ func (p JSONPointer) AppendString(token string) JSONPointer {
 //
 // Note: token is not encoded. Use p.PrependString to encode and prepend the
 // token.
-func (p JSONPointer) Prepend(token Token) JSONPointer {
+func (p Pointer) Prepend(token Token) Pointer {
 	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 {
+func (p Pointer) PrependString(token string) Pointer {
 	return p.Prepend(Token(encoder.Replace(token)))
 }
 
@@ -121,14 +125,14 @@ func (p JSONPointer) PrependString(token string) JSONPointer {
 // by a '0' or '1'.
 //
 //
-func (p JSONPointer) Validate() (err error) {
+func (p Pointer) Validate() (err error) {
 	if err = p.validateStart(); err != nil {
 		return err
 	}
 	return p.validateeEncoding()
 }
 
-func (p JSONPointer) validateeEncoding() error {
+func (p Pointer) validateeEncoding() error {
 	if len(p) == 0 {
 		return nil
 	}
@@ -143,29 +147,29 @@ func (p JSONPointer) validateeEncoding() error {
 	return nil
 }
 
-func (p JSONPointer) validateStart() error {
+func (p Pointer) validateStart() error {
 	if len(p) > 0 && !startsWithSlash(p) {
 		return ErrMalformedStart
 	}
 	return nil
 }
 
-func (p JSONPointer) Pop() (JSONPointer, Token, bool) {
+func (p Pointer) Pop() (Pointer, Token, bool) {
 	i := lastSlash(p)
 	if i == -1 {
 		return "", "", false
 	}
-	return JSONPointer(p[:i]), Token(p[i+1:]), true
+	return Pointer(p[:i]), Token(p[i+1:]), true
 }
 
-func (p JSONPointer) LastToken() (Token, bool) {
+func (p Pointer) LastToken() (Token, bool) {
 	_, t, e := p.Pop()
 	return t, e
 }
 
 // Next splits the JSONPointer at the first slash and returns the token and the
 // remaining JSONPointer.
-func (p JSONPointer) Next() (JSONPointer, Token, bool) {
+func (p Pointer) Next() (Pointer, Token, bool) {
 	if p == "" {
 		return "", "", false
 	}
@@ -176,27 +180,27 @@ func (p JSONPointer) Next() (JSONPointer, Token, bool) {
 	case 0:
 		return "", Token(p[1:]), true
 	default:
-		return JSONPointer(p[i:]), Token(p[1:i]), true
+		return Pointer(p[i:]), Token(p[1:i]), true
 	}
 }
 
 // NextToken splits the JSONPointer at the first slash and returns the token.
-func (p JSONPointer) NextToken() (Token, bool) {
+func (p Pointer) NextToken() (Token, bool) {
 	_, t, ok := p.Next()
 	return t, ok
 }
 
-func (p JSONPointer) NextPointer() (JSONPointer, bool) {
+func (p Pointer) NextPointer() (Pointer, bool) {
 	v, _, ok := p.Next()
 	return v, ok
 }
 
-func (p JSONPointer) IsRoot() bool {
+func (p Pointer) IsRoot() bool {
 	return p == Root
 }
 
 // Tokens returns the decoded tokens of the JSONPointer.
-func (p JSONPointer) Tokens() []string {
+func (p Pointer) Tokens() []string {
 	if p == "" {
 		return []string{}
 	}
@@ -212,19 +216,19 @@ func (p JSONPointer) Tokens() []string {
 
 // lastSlash(ptr) returns the index of the last slash in the JSONPointer or -1
 // if not present
-func lastSlash(ptr JSONPointer) int {
+func lastSlash(ptr Pointer) int {
 	return strings.LastIndexByte(string(ptr), '/')
 }
 
-func startsWithSlash(ptr JSONPointer) bool {
+func startsWithSlash(ptr Pointer) bool {
 	if len(ptr) == 0 {
 		return false
 	}
 	return ptr[0] == '/'
 }
 
 // nextSlash(ptr) returns the index of the next slash in the JSONPointer.
-func nextSlash(ptr JSONPointer) int {
+func nextSlash(ptr Pointer) int {
 	if !startsWithSlash(ptr) {
 		return -1
 	}

jsonpointer_test.go

@@ -34,7 +34,7 @@ func (str strval) String() string { return string(str) }
 func TestNew(t *testing.T) {
 	assert := require.New(t)
 	tests := []struct {
-		pointer        jsonpointer.JSONPointer
+		pointer        jsonpointer.Pointer
 		expectedstring string
 	}{
 		{jsonpointer.New(""), "/"},
@@ -52,7 +52,7 @@ func TestNew(t *testing.T) {
 func TestJSONPointerValidate(t *testing.T) {
 	assert := require.New(t)
 	tests := []struct {
-		ptr jsonpointer.JSONPointer
+		ptr jsonpointer.Pointer
 		err error
 	}{
 		{"", nil},
@@ -86,8 +86,8 @@ func TestNewFromStrings(t *testing.T) {
 func TestJSONPointerNext(t *testing.T) {
 	assert := require.New(t)
 	tests := []struct {
-		pointer         jsonpointer.JSONPointer
-		expectedpointer jsonpointer.JSONPointer
+		pointer         jsonpointer.Pointer
+		expectedpointer jsonpointer.Pointer
 		expectedtoken   jsonpointer.Token
 		expectedok      bool
 	}{
@@ -110,8 +110,8 @@ func TestJSONPointerNext(t *testing.T) {
 func TestJSONPointerPop(t *testing.T) {
 	assert := require.New(t)
 	pt := []struct {
-		pointer         jsonpointer.JSONPointer
-		expectedpointer jsonpointer.JSONPointer
+		pointer         jsonpointer.Pointer
+		expectedpointer jsonpointer.Pointer
 		expectedtoken   jsonpointer.Token
 		expectedok      bool
 	}{

resolve.go

@@ -21,13 +21,13 @@ import (
 // Resolver is the interface that is implemented by types which can resolve json
 // pointers. The method is expected not to have side effects to the source.
 type Resolver interface {
-	ResolveJSONPointer(ptr *JSONPointer, op Operation) (interface{}, error)
+	ResolveJSONPointer(ptr *Pointer, op Operation) (interface{}, error)
 }
 
 // Resolve performs resolution on src by traversing the path of the JSON Pointer
 // and assigning the value to dst. If the path can not be reached, an error is
 // returned.
-func Resolve(src interface{}, ptr JSONPointer, dst interface{}) error {
+func Resolve(src interface{}, ptr Pointer, dst interface{}) error {
 	dv := reflect.ValueOf(dst)
 	s := newState(ptr, Resolving)
 	defer s.Release()

resolve_test.go

@@ -49,7 +49,7 @@ func TestResolveField(t *testing.T) {
 	}
 
 	tests := []struct {
-		ptr         jsonpointer.JSONPointer
+		ptr         jsonpointer.Pointer
 		expectedval interface{}
 		expectederr error
 	}{
@@ -101,7 +101,7 @@ func TestResolveMapIndex(t *testing.T) {
 	}
 
 	tests := []struct {
-		ptr         jsonpointer.JSONPointer
+		ptr         jsonpointer.Pointer
 		expectedval interface{}
 		expectederr error
 	}{
@@ -151,7 +151,7 @@ func TestResolveArray(t *testing.T) {
 	}
 
 	tests := []struct {
-		ptr         jsonpointer.JSONPointer
+		ptr         jsonpointer.Pointer
 		expectedval interface{}
 		expectederr error
 	}{
@@ -206,7 +206,7 @@ func TestResolveSlice(t *testing.T) {
 	}
 
 	tests := []struct {
-		ptr         jsonpointer.JSONPointer
+		ptr         jsonpointer.Pointer
 		expectedval interface{}
 		expectederr error
 	}{
@@ -236,7 +236,7 @@ func TestResolveJSON(t *testing.T) {
 	assert := require.New(t)
 
 	tests := []struct {
-		ptr  jsonpointer.JSONPointer
+		ptr  jsonpointer.Pointer
 		json string
 		val  interface{}
 		err  error