Merge pull request #12 from evilmonkeyinc/feat/v2_expressions

Improved expression

Author: evilmonkeyinc

README.md

@@ -25,10 +25,10 @@ import (
 )
 
 func main() {
-	query := os.Args[1]
+	selector := os.Args[1]
 	data := os.Args[2]
 
-	result, err := jsonpath.QueryString(query, data)
+	result, err := jsonpath.QueryString(selector, data)
 	if err != nil {
 		fmt.Println(err)
 		os.Exit(1)
@@ -44,31 +44,31 @@ The following functions are exported to support the functionality
 
 ### Compile
 
-Will parse a JSONPath query and return a JSONPath object that can be used to query multiple JSON data objects or strings
+Will parse a JSONPath selector and return a Selector object that can be used to query multiple JSON data objects or strings
 
 ### Query
 
-Will compile a JSONPath query and will query the supplied JSON data in any various formats.
+Will compile a JSONPath selector and will query the supplied JSON data in any various formats.
 
 The parser can support querying struct types, and will use the `json` tags for struct fields if they are present, if not it will use the names as they appear in the golang code.
 
 ### QueryString
 
-Will compile a JSONPath query and will query the supplied JSON data. 
+Will compile a JSONPath selector and will query the supplied JSON data. 
 
 QueryString can support a JSON array or object strings, and will unmarshal them to `[]interface{}` or `map[string]interface{}` using the standard `encoding/json` package unmarshal functions.
 
 ## Types
 
-### JSONPath
+### Selector
 
 This object is returned by the `Compile` function.
 
-The JSONPath struct represents a reusable compiled JSONPath query which supports the `Query`, and `QueryString` functions as detailed above.
+The Selector struct represents a reusable compiled JSONPath selector which supports the `Query`, and `QueryString` functions as detailed above.
 
 ### Options
 
-Part of the JSONPath object, Options allows you to specify what additional functionality, if any, that you want to enable while querying data.
+Part of the Selector object, Options allows you to specify what additional functionality, if any, that you want to enable while querying data.
 
 You are able to enable index referencing support for maps for all tokens using `AllowMapReferenceByIndex` or use enable it for each token type individually.
 
@@ -95,7 +95,7 @@ You are able to enable index referencing support for strings for all tokens usin
 
 represents the data object being queried 
 
-this should always be the first token in a query. It is also possible to use the root symbol in scripts and filters, for example `$.store.book[?(@.category == $.onSaleCategory)]` would allow you to filter the elements i the book array based on its `category` value compared to the `onSaleCategory` value on the root object.
+this should always be the first token in a selector. It is also possible to use the root symbol in scripts and filters, for example `$.store.book[?(@.category == $.onSaleCategory)]` would allow you to filter the elements i the book array based on its `category` value compared to the `onSaleCategory` value on the root object.
 
 ### Child
 
@@ -190,7 +190,7 @@ If used with a map that has a key `length` it will return the corresponding valu
 
 ### Subscript, Union, and Range with maps and strings
 
-Using the Compile() function, and modifying the JSONPath Options, it is possible to use a map or a string in place of an array with the subscript `[1]` union `[1,2,3]` and range `[0:3]` operations. 
+Using the Compile() function, and modifying the Selector Options, it is possible to use a map or a string in place of an array with the subscript `[1]` union `[1,2,3]` and range `[0:3]` operations. 
 
 For maps, the keys will be sorted into alphabetical order and they will be used to determine the index order. For example, if you had a map with strings `a` and `b`, regardless of the order, `a` would be the `0` index, and `b` the `1` index.
 

errors.go

@@ -15,13 +15,13 @@ func getInvalidJSONData(reason error) error {
 	return fmt.Errorf("%w. %s", errors.ErrInvalidJSONData, reason.Error())
 }
 
-func getInvalidJSONPathQuery(query string) error {
-	return fmt.Errorf("%w '%s'", errors.ErrInvalidJSONPathQuery, query)
+func getInvalidJSONPathSelector(selector string) error {
+	return fmt.Errorf("%w '%s'", errors.ErrInvalidJSONPathSelector, selector)
 }
 
-func getInvalidJSONPathQueryWithReason(query string, reason error) error {
-	if goErr.Is(reason, errors.ErrInvalidJSONPathQuery) {
+func getInvalidJSONPathSelectorWithReason(selector string, reason error) error {
+	if goErr.Is(reason, errors.ErrInvalidJSONPathSelector) {
 		return reason
 	}
-	return fmt.Errorf("%w '%s' %s", errors.ErrInvalidJSONPathQuery, query, reason.Error())
+	return fmt.Errorf("%w '%s' %s", errors.ErrInvalidJSONPathSelector, selector, reason.Error())
 }

errors/errors.go

@@ -7,8 +7,8 @@ import (
 var (
 	// ErrInvalidExpression returned when an expression is invalid
 	ErrInvalidExpression error = fmt.Errorf("invalid expression")
-	// ErrInvalidJSONPathQuery returned when the JSONPath query is invalid
-	ErrInvalidJSONPathQuery error = fmt.Errorf("invalid JSONPath query")
+	// ErrInvalidJSONPathSelector returned when the JSONPath selector is invalid
+	ErrInvalidJSONPathSelector error = fmt.Errorf("invalid JSONPath selector")
 	// ErrInvalidJSONData returned when the JSON data is invalid
 	ErrInvalidJSONData error = fmt.Errorf("invalid data")
 	// ErrInvalidToken returned when a token is invalid

errors_test.go

@@ -35,40 +35,40 @@ func Test_getInvalidJSONData(t *testing.T) {
 	}
 }
 
-func Test_getInvalidJSONPathQuery(t *testing.T) {
+func Test_getInvalidJSONPathSelector(t *testing.T) {
 
 	tests := []struct {
 		input    string
 		expected string
 	}{
 		{
 			input:    "",
-			expected: "invalid JSONPath query ''",
+			expected: "invalid JSONPath selector ''",
 		},
 		{
 			input:    "test",
-			expected: "invalid JSONPath query 'test'",
+			expected: "invalid JSONPath selector 'test'",
 		},
 		{
 			input:    "other",
-			expected: "invalid JSONPath query 'other'",
+			expected: "invalid JSONPath selector 'other'",
 		},
 	}
 
 	for idx, test := range tests {
 		t.Run(fmt.Sprintf("%d", idx), func(t *testing.T) {
-			actual := getInvalidJSONPathQuery(test.input)
+			actual := getInvalidJSONPathSelector(test.input)
 			assert.EqualError(t, actual, test.expected)
-			assert.True(t, goErr.Is(actual, errors.ErrInvalidJSONPathQuery))
+			assert.True(t, goErr.Is(actual, errors.ErrInvalidJSONPathSelector))
 		})
 	}
 }
 
-func Test_getInvalidJSONPathQueryWithReason(t *testing.T) {
+func Test_getInvalidJSONPathSelectorWithReason(t *testing.T) {
 
 	type input struct {
-		query  string
-		reason error
+		selector string
+		reason   error
 	}
 
 	tests := []struct {
@@ -77,32 +77,32 @@ func Test_getInvalidJSONPathQueryWithReason(t *testing.T) {
 	}{
 		{
 			input: input{
-				query:  "",
-				reason: fmt.Errorf("the reason"),
+				selector: "",
+				reason:   fmt.Errorf("the reason"),
 			},
-			expected: "invalid JSONPath query '' the reason",
+			expected: "invalid JSONPath selector '' the reason",
 		},
 		{
 			input: input{
-				query:  "test",
-				reason: fmt.Errorf("other reason"),
+				selector: "test",
+				reason:   fmt.Errorf("other reason"),
 			},
-			expected: "invalid JSONPath query 'test' other reason",
+			expected: "invalid JSONPath selector 'test' other reason",
 		},
 		{
 			input: input{
-				query:  "other",
-				reason: getInvalidJSONPathQuery("inside"),
+				selector: "other",
+				reason:   getInvalidJSONPathSelector("inside"),
 			},
-			expected: "invalid JSONPath query 'inside'",
+			expected: "invalid JSONPath selector 'inside'",
 		},
 	}
 
 	for idx, test := range tests {
 		t.Run(fmt.Sprintf("%d", idx), func(t *testing.T) {
-			actual := getInvalidJSONPathQueryWithReason(test.input.query, test.input.reason)
+			actual := getInvalidJSONPathSelectorWithReason(test.input.selector, test.input.reason)
 			assert.EqualError(t, actual, test.expected)
-			assert.True(t, goErr.Is(actual, errors.ErrInvalidJSONPathQuery))
+			assert.True(t, goErr.Is(actual, errors.ErrInvalidJSONPathSelector))
 		})
 	}
 }

jsonpath.go

@@ -6,65 +6,78 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/evilmonkeyinc/jsonpath/option"
+	"github.com/evilmonkeyinc/jsonpath/script"
+	"github.com/evilmonkeyinc/jsonpath/script/standard"
 	"github.com/evilmonkeyinc/jsonpath/token"
 )
 
-// Compile compile the JSON path query
-func Compile(queryPath string) (*JSONPath, error) {
-	jsonPath := &JSONPath{}
-	if err := jsonPath.compile(queryPath); err != nil {
-		return nil, getInvalidJSONPathQueryWithReason(queryPath, err)
+// Compile will compile the JSONPath selector
+func Compile(selector string) (*Selector, error) {
+	engine := new(standard.ScriptEngine)
+
+	if selector == "$[?(@.key<3),?(@.key>6)]" {
+		// TODO
+		selector = "$[?(@.key<3),?(@.key>6)]"
+	}
+
+	jsonPath := &Selector{}
+	if err := jsonPath.compile(selector, engine); err != nil {
+		return nil, getInvalidJSONPathSelectorWithReason(selector, err)
 	}
 
 	return jsonPath, nil
 }
 
-// Query will return the result of the JSONPath query applied against the specified JSON data.
-func Query(queryPath string, jsonData interface{}) (interface{}, error) {
-	jsonPath, err := Compile(queryPath)
+// Query will return the result of the JSONPath selector applied against the specified JSON data.
+func Query(selector string, jsonData interface{}) (interface{}, error) {
+	jsonPath, err := Compile(selector)
 	if err != nil {
-		return nil, getInvalidJSONPathQueryWithReason(queryPath, err)
+		return nil, getInvalidJSONPathSelectorWithReason(selector, err)
 	}
 	return jsonPath.Query(jsonData)
 }
 
-// QueryString will return the result of the JSONPath query applied against the specified JSON data.
-func QueryString(queryPath string, jsonData string) (interface{}, error) {
-	jsonPath, err := Compile(queryPath)
+// QueryString will return the result of the JSONPath selector applied against the specified JSON data.
+func QueryString(selector string, jsonData string) (interface{}, error) {
+
+	jsonPath, err := Compile(selector)
 	if err != nil {
-		return nil, getInvalidJSONPathQueryWithReason(queryPath, err)
+		return nil, getInvalidJSONPathSelectorWithReason(selector, err)
 	}
 	return jsonPath.QueryString(jsonData)
 }
 
-// JSONPath represents a compiled JSONPath query
+// Selector represents a compiled JSONPath selector
 // and exposes functions to query JSON data and objects.
-type JSONPath struct {
-	Options     *token.Options
-	queryString string
-	tokens      []token.Token
+type Selector struct {
+	Options  *option.QueryOptions
+	engine   script.Engine
+	tokens   []token.Token
+	selector string
 }
 
-// String returns the compiled query string representation
-func (query *JSONPath) String() string {
+// String returns the compiled selector string representation
+func (query *Selector) String() string {
 	jsonPath := ""
 	for _, token := range query.tokens {
 		jsonPath += fmt.Sprintf("%s", token)
 	}
 	return jsonPath
 }
 
-func (query *JSONPath) compile(queryString string) error {
-	query.queryString = queryString
+func (query *Selector) compile(selector string, engine script.Engine) error {
+	query.engine = engine
+	query.selector = selector
 
-	tokenStrings, err := token.Tokenize(queryString)
+	tokenStrings, err := token.Tokenize(selector)
 	if err != nil {
 		return err
 	}
 
 	tokens := make([]token.Token, len(tokenStrings))
 	for idx, tokenString := range tokenStrings {
-		token, err := token.Parse(tokenString, query.Options)
+		token, err := token.Parse(tokenString, query.engine, query.Options)
 		if err != nil {
 			return err
 		}
@@ -76,9 +89,9 @@ func (query *JSONPath) compile(queryString string) error {
 }
 
 // Query will return the result of the JSONPath query applied against the specified JSON data.
-func (query *JSONPath) Query(root interface{}) (interface{}, error) {
+func (query *Selector) Query(root interface{}) (interface{}, error) {
 	if len(query.tokens) == 0 {
-		return nil, getInvalidJSONPathQuery(query.queryString)
+		return nil, getInvalidJSONPathSelector(query.selector)
 	}
 
 	tokens := make([]token.Token, 0)
@@ -94,7 +107,7 @@ func (query *JSONPath) Query(root interface{}) (interface{}, error) {
 }
 
 // QueryString will return the result of the JSONPath query applied against the specified JSON data.
-func (query *JSONPath) QueryString(jsonData string) (interface{}, error) {
+func (query *Selector) QueryString(jsonData string) (interface{}, error) {
 	jsonData = strings.TrimSpace(jsonData)
 	if jsonData == "" {
 		return nil, getInvalidJSONData(errDataIsUnexpectedTypeOrNil)