jsonpath

Documentation

Overview

package jsonpath is a template engine using jsonpath syntax, which can be seen at http://goessner.net/articles/JsonPath/. In addition, it has {range} {end} function to iterate list and slice.

Index

• Variables
• func UnquoteExtend(s string) (string, error)
• type ArrayNode
  • func (a *ArrayNode) String() string
• type BoolNode
  • func (b *BoolNode) String() string
• type FieldNode
  • func (f *FieldNode) String() string
• type FilterNode
  • func (f *FilterNode) String() string
• type FloatNode
  • func (i *FloatNode) String() string
• type IdentifierNode
  • func (f *IdentifierNode) String() string
• type IntNode
  • func (i *IntNode) String() string
• type JSONPath
  • func New(name string) *JSONPath
  • func (j *JSONPath) AllowMissingKeys(allow bool) *JSONPath
  • func (j *JSONPath) Execute(wr io.Writer, data interface{}) error
  • func (j *JSONPath) FindResults(data interface{}) ([][]Value, error)
  • func (j *JSONPath) Parse(text string) error
  • func (j *JSONPath) PrintResults(wr io.Writer, results []Value) error
• type ListNode
  • func (l *ListNode) String() string
• type Node
• type NodeType
  • func (t NodeType) String() string
  • func (t NodeType) Type() NodeType
• type ParamsEntry
• type Parser
  • func NewParser(name string) *Parser
  • func Parse(name, text string) (*Parser, error)
  • func (p *Parser) Parse(text string) error
• type RecursiveNode
  • func (r *RecursiveNode) String() string
• type TextNode
  • func (t *TextNode) String() string
• type UnionNode
  • func (u *UnionNode) String() string
• type Value
  • func ValueOf(v interface{}) Value
  • func Wrap(v reflect.Value) Value
  • func (v Value) CanSet() bool
  • func (v *Value) Set(newV reflect.Value)
  • func (v *Value) Sibling(name string) (val Value, ok bool)
• type WildcardNode
  • func (i *WildcardNode) String() string

Variables

var (
	ErrSyntax = errors.New("invalid syntax")
)

var NodeTypeName = map[NodeType]string{
	NodeText:       "NodeText",
	NodeArray:      "NodeArray",
	NodeList:       "NodeList",
	NodeField:      "NodeField",
	NodeIdentifier: "NodeIdentifier",
	NodeFilter:     "NodeFilter",
	NodeInt:        "NodeInt",
	NodeFloat:      "NodeFloat",
	NodeWildcard:   "NodeWildcard",
	NodeRecursive:  "NodeRecursive",
	NodeUnion:      "NodeUnion",
	NodeBool:       "NodeBool",
}

Functions

func UnquoteExtend

func UnquoteExtend(s string) (string, error)

UnquoteExtend is almost same as strconv.Unquote(), but it support parse single quotes as a string

Types

type ArrayNode

type ArrayNode struct {
	NodeType
	Params [3]ParamsEntry // start, end, step
}

ArrayNode holds start, end, step information for array index selection

func (*ArrayNode) String

func (a *ArrayNode) String() string

type BoolNode

type BoolNode struct {
	NodeType
	Value bool
}

BoolNode holds bool value

func (*BoolNode) String

func (b *BoolNode) String() string

type FieldNode

type FieldNode struct {
	NodeType
	Value string
}

FieldNode holds field of struct

func (*FieldNode) String

func (f *FieldNode) String() string

type FilterNode

type FilterNode struct {
	NodeType
	Left     *ListNode
	Right    *ListNode
	Operator string
}

FilterNode holds operand and operator information for filter

func (*FilterNode) String

func (f *FilterNode) String() string

type FloatNode

type FloatNode struct {
	NodeType
	Value float64
}

FloatNode holds float value

func (*FloatNode) String

func (i *FloatNode) String() string

type IdentifierNode

type IdentifierNode struct {
	NodeType
	Name string
}

IdentifierNode holds an identifier

func (*IdentifierNode) String

func (f *IdentifierNode) String() string

type IntNode

type IntNode struct {
	NodeType
	Value int
}

IntNode holds integer value

func (*IntNode) String

func (i *IntNode) String() string

type JSONPath

type JSONPath struct {
	// contains filtered or unexported fields
}

func New

func New(name string) *JSONPath

New creates a new JSONPath with the given name.

func (*JSONPath) AllowMissingKeys

func (j *JSONPath) AllowMissingKeys(allow bool) *JSONPath

AllowMissingKeys allows a caller to specify whether they want an error if a field or map key cannot be located, or simply an empty result. The receiver is returned for chaining.

func (*JSONPath) Execute

func (j *JSONPath) Execute(wr io.Writer, data interface{}) error

Execute bounds data into template and writes the result.

func (*JSONPath) FindResults

func (j *JSONPath) FindResults(data interface{}) ([][]Value, error)

func (*JSONPath) Parse

func (j *JSONPath) Parse(text string) error

Parse parses the given template and returns an error.

func (*JSONPath) PrintResults

func (j *JSONPath) PrintResults(wr io.Writer, results []Value) error

PrintResults writes the results into writer

type ListNode

type ListNode struct {
	NodeType
	Nodes []Node // The element nodes in lexical order.
}

ListNode holds a sequence of nodes.

func (*ListNode) String

func (l *ListNode) String() string

type Node

type Node interface {
	Type() NodeType
	String() string
}

type NodeType

type NodeType int

NodeType identifies the type of a parse tree node.

const (
	NodeText NodeType = iota
	NodeArray
	NodeList
	NodeField
	NodeIdentifier
	NodeFilter
	NodeInt
	NodeFloat
	NodeWildcard
	NodeRecursive
	NodeUnion
	NodeBool
)

func (NodeType) String

func (t NodeType) String() string

func (NodeType) Type

func (t NodeType) Type() NodeType

Type returns itself and provides an easy default implementation

type ParamsEntry

type ParamsEntry struct {
	Value   int
	Known   bool // whether the value is known when parse it
	Derived bool
}

ParamsEntry holds param information for ArrayNode

type Parser

type Parser struct {
	Name string
	Root *ListNode
	// contains filtered or unexported fields
}

func NewParser

func NewParser(name string) *Parser

func Parse

func Parse(name, text string) (*Parser, error)

Parse parsed the given text and return a node Parser. If an error is encountered, parsing stops and an empty Parser is returned with the error

func (*Parser) Parse

func (p *Parser) Parse(text string) error

type RecursiveNode

type RecursiveNode struct {
	NodeType
}

RecursiveNode means a recursive descent operator

func (*RecursiveNode) String

func (r *RecursiveNode) String() string

type TextNode

type TextNode struct {
	NodeType
	Text string // The text; may span newlines.
}

TextNode holds plain text.

func (*TextNode) String

func (t *TextNode) String() string

type UnionNode

type UnionNode struct {
	NodeType
	Nodes []*ListNode
}

UnionNode is union of ListNode

func (*UnionNode) String

func (u *UnionNode) String() string

type Value

type Value struct {
	reflect.Value
	// contains filtered or unexported fields
}

A wrapper around reflect.Value that allows callers to call Set() on a Value retrieved from inside a map index.

In the normal reflect package, the value in a map index is not addressable, because the internal map implementation might have to rearrange the map storage.

In this implementation, we keep an extra reference to the map that "owns" the value, so that we can call Set() on it.

func ValueOf

func ValueOf(v interface{}) Value

func Wrap

func Wrap(v reflect.Value) Value

func (Value) CanSet

func (v Value) CanSet() bool

func (*Value) Set

func (v *Value) Set(newV reflect.Value)

func (*Value) Sibling

func (v *Value) Sibling(name string) (val Value, ok bool)

type WildcardNode

type WildcardNode struct {
	NodeType
}

WildcardNode means a wildcard

func (*WildcardNode) String

func (i *WildcardNode) String() string