2016-08-11 06:07:45 +03:00
|
|
|
// Package gjson provides searching for json strings.
|
|
|
|
package gjson
|
|
|
|
|
2016-08-30 17:21:20 +03:00
|
|
|
import (
|
2016-09-08 18:34:01 +03:00
|
|
|
"reflect"
|
2016-08-30 17:21:20 +03:00
|
|
|
"strconv"
|
2016-09-08 18:08:53 +03:00
|
|
|
"unsafe"
|
2016-08-30 17:21:20 +03:00
|
|
|
|
|
|
|
"github.com/tidwall/match"
|
|
|
|
)
|
2016-08-11 06:07:45 +03:00
|
|
|
|
|
|
|
// Type is Result type
|
2016-08-18 17:18:24 +03:00
|
|
|
type Type int
|
2016-08-11 06:07:45 +03:00
|
|
|
|
|
|
|
const (
|
|
|
|
// Null is a null json value
|
|
|
|
Null Type = iota
|
|
|
|
// False is a json false boolean
|
|
|
|
False
|
|
|
|
// Number is json number
|
|
|
|
Number
|
|
|
|
// String is a json string
|
|
|
|
String
|
|
|
|
// True is a json true boolean
|
|
|
|
True
|
|
|
|
// JSON is a raw block of JSON
|
|
|
|
JSON
|
|
|
|
)
|
|
|
|
|
2016-10-19 03:13:15 +03:00
|
|
|
// String returns a string representation of the type.
|
|
|
|
func (t Type) String() string {
|
|
|
|
switch t {
|
|
|
|
default:
|
|
|
|
return ""
|
|
|
|
case Null:
|
|
|
|
return "Null"
|
|
|
|
case False:
|
|
|
|
return "False"
|
|
|
|
case Number:
|
|
|
|
return "Number"
|
|
|
|
case String:
|
|
|
|
return "String"
|
|
|
|
case True:
|
|
|
|
return "True"
|
|
|
|
case JSON:
|
|
|
|
return "JSON"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-11 06:07:45 +03:00
|
|
|
// Result represents a json value that is returned from Get().
|
|
|
|
type Result struct {
|
|
|
|
// Type is the json type
|
|
|
|
Type Type
|
|
|
|
// Raw is the raw json
|
|
|
|
Raw string
|
|
|
|
// Str is the json string
|
|
|
|
Str string
|
|
|
|
// Num is the json number
|
|
|
|
Num float64
|
2016-10-18 03:39:27 +03:00
|
|
|
// Index of raw value in original json, zero means index unknown
|
|
|
|
Index int
|
2016-08-11 06:07:45 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// String returns a string representation of the value.
|
|
|
|
func (t Result) String() string {
|
|
|
|
switch t.Type {
|
|
|
|
default:
|
|
|
|
return "null"
|
|
|
|
case False:
|
|
|
|
return "false"
|
|
|
|
case Number:
|
|
|
|
return strconv.FormatFloat(t.Num, 'f', -1, 64)
|
|
|
|
case String:
|
|
|
|
return t.Str
|
|
|
|
case JSON:
|
|
|
|
return t.Raw
|
|
|
|
case True:
|
|
|
|
return "true"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-22 16:05:51 +03:00
|
|
|
// Bool returns an boolean representation.
|
|
|
|
func (t Result) Bool() bool {
|
|
|
|
switch t.Type {
|
|
|
|
default:
|
|
|
|
return false
|
|
|
|
case True:
|
|
|
|
return true
|
|
|
|
case String:
|
|
|
|
return t.Str != "" && t.Str != "0"
|
|
|
|
case Number:
|
|
|
|
return t.Num != 0
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Int returns an integer representation.
|
|
|
|
func (t Result) Int() int64 {
|
|
|
|
switch t.Type {
|
|
|
|
default:
|
|
|
|
return 0
|
|
|
|
case True:
|
|
|
|
return 1
|
|
|
|
case String:
|
|
|
|
n, _ := strconv.ParseInt(t.Str, 10, 64)
|
|
|
|
return n
|
|
|
|
case Number:
|
|
|
|
return int64(t.Num)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Float returns an float64 representation.
|
|
|
|
func (t Result) Float() float64 {
|
|
|
|
switch t.Type {
|
|
|
|
default:
|
|
|
|
return 0
|
|
|
|
case True:
|
|
|
|
return 1
|
|
|
|
case String:
|
|
|
|
n, _ := strconv.ParseFloat(t.Str, 64)
|
|
|
|
return n
|
|
|
|
case Number:
|
|
|
|
return t.Num
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Array returns back an array of children. The result must be a JSON array.
|
|
|
|
func (t Result) Array() []Result {
|
|
|
|
if t.Type != JSON {
|
|
|
|
return nil
|
|
|
|
}
|
2016-08-26 06:17:32 +03:00
|
|
|
r := t.arrayOrMap('[', false)
|
|
|
|
return r.a
|
2016-08-22 16:05:51 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Map returns back an map of children. The result should be a JSON array.
|
|
|
|
func (t Result) Map() map[string]Result {
|
|
|
|
if t.Type != JSON {
|
|
|
|
return map[string]Result{}
|
|
|
|
}
|
2016-08-26 06:17:32 +03:00
|
|
|
r := t.arrayOrMap('{', false)
|
|
|
|
return r.o
|
2016-08-22 16:05:51 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Get searches result for the specified path.
|
|
|
|
// The result should be a JSON array or object.
|
|
|
|
func (t Result) Get(path string) Result {
|
|
|
|
return Get(t.Raw, path)
|
|
|
|
}
|
|
|
|
|
2016-08-26 06:17:32 +03:00
|
|
|
type arrayOrMapResult struct {
|
|
|
|
a []Result
|
|
|
|
ai []interface{}
|
|
|
|
o map[string]Result
|
|
|
|
oi map[string]interface{}
|
|
|
|
vc byte
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t Result) arrayOrMap(vc byte, valueize bool) (r arrayOrMapResult) {
|
2016-08-22 16:05:51 +03:00
|
|
|
var json = t.Raw
|
|
|
|
var i int
|
|
|
|
var value Result
|
|
|
|
var count int
|
|
|
|
var key Result
|
|
|
|
if vc == 0 {
|
|
|
|
for ; i < len(json); i++ {
|
|
|
|
if json[i] == '{' || json[i] == '[' {
|
2016-08-26 06:17:32 +03:00
|
|
|
r.vc = json[i]
|
2016-08-22 16:05:51 +03:00
|
|
|
i++
|
|
|
|
break
|
|
|
|
}
|
|
|
|
if json[i] > ' ' {
|
|
|
|
goto end
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for ; i < len(json); i++ {
|
|
|
|
if json[i] == vc {
|
|
|
|
i++
|
|
|
|
break
|
|
|
|
}
|
|
|
|
if json[i] > ' ' {
|
|
|
|
goto end
|
|
|
|
}
|
|
|
|
}
|
2016-08-26 06:17:32 +03:00
|
|
|
r.vc = vc
|
2016-08-22 16:05:51 +03:00
|
|
|
}
|
2016-08-26 06:17:32 +03:00
|
|
|
if r.vc == '{' {
|
2016-08-24 22:12:07 +03:00
|
|
|
if valueize {
|
2016-08-26 06:17:32 +03:00
|
|
|
r.oi = make(map[string]interface{})
|
2016-08-24 22:12:07 +03:00
|
|
|
} else {
|
2016-08-26 06:17:32 +03:00
|
|
|
r.o = make(map[string]Result)
|
2016-08-24 22:12:07 +03:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if valueize {
|
2016-08-26 06:17:32 +03:00
|
|
|
r.ai = make([]interface{}, 0)
|
2016-08-24 22:12:07 +03:00
|
|
|
} else {
|
2016-08-26 06:17:32 +03:00
|
|
|
r.a = make([]Result, 0)
|
2016-08-24 22:12:07 +03:00
|
|
|
}
|
|
|
|
}
|
2016-08-22 16:05:51 +03:00
|
|
|
for ; i < len(json); i++ {
|
|
|
|
if json[i] <= ' ' {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
// get next value
|
|
|
|
if json[i] == ']' || json[i] == '}' {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
switch json[i] {
|
|
|
|
default:
|
|
|
|
if (json[i] >= '0' && json[i] <= '9') || json[i] == '-' {
|
|
|
|
value.Type = Number
|
|
|
|
value.Raw, value.Num = tonum(json[i:])
|
|
|
|
} else {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
case '{', '[':
|
|
|
|
value.Type = JSON
|
|
|
|
value.Raw = squash(json[i:])
|
|
|
|
case 'n':
|
|
|
|
value.Type = Null
|
|
|
|
value.Raw = tolit(json[i:])
|
|
|
|
case 't':
|
|
|
|
value.Type = True
|
|
|
|
value.Raw = tolit(json[i:])
|
|
|
|
case 'f':
|
|
|
|
value.Type = False
|
|
|
|
value.Raw = tolit(json[i:])
|
|
|
|
case '"':
|
|
|
|
value.Type = String
|
|
|
|
value.Raw, value.Str = tostr(json[i:])
|
|
|
|
}
|
|
|
|
i += len(value.Raw) - 1
|
|
|
|
|
2016-08-26 06:17:32 +03:00
|
|
|
if r.vc == '{' {
|
2016-08-22 16:05:51 +03:00
|
|
|
if count%2 == 0 {
|
|
|
|
key = value
|
|
|
|
} else {
|
2016-08-24 22:12:07 +03:00
|
|
|
if valueize {
|
2016-08-26 06:17:32 +03:00
|
|
|
r.oi[key.Str] = value.Value()
|
2016-08-24 22:12:07 +03:00
|
|
|
} else {
|
2016-08-26 06:17:32 +03:00
|
|
|
r.o[key.Str] = value
|
2016-08-24 22:12:07 +03:00
|
|
|
}
|
2016-08-22 16:05:51 +03:00
|
|
|
}
|
|
|
|
count++
|
|
|
|
} else {
|
2016-08-24 22:12:07 +03:00
|
|
|
if valueize {
|
2016-08-26 06:17:32 +03:00
|
|
|
r.ai = append(r.ai, value.Value())
|
2016-08-24 22:12:07 +03:00
|
|
|
} else {
|
2016-08-26 06:17:32 +03:00
|
|
|
r.a = append(r.a, value)
|
2016-08-24 22:12:07 +03:00
|
|
|
}
|
2016-08-22 16:05:51 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
end:
|
2016-08-26 06:17:32 +03:00
|
|
|
return
|
2016-08-22 16:05:51 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Parse parses the json and returns a result
|
|
|
|
func Parse(json string) Result {
|
|
|
|
var value Result
|
|
|
|
for i := 0; i < len(json); i++ {
|
2016-08-24 22:12:07 +03:00
|
|
|
if json[i] == '{' || json[i] == '[' {
|
|
|
|
value.Type = JSON
|
|
|
|
value.Raw = json[i:] // just take the entire raw
|
|
|
|
break
|
|
|
|
}
|
2016-08-22 16:05:51 +03:00
|
|
|
if json[i] <= ' ' {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
switch json[i] {
|
|
|
|
default:
|
|
|
|
if (json[i] >= '0' && json[i] <= '9') || json[i] == '-' {
|
|
|
|
value.Type = Number
|
|
|
|
value.Raw, value.Num = tonum(json[i:])
|
|
|
|
} else {
|
|
|
|
return Result{}
|
|
|
|
}
|
|
|
|
case 'n':
|
|
|
|
value.Type = Null
|
|
|
|
value.Raw = tolit(json[i:])
|
|
|
|
case 't':
|
|
|
|
value.Type = True
|
|
|
|
value.Raw = tolit(json[i:])
|
|
|
|
case 'f':
|
|
|
|
value.Type = False
|
|
|
|
value.Raw = tolit(json[i:])
|
|
|
|
case '"':
|
|
|
|
value.Type = String
|
|
|
|
value.Raw, value.Str = tostr(json[i:])
|
|
|
|
}
|
|
|
|
break
|
|
|
|
}
|
|
|
|
return value
|
|
|
|
}
|
|
|
|
|
|
|
|
func squash(json string) string {
|
|
|
|
// expects that the lead character is a '[' or '{'
|
|
|
|
// squash the value, ignoring all nested arrays and objects.
|
|
|
|
// the first '[' or '{' has already been read
|
|
|
|
depth := 1
|
|
|
|
for i := 1; i < len(json); i++ {
|
|
|
|
if json[i] >= '"' && json[i] <= '}' {
|
|
|
|
switch json[i] {
|
|
|
|
case '"':
|
|
|
|
i++
|
|
|
|
s2 := i
|
|
|
|
for ; i < len(json); i++ {
|
|
|
|
if json[i] > '\\' {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if json[i] == '"' {
|
|
|
|
// look for an escaped slash
|
|
|
|
if json[i-1] == '\\' {
|
|
|
|
n := 0
|
|
|
|
for j := i - 2; j > s2-1; j-- {
|
|
|
|
if json[j] != '\\' {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
n++
|
|
|
|
}
|
|
|
|
if n%2 == 0 {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
case '{', '[':
|
|
|
|
depth++
|
|
|
|
case '}', ']':
|
|
|
|
depth--
|
|
|
|
if depth == 0 {
|
|
|
|
return json[:i+1]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return json
|
|
|
|
}
|
|
|
|
|
|
|
|
func tonum(json string) (raw string, num float64) {
|
|
|
|
for i := 1; i < len(json); i++ {
|
|
|
|
// less than dash might have valid characters
|
|
|
|
if json[i] <= '-' {
|
|
|
|
if json[i] <= ' ' || json[i] == ',' {
|
|
|
|
// break on whitespace and comma
|
|
|
|
raw = json[:i]
|
|
|
|
num, _ = strconv.ParseFloat(raw, 64)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// could be a '+' or '-'. let's assume so.
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if json[i] < ']' {
|
|
|
|
// probably a valid number
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if json[i] == 'e' || json[i] == 'E' {
|
|
|
|
// allow for exponential numbers
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
// likely a ']' or '}'
|
|
|
|
raw = json[:i]
|
|
|
|
num, _ = strconv.ParseFloat(raw, 64)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
raw = json
|
|
|
|
num, _ = strconv.ParseFloat(raw, 64)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
func tolit(json string) (raw string) {
|
|
|
|
for i := 1; i < len(json); i++ {
|
|
|
|
if json[i] <= 'a' || json[i] >= 'z' {
|
|
|
|
return json[:i]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return json
|
|
|
|
}
|
|
|
|
|
|
|
|
func tostr(json string) (raw string, str string) {
|
|
|
|
// expects that the lead character is a '"'
|
|
|
|
for i := 1; i < len(json); i++ {
|
|
|
|
if json[i] > '\\' {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if json[i] == '"' {
|
|
|
|
return json[:i+1], json[1:i]
|
|
|
|
}
|
|
|
|
if json[i] == '\\' {
|
|
|
|
i++
|
|
|
|
for ; i < len(json); i++ {
|
|
|
|
if json[i] > '\\' {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if json[i] == '"' {
|
|
|
|
// look for an escaped slash
|
|
|
|
if json[i-1] == '\\' {
|
|
|
|
n := 0
|
|
|
|
for j := i - 2; j > 0; j-- {
|
|
|
|
if json[j] != '\\' {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
n++
|
|
|
|
}
|
|
|
|
if n%2 == 0 {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
2016-10-19 03:13:15 +03:00
|
|
|
var ret string
|
|
|
|
if i+1 < len(json) {
|
|
|
|
ret = json[:i+1]
|
|
|
|
} else {
|
|
|
|
ret = json[:i]
|
|
|
|
}
|
|
|
|
return ret, unescape(json[1:i])
|
2016-08-22 16:05:51 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return json, json[1:]
|
|
|
|
}
|
|
|
|
|
2016-08-12 18:39:08 +03:00
|
|
|
// Exists returns true if value exists.
|
|
|
|
//
|
|
|
|
// if gjson.Get(json, "name.last").Exists(){
|
|
|
|
// println("value exists")
|
|
|
|
// }
|
|
|
|
func (t Result) Exists() bool {
|
2016-08-12 18:51:56 +03:00
|
|
|
return t.Type != Null || len(t.Raw) != 0
|
2016-08-12 18:39:08 +03:00
|
|
|
}
|
|
|
|
|
2016-08-11 06:07:45 +03:00
|
|
|
// Value returns one of these types:
|
|
|
|
//
|
|
|
|
// bool, for JSON booleans
|
|
|
|
// float64, for JSON numbers
|
|
|
|
// Number, for JSON numbers
|
|
|
|
// string, for JSON string literals
|
|
|
|
// nil, for JSON null
|
|
|
|
//
|
|
|
|
func (t Result) Value() interface{} {
|
2016-08-21 20:10:55 +03:00
|
|
|
if t.Type == String {
|
|
|
|
return t.Str
|
|
|
|
}
|
2016-08-11 06:07:45 +03:00
|
|
|
switch t.Type {
|
|
|
|
default:
|
|
|
|
return nil
|
|
|
|
case False:
|
|
|
|
return false
|
|
|
|
case Number:
|
|
|
|
return t.Num
|
|
|
|
case JSON:
|
2016-08-26 06:17:32 +03:00
|
|
|
r := t.arrayOrMap(0, true)
|
|
|
|
if r.vc == '{' {
|
|
|
|
return r.oi
|
|
|
|
} else if r.vc == '[' {
|
|
|
|
return r.ai
|
2016-08-22 16:05:51 +03:00
|
|
|
}
|
|
|
|
return nil
|
2016-08-11 06:07:45 +03:00
|
|
|
case True:
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-25 19:40:50 +03:00
|
|
|
func parseString(json string, i int) (int, string, bool, bool) {
|
2016-08-25 17:21:53 +03:00
|
|
|
var s = i
|
|
|
|
for ; i < len(json); i++ {
|
|
|
|
if json[i] > '\\' {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if json[i] == '"' {
|
2016-08-25 19:40:50 +03:00
|
|
|
return i + 1, json[s-1 : i+1], false, true
|
2016-08-25 17:21:53 +03:00
|
|
|
}
|
|
|
|
if json[i] == '\\' {
|
|
|
|
i++
|
|
|
|
for ; i < len(json); i++ {
|
|
|
|
if json[i] > '\\' {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if json[i] == '"' {
|
|
|
|
// look for an escaped slash
|
|
|
|
if json[i-1] == '\\' {
|
|
|
|
n := 0
|
|
|
|
for j := i - 2; j > 0; j-- {
|
|
|
|
if json[j] != '\\' {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
n++
|
|
|
|
}
|
|
|
|
if n%2 == 0 {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
2016-08-25 19:40:50 +03:00
|
|
|
return i + 1, json[s-1 : i+1], true, true
|
2016-08-25 17:21:53 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
2016-08-25 19:40:50 +03:00
|
|
|
return i, json[s-1:], false, false
|
2016-08-11 20:39:38 +03:00
|
|
|
}
|
|
|
|
|
2016-08-25 17:21:53 +03:00
|
|
|
func parseNumber(json string, i int) (int, string) {
|
|
|
|
var s = i
|
|
|
|
i++
|
|
|
|
for ; i < len(json); i++ {
|
|
|
|
if json[i] <= ' ' || json[i] == ',' || json[i] == ']' || json[i] == '}' {
|
|
|
|
return i, json[s:i]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return i, json[s:]
|
2016-08-11 20:39:38 +03:00
|
|
|
}
|
|
|
|
|
2016-08-25 17:21:53 +03:00
|
|
|
func parseLiteral(json string, i int) (int, string) {
|
|
|
|
var s = i
|
|
|
|
i++
|
|
|
|
for ; i < len(json); i++ {
|
|
|
|
if json[i] < 'a' || json[i] > 'z' {
|
|
|
|
return i, json[s:i]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return i, json[s:]
|
|
|
|
}
|
2016-08-11 06:07:45 +03:00
|
|
|
|
2016-08-25 20:05:03 +03:00
|
|
|
type arrayPathResult struct {
|
|
|
|
part string
|
|
|
|
path string
|
|
|
|
more bool
|
|
|
|
alogok bool
|
|
|
|
arrch bool
|
|
|
|
alogkey string
|
2016-08-31 23:23:20 +03:00
|
|
|
query struct {
|
|
|
|
on bool
|
|
|
|
path string
|
|
|
|
op string
|
|
|
|
value string
|
|
|
|
}
|
2016-08-25 20:05:03 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func parseArrayPath(path string) (r arrayPathResult) {
|
2016-08-11 20:39:38 +03:00
|
|
|
for i := 0; i < len(path); i++ {
|
2016-08-22 17:39:41 +03:00
|
|
|
if path[i] == '.' {
|
2016-08-25 20:05:03 +03:00
|
|
|
r.part = path[:i]
|
|
|
|
r.path = path[i+1:]
|
|
|
|
r.more = true
|
|
|
|
return
|
2016-08-25 17:21:53 +03:00
|
|
|
}
|
|
|
|
if path[i] == '#' {
|
2016-08-25 20:05:03 +03:00
|
|
|
r.arrch = true
|
2016-08-31 23:23:20 +03:00
|
|
|
if i == 0 && len(path) > 1 {
|
|
|
|
if path[1] == '.' {
|
|
|
|
r.alogok = true
|
|
|
|
r.alogkey = path[2:]
|
|
|
|
r.path = path[:1]
|
|
|
|
} else if path[1] == '[' {
|
|
|
|
r.query.on = true
|
|
|
|
// query
|
|
|
|
i += 2
|
|
|
|
// whitespace
|
|
|
|
for ; i < len(path); i++ {
|
|
|
|
if path[i] > ' ' {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
s := i
|
|
|
|
for ; i < len(path); i++ {
|
|
|
|
if path[i] <= ' ' || path[i] == '=' ||
|
|
|
|
path[i] == '<' || path[i] == '>' ||
|
|
|
|
path[i] == ']' {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
r.query.path = path[s:i]
|
|
|
|
// whitespace
|
|
|
|
for ; i < len(path); i++ {
|
|
|
|
if path[i] > ' ' {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if i < len(path) {
|
|
|
|
s = i
|
|
|
|
if path[i] == '<' || path[i] == '>' {
|
|
|
|
if i < len(path)-1 && path[i+1] == '=' {
|
|
|
|
i++
|
|
|
|
}
|
|
|
|
} else if path[i] == '=' {
|
|
|
|
if i < len(path)-1 && path[i+1] == '=' {
|
|
|
|
s++
|
|
|
|
i++
|
|
|
|
}
|
|
|
|
}
|
|
|
|
i++
|
|
|
|
r.query.op = path[s:i]
|
|
|
|
// whitespace
|
|
|
|
for ; i < len(path); i++ {
|
|
|
|
if path[i] > ' ' {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
s = i
|
|
|
|
for ; i < len(path); i++ {
|
|
|
|
if path[i] == '"' {
|
|
|
|
i++
|
|
|
|
s2 := i
|
|
|
|
for ; i < len(path); i++ {
|
|
|
|
if path[i] > '\\' {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if path[i] == '"' {
|
|
|
|
// look for an escaped slash
|
|
|
|
if path[i-1] == '\\' {
|
|
|
|
n := 0
|
|
|
|
for j := i - 2; j > s2-1; j-- {
|
|
|
|
if path[j] != '\\' {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
n++
|
|
|
|
}
|
|
|
|
if n%2 == 0 {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if path[i] == ']' {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if i > len(path) {
|
|
|
|
i = len(path)
|
|
|
|
}
|
|
|
|
v := path[s:i]
|
|
|
|
for len(v) > 0 && v[len(v)-1] <= ' ' {
|
|
|
|
v = v[:len(v)-1]
|
|
|
|
}
|
|
|
|
r.query.value = v
|
|
|
|
}
|
|
|
|
}
|
2016-08-21 15:35:33 +03:00
|
|
|
}
|
2016-08-22 17:39:41 +03:00
|
|
|
continue
|
|
|
|
}
|
2016-08-25 17:21:53 +03:00
|
|
|
}
|
2016-08-25 20:05:03 +03:00
|
|
|
r.part = path
|
|
|
|
r.path = ""
|
|
|
|
return
|
2016-08-25 17:21:53 +03:00
|
|
|
}
|
|
|
|
|
2016-08-25 20:05:03 +03:00
|
|
|
type objectPathResult struct {
|
|
|
|
part string
|
|
|
|
path string
|
|
|
|
wild bool
|
|
|
|
more bool
|
|
|
|
}
|
|
|
|
|
|
|
|
func parseObjectPath(path string) (r objectPathResult) {
|
2016-08-25 17:21:53 +03:00
|
|
|
for i := 0; i < len(path); i++ {
|
|
|
|
if path[i] == '.' {
|
2016-08-25 20:05:03 +03:00
|
|
|
r.part = path[:i]
|
|
|
|
r.path = path[i+1:]
|
|
|
|
r.more = true
|
|
|
|
return
|
2016-08-25 17:21:53 +03:00
|
|
|
}
|
2016-08-22 17:39:41 +03:00
|
|
|
if path[i] == '*' || path[i] == '?' {
|
2016-08-25 20:05:03 +03:00
|
|
|
r.wild = true
|
2016-08-22 17:39:41 +03:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
if path[i] == '\\' {
|
2016-08-21 15:35:33 +03:00
|
|
|
// go into escape mode. this is a slower path that
|
|
|
|
// strips off the escape character from the part.
|
2016-08-25 17:21:53 +03:00
|
|
|
epart := []byte(path[:i])
|
2016-08-21 15:35:33 +03:00
|
|
|
i++
|
|
|
|
if i < len(path) {
|
|
|
|
epart = append(epart, path[i])
|
2016-08-12 04:51:29 +03:00
|
|
|
i++
|
2016-08-21 15:35:33 +03:00
|
|
|
for ; i < len(path); i++ {
|
|
|
|
if path[i] == '\\' {
|
|
|
|
i++
|
|
|
|
if i < len(path) {
|
|
|
|
epart = append(epart, path[i])
|
|
|
|
}
|
|
|
|
continue
|
|
|
|
} else if path[i] == '.' {
|
2016-08-25 20:05:03 +03:00
|
|
|
r.part = string(epart)
|
|
|
|
r.path = path[i+1:]
|
|
|
|
r.more = true
|
|
|
|
return
|
2016-08-21 15:35:33 +03:00
|
|
|
} else if path[i] == '*' || path[i] == '?' {
|
2016-08-25 20:05:03 +03:00
|
|
|
r.wild = true
|
2016-08-12 04:51:29 +03:00
|
|
|
}
|
2016-08-21 15:35:33 +03:00
|
|
|
epart = append(epart, path[i])
|
2016-08-12 04:51:29 +03:00
|
|
|
}
|
|
|
|
}
|
2016-08-21 15:35:33 +03:00
|
|
|
// append the last part
|
2016-08-25 20:05:03 +03:00
|
|
|
r.part = string(epart)
|
|
|
|
return
|
2016-08-11 20:39:38 +03:00
|
|
|
}
|
|
|
|
}
|
2016-08-25 20:05:03 +03:00
|
|
|
r.part = path
|
|
|
|
return
|
2016-08-25 17:21:53 +03:00
|
|
|
}
|
2016-08-11 20:39:38 +03:00
|
|
|
|
2016-08-25 19:40:50 +03:00
|
|
|
func parseSquash(json string, i int) (int, string) {
|
2016-08-25 17:21:53 +03:00
|
|
|
// expects that the lead character is a '[' or '{'
|
|
|
|
// squash the value, ignoring all nested arrays and objects.
|
|
|
|
// the first '[' or '{' has already been read
|
|
|
|
s := i
|
|
|
|
i++
|
|
|
|
depth := 1
|
2016-08-11 06:07:45 +03:00
|
|
|
for ; i < len(json); i++ {
|
2016-08-25 17:21:53 +03:00
|
|
|
if json[i] >= '"' && json[i] <= '}' {
|
|
|
|
switch json[i] {
|
|
|
|
case '"':
|
2016-08-11 06:07:45 +03:00
|
|
|
i++
|
2016-08-25 17:21:53 +03:00
|
|
|
s2 := i
|
2016-08-11 06:07:45 +03:00
|
|
|
for ; i < len(json); i++ {
|
2016-08-21 17:17:11 +03:00
|
|
|
if json[i] > '\\' {
|
|
|
|
continue
|
|
|
|
}
|
2016-08-11 06:07:45 +03:00
|
|
|
if json[i] == '"' {
|
2016-08-25 17:21:53 +03:00
|
|
|
// look for an escaped slash
|
|
|
|
if json[i-1] == '\\' {
|
|
|
|
n := 0
|
|
|
|
for j := i - 2; j > s2-1; j-- {
|
|
|
|
if json[j] != '\\' {
|
|
|
|
break
|
2016-08-11 06:07:45 +03:00
|
|
|
}
|
2016-08-25 17:21:53 +03:00
|
|
|
n++
|
|
|
|
}
|
|
|
|
if n%2 == 0 {
|
|
|
|
continue
|
2016-08-11 06:07:45 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
2016-08-25 17:21:53 +03:00
|
|
|
case '{', '[':
|
|
|
|
depth++
|
|
|
|
case '}', ']':
|
|
|
|
depth--
|
|
|
|
if depth == 0 {
|
|
|
|
i++
|
|
|
|
return i, json[s:i]
|
|
|
|
}
|
2016-08-11 06:07:45 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-08-25 17:21:53 +03:00
|
|
|
return i, json[s:]
|
|
|
|
}
|
2016-08-11 06:07:45 +03:00
|
|
|
|
2016-08-25 19:40:50 +03:00
|
|
|
func parseObject(c *parseContext, i int, path string) (int, bool) {
|
2016-08-30 17:21:20 +03:00
|
|
|
var pmatch, kesc, vesc, ok, hit bool
|
2016-08-25 17:21:53 +03:00
|
|
|
var key, val string
|
2016-08-25 20:05:03 +03:00
|
|
|
rp := parseObjectPath(path)
|
2016-08-25 19:40:50 +03:00
|
|
|
for i < len(c.json) {
|
|
|
|
for ; i < len(c.json); i++ {
|
|
|
|
if c.json[i] == '"' {
|
|
|
|
// parse_key_string
|
|
|
|
// this is slightly different from getting s string value
|
|
|
|
// because we don't need the outer quotes.
|
|
|
|
i++
|
|
|
|
var s = i
|
|
|
|
for ; i < len(c.json); i++ {
|
|
|
|
if c.json[i] > '\\' {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if c.json[i] == '"' {
|
|
|
|
i, key, kesc, ok = i+1, c.json[s:i], false, true
|
|
|
|
goto parse_key_string_done
|
|
|
|
}
|
|
|
|
if c.json[i] == '\\' {
|
|
|
|
i++
|
|
|
|
for ; i < len(c.json); i++ {
|
|
|
|
if c.json[i] > '\\' {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if c.json[i] == '"' {
|
|
|
|
// look for an escaped slash
|
|
|
|
if c.json[i-1] == '\\' {
|
|
|
|
n := 0
|
|
|
|
for j := i - 2; j > 0; j-- {
|
|
|
|
if c.json[j] != '\\' {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
n++
|
|
|
|
}
|
|
|
|
if n%2 == 0 {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
|
|
|
i, key, kesc, ok = i+1, c.json[s:i], true, true
|
|
|
|
goto parse_key_string_done
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
i, key, kesc, ok = i, c.json[s:], false, false
|
|
|
|
parse_key_string_done:
|
2016-08-25 17:21:53 +03:00
|
|
|
break
|
|
|
|
}
|
2016-08-25 19:40:50 +03:00
|
|
|
if c.json[i] == '}' {
|
2016-08-25 17:21:53 +03:00
|
|
|
return i + 1, false
|
|
|
|
}
|
2016-08-12 04:51:29 +03:00
|
|
|
}
|
2016-08-25 17:21:53 +03:00
|
|
|
if !ok {
|
|
|
|
return i, false
|
|
|
|
}
|
2016-08-25 20:05:03 +03:00
|
|
|
if rp.wild {
|
2016-08-25 17:21:53 +03:00
|
|
|
if kesc {
|
2016-08-30 17:21:20 +03:00
|
|
|
pmatch = match.Match(unescape(key), rp.part)
|
2016-08-25 17:21:53 +03:00
|
|
|
} else {
|
2016-08-30 17:21:20 +03:00
|
|
|
pmatch = match.Match(key, rp.part)
|
2016-08-12 04:51:29 +03:00
|
|
|
}
|
2016-08-25 17:21:53 +03:00
|
|
|
} else {
|
|
|
|
if kesc {
|
2016-08-30 17:21:20 +03:00
|
|
|
pmatch = rp.part == unescape(key)
|
2016-08-25 17:21:53 +03:00
|
|
|
} else {
|
2016-08-30 17:21:20 +03:00
|
|
|
pmatch = rp.part == key
|
2016-08-25 17:21:53 +03:00
|
|
|
}
|
|
|
|
}
|
2016-08-30 17:21:20 +03:00
|
|
|
hit = pmatch && !rp.more
|
2016-08-25 19:40:50 +03:00
|
|
|
for ; i < len(c.json); i++ {
|
|
|
|
switch c.json[i] {
|
2016-08-25 17:21:53 +03:00
|
|
|
default:
|
|
|
|
continue
|
|
|
|
case '"':
|
|
|
|
i++
|
2016-08-25 19:40:50 +03:00
|
|
|
i, val, vesc, ok = parseString(c.json, i)
|
2016-08-25 17:21:53 +03:00
|
|
|
if !ok {
|
|
|
|
return i, false
|
|
|
|
}
|
|
|
|
if hit {
|
|
|
|
if vesc {
|
2016-08-25 19:40:50 +03:00
|
|
|
c.value.Str = unescape(val[1 : len(val)-1])
|
2016-08-25 17:21:53 +03:00
|
|
|
} else {
|
2016-08-25 19:40:50 +03:00
|
|
|
c.value.Str = val[1 : len(val)-1]
|
2016-08-19 23:51:52 +03:00
|
|
|
}
|
2016-08-25 19:40:50 +03:00
|
|
|
c.value.Raw = val
|
|
|
|
c.value.Type = String
|
2016-08-25 17:21:53 +03:00
|
|
|
return i, true
|
2016-08-19 23:51:52 +03:00
|
|
|
}
|
2016-08-25 17:21:53 +03:00
|
|
|
case '{':
|
2016-08-30 17:21:20 +03:00
|
|
|
if pmatch && !hit {
|
2016-08-25 20:05:03 +03:00
|
|
|
i, hit = parseObject(c, i+1, rp.path)
|
2016-08-25 17:21:53 +03:00
|
|
|
if hit {
|
|
|
|
return i, true
|
|
|
|
}
|
|
|
|
} else {
|
2016-08-25 19:40:50 +03:00
|
|
|
i, val = parseSquash(c.json, i)
|
2016-08-25 17:21:53 +03:00
|
|
|
if hit {
|
2016-08-25 19:40:50 +03:00
|
|
|
c.value.Raw = val
|
|
|
|
c.value.Type = JSON
|
2016-08-25 17:21:53 +03:00
|
|
|
return i, true
|
|
|
|
}
|
2016-08-19 23:51:52 +03:00
|
|
|
}
|
2016-08-25 17:21:53 +03:00
|
|
|
case '[':
|
2016-08-30 17:21:20 +03:00
|
|
|
if pmatch && !hit {
|
2016-08-25 20:05:03 +03:00
|
|
|
i, hit = parseArray(c, i+1, rp.path)
|
2016-08-25 17:21:53 +03:00
|
|
|
if hit {
|
|
|
|
return i, true
|
|
|
|
}
|
|
|
|
} else {
|
2016-08-25 19:40:50 +03:00
|
|
|
i, val = parseSquash(c.json, i)
|
2016-08-25 17:21:53 +03:00
|
|
|
if hit {
|
2016-08-25 19:40:50 +03:00
|
|
|
c.value.Raw = val
|
|
|
|
c.value.Type = JSON
|
2016-08-25 17:21:53 +03:00
|
|
|
return i, true
|
|
|
|
}
|
2016-08-11 06:07:45 +03:00
|
|
|
}
|
2016-08-25 17:21:53 +03:00
|
|
|
case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
|
2016-08-25 19:40:50 +03:00
|
|
|
i, val = parseNumber(c.json, i)
|
2016-08-25 17:21:53 +03:00
|
|
|
if hit {
|
2016-08-25 19:40:50 +03:00
|
|
|
c.value.Raw = val
|
|
|
|
c.value.Type = Number
|
|
|
|
c.value.Num, _ = strconv.ParseFloat(val, 64)
|
2016-08-25 17:21:53 +03:00
|
|
|
return i, true
|
|
|
|
}
|
|
|
|
case 't', 'f', 'n':
|
2016-08-25 19:40:50 +03:00
|
|
|
vc := c.json[i]
|
|
|
|
i, val = parseLiteral(c.json, i)
|
2016-08-25 17:21:53 +03:00
|
|
|
if hit {
|
2016-08-25 19:40:50 +03:00
|
|
|
c.value.Raw = val
|
2016-08-25 17:21:53 +03:00
|
|
|
switch vc {
|
|
|
|
case 't':
|
2016-08-25 19:40:50 +03:00
|
|
|
c.value.Type = True
|
2016-08-25 17:21:53 +03:00
|
|
|
case 'f':
|
2016-08-25 19:40:50 +03:00
|
|
|
c.value.Type = False
|
2016-08-25 17:21:53 +03:00
|
|
|
}
|
|
|
|
return i, true
|
2016-08-12 04:51:29 +03:00
|
|
|
}
|
|
|
|
}
|
2016-08-25 17:21:53 +03:00
|
|
|
break
|
|
|
|
}
|
2016-08-11 06:07:45 +03:00
|
|
|
}
|
2016-08-25 17:21:53 +03:00
|
|
|
return i, false
|
|
|
|
}
|
2016-08-31 23:23:20 +03:00
|
|
|
func queryMatches(rp *arrayPathResult, value Result) bool {
|
|
|
|
rpv := rp.query.value
|
|
|
|
if len(rpv) > 2 && rpv[0] == '"' && rpv[len(rpv)-1] == '"' {
|
|
|
|
rpv = rpv[1 : len(rpv)-1]
|
|
|
|
}
|
|
|
|
switch value.Type {
|
|
|
|
case String:
|
|
|
|
switch rp.query.op {
|
|
|
|
case "=":
|
|
|
|
return value.Str == rpv
|
|
|
|
case "<":
|
|
|
|
return value.Str < rpv
|
|
|
|
case "<=":
|
|
|
|
return value.Str <= rpv
|
|
|
|
case ">":
|
|
|
|
return value.Str > rpv
|
|
|
|
case ">=":
|
|
|
|
return value.Str >= rpv
|
|
|
|
}
|
|
|
|
case Number:
|
|
|
|
rpvn, _ := strconv.ParseFloat(rpv, 64)
|
|
|
|
switch rp.query.op {
|
|
|
|
case "=":
|
|
|
|
return value.Num == rpvn
|
|
|
|
case "<":
|
|
|
|
return value.Num < rpvn
|
|
|
|
case "<=":
|
|
|
|
return value.Num <= rpvn
|
|
|
|
case ">":
|
|
|
|
return value.Num > rpvn
|
|
|
|
case ">=":
|
|
|
|
return value.Num >= rpvn
|
|
|
|
}
|
|
|
|
case True:
|
|
|
|
switch rp.query.op {
|
|
|
|
case "=":
|
|
|
|
return rpv == "true"
|
|
|
|
case ">":
|
|
|
|
return rpv == "false"
|
|
|
|
case ">=":
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
case False:
|
|
|
|
switch rp.query.op {
|
|
|
|
case "=":
|
|
|
|
return rpv == "false"
|
|
|
|
case "<":
|
|
|
|
return rpv == "true"
|
|
|
|
case "<=":
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
2016-08-25 19:40:50 +03:00
|
|
|
func parseArray(c *parseContext, i int, path string) (int, bool) {
|
2016-08-30 17:21:20 +03:00
|
|
|
var pmatch, vesc, ok, hit bool
|
2016-08-25 17:21:53 +03:00
|
|
|
var val string
|
|
|
|
var h int
|
|
|
|
var alog []int
|
|
|
|
var partidx int
|
2016-08-25 20:05:03 +03:00
|
|
|
rp := parseArrayPath(path)
|
|
|
|
if !rp.arrch {
|
|
|
|
n, err := strconv.ParseUint(rp.part, 10, 64)
|
2016-08-25 17:21:53 +03:00
|
|
|
if err != nil {
|
|
|
|
partidx = -1
|
|
|
|
} else {
|
|
|
|
partidx = int(n)
|
|
|
|
}
|
|
|
|
}
|
2016-08-25 19:40:50 +03:00
|
|
|
for i < len(c.json) {
|
2016-08-25 20:05:03 +03:00
|
|
|
if !rp.arrch {
|
2016-08-30 17:21:20 +03:00
|
|
|
pmatch = partidx == h
|
|
|
|
hit = pmatch && !rp.more
|
2016-08-25 17:21:53 +03:00
|
|
|
}
|
|
|
|
h++
|
2016-08-25 20:05:03 +03:00
|
|
|
if rp.alogok {
|
2016-08-25 17:21:53 +03:00
|
|
|
alog = append(alog, i)
|
|
|
|
}
|
2016-08-25 19:40:50 +03:00
|
|
|
for ; i < len(c.json); i++ {
|
|
|
|
switch c.json[i] {
|
2016-08-25 17:21:53 +03:00
|
|
|
default:
|
|
|
|
continue
|
|
|
|
case '"':
|
|
|
|
i++
|
2016-08-25 19:40:50 +03:00
|
|
|
i, val, vesc, ok = parseString(c.json, i)
|
2016-08-25 17:21:53 +03:00
|
|
|
if !ok {
|
|
|
|
return i, false
|
|
|
|
}
|
|
|
|
if hit {
|
2016-08-25 20:05:03 +03:00
|
|
|
if rp.alogok {
|
2016-08-25 17:21:53 +03:00
|
|
|
break
|
|
|
|
}
|
|
|
|
if vesc {
|
2016-08-25 19:40:50 +03:00
|
|
|
c.value.Str = unescape(val[1 : len(val)-1])
|
2016-08-25 17:21:53 +03:00
|
|
|
} else {
|
2016-08-25 19:40:50 +03:00
|
|
|
c.value.Str = val[1 : len(val)-1]
|
2016-08-25 17:21:53 +03:00
|
|
|
}
|
2016-08-25 19:40:50 +03:00
|
|
|
c.value.Raw = val
|
|
|
|
c.value.Type = String
|
2016-08-25 17:21:53 +03:00
|
|
|
return i, true
|
|
|
|
}
|
|
|
|
case '{':
|
2016-08-30 17:21:20 +03:00
|
|
|
if pmatch && !hit {
|
2016-08-25 20:05:03 +03:00
|
|
|
i, hit = parseObject(c, i+1, rp.path)
|
2016-08-25 17:21:53 +03:00
|
|
|
if hit {
|
2016-08-25 20:05:03 +03:00
|
|
|
if rp.alogok {
|
2016-08-25 17:21:53 +03:00
|
|
|
break
|
2016-08-21 17:17:11 +03:00
|
|
|
}
|
2016-08-25 17:21:53 +03:00
|
|
|
return i, true
|
|
|
|
}
|
|
|
|
} else {
|
2016-08-25 19:40:50 +03:00
|
|
|
i, val = parseSquash(c.json, i)
|
2016-08-31 23:23:20 +03:00
|
|
|
if rp.query.on {
|
|
|
|
res := Get(val, rp.query.path)
|
|
|
|
if queryMatches(&rp, res) {
|
|
|
|
if rp.more {
|
|
|
|
c.value = Get(val, rp.path)
|
|
|
|
} else {
|
|
|
|
c.value.Raw = val
|
|
|
|
c.value.Type = JSON
|
|
|
|
}
|
|
|
|
return i, true
|
|
|
|
}
|
|
|
|
} else if hit {
|
2016-08-25 20:05:03 +03:00
|
|
|
if rp.alogok {
|
2016-08-12 04:51:29 +03:00
|
|
|
break
|
2016-08-11 06:07:45 +03:00
|
|
|
}
|
2016-08-25 19:40:50 +03:00
|
|
|
c.value.Raw = val
|
|
|
|
c.value.Type = JSON
|
2016-08-25 17:21:53 +03:00
|
|
|
return i, true
|
2016-08-12 04:51:29 +03:00
|
|
|
}
|
2016-08-25 17:21:53 +03:00
|
|
|
}
|
|
|
|
case '[':
|
2016-08-30 17:21:20 +03:00
|
|
|
if pmatch && !hit {
|
2016-08-25 20:05:03 +03:00
|
|
|
i, hit = parseArray(c, i+1, rp.path)
|
2016-08-25 17:21:53 +03:00
|
|
|
if hit {
|
2016-08-25 20:05:03 +03:00
|
|
|
if rp.alogok {
|
2016-08-25 17:21:53 +03:00
|
|
|
break
|
|
|
|
}
|
|
|
|
return i, true
|
|
|
|
}
|
|
|
|
} else {
|
2016-08-25 19:40:50 +03:00
|
|
|
i, val = parseSquash(c.json, i)
|
2016-08-25 17:21:53 +03:00
|
|
|
if hit {
|
2016-08-25 20:05:03 +03:00
|
|
|
if rp.alogok {
|
2016-08-25 17:21:53 +03:00
|
|
|
break
|
|
|
|
}
|
2016-08-25 19:40:50 +03:00
|
|
|
c.value.Raw = val
|
|
|
|
c.value.Type = JSON
|
2016-08-25 17:21:53 +03:00
|
|
|
return i, true
|
2016-08-11 06:07:45 +03:00
|
|
|
}
|
|
|
|
}
|
2016-08-25 17:21:53 +03:00
|
|
|
case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
|
2016-08-25 19:40:50 +03:00
|
|
|
i, val = parseNumber(c.json, i)
|
2016-08-25 17:21:53 +03:00
|
|
|
if hit {
|
2016-08-25 20:05:03 +03:00
|
|
|
if rp.alogok {
|
2016-08-25 17:21:53 +03:00
|
|
|
break
|
2016-08-22 16:05:51 +03:00
|
|
|
}
|
2016-08-25 19:40:50 +03:00
|
|
|
c.value.Raw = val
|
|
|
|
c.value.Type = Number
|
|
|
|
c.value.Num, _ = strconv.ParseFloat(val, 64)
|
2016-08-25 17:21:53 +03:00
|
|
|
return i, true
|
|
|
|
}
|
|
|
|
case 't', 'f', 'n':
|
2016-08-25 19:40:50 +03:00
|
|
|
vc := c.json[i]
|
|
|
|
i, val = parseLiteral(c.json, i)
|
2016-08-25 17:21:53 +03:00
|
|
|
if hit {
|
2016-08-25 20:05:03 +03:00
|
|
|
if rp.alogok {
|
2016-08-11 06:07:45 +03:00
|
|
|
break
|
|
|
|
}
|
2016-08-25 19:40:50 +03:00
|
|
|
c.value.Raw = val
|
2016-08-25 17:21:53 +03:00
|
|
|
switch vc {
|
|
|
|
case 't':
|
2016-08-25 19:40:50 +03:00
|
|
|
c.value.Type = True
|
2016-08-25 17:21:53 +03:00
|
|
|
case 'f':
|
2016-08-25 19:40:50 +03:00
|
|
|
c.value.Type = False
|
2016-08-25 17:21:53 +03:00
|
|
|
}
|
|
|
|
return i, true
|
|
|
|
}
|
|
|
|
case ']':
|
2016-08-25 20:05:03 +03:00
|
|
|
if rp.arrch && rp.part == "#" {
|
|
|
|
if rp.alogok {
|
2016-08-25 17:21:53 +03:00
|
|
|
var jsons = make([]byte, 0, 64)
|
|
|
|
jsons = append(jsons, '[')
|
|
|
|
for j := 0; j < len(alog); j++ {
|
2016-08-25 20:05:03 +03:00
|
|
|
res := Get(c.json[alog[j]:], rp.alogkey)
|
2016-08-25 17:21:53 +03:00
|
|
|
if res.Exists() {
|
|
|
|
if j > 0 {
|
|
|
|
jsons = append(jsons, ',')
|
2016-08-11 06:07:45 +03:00
|
|
|
}
|
2016-08-25 17:21:53 +03:00
|
|
|
jsons = append(jsons, []byte(res.Raw)...)
|
2016-08-11 06:07:45 +03:00
|
|
|
}
|
|
|
|
}
|
2016-08-25 17:21:53 +03:00
|
|
|
jsons = append(jsons, ']')
|
2016-08-25 19:40:50 +03:00
|
|
|
c.value.Type = JSON
|
|
|
|
c.value.Raw = string(jsons)
|
2016-08-25 17:21:53 +03:00
|
|
|
return i + 1, true
|
|
|
|
} else {
|
2016-08-25 20:05:03 +03:00
|
|
|
if rp.alogok {
|
2016-08-11 06:07:45 +03:00
|
|
|
break
|
|
|
|
}
|
2016-08-25 19:40:50 +03:00
|
|
|
c.value.Raw = val
|
|
|
|
c.value.Type = Number
|
|
|
|
c.value.Num = float64(h - 1)
|
2016-08-25 17:21:53 +03:00
|
|
|
return i + 1, true
|
2016-08-11 06:07:45 +03:00
|
|
|
}
|
|
|
|
}
|
2016-08-25 17:21:53 +03:00
|
|
|
return i + 1, false
|
2016-08-11 06:07:45 +03:00
|
|
|
}
|
2016-08-25 17:21:53 +03:00
|
|
|
break
|
2016-08-11 06:07:45 +03:00
|
|
|
}
|
|
|
|
}
|
2016-08-25 17:21:53 +03:00
|
|
|
return i, false
|
|
|
|
}
|
2016-08-11 06:07:45 +03:00
|
|
|
|
2016-09-08 18:08:53 +03:00
|
|
|
type parseContext struct {
|
|
|
|
json string
|
|
|
|
value Result
|
|
|
|
}
|
|
|
|
|
2016-08-25 17:21:53 +03:00
|
|
|
// Get searches json for the specified path.
|
|
|
|
// A path is in dot syntax, such as "name.last" or "age".
|
|
|
|
// This function expects that the json is well-formed, and does not validate.
|
|
|
|
// Invalid json will not panic, but it may return back unexpected results.
|
|
|
|
// When the value is found it's returned immediately.
|
|
|
|
//
|
|
|
|
// A path is a series of keys seperated by a dot.
|
|
|
|
// A key may contain special wildcard characters '*' and '?'.
|
|
|
|
// To access an array value use the index as the key.
|
|
|
|
// To get the number of elements in an array or to access a child path, use the '#' character.
|
|
|
|
// The dot and wildcard character can be escaped with '\'.
|
|
|
|
//
|
|
|
|
// {
|
|
|
|
// "name": {"first": "Tom", "last": "Anderson"},
|
|
|
|
// "age":37,
|
|
|
|
// "children": ["Sara","Alex","Jack"],
|
|
|
|
// "friends": [
|
|
|
|
// {"first": "James", "last": "Murphy"},
|
|
|
|
// {"first": "Roger", "last": "Craig"}
|
|
|
|
// ]
|
|
|
|
// }
|
|
|
|
// "name.last" >> "Anderson"
|
|
|
|
// "age" >> 37
|
|
|
|
// "children.#" >> 3
|
|
|
|
// "children.1" >> "Alex"
|
|
|
|
// "child*.2" >> "Jack"
|
|
|
|
// "c?ildren.0" >> "Sara"
|
|
|
|
// "friends.#.first" >> [ "James", "Roger" ]
|
|
|
|
//
|
|
|
|
func Get(json, path string) Result {
|
|
|
|
var i int
|
2016-08-25 19:40:50 +03:00
|
|
|
var c = &parseContext{json: json}
|
|
|
|
for ; i < len(c.json); i++ {
|
|
|
|
if c.json[i] == '{' {
|
2016-08-11 06:07:45 +03:00
|
|
|
i++
|
2016-08-25 19:40:50 +03:00
|
|
|
parseObject(c, i, path)
|
2016-08-25 17:21:53 +03:00
|
|
|
break
|
|
|
|
}
|
2016-08-25 19:40:50 +03:00
|
|
|
if c.json[i] == '[' {
|
2016-08-25 17:21:53 +03:00
|
|
|
i++
|
2016-08-25 19:40:50 +03:00
|
|
|
parseArray(c, i, path)
|
2016-08-25 17:21:53 +03:00
|
|
|
break
|
2016-08-11 06:07:45 +03:00
|
|
|
}
|
|
|
|
}
|
2016-10-18 03:39:27 +03:00
|
|
|
if len(c.value.Raw) > 0 {
|
|
|
|
jhdr := *(*reflect.StringHeader)(unsafe.Pointer(&json))
|
|
|
|
rhdr := *(*reflect.StringHeader)(unsafe.Pointer(&(c.value.Raw)))
|
|
|
|
c.value.Index = int(rhdr.Data - jhdr.Data)
|
|
|
|
if c.value.Index < 0 || c.value.Index >= len(json) {
|
|
|
|
c.value.Index = 0
|
|
|
|
}
|
|
|
|
}
|
2016-08-25 19:40:50 +03:00
|
|
|
return c.value
|
|
|
|
}
|
|
|
|
|
2016-09-08 18:08:53 +03:00
|
|
|
// GetBytes searches json for the specified path.
|
|
|
|
// If working with bytes, this method preferred over Get(string(data), path)
|
|
|
|
func GetBytes(json []byte, path string) Result {
|
|
|
|
var result Result
|
|
|
|
if json != nil {
|
|
|
|
// unsafe cast to string
|
|
|
|
result = Get(*(*string)(unsafe.Pointer(&json)), path)
|
2016-09-10 01:49:48 +03:00
|
|
|
// safely get the string headers
|
|
|
|
rawhi := *(*reflect.StringHeader)(unsafe.Pointer(&result.Raw))
|
|
|
|
strhi := *(*reflect.StringHeader)(unsafe.Pointer(&result.Str))
|
|
|
|
// create byte slice headers
|
|
|
|
rawh := reflect.SliceHeader{Data: rawhi.Data, Len: rawhi.Len}
|
|
|
|
strh := reflect.SliceHeader{Data: strhi.Data, Len: strhi.Len}
|
2016-09-08 18:34:01 +03:00
|
|
|
if strh.Data == 0 {
|
2016-09-10 01:49:48 +03:00
|
|
|
// str is nil
|
2016-09-08 18:34:01 +03:00
|
|
|
if rawh.Data == 0 {
|
2016-09-10 01:49:48 +03:00
|
|
|
// raw is nil
|
2016-09-08 18:34:01 +03:00
|
|
|
result.Raw = ""
|
|
|
|
} else {
|
2016-09-10 01:49:48 +03:00
|
|
|
// raw has data, safely copy the slice header to a string
|
|
|
|
result.Raw = string(*(*[]byte)(unsafe.Pointer(&rawh)))
|
2016-09-08 18:34:01 +03:00
|
|
|
}
|
|
|
|
result.Str = ""
|
|
|
|
} else if rawh.Data == 0 {
|
2016-09-10 01:49:48 +03:00
|
|
|
// raw is nil
|
2016-09-08 18:34:01 +03:00
|
|
|
result.Raw = ""
|
2016-09-10 01:49:48 +03:00
|
|
|
// str has data, safely copy the slice header to a string
|
|
|
|
result.Str = string(*(*[]byte)(unsafe.Pointer(&strh)))
|
2016-09-08 19:02:40 +03:00
|
|
|
} else if strh.Data >= rawh.Data &&
|
|
|
|
int(strh.Data)+strh.Len <= int(rawh.Data)+rawh.Len {
|
2016-09-08 18:34:01 +03:00
|
|
|
// Str is a substring of Raw.
|
|
|
|
start := int(strh.Data - rawh.Data)
|
2016-09-10 01:49:48 +03:00
|
|
|
// safely copy the raw slice header
|
|
|
|
result.Raw = string(*(*[]byte)(unsafe.Pointer(&rawh)))
|
|
|
|
// substring the raw
|
2016-09-08 18:34:01 +03:00
|
|
|
result.Str = result.Raw[start : start+strh.Len]
|
|
|
|
} else {
|
2016-09-10 01:49:48 +03:00
|
|
|
// safely copy both the raw and str slice headers to strings
|
|
|
|
result.Raw = string(*(*[]byte)(unsafe.Pointer(&rawh)))
|
|
|
|
result.Str = string(*(*[]byte)(unsafe.Pointer(&strh)))
|
2016-09-08 18:34:01 +03:00
|
|
|
}
|
2016-09-08 18:08:53 +03:00
|
|
|
}
|
|
|
|
return result
|
2016-08-11 06:07:45 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// unescape unescapes a string
|
|
|
|
func unescape(json string) string { //, error) {
|
|
|
|
var str = make([]byte, 0, len(json))
|
|
|
|
for i := 0; i < len(json); i++ {
|
|
|
|
switch {
|
|
|
|
default:
|
|
|
|
str = append(str, json[i])
|
|
|
|
case json[i] < ' ':
|
|
|
|
return "" //, errors.New("invalid character in string")
|
|
|
|
case json[i] == '\\':
|
|
|
|
i++
|
|
|
|
if i >= len(json) {
|
|
|
|
return "" //, errors.New("invalid escape sequence")
|
|
|
|
}
|
|
|
|
switch json[i] {
|
|
|
|
default:
|
|
|
|
return "" //, errors.New("invalid escape sequence")
|
|
|
|
case '\\':
|
|
|
|
str = append(str, '\\')
|
|
|
|
case '/':
|
|
|
|
str = append(str, '/')
|
|
|
|
case 'b':
|
|
|
|
str = append(str, '\b')
|
|
|
|
case 'f':
|
|
|
|
str = append(str, '\f')
|
|
|
|
case 'n':
|
|
|
|
str = append(str, '\n')
|
|
|
|
case 'r':
|
|
|
|
str = append(str, '\r')
|
|
|
|
case 't':
|
|
|
|
str = append(str, '\t')
|
|
|
|
case '"':
|
|
|
|
str = append(str, '"')
|
|
|
|
case 'u':
|
|
|
|
if i+5 > len(json) {
|
|
|
|
return "" //, errors.New("invalid escape sequence")
|
|
|
|
}
|
|
|
|
i++
|
|
|
|
// extract the codepoint
|
|
|
|
var code int
|
|
|
|
for j := i; j < i+4; j++ {
|
|
|
|
switch {
|
|
|
|
default:
|
|
|
|
return "" //, errors.New("invalid escape sequence")
|
|
|
|
case json[j] >= '0' && json[j] <= '9':
|
|
|
|
code += (int(json[j]) - '0') << uint(12-(j-i)*4)
|
|
|
|
case json[j] >= 'a' && json[j] <= 'f':
|
|
|
|
code += (int(json[j]) - 'a' + 10) << uint(12-(j-i)*4)
|
|
|
|
case json[j] >= 'a' && json[j] <= 'f':
|
|
|
|
code += (int(json[j]) - 'a' + 10) << uint(12-(j-i)*4)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
str = append(str, []byte(string(code))...)
|
|
|
|
i += 3 // only 3 because we will increment on the for-loop
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return string(str) //, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Less return true if a token is less than another token.
|
|
|
|
// The caseSensitive paramater is used when the tokens are Strings.
|
|
|
|
// The order when comparing two different type is:
|
|
|
|
//
|
2016-08-22 16:05:51 +03:00
|
|
|
// Null < False < Number < String < True < JSON
|
2016-08-11 06:07:45 +03:00
|
|
|
//
|
|
|
|
func (t Result) Less(token Result, caseSensitive bool) bool {
|
|
|
|
if t.Type < token.Type {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
if t.Type > token.Type {
|
|
|
|
return false
|
|
|
|
}
|
2016-08-21 20:10:55 +03:00
|
|
|
if t.Type == String {
|
2016-08-11 06:07:45 +03:00
|
|
|
if caseSensitive {
|
|
|
|
return t.Str < token.Str
|
|
|
|
}
|
|
|
|
return stringLessInsensitive(t.Str, token.Str)
|
2016-08-21 20:10:55 +03:00
|
|
|
}
|
|
|
|
if t.Type == Number {
|
|
|
|
return t.Num < token.Num
|
|
|
|
}
|
|
|
|
return t.Raw < token.Raw
|
2016-08-11 06:07:45 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func stringLessInsensitive(a, b string) bool {
|
|
|
|
for i := 0; i < len(a) && i < len(b); i++ {
|
|
|
|
if a[i] >= 'A' && a[i] <= 'Z' {
|
|
|
|
if b[i] >= 'A' && b[i] <= 'Z' {
|
|
|
|
// both are uppercase, do nothing
|
|
|
|
if a[i] < b[i] {
|
|
|
|
return true
|
|
|
|
} else if a[i] > b[i] {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// a is uppercase, convert a to lowercase
|
|
|
|
if a[i]+32 < b[i] {
|
|
|
|
return true
|
|
|
|
} else if a[i]+32 > b[i] {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if b[i] >= 'A' && b[i] <= 'Z' {
|
|
|
|
// b is uppercase, convert b to lowercase
|
|
|
|
if a[i] < b[i]+32 {
|
|
|
|
return true
|
|
|
|
} else if a[i] > b[i]+32 {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// neither are uppercase
|
|
|
|
if a[i] < b[i] {
|
|
|
|
return true
|
|
|
|
} else if a[i] > b[i] {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return len(a) < len(b)
|
|
|
|
}
|