cfc65a13f6
This commit includes updates that affects the build, testing, and
deployment of Tile38.
- The root level build.sh has been broken up into multiple scripts
and placed in the "scripts" directory.
- The vendor directory has been updated to follow the Go modules
rules, thus `make` should work on isolated environments. Also
some vendored packages may have been updated to a later
version, if needed.
- The Makefile has been updated to allow for making single
binaries such as `make tile38-server`. There is some scaffolding
during the build process, so from now on all binaries should be
made using make. For example, to run a development version of
the tile38-cli binary, do this:
make tile38-cli && ./tile38-cli
not this:
go run cmd/tile38-cli/main.go
- Travis.CI docker push script has been updated to address a
change to Docker's JSON repo meta output, which in turn fixes
a bug where new Tile38 versions were not being properly pushed
to Docker
50 lines
1.4 KiB
Go
50 lines
1.4 KiB
Go
package jmespath
|
|
|
|
import "strconv"
|
|
|
|
// JMESPath is the epresentation of a compiled JMES path query. A JMESPath is
|
|
// safe for concurrent use by multiple goroutines.
|
|
type JMESPath struct {
|
|
ast ASTNode
|
|
intr *treeInterpreter
|
|
}
|
|
|
|
// Compile parses a JMESPath expression and returns, if successful, a JMESPath
|
|
// object that can be used to match against data.
|
|
func Compile(expression string) (*JMESPath, error) {
|
|
parser := NewParser()
|
|
ast, err := parser.Parse(expression)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
jmespath := &JMESPath{ast: ast, intr: newInterpreter()}
|
|
return jmespath, nil
|
|
}
|
|
|
|
// MustCompile is like Compile but panics if the expression cannot be parsed.
|
|
// It simplifies safe initialization of global variables holding compiled
|
|
// JMESPaths.
|
|
func MustCompile(expression string) *JMESPath {
|
|
jmespath, err := Compile(expression)
|
|
if err != nil {
|
|
panic(`jmespath: Compile(` + strconv.Quote(expression) + `): ` + err.Error())
|
|
}
|
|
return jmespath
|
|
}
|
|
|
|
// Search evaluates a JMESPath expression against input data and returns the result.
|
|
func (jp *JMESPath) Search(data interface{}) (interface{}, error) {
|
|
return jp.intr.Execute(jp.ast, data)
|
|
}
|
|
|
|
// Search evaluates a JMESPath expression against input data and returns the result.
|
|
func Search(expression string, data interface{}) (interface{}, error) {
|
|
intr := newInterpreter()
|
|
parser := NewParser()
|
|
ast, err := parser.Parse(expression)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return intr.Execute(ast, data)
|
|
}
|