Spelling

README.md

@@ -225,4 +225,4 @@ This application is included in the [speakeasy](https://github.com/speakeasy-api
 
 ## Contributing
 
-We welcome contributions to this repository! Please open a Github issue or a Pull Request if you have an implementation for a bug fix or feature. This repository is compliant with the [jsonpath standard compliance test suite](https://github.com/jsonpath-standard/jsonpath-compliance-test-suite/tree/9277705cda4489c3d0d984831e7656e48145399b) 
+We welcome contributions to this repository! Please open a GitHub issue or a Pull Request if you have an implementation for a bug fix or feature. This repository is compliant with the [jsonpath standard compliance test suite](https://github.com/jsonpath-standard/jsonpath-compliance-test-suite/tree/9277705cda4489c3d0d984831e7656e48145399b) 

cmd/wasm/functions.go

@@ -5,13 +5,14 @@ package main
 import (
 	"encoding/json"
 	"fmt"
+	"reflect"
+	"syscall/js"
+
 	"github.com/speakeasy-api/jsonpath/pkg/jsonpath"
 	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/config"
 	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/token"
 	"github.com/speakeasy-api/jsonpath/pkg/overlay"
 	"gopkg.in/yaml.v3"
-	"reflect"
-	"syscall/js"
 )
 
 func CalculateOverlay(originalYAML, targetYAML, existingOverlay string) (string, error) {

integration_test.go

@@ -2,14 +2,15 @@ package jsonpath_test
 
 import (
 	"encoding/json"
-	"github.com/pmezard/go-difflib/difflib"
-	"github.com/speakeasy-api/jsonpath/pkg/jsonpath"
-	"github.com/stretchr/testify/require"
-	"gopkg.in/yaml.v3"
 	"os"
 	"slices"
 	"strings"
 	"testing"
+
+	"github.com/pmezard/go-difflib/difflib"
+	"github.com/speakeasy-api/jsonpath/pkg/jsonpath"
+	"github.com/stretchr/testify/require"
+	"gopkg.in/yaml.v3"
 )
 
 type FullTestSuite struct {

pkg/jsonpath/filter.go

@@ -1,9 +1,10 @@
 package jsonpath
 
 import (
-	"gopkg.in/yaml.v3"
 	"strconv"
 	"strings"
+
+	"gopkg.in/yaml.v3"
 )
 
 // filter-selector     = "?" S logical-expr
@@ -78,13 +79,13 @@ func (q filterQuery) ToString() string {
 	return ""
 }
 
-// functionArgument function-argument   = literal /
+// functionArgument function-argument   = literal-value /
 //
 //	filter-query / ; (includes singular-query)
 //	logical-expr /
 //	function-expr
 type functionArgument struct {
-	literal      *literal
+	literalValue *literal
 	filterQuery  *filterQuery
 	logicalExpr  *logicalOrExpr
 	functionExpr *functionExpr
@@ -104,8 +105,8 @@ type resolvedArgument struct {
 }
 
 func (a functionArgument) Eval(idx index, node *yaml.Node, root *yaml.Node) resolvedArgument {
-	if a.literal != nil {
-		return resolvedArgument{kind: functionArgTypeLiteral, literal: a.literal}
+	if a.literalValue != nil {
+		return resolvedArgument{kind: functionArgTypeLiteral, literal: a.literalValue}
 	} else if a.filterQuery != nil {
 		result := a.filterQuery.Query(idx, node, root)
 		lits := make([]*literal, len(result))
@@ -130,8 +131,8 @@ func (a functionArgument) Eval(idx index, node *yaml.Node, root *yaml.Node) reso
 
 func (a functionArgument) ToString() string {
 	builder := strings.Builder{}
-	if a.literal != nil {
-		builder.WriteString(a.literal.ToString())
+	if a.literalValue != nil {
+		builder.WriteString(a.literalValue.ToString())
 	} else if a.filterQuery != nil {
 		builder.WriteString(a.filterQuery.ToString())
 	} else if a.logicalExpr != nil {
@@ -241,7 +242,7 @@ func (e basicExpr) ToString() string {
 	return ""
 }
 
-// literal literal = number /
+// literal literal-value = number /
 // . string-literal /
 // . true / false / null
 type literal struct {
@@ -352,18 +353,18 @@ func (q singularQuery) ToString() string {
 
 // comparable
 //
-//	comparable = literal /
+//	comparable = literal-value /
 //	singular-query / ; singular query value
 //	function-expr    ; ValueType
 type comparable struct {
-	literal       *literal
+	literalValue  *literal
 	singularQuery *singularQuery
 	functionExpr  *functionExpr
 }
 
 func (c comparable) ToString() string {
-	if c.literal != nil {
-		return c.literal.ToString()
+	if c.literalValue != nil {
+		return c.literalValue.ToString()
 	} else if c.singularQuery != nil {
 		return c.singularQuery.ToString()
 	} else if c.functionExpr != nil {
@@ -375,9 +376,9 @@ func (c comparable) ToString() string {
 // comparisonExpr represents a comparison expression
 //
 //	comparison-expr     = comparable S comparison-op S comparable
-//	literal             = number / string-literal /
+//	literal-value       = number / string-literal /
 //	                      true / false / null
-//	comparable          = literal /
+//	comparable          = literal-value /
 //	                      singular-query / ; singular query value
 //	                      function-expr    ; ValueType
 //	comparison-op       = "==" / "!=" /

pkg/jsonpath/jsonpath.go

@@ -2,6 +2,7 @@ package jsonpath
 
 import (
 	"fmt"
+
 	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/config"
 	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/token"
 	"gopkg.in/yaml.v3"

pkg/jsonpath/parser.go

@@ -3,10 +3,11 @@ package jsonpath
 import (
 	"errors"
 	"fmt"
-	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/config"
-	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/token"
 	"strconv"
 	"strings"
+
+	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/config"
+	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/token"
 )
 
 const MaxSafeFloat int64 = 9007199254740991
@@ -107,7 +108,7 @@ func (p *JSONPath) parseSegment() (*segment, error) {
 		return &segment{kind: segmentKindChild, child: child}, nil
 	} else if p.config.PropertyNameEnabled() && currentToken.Token == token.PROPERTY_NAME {
 		p.current++
-		return &segment{kind: segmentKindProperyName}, nil
+		return &segment{kind: segmentKindPropertyName}, nil
 	}
 	return nil, p.parseFailure(&currentToken, "unexpected token when parsing segment")
 }
@@ -460,7 +461,7 @@ func (p *JSONPath) parseComparable() (*comparable, error) {
 	//	singular-query / ; singular query value
 	//	function-expr    ; ValueType
 	if literal, err := p.parseLiteral(); err == nil {
-		return &comparable{literal: literal}, nil
+		return &comparable{literalValue: literal}, nil
 	}
 	if funcExpr, err := p.parseFunctionExpr(); err == nil {
 		if funcExpr.funcType == functionTypeMatch {
@@ -573,7 +574,7 @@ func (p *JSONPath) parseFunctionExpr() (*functionExpr, error) {
 		if err != nil {
 			return nil, err
 		}
-		if arg.literal != nil && arg.literal.node == nil {
+		if arg.literalValue != nil && arg.literalValue.node == nil {
 			return nil, p.parseFailure(&p.tokens[p.current], "count function only supports containers")
 		}
 		args = append(args, arg)
@@ -636,7 +637,7 @@ func (p *JSONPath) parseFunctionArgument(single bool) (*functionArgument, error)
 	//	function-expr
 
 	if lit, err := p.parseLiteral(); err == nil {
-		return &functionArgument{literal: lit}, nil
+		return &functionArgument{literalValue: lit}, nil
 	}
 	switch p.tokens[p.current].Token {
 	case token.CURRENT:

pkg/jsonpath/parser_test.go

@@ -1,10 +1,11 @@
 package jsonpath_test
 
 import (
+	"testing"
+
 	"github.com/speakeasy-api/jsonpath/pkg/jsonpath"
 	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/config"
 	"github.com/stretchr/testify/require"
-	"testing"
 )
 
 func TestParser(t *testing.T) {

pkg/jsonpath/segment.go

@@ -1,16 +1,17 @@
 package jsonpath
 
 import (
-	"gopkg.in/yaml.v3"
 	"strings"
+
+	"gopkg.in/yaml.v3"
 )
 
 type segmentKind int
 
 const (
-	segmentKindChild       segmentKind = iota // .
-	segmentKindDescendant                     // ..
-	segmentKindProperyName                    // ~ (extension only)
+	segmentKindChild        segmentKind = iota // .
+	segmentKindDescendant                      // ..
+	segmentKindPropertyName                    // ~ (extension only)
 )
 
 type segment struct {
@@ -37,7 +38,7 @@ func (s segment) ToString() string {
 		}
 	case segmentKindDescendant:
 		return ".." + s.descendant.ToString()
-	case segmentKindProperyName:
+	case segmentKindPropertyName:
 		return "~"
 	}
 	panic("unknown segment kind")

pkg/jsonpath/token/token.go

@@ -2,9 +2,10 @@ package token
 
 import (
 	"fmt"
-	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/config"
 	"strconv"
 	"strings"
+
+	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/config"
 )
 
 // *****************************************************************************

pkg/jsonpath/token/token_test.go

@@ -2,8 +2,9 @@ package token
 
 import (
 	"fmt"
-	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/config"
 	"testing"
+
+	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/config"
 )
 
 func TestTokenizer(t *testing.T) {

pkg/jsonpath/yaml_eval.go

@@ -2,11 +2,12 @@ package jsonpath
 
 import (
 	"fmt"
-	"gopkg.in/yaml.v3"
 	"reflect"
 	"regexp"
 	"strconv"
 	"unicode/utf8"
+
+	"gopkg.in/yaml.v3"
 )
 
 func (l literal) Equals(value literal) bool {
@@ -105,8 +106,8 @@ func (l literal) LessThanOrEqual(value literal) bool {
 }
 
 func (c comparable) Evaluate(idx index, node *yaml.Node, root *yaml.Node) literal {
-	if c.literal != nil {
-		return *c.literal
+	if c.literalValue != nil {
+		return *c.literalValue
 	}
 	if c.singularQuery != nil {
 		return c.singularQuery.Evaluate(idx, node, root)

pkg/jsonpath/yaml_eval_test.go

@@ -212,7 +212,7 @@ func TestComparableEvaluate(t *testing.T) {
 	}{
 		{
 			name:       "literal",
-			comparable: comparable{literal: &literal{integer: intPtr(10)}},
+			comparable: comparable{literalValue: &literal{integer: intPtr(10)}},
 			node:       yamlNodeFromString("foo"),
 			root:       yamlNodeFromString("foo"),
 			expected:   literal{integer: intPtr(10)},

pkg/jsonpath/yaml_query.go

@@ -68,7 +68,7 @@ func (s segment) Query(idx index, value *yaml.Node, root *yaml.Node) []*yaml.Nod
 		// make children unique by pointer value
 		result = unique(result)
 		return result
-	case segmentKindProperyName:
+	case segmentKindPropertyName:
 		found := idx.getPropertyKey(value)
 		if found != nil {
 			return []*yaml.Node{found}

pkg/jsonpath/yaml_query_test.go

@@ -1,12 +1,13 @@
 package jsonpath
 
 import (
-	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/config"
-	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/token"
-	"gopkg.in/yaml.v3"
 	"reflect"
 	"strings"
 	"testing"
+
+	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/config"
+	"github.com/speakeasy-api/jsonpath/pkg/jsonpath/token"
+	"gopkg.in/yaml.v3"
 )
 
 func TestQuery(t *testing.T) {

pkg/overlay/apply_test.go

@@ -2,11 +2,12 @@ package overlay_test
 
 import (
 	"bytes"
+	"os"
+	"testing"
+
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"gopkg.in/yaml.v3"
-	"os"
-	"testing"
 )
 
 // NodeMatchesFile is a test that marshals the YAML file from the given node,

pkg/overlay/compare_test.go

@@ -2,12 +2,13 @@ package overlay_test
 
 import (
 	"fmt"
+	"os"
+	"testing"
+
 	"github.com/speakeasy-api/jsonpath/pkg/overlay"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"gopkg.in/yaml.v3"
-	"os"
-	"testing"
 )
 
 func LoadSpecification(path string) (*yaml.Node, error) {

pkg/overlay/parse.go

@@ -2,10 +2,11 @@ package overlay
 
 import (
 	"fmt"
-	"gopkg.in/yaml.v3"
 	"io"
 	"os"
 	"path/filepath"
+
+	"gopkg.in/yaml.v3"
 )
 
 // Parse will parse the given reader as an overlay file.

pkg/overlay/parse_test.go

@@ -1,11 +1,12 @@
 package overlay_test
 
 import (
+	"os"
+	"testing"
+
 	"github.com/speakeasy-api/jsonpath/pkg/overlay"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"os"
-	"testing"
 )
 
 var expectOverlay = &overlay.Overlay{

pkg/overlay/schema.go

@@ -2,6 +2,7 @@ package overlay
 
 import (
 	"bytes"
+
 	"gopkg.in/yaml.v3"
 )