Custom coercions (#15)

Author: Dean Karn

.github/workflows/workflow.yml

@@ -8,7 +8,7 @@ jobs:
   test:
     strategy:
       matrix:
-        go-version: [1.19.x]
+        go-version: [1.20.x,1.19.x]
         os: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{ matrix.os }}
     steps:
@@ -32,7 +32,7 @@ jobs:
         run: go test -race -covermode=atomic -coverprofile="profile.cov" ./...
 
       - name: Send Coverage
-        if: matrix.os == 'ubuntu-latest' && matrix.go-version == '1.19.x'
+        if: matrix.os == 'ubuntu-latest' && matrix.go-version == '1.20.x'
         uses: shogo82148/actions-goveralls@v1
         with:
           path-to-profile: profile.cov
@@ -43,6 +43,6 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v2
+        uses: golangci/golangci-lint-action@v3
         with:
           version: latest

CHANGELOG.md

@@ -6,6 +6,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.8.0] - 2023-06-10
+### Added
+- Ability to register new, remove existing and replace existing COERCE types.
+
 ## [0.7.0] - 2023-05-31
 ### Added
 - _string_ & _number_ COERCE types.
@@ -66,8 +70,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 - Initial conversion from https://github.com/rust-playground/ksql.
 
-[Unreleased]: https://github.com/go-playground/ksql/compare/v0.7.0...HEAD
-[0.6.1]: https://github.com/go-playground/ksql/compare/v0.7.0...v0.7.0
+[Unreleased]: https://github.com/go-playground/ksql/compare/v0.8.0...HEAD
+[0.8.0]: https://github.com/go-playground/ksql/compare/v0.7.0...v0.8.0
+[0.7.0]: https://github.com/go-playground/ksql/compare/v0.6.1...v0.7.0
 [0.6.1]: https://github.com/go-playground/ksql/compare/v0.6.0...v0.6.1
 [0.6.0]: https://github.com/go-playground/ksql/compare/v0.5.1...v0.6.0
 [0.5.1]: https://github.com/go-playground/ksql/compare/v0.5.0...v0.5.1

README.md

@@ -1,6 +1,6 @@
 ksql
 =====
-![Project status](https://img.shields.io/badge/version-0.7.0-green.svg)
+![Project status](https://img.shields.io/badge/version-0.8.0-green.svg)
 [![GoDoc](https://godoc.org/github.com/go-playground/ksql?status.svg)](https://pkg.go.dev/github.com/go-playground/ksql)
 ![License](https://img.shields.io/dub/l/vibe-d.svg)
 

_examples/custom-coercion/main.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/go-playground/ksql"
+)
+
+type Star struct {
+	expression ksql.Expression
+}
+
+func (s *Star) Calculate(json []byte) (interface{}, error) {
+	inner, err := s.expression.Calculate(json)
+	if err != nil {
+		return nil, err
+	}
+
+	switch t := inner.(type) {
+	case string:
+		return strings.Repeat("*", len(t)), nil
+	default:
+		return nil, fmt.Errorf("cannot star value %v", inner)
+	}
+}
+
+func main() {
+	// Add custom coercion to the parser.
+	// REMEMBER: coercions start and end with an _(underscore).
+	guard := ksql.Coercions.Lock()
+	guard.T["_star_"] = func(constEligible bool, expression ksql.Expression) (stillConstEligible bool, e ksql.Expression, err error) {
+		return constEligible, &Star{expression}, nil
+	}
+	guard.Unlock()
+
+	expression := []byte(`COERCE "My Name" _star_`)
+	input := []byte(`{}`)
+	ex, err := ksql.Parse(expression)
+	if err != nil {
+		panic(err)
+	}
+
+	result, err := ex.Calculate(input)
+	if err != nil {
+		panic(err)
+	}
+	fmt.Printf("%v\n", result)
+}

go.mod

@@ -5,8 +5,8 @@ go 1.18
 require (
 	github.com/araddon/dateparse v0.0.0-20210429162001-6b43995a97de
 	github.com/go-playground/itertools v0.1.0
-	github.com/go-playground/pkg/v5 v5.18.0
 	github.com/stretchr/testify v1.8.1
+	github.com/go-playground/pkg/v5 v5.18.0
 	github.com/tidwall/gjson v1.14.4
 )
 

parser.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"github.com/go-playground/itertools"
+	syncext "github.com/go-playground/pkg/v5/sync"
 	resultext "github.com/go-playground/pkg/v5/values/result"
 	"io"
 	"reflect"
@@ -17,6 +18,86 @@ import (
 	"github.com/tidwall/gjson"
 )
 
+var (
+	// Coercions is a `map` of all coercions guarded by a Mutex for use allowing registration,
+	// removal or even replacing of existing coercions.
+	Coercions = syncext.NewRWMutex2(map[string]func(constEligible bool, expression Expression) (stillConstEligible bool, e Expression, err error){
+		"_datetime_": func(constEligible bool, expression Expression) (stillConstEligible bool, e Expression, err error) {
+			expression = coerceDateTime{value: expression}
+			if constEligible {
+				value, err := expression.Calculate([]byte{})
+				if err != nil {
+					return false, nil, err
+				}
+				return constEligible, coercedConstant{value: value}, nil
+			} else {
+				return false, expression, nil
+			}
+		},
+		"_lowercase_": func(constEligible bool, expression Expression) (stillConstEligible bool, e Expression, err error) {
+			expression = coerceLowercase{value: expression}
+			if constEligible {
+				value, err := expression.Calculate([]byte{})
+				if err != nil {
+					return false, nil, err
+				}
+				return constEligible, coercedConstant{value: value}, nil
+			} else {
+				return false, expression, nil
+			}
+		},
+		"_string_": func(constEligible bool, expression Expression) (stillConstEligible bool, e Expression, err error) {
+			expression = coerceString{value: expression}
+			if constEligible {
+				value, err := expression.Calculate([]byte{})
+				if err != nil {
+					return false, nil, err
+				}
+				return constEligible, coercedConstant{value: value}, nil
+			} else {
+				return false, expression, nil
+			}
+		},
+		"_number_": func(constEligible bool, expression Expression) (stillConstEligible bool, e Expression, err error) {
+			expression = coerceNumber{value: expression}
+			if constEligible {
+				value, err := expression.Calculate([]byte{})
+				if err != nil {
+					return false, nil, err
+				}
+				return constEligible, coercedConstant{value: value}, nil
+			} else {
+				return false, expression, nil
+			}
+		},
+		"_uppercase_": func(constEligible bool, expression Expression) (stillConstEligible bool, e Expression, err error) {
+			expression = coerceUppercase{value: expression}
+			if constEligible {
+				value, err := expression.Calculate([]byte{})
+				if err != nil {
+					return false, nil, err
+				}
+				return constEligible, coercedConstant{value: value}, nil
+			} else {
+				return false, expression, nil
+			}
+		},
+		"_title_": func(constEligible bool, expression Expression) (stillConstEligible bool, e Expression, err error) {
+			expression = coerceTitle{value: expression}
+			if constEligible {
+				value, err := expression.Calculate([]byte{})
+				if err != nil {
+					return false, nil, err
+				}
+				return constEligible, coercedConstant{value: value}, nil
+			} else {
+				return false, expression, nil
+			}
+		},
+	})
+)
+
+// Expression Represents a stateless parsed expression that can be applied to JSON data.
 type Expression interface {
 
 	// Calculate will execute the parsed expression and apply it against the supplied data.
@@ -196,29 +277,19 @@ func (p *parser) parseValue(token Token) (Expression, error) {
 				return nil, fmt.Errorf("COERCE missing data type identifier, found instead: %s", identifier)
 			}
 
-			switch identifier {
-			case "_datetime_":
-				expression = coerceDateTime{value: expression}
-				if constEligible {
-					value, err := expression.Calculate([]byte{})
-					if err != nil {
-						return nil, err
-					}
-					expression = coercedConstant{value: value}
+			guard := Coercions.RLock()
+			fn, found := guard.T[identifier]
+			guard.RUnlock()
+
+			if found {
+				constEligible, expression, err = fn(constEligible, expression)
+				if err != nil {
+					return nil, err
 				}
-			case "_lowercase_":
-				expression = coerceLowercase{value: expression}
-			case "_string_":
-				expression = coerceString{value: expression}
-			case "_number_":
-				expression = coerceNumber{value: expression}
-			case "_uppercase_":
-				expression = coerceUppercase{value: expression}
-			case "_title_":
-				expression = coerceTitle{value: expression}
-			default:
+			} else {
 				return nil, fmt.Errorf("invalid COERCE data type '%s'", identifier)
 			}
+
 			nextPeeked := p.tokenizer.Peek()
 			if nextPeeked.IsSome() && nextPeeked.Unwrap().IsOk() && nextPeeked.Unwrap().Unwrap().kind == Comma {
 				_ = p.tokenizer.Next() // consume peeked comma

parser_test.go

@@ -1,7 +1,9 @@
 package ksql
 
 import (
+	"fmt"
 	"github.com/stretchr/testify/require"
+	"strings"
 	"testing"
 	"time"
 )
@@ -727,3 +729,41 @@ func TestParser(t *testing.T) {
 		})
 	}
 }
+
+type Star struct {
+	expression Expression
+}
+
+func (s *Star) Calculate(json []byte) (interface{}, error) {
+	inner, err := s.expression.Calculate(json)
+	if err != nil {
+		return nil, err
+	}
+
+	switch t := inner.(type) {
+	case string:
+		return strings.Repeat("*", len(t)), nil
+	default:
+		return nil, fmt.Errorf("cannot star value %v", inner)
+	}
+}
+
+func TestParserCustomCoercion(t *testing.T) {
+	assert := require.New(t)
+
+	guard := Coercions.Lock()
+	guard.T["_star_"] = func(constEligible bool, expression Expression) (stillConstEligible bool, e Expression, err error) {
+		return constEligible, &Star{expression}, nil
+	}
+	guard.Unlock()
+
+	expression := []byte(`COERCE "My Name" _star_`)
+	input := []byte(`{}`)
+	ex, err := Parse(expression)
+	assert.NoError(err)
+
+	result, err := ex.Calculate(input)
+	assert.NoError(err)
+
+	assert.Equal("*******", result)
+}