comments

Author: chanced

delete.go

@@ -15,6 +15,8 @@ package jsonpointer
 
 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
 }

errors.go

@@ -165,6 +165,9 @@ func IsKeyError(err error) bool {
 	return ok
 }
 
+// AsKeyError returns err as a ValueError, if possible. It does so by calling
+// errors.As, returning a KeyError and true if successful. If unsuccessful, nil
+// and false is returned.
 func AsKeyError(err error) (KeyError, bool) {
 	var e KeyError
 	return e, errors.As(err, &e)
@@ -243,6 +246,7 @@ func IsValueError(err error) bool {
 	return ok
 }
 
+// AsValueError returns err as a ValueError, if possible.
 func AsValueError(err error) (ValueError, bool) {
 	var e ValueError
 	return e, errors.As(err, &e)
@@ -317,9 +321,9 @@ func (e *indexError) Error() string {
 	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
+// AsIndexError returns err as a IndexError, if possible. It does so by calling
+// errors.As, returning a IndexError and true if successful. If unsuccessful, nil
+// and false is returned.
 func AsIndexError(err error) (IndexError, bool) {
 	var ie IndexError
 	return ie, errors.As(err, &ie)

resolve.go

@@ -18,10 +18,15 @@ import (
 	"reflect"
 )
 
+// 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)
 }
 
+// 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 {
 	dv := reflect.ValueOf(dst)
 	s := newState(ptr, Resolving)

token.go

@@ -18,32 +18,48 @@ import (
 	"strconv"
 )
 
+// Decode decodes a JSON Pointer token by replacing each encoded slash ("~1")
+// with '/' (%x2F) and each encoded tilde ("~0") with '~' (%x7E).
 func Decode(token string) string {
 	return decoder.Replace(token)
 }
 
+// Encode encodes a string to a token of a JSON Pointer by replacing each '~'
+// (%x7E) with "~0" and '/' (%x2F) with "~1".
 func Encode(token string) string {
 	return encoder.Replace(token)
 }
 
+// Token is a segment of a JSON Pointer, divided by '/' (%x2F).
 type Token string
 
+// Bytes returns the decoded Bytes of t
 func (t Token) Bytes() []byte {
-	return []byte(t)
+	return []byte(t.String())
 }
 
+// String returns the decoded value of t
 func (t Token) String() string {
 	return decoder.Replace(string(t))
 }
 
+// Int64 attempts to parse t as an int64. If t can be parsed as an int64 then
+// the value is returned. If t can not be parsed as an int64 then an error is
+// returned.
 func (t Token) Int64() (int64, error) {
 	return strconv.ParseInt(t.String(), 10, 64)
 }
 
+// Uint64 attempts to parse t as an uint64. If t can be parsed as an uint64 then
+// the value is returned. If t can not be parsed as an uint64 then an error is
+// returned.
 func (t Token) Uint64() (uint64, error) {
 	return strconv.ParseUint(t.String(), 10, 64)
 }
 
+// Int attempts to parse t as an int. If t can be parsed as an int then
+// the value is returned. If t can not be parsed as an int then an error is
+// returned.
 func (t Token) Int() (int, error) {
 	return strconv.Atoi(t.String())
 }
@@ -52,27 +68,6 @@ func (t Token) ptr() JSONPointer {
 	return JSONPointer(t)
 }
 
-// Tokens is a slice of Tokens.
-type Tokens []Token
-
-// Strings returns ts as a slice of strings
-func (ts Tokens) Strings() []string {
-	s := make([]string, len(ts))
-	for i, t := range ts {
-		s[i] = t.String()
-	}
-	return s
-}
-
-// Stringers returns ts as a slice of fmt.Stringers
-func (ts Tokens) Stringers() []fmt.Stringer {
-	s := make([]fmt.Stringer, len(ts))
-	for i, t := range ts {
-		s[i] = t
-	}
-	return s
-}
-
 // Index parses t for an index value. If t can be parsed as an int, is equal to
 // or greater than 0 and less than or equal to next then the value is returned.
 // If t is equal to "-" then next is returned. If neither condition is true, -1
@@ -103,3 +98,24 @@ func (t Token) Index(next int) (int, error) {
 	}
 	return i, nil
 }
+
+// Tokens is a slice of Tokens.
+type Tokens []Token
+
+// Strings returns ts as a slice of strings
+func (ts Tokens) Strings() []string {
+	s := make([]string, len(ts))
+	for i, t := range ts {
+		s[i] = t.String()
+	}
+	return s
+}
+
+// Stringers returns ts as a slice of fmt.Stringers
+func (ts Tokens) Stringers() []fmt.Stringer {
+	s := make([]fmt.Stringer, len(ts))
+	for i, t := range ts {
+		s[i] = t
+	}
+	return s
+}