Add relative json pointers.

Author: q-uint

.github/workflows/ci.yml

@@ -0,0 +1,10 @@
+on: [ push ]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-go@v4
+        with:
+          go-version: '1.20'
+      - run: go test -v ./...

README.md

@@ -1,3 +1,4 @@
 # (Relative) JSON Pointers
 
 - [RFC6901 - JSON Pointers](https://datatracker.ietf.org/doc/html/rfc6901)
+- [Relative JSON Pointers](https://www.ietf.org/archive/id/draft-hha-relative-json-pointer-00.html)

abnf/ir/ir.go

@@ -3,6 +3,7 @@ package ir
 import (
 	"fmt"
 	"github.com/0x51-dev/upeg/parser"
+	"strconv"
 	"strings"
 )
 
@@ -24,3 +25,56 @@ func ParseJsonPointer(n *parser.Node) ([]string, error) {
 	}
 	return tokens, nil
 }
+
+type RelativeJsonPointer struct {
+	NonNegativeInteger int
+	IndexManipulation  *int
+	JsonPointer        *[]string
+}
+
+func ParseRelativeJsonPointer(n *parser.Node) (*RelativeJsonPointer, error) {
+	if n.Name != "RelativeJsonPointer" {
+		return nil, fmt.Errorf("expected RelativeJsonPointer, got %s", n.Name)
+	}
+	var ptr RelativeJsonPointer
+	for _, n := range n.Children() {
+		switch n.Name {
+		case "JsonPointer":
+			v, err := ParseJsonPointer(n)
+			if err != nil {
+				return nil, err
+			}
+			ptr.JsonPointer = &v
+		case "OriginSpecification":
+			for _, n := range n.Children() {
+				switch n.Name {
+				case "NonNegativeInteger":
+					v, err := strconv.Atoi(n.Value())
+					if err != nil {
+						return nil, err
+					}
+					ptr.NonNegativeInteger = v
+				case "IndexManipulation":
+					str := n.Value()
+					v, err := strconv.Atoi(str[1:])
+					if err != nil {
+						return nil, err
+					}
+					switch str[0] {
+					case '+':
+					case '-':
+						v = -v
+					default:
+						return nil, fmt.Errorf("expected + or -, got %c", str[0])
+					}
+					ptr.IndexManipulation = &v
+				default:
+					return nil, fmt.Errorf("expected NonNegativeInteger or IndexManipulation, got %s", n.Name)
+				}
+			}
+		default:
+			return nil, fmt.Errorf("expected JsonPointer or OriginSpecification, got %s", n.Name)
+		}
+	}
+	return &ptr, nil
+}

abnf/jsonptr.abnf

@@ -4,7 +4,11 @@ unescaped             = %x00-2E / %x30-7D / %x7F-FFFC / %xFFFE-10FFFF
     ; %x2F ('/') and %x7E ('~') are excluded from 'unescaped'
 escaped               = "~" ( "0" / "1" )
     ; representing '~' and '/', respectively
-relative-json-pointer =  non-negative-integer ([index-manipulation] json-pointer / "#")
-index-manipulation    =  ("+" / "-") non-negative-integer
-non-negative-integer  =  %x30 / %x31-39 *( %x30-39 )
-    ; "0", or digits without a leading "0"
+
+relative-json-pointer = origin-specification ( "#" / json-pointer )
+    ; json-pointer from RFC 6901
+origin-specification  = non-negative-integer [ index-manipulation ]
+index-manipulation    = ( "+" / "-" ) positive-integer
+non-negative-integer  = "0" / positive-integer
+positive-integer      = %x31-39 *%x30-39
+    ; digits without a leading zero

abnf/jsonptr.go

@@ -10,7 +10,9 @@ var (
 	ReferenceToken      = op.Capture{Name: "ReferenceToken", Value: op.ZeroOrMore{Value: op.Or{Unescaped, Escaped}}}
 	Unescaped           = op.Or{op.RuneRange{Min: 0x00, Max: 0x2E}, op.RuneRange{Min: 0x30, Max: 0x7D}, op.RuneRange{Min: 0x7F, Max: 0xFFFC}, op.RuneRange{Min: 0xFFFE, Max: 0x10FFFF}}
 	Escaped             = op.And{'~', op.Or{'0', '1'}}
-	RelativeJsonPointer = op.Capture{Name: "RelativeJsonPointer", Value: op.And{NonNegativeInteger, op.Or{op.And{op.Optional{Value: IndexManipulation}, JsonPointer}, '#'}}}
-	IndexManipulation   = op.Capture{Name: "IndexManipulation", Value: op.And{op.Or{'+', '-'}, NonNegativeInteger}}
-	NonNegativeInteger  = op.Capture{Name: "NonNegativeInteger", Value: op.Or{rune(0x30), op.And{op.RuneRange{Min: 0x31, Max: 0x39}, op.ZeroOrMore{Value: op.RuneRange{Min: 0x30, Max: 0x39}}}}}
+	RelativeJsonPointer = op.Capture{Name: "RelativeJsonPointer", Value: op.And{OriginSpecification, op.Or{'#', JsonPointer}}}
+	OriginSpecification = op.Capture{Name: "OriginSpecification", Value: op.And{NonNegativeInteger, op.Optional{Value: IndexManipulation}}}
+	IndexManipulation   = op.Capture{Name: "IndexManipulation", Value: op.And{op.Or{'+', '-'}, PositiveInteger}}
+	NonNegativeInteger  = op.Capture{Name: "NonNegativeInteger", Value: op.Or{'0', PositiveInteger}}
+	PositiveInteger     = op.And{op.RuneRange{Min: 0x31, Max: 0x39}, op.ZeroOrMore{Value: op.RuneRange{Min: 0x30, Max: 0x39}}}
 )

abnf/jsonptr_test.go

@@ -8,7 +8,7 @@ import (
 	"testing"
 )
 
-func TestRelativeJsonPointer(t *testing.T) {
+func TestJsonPointer(t *testing.T) {
 	for _, test := range []struct {
 		ptr      string
 		expected []string
@@ -47,3 +47,27 @@ func TestRelativeJsonPointer(t *testing.T) {
 		}
 	}
 }
+
+func TestRelativePointer(t *testing.T) {
+	for _, test := range []string{
+		"0",
+		"1/0",
+		"0-1",
+		"2/highly/nested/objects",
+		"0#",
+		"0-1#",
+		"1#",
+	} {
+		p, err := parser.New([]rune(test))
+		if err != nil {
+			t.Fatal(err)
+		}
+		n, err := p.Parse(op.And{abnf.RelativeJsonPointer, op.EOF{}})
+		if err != nil {
+			t.Fatal(test, err)
+		}
+		if _, err := ir.ParseRelativeJsonPointer(n); err != nil {
+			t.Fatal(err)
+		}
+	}
+}

jsonptr.go

@@ -69,3 +69,79 @@ func (ptr JsonPointer) evalMap(document map[string]any) (any, error) {
 	}
 	return ptr[1:].evalAny(v)
 }
+
+type RelativeJsonPointer ir.RelativeJsonPointer
+
+func ParseRelativeJsonPointer(ptr string) (*RelativeJsonPointer, error) {
+	p, err := parser.New([]rune(ptr))
+	if err != nil {
+		return nil, err
+	}
+	n, err := p.Parse(op.And{abnf.RelativeJsonPointer, op.EOF{}})
+	if err != nil {
+		return nil, err
+	}
+	r, err := ir.ParseRelativeJsonPointer(n)
+	if err != nil {
+		return nil, err
+	}
+	return (*RelativeJsonPointer)(r), nil
+}
+
+func (ptr RelativeJsonPointer) Eval(start JsonPointer, document map[string]any) (any, error) {
+	current := start[:]
+
+	// 1. Processing the non-negative-integer prefix.
+	switch ptr.NonNegativeInteger {
+	case 0: // Skip!
+	default:
+		for i := 0; i < ptr.NonNegativeInteger; i++ {
+			if len(current) == 0 {
+				// If the current referenced value is the root of the document, then evaluation fails.
+				return nil, fmt.Errorf("referencing root document")
+			}
+			// If the referenced value is an item within an array/object, then the new referenced value is that array/object.
+			current = current[:len(current)-1]
+		}
+	}
+
+	// 2. Processing the index-manipulation suffix.
+	if ptr.IndexManipulation != nil {
+		v, err := strconv.Atoi(current[len(current)-1])
+		if err != nil {
+			return nil, fmt.Errorf("referencing non-integer key")
+		}
+		v += *ptr.IndexManipulation
+		current[len(current)-1] = strconv.Itoa(v)
+	}
+
+	// 3. Processing the JSON Pointer suffix.
+	if ptr.JsonPointer != nil {
+		current = append(current, *ptr.JsonPointer...)
+	} else {
+		// The remainder of the Relative JSON Pointer is the character '#'.
+		if len(current) == 0 {
+			// If the current referenced value is the root of the document, then evaluation fails.
+			return nil, fmt.Errorf("referencing root document")
+		}
+		p, err := current[:len(current)-1].Eval(document)
+		if err != nil {
+			return nil, err
+		}
+		switch p.(type) {
+		case nil, map[string]any:
+			return current[len(current)-1], nil
+		case []any:
+			v := current[len(current)-1]
+			i, err := strconv.Atoi(v)
+			if err != nil {
+				return nil, fmt.Errorf("referencing non-integer key")
+			}
+			return float64(i), nil
+		default:
+			return nil, fmt.Errorf("referencing non-object, non-array")
+		}
+	}
+
+	return current.Eval(document)
+}

jsonptr_test.go

@@ -47,23 +47,97 @@ func TestJsonPointer_Eval(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		switch v := test.val.(type) {
-		case []any:
-			for i, v := range v {
-				if v != val.([]any)[i] {
-					t.Fatalf("expected %v, got %v", test.val, val)
-				}
+		cmp(t, test.val, val)
+	}
+}
+
+func TestRelativeJsonPointer_Eval(t *testing.T) {
+	documentStr := `{
+		"foo": ["bar", "baz", "biz"],
+		"highly": {
+			"nested": {
+				"objects": true
 			}
-		default:
-			switch v := test.val.(type) {
-			case string:
-				if val != v {
-					t.Fatalf("expected %v, got %v", test.val, val)
+		}
+	}`
+	var document map[string]any
+	if err := json.Unmarshal([]byte(documentStr), &document); err != nil {
+		t.Fatal(err)
+	}
+	for _, test := range []struct {
+		path  string
+		tests []struct {
+			ptr string
+			val any
+		}
+	}{
+		{
+			path: "/foo/1",
+			tests: []struct {
+				ptr string
+				val any
+			}{
+				{"0", "baz"},
+				{"1/0", "bar"},
+				{"0-1", "bar"},
+				{"2/highly/nested/objects", true},
+				{"0#", 1},
+				{"0+1#", 2},
+				{"1#", "foo"},
+			},
+		},
+		{
+			path: "/highly/nested",
+			tests: []struct {
+				ptr string
+				val any
+			}{
+				{"0/objects", true},
+				{"1/nested/objects", true},
+				{"2/foo/0", "bar"},
+				{"0#", "nested"},
+				{"1#", "highly"},
+			},
+		},
+	} {
+		t.Run(test.path, func(t *testing.T) {
+			path := test.path
+			for _, test := range test.tests {
+				start, err := jsonptr.ParseJsonPointer(path)
+				if err != nil {
+					t.Fatal(err)
 				}
-			case int:
-				if val != float64(v) { // JSON numbers are always float64.
-					t.Fatalf("expected %v, got %v", test.val, val)
+				ptr, err := jsonptr.ParseRelativeJsonPointer(test.ptr)
+				if err != nil {
+					t.Fatal(err)
 				}
+				val, err := ptr.Eval(start, document)
+				if err != nil {
+					t.Fatal(err)
+				}
+				cmp(t, test.val, val)
+			}
+		})
+	}
+}
+
+func cmp(t *testing.T, a, b any) {
+	switch a := a.(type) {
+	case []any:
+		for i, a := range a {
+			if a != b.([]any)[i] {
+				t.Fatalf("expected %v, got %v", a, b)
+			}
+		}
+	default:
+		switch a := a.(type) {
+		case string:
+			if b != a {
+				t.Fatalf("expected %v, got %v", a, b)
+			}
+		case int:
+			if b != float64(a) { // JSON numbers are always float64.
+				t.Fatalf("expected %v, got %v", a, b)
 			}
 		}
 	}