jpath/match.go

package jpath

import (
  . "github.com/pelletier/go-toml"
)

type QueryPath []PathFn

type PathFn func(context interface{}, next QueryPath)

func (path QueryPath) Fn(context interface{}) {
  path[0](context, path[1:])
}

func treeValue(tree *TomlTree, key string) interface{} {
  return tree.GetPath([]string{key})
}

func matchKeyFn(name string) PathFn {
  return func(context interface{}, next QueryPath) {
    if tree, ok := context.(*TomlTree); ok {
      item := treeValue(tree, name)
      if item != nil {
        next.Fn(item)
      }
    }
  }
}

func matchIndexFn(idx int) PathFn {
  return func(context interface{}, next QueryPath) {
    if arr, ok := context.([]interface{}); ok {
      if idx < len(arr) && idx >= 0 {
        next.Fn(arr[idx])
      }
    }
  }
}

func matchSliceFn(start, end, step int) PathFn {
  return func(context interface{}, next QueryPath) {
    if arr, ok := context.([]interface{}); ok {
      // adjust indexes for negative values, reverse ordering
      realStart, realEnd := start, 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 += step {
        next.Fn(arr[idx])
      }
    }
  }
}

func matchAnyFn() PathFn {
  return func(context interface{}, next QueryPath) {
    if tree, ok := context.(*TomlTree); ok {
      for _, key := range tree.Keys() {
        item := treeValue(tree, key)
        next.Fn(item)
      }
    }
  }
}

func matchUnionFn(union QueryPath) PathFn {
  return func(context interface{}, next QueryPath) {
    for _, fn := range union {
      fn(context, next)
    }
  }
}

func matchRecurseFn() PathFn {
  return func(context interface{}, next QueryPath) {
    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)
          switch node := item.(type) {
          case *TomlTree:
            visit(node)
          case []*TomlTree:
            for _, subtree := range node {
              visit(subtree)
            }
          }
        }
      }
      visit(tree)
    }
  }
}


func processPath(path QueryPath, context interface{}) []interface{} {
  // terminate the path with a collection funciton
  result := []interface{}{}
  newPath := append(path, func(context interface{}, next QueryPath) {
    result = append(result, context)
  })

  // execute the path
  newPath.Fn(context)
  return result
}