feat: can validate a jsonpointer str + get the corresponding value in a JSON object

Author: BragdonD

pointer.go

@@ -0,0 +1,106 @@
+package jsonpointergo
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+const (
+	JSONPointerEmptyPointer   = ""
+	JSONPointerSeparatorToken = "/"
+	JSONPointerEscapeToken    = "~"
+	JSONPointerSlashEncoded   = "~1"
+	JSONPointerTildaEncoded   = "~0"
+)
+
+type JSONObject = map[string]any
+
+type JSONPointer struct {
+	referenceTokens []string
+}
+
+func NewJSONPointer(jsonPointer string) (*JSONPointer, error) {
+	tokens, err := parseJSONPointerString(jsonPointer)
+	if err != nil {
+		return nil, err
+	}
+	return &JSONPointer{
+		referenceTokens: tokens,
+	}, nil
+}
+
+func parseJSONPointerString(jsonPointer string) ([]string, error) {
+	if jsonPointer == JSONPointerEmptyPointer {
+		return nil, fmt.Errorf(
+			"jsonpointer: the jsonpointer is empty",
+		)
+	}
+	if !strings.HasPrefix(jsonPointer, JSONPointerSeparatorToken) {
+		return nil, fmt.Errorf(
+			"jsonpointer: a jsonpointer should start with a reference to the root value: %v",
+			JSONPointerSeparatorToken,
+		)
+	}
+	tokens := strings.Split(jsonPointer, JSONPointerSeparatorToken)
+	return tokens[1:], nil
+}
+
+func (jp *JSONPointer) GetValue(document JSONObject) (any, error) {
+	if document == nil {
+		return nil, fmt.Errorf(
+			"jsonpointer: the JSON document provided is nil",
+		)
+	}
+	var subDocument any
+	subDocument = document
+	for i, tokenRefEncoded := range jp.referenceTokens {
+		tokenRef := decodeJSONPointerReference(tokenRefEncoded)
+		jsonDoc, ok := subDocument.(JSONObject)
+		if ok {
+			value, ok := jsonDoc[tokenRef]
+			if !ok {
+				return nil, fmt.Errorf(
+					"jsonpointer: the document provided does not have the following reference: %v, %v",
+					tokenRef, i,
+				)
+			}
+			subDocument = value
+			continue
+		}
+		jsonArray, ok := subDocument.([]any)
+		if ok {
+			index, err := strconv.Atoi(tokenRef)
+			if err != nil {
+				return nil, fmt.Errorf(
+					"jsonpointer: the reference is trying to access a field on an array: %v",
+					tokenRef,
+				)
+			}
+			if index < 0 || index >= len(jsonArray) {
+				return nil, fmt.Errorf(
+					"jsonpointer: the index provided [%v] is trying to access an out of bond item on an array of length %v",
+					index,
+					len(jsonArray),
+				)
+			}
+			subDocument = jsonArray[index]
+			continue
+		}
+		return nil, fmt.Errorf("jsonpointer: the reference is trying to access a single value: %v. Type of subdocument: %T", tokenRef, subDocument)
+	}
+	return subDocument, nil
+}
+
+func decodeJSONPointerReference(ref string) string {
+	refWithSlash := strings.ReplaceAll(
+		ref,
+		JSONPointerSlashEncoded,
+		JSONPointerSeparatorToken,
+	)
+	return strings.ReplaceAll(
+		refWithSlash,
+		JSONPointerTildaEncoded,
+		JSONPointerEscapeToken,
+	)
+}

pointer_test.go

@@ -0,0 +1,75 @@
+package jsonpointergo
+
+import (
+	"testing"
+)
+
+func TestNewJSONPointer(t *testing.T) {
+	tests := []struct {
+		jsonPointer string
+		wantErr     bool
+	}{
+		{"/foo/bar", false},
+		{"", true},
+		{"foo/bar", true},
+	}
+
+	for _, test := range tests {
+		_, err := NewJSONPointer(test.jsonPointer)
+		if (err != nil) != test.wantErr {
+			t.Errorf("NewJSONPointer(%v) error = %v, wantErr %v", test.jsonPointer, err, test.wantErr)
+		}
+	}
+}
+
+func TestGetValue(t *testing.T) {
+	document := map[string]any{
+		"foo": map[string]any{
+			"bar": "baz",
+		},
+		"array": []any{1, 2, 3},
+	}
+
+	tests := []struct {
+		jsonPointer string
+		want        any
+		wantErr     bool
+	}{
+		{"/foo/bar", "baz", false},
+		{"/array/0", 1, false},
+		{"/array/3", nil, true},
+		{"/nonexistent", nil, true},
+	}
+
+	for _, test := range tests {
+		jp, err := NewJSONPointer(test.jsonPointer)
+		if err != nil {
+			t.Fatalf("NewJSONPointer(%v) error = %v", test.jsonPointer, err)
+		}
+		got, err := jp.GetValue(document)
+		if (err != nil) != test.wantErr {
+			t.Errorf("JSONPointer.GetValue() error = %v, wantErr %v", err, test.wantErr)
+			continue
+		}
+		if got != test.want {
+			t.Errorf("JSONPointer.GetValue() = %v, want %v", got, test.want)
+		}
+	}
+}
+
+func TestDecodeJSONPointerReference(t *testing.T) {
+	tests := []struct {
+		ref  string
+		want string
+	}{
+		{"~1", "/"},
+		{"~0", "~"},
+		{"~01", "~1"},
+	}
+
+	for _, test := range tests {
+		if got := decodeJSONPointerReference(test.ref); got != test.want {
+			t.Errorf("decodeJSONPointerReference(%v) = %v, want %v", test.ref, got, test.want)
+		}
+	}
+}