feat(Descendant,WalkJSON): added pointer descendant method, experimental WalkJSON func

Descendant creates subpath pointer from a given pointer.

WalkJSON is a work-in-progress

Author: b5

.circleci/config.yml

@@ -20,7 +20,7 @@ jobs:
             github.com/jstemmer/go-junit-report 
       - run: 
           name: Run Lint Tests
-          command: golint ./...
+          command: golint -set_exit_status ./...
       - run:
           name: Run Tests
           command: go test -v -race -coverprofile=coverage.txt -covermode=atomic

pointer.go

@@ -86,6 +86,24 @@ func (p Pointer) Eval(data interface{}) (result interface{}, err error) {
 	return
 }
 
+// Descendant returns a new pointer to a descendant of the current pointer
+// parsing the input path into components
+func (p Pointer) Descendant(path string) (Pointer, error) {
+	if !strings.HasPrefix(path, "/") {
+		path = "/" + path
+	}
+	dpath, err := parse(path)
+	if err != nil {
+		return p, err
+	}
+
+	if p.String() == "/" {
+		return dpath, nil
+	}
+
+	return append(p, dpath...), nil
+}
+
 // Evaluation of each reference token begins by decoding any escaped
 // character sequence.  This is performed by first transforming any
 // occurrence of the sequence '~1' to '/', and then transforming any

pointer_test.go

@@ -56,7 +56,9 @@ func TestParse(t *testing.T) {
 		parsed string
 		err    string
 	}{
+		{"#/", "/", ""},
 		{"#/foo", "/foo", ""},
+		{"#/foo/", "/foo/", ""},
 
 		{"://", "", "parse ://: missing protocol scheme"},
 		{"#7", "", "non-empty references must begin with a '/' character"},
@@ -148,6 +150,40 @@ func TestEval(t *testing.T) {
 	}
 }
 
+func TestDescendent(t *testing.T) {
+	cases := []struct {
+		parent string
+		path   string
+		parsed string
+		err    string
+	}{
+		{"#/", "0", "/0", ""},
+		{"/0", "0", "/0/0", ""},
+		{"/foo", "0", "/foo/0", ""},
+		{"/foo", "0", "/foo/0", ""},
+		{"/foo/0", "0", "/foo/0/0", ""},
+	}
+
+	for i, c := range cases {
+		p, err := Parse(c.parent)
+		if err != nil {
+			t.Errorf("case %d error parsing parent: %s", i, err.Error())
+			continue
+		}
+
+		desc, err := p.Descendant(c.path)
+		if !(err == nil && c.err == "" || err != nil && err.Error() == c.err) {
+			t.Errorf("case %d error mismatch. expected: %s, got: %s", i, c.err, err)
+			continue
+		}
+
+		if desc.String() != c.parsed {
+			t.Errorf("case %d: expected: %s, got: %s", i, c.parsed, desc.String())
+			continue
+		}
+	}
+}
+
 func BenchmarkEval(b *testing.B) {
 	document := []byte(`{ 
     "foo": {

traversal.go

@@ -0,0 +1,99 @@
+package jsonpointer
+
+import (
+	"reflect"
+)
+
+// JSONContainer returns any existing child value for a given JSON property string
+type JSONContainer interface {
+	// JSONProp takes a string reference for a given JSON property.
+	// implementations must return any matching property of that name,
+	// nil if no such subproperty exists.
+	// Note that implementations on slice-types are expected to convert
+	// prop to an integer value
+	JSONProp(prop string) interface{}
+}
+
+// JSONParent is an interface that enables tree traversal by listing
+// all immediate children of an object
+type JSONParent interface {
+	// JSONChildren should return all immidiate children of this element
+	// with json property names as keys, go types as values
+	// Note that implementations on slice-types are expected to convert
+	// integers to string keys
+	JSONProps() map[string]interface{}
+}
+
+// WalkJSON calls visit on all elements in a tree of decoded json
+func WalkJSON(tree interface{}, visit func(elem interface{}) error) error {
+	if tree == nil {
+		return nil
+	}
+
+	if err := visit(tree); err != nil {
+		return err
+	}
+
+	if con, ok := tree.(JSONParent); ok {
+		for _, ch := range con.JSONProps() {
+			if err := WalkJSON(ch, visit); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+
+	// fast-path for common json types
+	switch t := tree.(type) {
+	case map[string]interface{}:
+		for _, val := range t {
+			if err := WalkJSON(val, visit); err != nil {
+				return err
+			}
+		}
+		return nil
+	case []interface{}:
+		for _, val := range t {
+			if err := WalkJSON(val, visit); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+
+	return walkValue(reflect.ValueOf(tree), visit)
+}
+
+func walkValue(v reflect.Value, visit func(elem interface{}) error) error {
+	switch v.Kind() {
+	case reflect.Invalid:
+		return nil
+	case reflect.Ptr:
+		if !v.IsNil() {
+			walkValue(v.Elem(), visit)
+		}
+	case reflect.Map:
+		for _, key := range v.MapKeys() {
+			mi := v.MapIndex(key)
+			if mi.CanInterface() {
+				WalkJSON(mi.Interface(), visit)
+			}
+		}
+	case reflect.Struct:
+		// t := v.Type()
+		// TypeOf returns the reflection Type that represents the dynamic type of variable.
+		// If variable is a nil interface value, TypeOf returns nil.
+		for i := 0; i < v.NumField(); i++ {
+			f := v.Field(i)
+			// fmt.Printf("%d: %s %s %s = %v\n", i, t.Field(i).Name, f.Type(), t.Field(i).Tag.Get("json"), f.CanInterface())
+			if f.CanInterface() {
+				WalkJSON(f.Interface(), visit)
+			}
+		}
+	case reflect.Slice, reflect.Array:
+		for i := 0; i < v.Len(); i++ {
+			WalkJSON(v.Index(i).Interface(), visit)
+		}
+	}
+	return nil
+}

traversal_test.go

@@ -0,0 +1,65 @@
+package jsonpointer
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+type A struct {
+	Foo  string `json:"$foo,omitempty"`
+	Foo2 bool   `json:"$foo2"`
+	Bar  B
+}
+
+type B struct {
+	nope string
+	Baz  int
+	C    C
+	D    D
+}
+
+type C struct {
+	Nope string
+}
+
+func (c C) JSONProps() map[string]interface{} {
+	return map[string]interface{}{
+		"bat":   "book",
+		"stuff": false,
+		"other": nil,
+	}
+}
+
+type D []string
+
+var data = []byte(`{
+  "$foo" : "fooval",
+  "$foo2" : true,
+  "bar" : {
+    "baz" : 1,
+    "C" : {
+      "won't" : "register"
+    }
+  }
+}`)
+
+func TestWalkJSON(t *testing.T) {
+	a := &A{}
+	if err := json.Unmarshal(data, a); err != nil {
+		t.Errorf("unexpected unmarshal error: %s", err.Error())
+		return
+	}
+
+	elements := 0
+	expectElements := 9
+	WalkJSON(a, func(elem interface{}) error {
+		t.Logf("%#v", elem)
+		elements++
+		return nil
+	})
+
+	if elements != expectElements {
+		t.Errorf("expected %d elements, got: %d", expectElements, elements)
+	}
+
+}