Adding ExecutePath utility

Author: yazgazan

jpath/jpath.go

@@ -1,10 +1,23 @@
 package jpath
 
 import (
+	"errors"
 	"fmt"
+	"reflect"
+	"strconv"
 	"strings"
 )
 
+var (
+	ErrInvalidPath      = errors.New("invalid path")
+	ErrNotSlice         = errors.New("not a slice")
+	ErrNotMap           = errors.New("not a map")
+	ErrOutOfBounds      = errors.New("index out of bounds")
+	ErrInvalidInterface = errors.New("cannot get interface of value")
+	ErrNil              = errors.New("cannot get index or key of nil")
+	ErrKeyType          = errors.New("cannot handle this type of key")
+)
+
 // StripIndices removes the characters in between brackets in a json path
 func StripIndices(path string) string {
 	r := make([]byte, 0, len(path))
@@ -61,3 +74,98 @@ func EscapeKey(v interface{}) string {
 	}
 	return fmt.Sprintf("%q", s)
 }
+
+func Split(path string) (head, tail string) {
+	if path == "" {
+		return "", ""
+	}
+
+	if path[0] == '[' {
+		for i := 1; i < len(path); i++ {
+			if path[i] == ']' {
+				return path[0 : i+1], path[i+1 : len(path)]
+			}
+		}
+	}
+	// Skipping first character as we espect the path to start with a dot.
+	for i := 1; i < len(path); i++ {
+		if path[i] == '.' || path[i] == '[' {
+			return path[0:i], path[i:len(path)]
+		}
+	}
+
+	// tail not found, returning the path as head
+	return path, ""
+}
+
+func getKey(s string, kind reflect.Kind) (reflect.Value, error) {
+	switch kind {
+	default:
+		return reflect.Value{}, ErrKeyType
+	case reflect.Int:
+		i, err := strconv.Atoi(s)
+		if err != nil {
+			return reflect.Value{}, err
+		}
+		return reflect.ValueOf(i), nil
+	case reflect.String:
+		return reflect.ValueOf(s), nil
+	}
+}
+
+func ExecutePath(path string, i interface{}) (interface{}, error) {
+	// TODO(yazgazan): better errors
+	head, tail := Split(path)
+	if head == "" {
+		return i, nil
+	}
+
+	v := reflect.ValueOf(i)
+
+	switch head[0] {
+	default:
+		return nil, ErrInvalidPath
+	case '[':
+		if v.Kind() != reflect.Slice {
+			return nil, ErrNotSlice
+		}
+		if v.IsNil() {
+			return nil, ErrNil
+		}
+		if head[len(head)-1] != ']' {
+			return nil, ErrInvalidPath
+		}
+		index, err := strconv.Atoi(head[1 : len(head)-1])
+		if err != nil {
+			return nil, err
+		}
+		if index >= v.Len() {
+			return nil, ErrOutOfBounds
+		}
+		val := v.Index(index)
+		if !val.CanInterface() {
+			return nil, ErrInvalidInterface
+		}
+		return ExecutePath(tail, val.Interface())
+	case '.':
+		if v.Kind() != reflect.Map {
+			return nil, ErrNotMap
+		}
+		keyStr := head[1:len(head)]
+		if keyStr == "" {
+			return nil, ErrInvalidPath
+		}
+		key, err := getKey(keyStr, v.Type().Key().Kind())
+		if err != nil {
+			return nil, err
+		}
+		if v.IsNil() {
+			return nil, ErrNil
+		}
+		val := v.MapIndex(key)
+		if !val.CanInterface() {
+			return nil, ErrInvalidInterface
+		}
+		return ExecutePath(tail, val.Interface())
+	}
+}

jpath/jpath_test.go

@@ -1,6 +1,9 @@
 package jpath
 
-import "testing"
+import (
+	"reflect"
+	"testing"
+)
 
 func TestStripIndices(t *testing.T) {
 	for _, test := range []struct {
@@ -65,3 +68,69 @@ func TestHasSuffix(t *testing.T) {
 		}
 	}
 }
+
+func TestSplit(t *testing.T) {
+	for _, test := range []struct {
+		In   string
+		Head string
+		Tail string
+	}{
+		{"", "", ""},
+		{".", ".", ""},
+		{"foo", "foo", ""},
+		{".foo.", ".foo", "."},
+		{".foo", ".foo", ""},
+		{".foo.bar", ".foo", ".bar"},
+		{".foo[2].bar.fizz", ".foo", "[2].bar.fizz"},
+		{"[2].bar.fizz", "[2]", ".bar.fizz"},
+		{"[2]", "[2]", ""},
+	} {
+		head, tail := Split(test.In)
+		if head != test.Head || tail != test.Tail {
+			t.Errorf("Split(%q) = (%q, %q), expected (%q, %q)", test.In, head, tail, test.Head, test.Tail)
+		}
+	}
+}
+
+func TestExecutePath(t *testing.T) {
+	for _, test := range []struct {
+		I        interface{}
+		Path     string
+		Expected interface{}
+	}{
+		{
+			map[string]int{"foo": 42},
+			".foo",
+			42,
+		},
+		{
+			map[string][]int{
+				"foo": []int{1, 2, 3},
+				"bar": []int{4, 5, 6},
+			},
+			".foo[1]",
+			2,
+		},
+		{
+			map[string][]map[int]string{
+				"foo": []map[int]string{
+					map[int]string{
+						23: "ha",
+						44: "bar",
+					},
+				},
+			},
+			".foo[0].23",
+			"ha",
+		},
+	} {
+		got, err := ExecutePath(test.Path, test.I)
+		if err != nil {
+			t.Errorf("ExecutePath(%q, %+v): unexpected error: %s", test.Path, test.I, err)
+			continue
+		}
+		if !reflect.DeepEqual(got, test.Expected) {
+			t.Errorf("ExecutePath(%q, %+v) = %+v, expected %+v", test.Path, test.I, got, test.Expected)
+		}
+	}
+}