ostiwe/go-toml
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactored match to use function chaining

Browse Source
This commit is contained in:
eanderton
2014-09-07 16:32:29 -04:00
parent a98788e0d7
commit c81f1892c2
4 changed files with 232 additions and 145 deletions
Download Patch File Download Diff File Expand all files Collapse all files
jpath/match.go
+119 -38
View File
@@ -4,14 +4,84 @@ import (
. "github.com/pelletier/go-toml"
)
type PathFn interface{
Call(context interface{}, next QueryPath)
// result set for storage of results
type pathResult struct {
Values []interface{}
}
type QueryPath []PathFn
func newPathResult() *pathResult {
return &pathResult {
Values: []interface{}{},
}
}
func (path QueryPath) Fn(context interface{}) {
path[0].Call(context, path[1:])
func (r *pathResult) Append(value interface{}) {
r.Values = append(r.Values, value)
}
// generic path functor interface
type PathFn interface{
SetNext(next PathFn)
Call(context interface{}, results *pathResult)
}
// contains a functor chain
type QueryPath struct {
root PathFn
tail PathFn
}
func newQueryPath() *QueryPath {
return &QueryPath {
root: nil,
tail: nil,
}
}
func (path *QueryPath) Append(next PathFn) {
if path.root == nil {
path.root = next
} else {
path.tail.SetNext(next)
}
path.tail = next
next.SetNext(newTerminatingFn()) // init the next functor
}
func (path *QueryPath) Call(context interface{}) []interface{} {
results := newPathResult()
if path.root == nil {
results.Append(context) // identity query for no predicates
} else {
path.root.Call(context, results)
}
return results.Values
}
// base match
type matchBase struct {
next PathFn
}
func (f *matchBase) SetNext(next PathFn) {
f.next = next
}
// terminating functor - gathers results
type terminatingFn struct {
// empty
}
func newTerminatingFn() *terminatingFn {
return &terminatingFn{}
}
func (f *terminatingFn) SetNext(next PathFn) {
// do nothing
}
func (f *terminatingFn) Call(context interface{}, results *pathResult) {
results.Append(context)
}
// shim to ease functor writing
@@ -21,37 +91,52 @@ func treeValue(tree *TomlTree, key string) interface{} {
// match single key
type matchKeyFn struct {
matchBase
Name string
}
func (f *matchKeyFn) Call(context interface{}, next QueryPath) {
func newMatchKeyFn(name string) *matchKeyFn {
return &matchKeyFn{ Name: name }
}
func (f *matchKeyFn) Call(context interface{}, results *pathResult) {
if tree, ok := context.(*TomlTree); ok {
item := treeValue(tree, f.Name)
if item != nil {
next.Fn(item)
f.next.Call(item, results)
}
}
}
// match single index
type matchIndexFn struct {
matchBase
Idx int
}
func (f *matchIndexFn) Call(context interface{}, next QueryPath) {
func newMatchIndexFn(idx int) *matchIndexFn {
return &matchIndexFn{ Idx: idx }
}
func (f *matchIndexFn) Call(context interface{}, results *pathResult) {
if arr, ok := context.([]interface{}); ok {
if f.Idx < len(arr) && f.Idx >= 0 {
next.Fn(arr[f.Idx])
f.next.Call(arr[f.Idx], results)
}
}
}
// filter by slicing
type matchSliceFn struct {
matchBase
Start, End, Step int
}
func (f *matchSliceFn) Call(context interface{}, next QueryPath) {
func newMatchSliceFn(start, end, step int) *matchSliceFn {
return &matchSliceFn{ Start: start, End: end, Step: step }
}
func (f *matchSliceFn) Call(context interface{}, results *pathResult) {
if arr, ok := context.([]interface{}); ok {
// adjust indexes for negative values, reverse ordering
realStart, realEnd := f.Start, f.End
@@ -66,48 +151,63 @@ func (f *matchSliceFn) Call(context interface{}, next QueryPath) {
}
// loop and gather
for idx := realStart; idx < realEnd; idx += f.Step {
next.Fn(arr[idx])
f.next.Call(arr[idx], results)
}
}
}
// match anything
type matchAnyFn struct {
matchBase
// empty
}
func (f *matchAnyFn) Call(context interface{}, next QueryPath) {
func newMatchAnyFn() *matchAnyFn {
return &matchAnyFn{}
}
func (f *matchAnyFn) Call(context interface{}, results *pathResult) {
if tree, ok := context.(*TomlTree); ok {
for _, key := range tree.Keys() {
item := treeValue(tree, key)
next.Fn(item)
f.next.Call(item, results)
}
}
}
// filter through union
type matchUnionFn struct {
Union QueryPath
Union []PathFn
}
func (f *matchUnionFn) Call(context interface{}, next QueryPath) {
func (f *matchUnionFn) SetNext(next PathFn) {
for _, fn := range f.Union {
fn.Call(context, next)
fn.SetNext(next)
}
}
func (f *matchUnionFn) Call(context interface{}, results *pathResult) {
for _, fn := range f.Union {
fn.Call(context, results)
}
}
// match every single last node in the tree
type matchRecursiveFn struct {
// empty
matchBase
}
func (f *matchRecursiveFn) Call(context interface{}, next QueryPath) {
func newMatchRecursiveFn() *matchRecursiveFn{
return &matchRecursiveFn{}
}
func (f *matchRecursiveFn) Call(context interface{}, results *pathResult) {
if tree, ok := context.(*TomlTree); ok {
var visit func(tree *TomlTree)
visit = func(tree *TomlTree) {
for _, key := range tree.Keys() {
item := treeValue(tree, key)
next.Fn(item)
f.next.Call(item, results)
switch node := item.(type) {
case *TomlTree:
visit(node)
@@ -121,22 +221,3 @@ func (f *matchRecursiveFn) Call(context interface{}, next QueryPath) {
visit(tree)
}
}
// terminating expression
type matchEndFn struct {
Result []interface{}
}
func (f *matchEndFn) Call(context interface{}, next QueryPath) {
f.Result = append(f.Result, context)
}
func processPath(path QueryPath, context interface{}) []interface{} {
// terminate the path with a collection funciton
endFn := &matchEndFn{ []interface{}{} }
newPath := append(path, endFn)
// execute the path
newPath.Fn(context)
return endFn.Result
}
jpath/match_test.go
+91 -88
View File
@@ -6,181 +6,184 @@ import (
"testing"
)
func pathString(path QueryPath) string {
result := "["
for _, v := range path {
result += fmt.Sprintf("%T:%v, ", v, v)
// dump path tree to a string
func pathString(root PathFn) string {
result := fmt.Sprintf("%T:")
switch fn := root.(type) {
case *terminatingFn:
result += "{}"
case *matchKeyFn:
result += fmt.Sprintf("{%s}", fn.Name)
result += pathString(fn.next)
case *matchIndexFn:
result += fmt.Sprintf("{%d}", fn.Idx)
result += pathString(fn.next)
case *matchSliceFn:
result += fmt.Sprintf("{%d:%d:%d}",
fn.Start, fn.End, fn.Step)
result += pathString(fn.next)
case *matchAnyFn:
result += "{}"
result += pathString(fn.next)
case *matchUnionFn:
result += "{["
for _, v := range fn.Union {
result += pathString(v)
}
result += "]}"
case *matchRecursiveFn:
result += "{}"
result += pathString(fn.next)
}
return result + "]"
return result
}
func assertPathMatch(t *testing.T, path, ref QueryPath) bool {
if len(path) != len(ref) {
t.Errorf("lengths do not match: %v vs %v",
pathString(path), pathString(ref))
func assertPathMatch(t *testing.T, path, ref *QueryPath) bool {
pathStr := pathString(path.root)
refStr := pathString(ref.root)
if pathStr != refStr {
t.Errorf("paths do not match: %v vs %v")
t.Log("test:", pathStr)
t.Log("ref: ", refStr)
return false
} else {
for i, v := range ref {
pass := false
node := path[i]
// compare by value
switch refNode := v.(type) {
case *matchKeyFn:
castNode, ok := node.(*matchKeyFn)
pass = ok && (*refNode == *castNode)
case *matchIndexFn:
castNode, ok := node.(*matchIndexFn)
pass = ok && (*refNode == *castNode)
case *matchSliceFn:
castNode, ok := node.(*matchSliceFn)
pass = ok && (*refNode == *castNode)
case *matchAnyFn:
castNode, ok := node.(*matchAnyFn)
pass = ok && (*refNode == *castNode)
case *matchUnionFn:
castNode, ok := node.(*matchUnionFn)
// special case - comapre all contents
pass = ok && assertPathMatch(t, castNode.Union, refNode.Union)
case *matchRecursiveFn:
castNode, ok := node.(*matchRecursiveFn)
pass = ok && (*refNode == *castNode)
}
if !pass {
t.Errorf("paths do not match at index %d: %v vs %v",
i, pathString(path), pathString(ref))
return false
}
}
}
return true
}
func assertPath(t *testing.T, query string, ref QueryPath) {
func assertPath(t *testing.T, query string, ref *QueryPath) {
_, flow := lex(query)
path := parse(flow)
assertPathMatch(t, path, ref)
}
func buildPath(parts... PathFn) *QueryPath {
path := newQueryPath()
for _, v := range parts {
path.Append(v)
}
return path
}
func TestPathRoot(t *testing.T) {
assertPath(t,
"$",
QueryPath{
buildPath(
// empty
})
))
}
func TestPathKey(t *testing.T) {
assertPath(t,
"$.foo",
QueryPath{
&matchKeyFn{ "foo" },
})
buildPath(
newMatchKeyFn("foo"),
))
}
func TestPathBracketKey(t *testing.T) {
assertPath(t,
"$[foo]",
QueryPath{
&matchKeyFn{ "foo" },
})
buildPath(
newMatchKeyFn("foo"),
))
}
func TestPathBracketStringKey(t *testing.T) {
assertPath(t,
"$['foo']",
QueryPath{
&matchKeyFn{ "foo" },
})
buildPath(
newMatchKeyFn("foo"),
))
}
func TestPathIndex(t *testing.T) {
assertPath(t,
"$[123]",
QueryPath{
&matchIndexFn{ 123 },
})
buildPath(
newMatchIndexFn(123),
))
}
func TestPathSliceStart(t *testing.T) {
assertPath(t,
"$[123:]",
QueryPath{
&matchSliceFn{ 123, math.MaxInt64, 1 },
})
buildPath(
newMatchSliceFn(123, math.MaxInt64, 1),
))
}
func TestPathSliceStartEnd(t *testing.T) {
assertPath(t,
"$[123:456]",
QueryPath{
&matchSliceFn{ 123, 456, 1 },
})
buildPath(
newMatchSliceFn(123, 456, 1),
))
}
func TestPathSliceStartEndColon(t *testing.T) {
assertPath(t,
"$[123:456:]",
QueryPath{
&matchSliceFn{ 123, 456, 1 },
})
buildPath(
newMatchSliceFn(123, 456, 1),
))
}
func TestPathSliceStartStep(t *testing.T) {
assertPath(t,
"$[123::7]",
QueryPath{
&matchSliceFn{ 123, math.MaxInt64, 7 },
})
buildPath(
newMatchSliceFn(123, math.MaxInt64, 7),
))
}
func TestPathSliceEndStep(t *testing.T) {
assertPath(t,
"$[:456:7]",
QueryPath{
&matchSliceFn{ 0, 456, 7 },
})
buildPath(
newMatchSliceFn(0, 456, 7),
))
}
func TestPathSliceStep(t *testing.T) {
assertPath(t,
"$[::7]",
QueryPath{
&matchSliceFn{ 0, math.MaxInt64, 7 },
})
buildPath(
newMatchSliceFn(0, math.MaxInt64, 7),
))
}
func TestPathSliceAll(t *testing.T) {
assertPath(t,
"$[123:456:7]",
QueryPath{
&matchSliceFn{ 123, 456, 7 },
})
buildPath(
newMatchSliceFn(123, 456, 7),
))
}
func TestPathAny(t *testing.T) {
assertPath(t,
"$.*",
QueryPath{
&matchAnyFn{},
})
buildPath(
newMatchAnyFn(),
))
}
func TestPathUnion(t *testing.T) {
assertPath(t,
"$[foo, bar, baz]",
QueryPath{
buildPath(
&matchUnionFn{ []PathFn {
&matchKeyFn{ "foo" },
&matchKeyFn{ "bar" },
&matchKeyFn{ "baz" },
newMatchKeyFn("foo"),
newMatchKeyFn("bar"),
newMatchKeyFn("baz"),
}},
})
))
}
func TestPathRecurse(t *testing.T) {
assertPath(t,
"$..*",
QueryPath{
&matchRecursiveFn{},
})
buildPath(
newMatchRecursiveFn(),
))
}
jpath/parser.go
+21 -18
View File
@@ -1,3 +1,10 @@
/*
Based on the "jsonpath" spec/concept.
http://goessner.net/articles/JsonPath/
https://code.google.com/p/json-path/
*/
package jpath
import (
@@ -8,7 +15,7 @@ import (
type parser struct {
flow chan token
tokensBuffer []token
path []PathFn
path *QueryPath
union []PathFn
}
@@ -76,10 +83,6 @@ func (p *parser) getToken() *token {
return &tok
}
func (p *parser) appendPath(fn PathFn) {
p.path = append(p.path, fn)
}
func parseStart(p *parser) parserStateFn {
tok := p.getToken()
@@ -99,12 +102,12 @@ func parseMatchExpr(p *parser) parserStateFn {
tok := p.getToken()
switch tok.typ {
case tokenDotDot:
p.appendPath(&matchRecursiveFn{})
p.path.Append(&matchRecursiveFn{})
// nested parse for '..'
tok := p.getToken()
switch tok.typ {
case tokenKey:
p.appendPath(&matchKeyFn{tok.val})
p.path.Append(newMatchKeyFn(tok.val))
return parseMatchExpr
case tokenLBracket:
return parseBracketExpr
@@ -118,10 +121,10 @@ func parseMatchExpr(p *parser) parserStateFn {
tok := p.getToken()
switch tok.typ {
case tokenKey:
p.appendPath(&matchKeyFn{tok.val})
p.path.Append(newMatchKeyFn(tok.val))
return parseMatchExpr
case tokenStar:
p.appendPath(&matchAnyFn{})
p.path.Append(&matchAnyFn{})
return parseMatchExpr
}
@@ -158,11 +161,11 @@ loop: // labeled loop for easy breaking
tok := p.getToken()
switch tok.typ {
case tokenInteger:
p.union = append(p.union, &matchIndexFn{tok.Int()})
p.union = append(p.union, newMatchIndexFn(tok.Int()))
case tokenKey:
p.union = append(p.union, &matchKeyFn{tok.val})
p.union = append(p.union, newMatchKeyFn(tok.val))
case tokenString:
p.union = append(p.union, &matchKeyFn{tok.val})
p.union = append(p.union, newMatchKeyFn(tok.val))
case tokenQuestion:
return parseFilterExpr
case tokenLParen:
@@ -184,9 +187,9 @@ loop: // labeled loop for easy breaking
// if there is only one sub-expression, use that instead
if len(p.union) == 1 {
p.appendPath(p.union[0])
p.path.Append(p.union[0])
}else {
p.appendPath(&matchUnionFn{p.union})
p.path.Append(&matchUnionFn{p.union})
}
p.union = nil // clear out state
@@ -214,7 +217,7 @@ func parseSliceExpr(p *parser) parserStateFn {
tok = p.getToken()
}
if tok.typ == tokenRBracket {
p.appendPath(&matchSliceFn{start, end, step})
p.path.Append(newMatchSliceFn(start, end, step))
return parseMatchExpr
}
if tok.typ != tokenColon {
@@ -234,7 +237,7 @@ func parseSliceExpr(p *parser) parserStateFn {
p.raiseError(tok, "expected ']'")
}
p.appendPath(&matchSliceFn{start, end, step})
p.path.Append(newMatchSliceFn(start, end, step))
return parseMatchExpr
}
@@ -248,11 +251,11 @@ func parseScriptExpr(p *parser) parserStateFn {
return nil
}
func parse(flow chan token) []PathFn {
func parse(flow chan token) *QueryPath {
parser := &parser{
flow: flow,
tokensBuffer: []token{},
path: []PathFn{},
path: newQueryPath(),
}
parser.run()
return parser.path
jpath/parser_test.go
+1 -1
View File
@@ -18,7 +18,7 @@ func assertQuery(t *testing.T, toml, query string, ref []interface{}) {
return
}
path := parse(flow)
result := processPath(path, tree)
result := path.Call(tree)
assertValue(t, result, ref, "((" + query + ")) -> ")
}