Final Toml-Path Solution

* Refactored type names and file names to mesh with existing TOML library more closely
* Added QueryResult structure that provides values and position data
* Added Query() method to TomlTree type
* Tests, tests, and more tests
* Fixed bug where positions returned from some tables were invalid
* Added test case for bug patch

The bugfix was an interesting case. Position information wasn't being
set in cases where createPath was called.  So table names like [foo.bar]
would result in table 'foo' having no position.

match.go

@@ -0,0 +1,250 @@
+package toml
+
+import (
+	"fmt"
+)
+
+// support function to set positions for tomlValues
+// NOTE: this is done to allow ctx.lastPosition to indicate the start of any
+// values returned by the query engines
+func tomlValueCheck(node interface{}, ctx *queryContext) interface{} {
+  switch castNode := node.(type) {
+  case *tomlValue:
+    ctx.lastPosition = castNode.position
+    return castNode.value
+  case []*TomlTree:
+    if len(castNode) > 0 {
+      ctx.lastPosition = castNode[0].position
+    }
+    return node
+	default:
+    return node
+  }
+}
+
+// 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(node interface{}, ctx *queryContext) {
+  switch castNode := node.(type) {
+  case *TomlTree:
+	  ctx.result.appendResult(node, castNode.position)
+  case *tomlValue:
+	  ctx.result.appendResult(node, castNode.position)
+  default:
+    // use last position for scalars
+	  ctx.result.appendResult(node, ctx.lastPosition)
+  }
+}
+
+// match single key
+type matchKeyFn struct {
+	matchBase
+	Name string
+}
+
+func newMatchKeyFn(name string) *matchKeyFn {
+	return &matchKeyFn{Name: name}
+}
+
+func (f *matchKeyFn) Call(node interface{}, ctx *queryContext) {
+	if tree, ok := node.(*TomlTree); ok {
+		item := tree.values[f.Name]
+		if item != nil {
+			f.next.Call(item, ctx)
+		}
+	}
+}
+
+// match single index
+type matchIndexFn struct {
+	matchBase
+	Idx int
+}
+
+func newMatchIndexFn(idx int) *matchIndexFn {
+	return &matchIndexFn{Idx: idx}
+}
+
+func (f *matchIndexFn) Call(node interface{}, ctx *queryContext) {
+  if arr, ok := tomlValueCheck(node, ctx).([]interface{}); ok {
+    if f.Idx < len(arr) && f.Idx >= 0 {
+      f.next.Call(arr[f.Idx], ctx)
+    }
+  }
+}
+
+// filter by slicing
+type matchSliceFn struct {
+	matchBase
+	Start, End, Step int
+}
+
+func newMatchSliceFn(start, end, step int) *matchSliceFn {
+	return &matchSliceFn{Start: start, End: end, Step: step}
+}
+
+func (f *matchSliceFn) Call(node interface{}, ctx *queryContext) {
+	if arr, ok := tomlValueCheck(node, ctx).([]interface{}); ok {
+		// adjust indexes for negative values, reverse ordering
+		realStart, realEnd := f.Start, f.End
+		if realStart < 0 {
+			realStart = len(arr) + realStart
+		}
+		if realEnd < 0 {
+			realEnd = len(arr) + realEnd
+		}
+		if realEnd < realStart {
+			realEnd, realStart = realStart, realEnd // swap
+		}
+		// loop and gather
+		for idx := realStart; idx < realEnd; idx += f.Step {
+			f.next.Call(arr[idx], ctx)
+		}
+	}
+}
+
+// match anything
+type matchAnyFn struct {
+	matchBase
+}
+
+func newMatchAnyFn() *matchAnyFn {
+	return &matchAnyFn{}
+}
+
+func (f *matchAnyFn) Call(node interface{}, ctx *queryContext) {
+	if tree, ok := node.(*TomlTree); ok {
+		for _,v := range tree.values {
+			f.next.Call(v, ctx)
+		}
+	}
+}
+
+// filter through union
+type matchUnionFn struct {
+	Union []PathFn
+}
+
+func (f *matchUnionFn) SetNext(next PathFn) {
+	for _, fn := range f.Union {
+		fn.SetNext(next)
+	}
+}
+
+func (f *matchUnionFn) Call(node interface{}, ctx *queryContext) {
+	for _, fn := range f.Union {
+		fn.Call(node, ctx)
+	}
+}
+
+// match every single last node in the tree
+type matchRecursiveFn struct {
+	matchBase
+}
+
+func newMatchRecursiveFn() *matchRecursiveFn {
+	return &matchRecursiveFn{}
+}
+
+func (f *matchRecursiveFn) Call(node interface{}, ctx *queryContext) {
+	if tree, ok := node.(*TomlTree); ok {
+		var visit func(tree *TomlTree)
+		visit = func(tree *TomlTree) {
+			for _, v := range tree.values {
+				f.next.Call(v, ctx)
+				switch node := v.(type) {
+				case *TomlTree:
+					visit(node)
+				case []*TomlTree:
+					for _, subtree := range node {
+						visit(subtree)
+					}
+				}
+			}
+		}
+		visit(tree)
+	}
+}
+
+// match based on an externally provided functional filter
+type matchFilterFn struct {
+	matchBase
+	Pos  Position
+	Name string
+}
+
+func newMatchFilterFn(name string, pos Position) *matchFilterFn {
+	return &matchFilterFn{Name: name, Pos: pos}
+}
+
+func (f *matchFilterFn) Call(node interface{}, ctx *queryContext) {
+	fn, ok := (*ctx.filters)[f.Name]
+	if !ok {
+		panic(fmt.Sprintf("%s: query context does not have filter '%s'",
+			f.Pos, f.Name))
+	}
+	switch castNode := tomlValueCheck(node, ctx).(type) {
+	case *TomlTree:
+		for _, v := range castNode.values {
+			if fn(v) {
+				f.next.Call(v, ctx)
+			}
+		}
+	case []interface{}:
+		for _, v := range castNode {
+			if fn(v) {
+				f.next.Call(v, ctx)
+			}
+		}
+	}
+}
+
+// match based using result of an externally provided functional filter
+type matchScriptFn struct {
+	matchBase
+	Pos  Position
+	Name string
+}
+
+func newMatchScriptFn(name string, pos Position) *matchScriptFn {
+	return &matchScriptFn{Name: name, Pos: pos}
+}
+
+func (f *matchScriptFn) Call(node interface{}, ctx *queryContext) {
+	fn, ok := (*ctx.scripts)[f.Name]
+	if !ok {
+		panic(fmt.Sprintf("%s: query context does not have script '%s'",
+			f.Pos, f.Name))
+	}
+	switch result := fn(tomlValueCheck(node, ctx)).(type) {
+	case string:
+		nextMatch := newMatchKeyFn(result)
+		nextMatch.SetNext(f.next)
+		nextMatch.Call(node, ctx)
+	case int:
+		nextMatch := newMatchIndexFn(result)
+		nextMatch.SetNext(f.next)
+		nextMatch.Call(node, ctx)
+		//TODO: support other return types?
+	}
+}