Merge pull request #10 from magodo/offset

New method `Offset` to `jsonpointer.Pointer` to return the offset

Author: casualjim

pointer.go

@@ -26,6 +26,7 @@
 package jsonpointer
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"reflect"
@@ -40,6 +41,7 @@ const (
 	pointerSeparator = `/`
 
 	invalidStart = `JSON pointer must be empty or start with a "` + pointerSeparator
+	notFound     = `Can't find the pointer in the document`
 )
 
 var jsonPointableType = reflect.TypeOf(new(JSONPointable)).Elem()
@@ -361,6 +363,127 @@ func (p *Pointer) String() string {
 	return pointerString
 }
 
+func (p *Pointer) Offset(document string) (int64, error) {
+	dec := json.NewDecoder(strings.NewReader(document))
+	var offset int64
+	for _, ttk := range p.DecodedTokens() {
+		tk, err := dec.Token()
+		if err != nil {
+			return 0, err
+		}
+		switch tk := tk.(type) {
+		case json.Delim:
+			switch tk {
+			case '{':
+				offset, err = offsetSingleObject(dec, ttk)
+				if err != nil {
+					return 0, err
+				}
+			case '[':
+				offset, err = offsetSingleArray(dec, ttk)
+				if err != nil {
+					return 0, err
+				}
+			default:
+				return 0, fmt.Errorf("invalid token %#v", tk)
+			}
+		default:
+			return 0, fmt.Errorf("invalid token %#v", tk)
+		}
+	}
+	return offset, nil
+}
+
+func offsetSingleObject(dec *json.Decoder, decodedToken string) (int64, error) {
+	for dec.More() {
+		offset := dec.InputOffset()
+		tk, err := dec.Token()
+		if err != nil {
+			return 0, err
+		}
+		switch tk := tk.(type) {
+		case json.Delim:
+			switch tk {
+			case '{':
+				if err := drainSingle(dec); err != nil {
+					return 0, err
+				}
+			case '[':
+				if err := drainSingle(dec); err != nil {
+					return 0, err
+				}
+			}
+		case string:
+			if tk == decodedToken {
+				return offset, nil
+			}
+		default:
+			return 0, fmt.Errorf("invalid token %#v", tk)
+		}
+	}
+	return 0, fmt.Errorf("token reference %q not found", decodedToken)
+}
+
+func offsetSingleArray(dec *json.Decoder, decodedToken string) (int64, error) {
+	idx, err := strconv.Atoi(decodedToken)
+	if err != nil {
+		return 0, fmt.Errorf("token reference %q is not a number: %v", decodedToken, err)
+	}
+	var i int
+	for i = 0; i < idx && dec.More(); i++ {
+		tk, err := dec.Token()
+		if err != nil {
+			return 0, err
+		}
+		switch tk := tk.(type) {
+		case json.Delim:
+			switch tk {
+			case '{':
+				if err := drainSingle(dec); err != nil {
+					return 0, err
+				}
+			case '[':
+				if err := drainSingle(dec); err != nil {
+					return 0, err
+				}
+			}
+		}
+	}
+	if !dec.More() {
+		return 0, fmt.Errorf("token reference %q not found", decodedToken)
+	}
+	return dec.InputOffset(), nil
+}
+
+// drainSingle drains a single level of object or array.
+// The decoder has to guarantee the begining delim (i.e. '{' or '[') has been consumed.
+func drainSingle(dec *json.Decoder) error {
+	for dec.More() {
+		tk, err := dec.Token()
+		if err != nil {
+			return err
+		}
+		switch tk := tk.(type) {
+		case json.Delim:
+			switch tk {
+			case '{':
+				if err := drainSingle(dec); err != nil {
+					return err
+				}
+			case '[':
+				if err := drainSingle(dec); err != nil {
+					return err
+				}
+			}
+		}
+	}
+	// Consumes the ending delim
+	if _, err := dec.Token(); err != nil {
+		return err
+	}
+	return nil
+}
+
 // Specific JSON pointer encoding here
 // ~0 => ~
 // ~1 => /

pointer_test.go

@@ -595,3 +595,65 @@ func TestSetNode(t *testing.T) {
 		}
 	}
 }
+
+func TestOffset(t *testing.T) {
+	cases := []struct {
+		name     string
+		ptr      string
+		input    string
+		offset   int64
+		hasError bool
+	}{
+		{
+			name:   "object key",
+			ptr:    "/foo/bar",
+			input:  `{"foo": {"bar": 21}}`,
+			offset: 9,
+		},
+		{
+			name:   "complex object key",
+			ptr:    "/paths/~1p~1{}/get",
+			input:  `{"paths": {"foo": {"bar": 123, "baz": {}}, "/p/{}": {"get": {}}}}`,
+			offset: 53,
+		},
+		{
+			name:   "array index",
+			ptr:    "/0/1",
+			input:  `[[1,2], [3,4]]`,
+			offset: 3,
+		},
+		{
+			name:   "mix array index and object key",
+			ptr:    "/0/1/foo/0",
+			input:  `[[1, {"foo": ["a", "b"]}], [3, 4]]`,
+			offset: 14,
+		},
+		{
+			name:     "nonexist object key",
+			ptr:      "/foo/baz",
+			input:    `{"foo": {"bar": 21}}`,
+			hasError: true,
+		},
+		{
+			name:     "nonexist array index",
+			ptr:      "/0/2",
+			input:    `[[1,2], [3,4]]`,
+			hasError: true,
+		},
+	}
+
+	for _, tt := range cases {
+		t.Run(tt.name, func(t *testing.T) {
+			ptr, err := New(tt.ptr)
+			assert.NoError(t, err)
+			offset, err := ptr.Offset(tt.input)
+			if tt.hasError {
+				assert.Error(t, err)
+				return
+			}
+			t.Log(offset, err)
+			assert.NoError(t, err)
+			assert.Equal(t, tt.offset, offset)
+		})
+	}
+}