parse.go

package jsonpath

import (
	"errors"
	"io"
	"reflect"
	"sort"
	"strconv"
	"strings"
)

type Applicator interface {
	Apply(v interface{}) (interface{}, error)
}

type node interface {
	Applicator
	SetNext(v node)
}

var (
	MapTypeError      = errors.New("Expected Type to be a Map.")
	ArrayTypeError    = errors.New("Expected Type to be an Array.")
	SyntaxError       = errors.New("Bad Syntax.")
	NotSupportedError = errors.New("Not Supported")
	NotFound          = errors.New("Not Found")
	IndexOutOfBounds  = errors.New("Out of Bounds")
)

func applyNext(nn node, v interface{}) (interface{}, error) {
	if nn == nil {
		return v, nil
	}
	return nn.Apply(v)
}

// RootNode is always the top node. It does not really do anything other then
// delegate to the next node, and acts as a starting point.
// Every other node type embeds this node To get the NextNode functions.
type RootNode struct {
	// The next Node in the sequence.
	NextNode node
}

// Set the next node.
func (r *RootNode) SetNext(n node) {
	r.NextNode = n
}

// Apply is the main workhourse, each node type will apply it's filtering rules
// to the provided value, returning the filtered result.
// It is expected that the node will call's it's Next Nodes Apply method as
// need by the rules of the Node.
func (r *RootNode) Apply(v interface{}) (interface{}, error) {
	return applyNext(r.NextNode, v)
}

// MapSelection is a the basic filter for a Map type key. It will look at the
// in coming v and try to turn it into a map[string]interface{} value. If it
// successeeds it will then apply the NextNode to that interface value, or it
// will return the value if it has no NextNode.
type MapSelection struct {
	Key string
	RootNode
}

func (m *MapSelection) Apply(v interface{}) (interface{}, error) {
	mv, ok := v.(map[string]interface{})
	if !ok {
		return v, MapTypeError
	}
	nv, ok := mv[m.Key]
	if !ok {
		return nil, NotFound
	}
	return applyNext(m.NextNode, nv)
}

// ArrySelection is a the basic filter for a Array type key. It is like MapSelection but for Arrays.
type ArraySelection struct {
	Key int
	RootNode
}

func (a *ArraySelection) Apply(v interface{}) (interface{}, error) {
	arv, ok := v.([]interface{})
	if !ok {
		return v, ArrayTypeError
	}
	// Check to see if the value is in bounds for the array.
	if a.Key < 0 || a.Key >= len(arv) {
		return nil, IndexOutOfBounds

	}
	return applyNext(a.NextNode, arv[a.Key])
}

// WildCardSelection is a filter that grabs all the values and returns an Array of them
// It applies it's NextNode on each value.
type WildCardSelection struct {
	RootNode
}

func (w *WildCardSelection) Apply(v interface{}) (interface{}, error) {
	switch tv := v.(type) {
	case map[string]interface{}:
		var ret []interface{}
		var keys []string
		for key, _ := range tv {
			keys = append(keys, key)
		}
		sort.Strings(keys)
		for _, key := range keys {
			rval, err := applyNext(w.NextNode, tv[key])
			// Don't add anything that causes an error or returns nil.
			if err == nil || rval != nil {
				ret = append(ret, rval)
			}
		}
		return ret, nil
	case []interface{}:
		var ret []interface{}
		for _, val := range tv {
			rval, err := applyNext(w.NextNode, val)
			// Don't add anything that causes an error or returns nil.
			if err == nil || rval != nil {
				ret = append(ret, rval)
			}
		}
		return ret, nil

	default:
		return applyNext(w.NextNode, v)
	}
}

// DescentSelection is a filter that recursively descends applying it's NextNode and
// corrlating the results.
type DescentSelection struct {
	RootNode
}

func isNil(i interface{}) bool {
	vi := reflect.ValueOf(i)
	if !vi.IsValid() {
		return true
	}
	switch vi.Kind() {
	case reflect.Chan, reflect.Interface, reflect.Func, reflect.Slice, reflect.Map, reflect.Ptr:
		return vi.IsNil()
	default:
		return false
	}
}
func flattenAppend(src []interface{}, values ...interface{}) []interface{} {
	for _, value := range values {
		av, ok := value.([]interface{})
		if ok {
			if len(av) > 0 {
				src = flattenAppend(src, av...)
			}
		} else {
			src = append(src, value)
		}
	}
	return src
}

func (d *DescentSelection) Apply(v interface{}) (interface{}, error) {
	var ret []interface{}
	rval, err := applyNext(d.NextNode, v)

	// Ignore errors here.
	if err == nil && !isNil(rval) {
		ret = flattenAppend(ret, rval)
	}
	switch tv := v.(type) {
	default:
		return ret, nil
	case map[string]interface{}:
		var keys []string
		for key, _ := range tv {
			keys = append(keys, key)
		}
		sort.Strings(keys)
		for _, key := range keys {
			rval, err := d.Apply(tv[key])
			// Don't add anything that causes an error or returns nil.
			if err == nil && !isNil(rval) {
				ret = flattenAppend(ret, rval)
			}
		}
		return ret, nil
	case []interface{}:
		for _, val := range tv {
			rval, err := d.Apply(val)
			// Don't add anything that causes an error or returns nil.
			if err == nil && !isNil(rval) {
				ret = flattenAppend(ret, rval)
			}
		}
		return ret, nil
	}
}

// The first thing we need to do is transform a dot–notation to a bracket–notation.

func minNotNeg1(a int, bs ...int) int {
	m := a
	for _, b := range bs {
		if a == -1 || (b != -1 && b < m) {
			m = b
		}
	}
	return m
}

func normalize(s string) string {
	if s == "" || s == "$." {
		return "$"
	}
	r := "$"
	// first thing to do is read passed the $
	if s[0] == '$' {
		s = s[1:]
	}
	for len(s) > 0 {

		// Grab all the bracketed entries
		for len(s) > 0 && s[0] == '[' {
			n := strings.Index(s, "]")
			r += s[0 : n+1]
			s = s[n+1:]
		}
		if len(s) <= 0 || s == "." {
			break
		}

		if s[0] == '.' {
			if s[1] == '.' {
				r += "[..]"
				s = s[2:]

			} else {
				s = s[1:]
			}
		}
		if len(s) == 0 {
			break
		}
		if s[0] == '*' {
			r += "[*]"
			if len(s) == 1 {
				break
			}
			s = s[1:]
		}

		n := minNotNeg1(strings.Index(s, "["), strings.Index(s, "."))
		if n == 0 {
			continue
		}
		if n != -1 {
			r += `["` + s[:n] + `"]`
			s = s[n:]
		} else {
			r += `["` + s + `"]`
			s = ""
		}
	}
	return r
}

func getNode(s string) (node, string, error) {
	var rs string
	if len(s) == 0 {
		return nil, s, io.EOF
	}
	n := strings.Index(s, "]")
	if n == -1 {
		return nil, s, SyntaxError
	}
	if len(s) > n {
		rs = s[n+1:]
	}
	switch s[:2] {
	case "[\"":
		return &MapSelection{Key: s[2 : n-1]}, rs, nil
	case "[*":
		return &WildCardSelection{}, rs, nil
	case "[.":
		return &DescentSelection{}, rs, nil
	case "[?", "[(":
		return nil, rs, NotSupportedError
	default: // Assume it's a array index otherwise.
		i, err := strconv.Atoi(s[1:n])
		if err != nil {
			return nil, rs, SyntaxError
		}
		return &ArraySelection{Key: i}, rs, nil
	}
}

// Parse parses the JSONPath and returns a object that can be applied to
// a structure to filter it down.
func Parse(s string) (Applicator, error) {
	var nn node
	var err error
	s = normalize(s)
	rt := RootNode{}
	// Remove the starting '$'
	s = s[1:]
	var c node
	c = &rt
	for len(s) > 0 {
		nn, s, err = getNode(s)
		if err != nil {
			return nil, err
		}
		c.SetNext(nn)
		c = nn
	}
	return &rt, nil
}