Start moving function

Author: theory

parser/parse_test.go

@@ -197,14 +197,14 @@ func TestParseFilter(t *testing.T) {
 	a := assert.New(t)
 	r := require.New(t)
 	reg := registry.New()
-	_ = reg.Register(registry.NewFunction(
+	_ = reg.Register(
 		"__true",
 		spec.FuncLogical,
 		func([]spec.FuncExprArg) error { return nil },
 		func([]spec.JSONPathValue) spec.JSONPathValue {
 			return spec.LogicalTrue
 		},
-	))
+	)
 	trueFunc := reg.Get("__true")
 
 	for _, tc := range []struct {

path_example_test.go

@@ -237,12 +237,12 @@ func ExampleParser() {
 func ExampleWithRegistry() {
 	// Register the first function.
 	reg := registry.New()
-	err := reg.Register(registry.NewFunction(
+	err := reg.Register(
 		"first",           // name
 		spec.FuncValue,    // returns a single value
 		validateFirstArgs, // parse-time validation defined below
 		firstFunc,         // function defined below
-	))
+	)
 	if err != nil {
 		log.Fatalf("Error %v", err)
 	}

registry/registry.go

@@ -15,7 +15,7 @@ import (
 // [RFC 9535]: https://www.rfc-editor.org/rfc/rfc9535.html
 type Registry struct {
 	mu    sync.RWMutex
-	funcs map[string]spec.PathFunction
+	funcs map[string]*spec.Func
 }
 
 // New returns a new [Registry] loaded with the [RFC 9535]-mandated functions:
@@ -35,104 +35,52 @@ type Registry struct {
 func New() *Registry {
 	return &Registry{
 		mu: sync.RWMutex{},
-		funcs: map[string]spec.PathFunction{
-			"length": NewFunction("length", spec.FuncValue, checkLengthArgs, lengthFunc),
-			"count":  NewFunction("count", spec.FuncValue, checkCountArgs, countFunc),
-			"value":  NewFunction("value", spec.FuncValue, checkValueArgs, valueFunc),
-			"match":  NewFunction("match", spec.FuncLogical, checkMatchArgs, matchFunc),
-			"search": NewFunction("search", spec.FuncLogical, checkSearchArgs, searchFunc),
+		funcs: map[string]*spec.Func{
+			"length": spec.NewFunction("length", spec.FuncValue, checkLengthArgs, lengthFunc),
+			"count":  spec.NewFunction("count", spec.FuncValue, checkCountArgs, countFunc),
+			"value":  spec.NewFunction("value", spec.FuncValue, checkValueArgs, valueFunc),
+			"match":  spec.NewFunction("match", spec.FuncLogical, checkMatchArgs, matchFunc),
+			"search": spec.NewFunction("search", spec.FuncLogical, checkSearchArgs, searchFunc),
 		},
 	}
 }
 
-// Validator functions validate that the args expressions to a function can be
-// processed by the function.
-type Validator func(args []spec.FuncExprArg) error
-
-// Evaluator functions execute a function against the values returned by args
-// and returns a result.
-type Evaluator func(args []spec.JSONPathValue) spec.JSONPathValue
-
 // ErrRegister errors are returned by [Register].
 var ErrRegister = errors.New("register")
 
-// Register registers a function extension by its name. Returns an
-// [ErrRegister] error if r already contains the name of fn.
-func (r *Registry) Register(fn spec.PathFunction) error {
+// Register registers a function extension by its name. Returns [ErrRegister]
+// if validator or nil or evaluator is nil or if r already contains name.
+func (r *Registry) Register(
+	name string,
+	resultType spec.FuncType,
+	validator spec.Validator,
+	evaluator spec.Evaluator,
+) error {
+	if validator == nil {
+		return fmt.Errorf("%w: validator is nil", ErrRegister)
+	}
+	if evaluator == nil {
+		return fmt.Errorf("%w: evaluator is nil", ErrRegister)
+	}
+
 	r.mu.Lock()
 	defer r.mu.Unlock()
-	if _, dup := r.funcs[fn.Name()]; dup {
+	if _, dup := r.funcs[name]; dup {
 		return fmt.Errorf(
 			"%w: Register called twice for function %v",
-			ErrRegister, fn.Name(),
+			ErrRegister, name,
 		)
 	}
 
-	r.funcs[fn.Name()] = fn
+	r.funcs[name] = spec.NewFunction(name, resultType, validator, evaluator)
 	return nil
 }
 
 // Get returns a reference to the registered function named name. Returns nil
 // if no function with that name has been registered.
-//
-//nolint:ireturn
-func (r *Registry) Get(name string) spec.PathFunction {
+func (r *Registry) Get(name string) *spec.Func {
 	r.mu.RLock()
 	defer r.mu.RUnlock()
 	function := r.funcs[name]
 	return function
 }
-
-// Function defines a JSONPath function. Use [Register] to register a new
-// function. Implements [spec.PathFunction].
-type Function struct {
-	// name is the name of the function. Must be unique among all functions in
-	// a registry.
-	name string
-
-	// resultType defines the type of the function return value.
-	resultType spec.FuncType
-
-	// validator executes at parse time to validate that all the args to
-	// the function are compatible with the function.
-	validator Validator
-
-	// evaluator executes the function and returns the result of type
-	// resultType.
-	evaluator Evaluator
-}
-
-// NewFunction creates a new JSONPath function extension. The parameters are:
-//
-//   - name: the name of the function as used in JSONPath queries.
-//   - resultType: The data type of the function return value.
-//   - validator: A validation function that will be called by at parse time
-//     to validate that all the function args are compatible with the function.
-//   - evaluator: The implementation of the function itself that executes the
-//     against args and returns the result defined by resultType.
-func NewFunction(
-	name string,
-	resultType spec.FuncType,
-	validator func(args []spec.FuncExprArg) error,
-	evaluator func(args []spec.JSONPathValue) spec.JSONPathValue,
-) *Function {
-	return &Function{name, resultType, validator, evaluator}
-}
-
-// Name returns the name of the function.
-func (f *Function) Name() string { return f.name }
-
-// ResultType returns the data type of the function return value.
-func (f *Function) ResultType() spec.FuncType { return f.resultType }
-
-// Evaluate executes the function against args and returns the result of type
-// [ResultType].
-func (f *Function) Evaluate(args []spec.JSONPathValue) spec.JSONPathValue {
-	return f.evaluator(args)
-}
-
-// Validate executes at parse time to validate that all the args to the
-// function are compatible with the function.
-func (f *Function) Validate(args []spec.FuncExprArg) error {
-	return f.validator((args))
-}

registry/registry_example_test.go

@@ -14,12 +14,12 @@ import (
 // [github.com/theory/jsonpath.WithRegistry] for a more complete example.
 func Example() {
 	reg := registry.New()
-	err := reg.Register(registry.NewFunction(
+	err := reg.Register(
 		"first",           // function name
 		spec.FuncValue,    // returns a single value
 		validateFirstArgs, // parse-time validation defined below
 		firstFunc,         // function defined below
-	))
+	)
 	if err != nil {
 		log.Fatalf("Error %v", err)
 	}
@@ -30,12 +30,12 @@ func Example() {
 // validateFirstArgs validates that a single argument is passed to the first()
 // function, and that it can be converted to [spec.NodesType], so that first()
 // can return the first node. It's called by the parser.
-func validateFirstArgs(fea []spec.FuncExprArg) error {
-	if len(fea) != 1 {
-		return fmt.Errorf("expected 1 argument but found %v", len(fea))
+func validateFirstArgs(args []spec.FuncExprArg) error {
+	if len(args) != 1 {
+		return fmt.Errorf("expected 1 argument but found %v", len(args))
 	}
 
-	if !fea[0].ResultType().ConvertsToNodes() {
+	if !args[0].ResultType().ConvertsToNodes() {
 		return errors.New("cannot convert argument to Nodes")
 	}
 

registry/registry_test.go

@@ -1,7 +1,6 @@
 package registry
 
 import (
-	"errors"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -80,8 +79,8 @@ func TestRegisterErr(t *testing.T) {
 	for _, tc := range []struct {
 		name   string
 		fnName string
-		valid  Validator
-		eval   Evaluator
+		valid  spec.Validator
+		eval   spec.Evaluator
 		err    string
 	}{
 		{
@@ -94,53 +93,9 @@ func TestRegisterErr(t *testing.T) {
 	} {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
-			err := reg.Register(
-				NewFunction(tc.fnName, spec.FuncValue, tc.valid, tc.eval),
-			)
+			err := reg.Register(tc.fnName, spec.FuncValue, tc.valid, tc.eval)
 			r.ErrorIs(err, ErrRegister, tc.name)
 			r.EqualError(err, tc.err, tc.name)
 		})
 	}
 }
-
-func TestFunction(t *testing.T) {
-	t.Parallel()
-	a := assert.New(t)
-
-	for _, tc := range []struct {
-		name string
-		fn   *Function
-		args []spec.JSONPathValue
-		err  error
-		exp  spec.JSONPathValue
-	}{
-		{
-			name: "valid_err_value",
-			fn: NewFunction(
-				"xyz", spec.FuncValue,
-				func([]spec.FuncExprArg) error { return errors.New("oops") },
-				func([]spec.JSONPathValue) spec.JSONPathValue { return spec.Value(42) },
-			),
-			args: []spec.JSONPathValue{},
-			exp:  spec.Value(42),
-			err:  errors.New("oops"),
-		},
-		{
-			name: "no_valid_err_nodes",
-			fn: NewFunction(
-				"abc", spec.FuncNodes,
-				func([]spec.FuncExprArg) error { return nil },
-				func([]spec.JSONPathValue) spec.JSONPathValue { return spec.Nodes("hi") },
-			),
-			args: []spec.JSONPathValue{},
-			exp:  spec.Nodes("hi"),
-		},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-			a.Equal(tc.fn.name, tc.fn.Name())
-			a.Equal(tc.err, tc.fn.Validate(nil))
-			a.Equal(tc.exp, tc.fn.Evaluate(tc.args))
-		})
-	}
-}

spec/function.go

@@ -8,6 +8,18 @@ import (
 	"strings"
 )
 
+// ResultType blah blah.
+type ResultType uint8
+
+const (
+	// ResultValue blah blah.
+	ResultValue ResultType = iota + 1 // Value
+	// ResultLogical blah blah.
+	ResultLogical // Logical
+	// ResultNodes blah blah.
+	ResultNodes // Nodes
+)
+
 // FuncType describes the types of function parameters and results for the
 // purpose of validating function parameters.
 //
@@ -476,6 +488,68 @@ func (fq *NodesQueryExpr) writeTo(buf *strings.Builder) {
 	buf.WriteString(fq.String())
 }
 
+// Validator functions validate that the args expressions to a function can be
+// processed by the function.
+type Validator func(args []FuncExprArg) error
+
+// Evaluator functions execute a function against the values returned by args
+// and returns a result.
+type Evaluator func(args []JSONPathValue) JSONPathValue
+
+// Func defines a JSONPath function. Use [Register] to register a new
+// function. Implements [PathFunction].
+type Func struct {
+	// name is the name of the function. Must be unique among all functions in
+	// a registry.
+	name string
+
+	// resultType defines the type of the function return value.
+	resultType FuncType
+
+	// validator executes at parse time to validate that all the args to
+	// the function are compatible with the function.
+	validator Validator
+
+	// evaluator executes the function and returns the result of type
+	// resultType.
+	evaluator Evaluator
+}
+
+// NewFunction creates a new JSONPath function extension. The parameters are:
+//
+//   - name: the name of the function as used in JSONPath queries.
+//   - resultType: The data type of the function return value.
+//   - validator: A validation function that will be called by at parse time
+//     to validate that all the function args are compatible with the function.
+//   - evaluator: The implementation of the function itself that executes the
+//     against args and returns the result defined by resultType.
+func NewFunction(
+	name string,
+	resultType FuncType,
+	validator Validator,
+	evaluator Evaluator,
+) *Func {
+	return &Func{name, resultType, validator, evaluator}
+}
+
+// Name returns the name of the function.
+func (f *Func) Name() string { return f.name }
+
+// ResultType returns the data type of the function return value.
+func (f *Func) ResultType() FuncType { return f.resultType }
+
+// Evaluate executes the function against args and returns the result of type
+// [ResultType].
+func (f *Func) Evaluate(args []JSONPathValue) JSONPathValue {
+	return f.evaluator(args)
+}
+
+// Validate executes at parse time to validate that all the args to the
+// function are compatible with the function.
+func (f *Func) Validate(args []FuncExprArg) error {
+	return f.validator(args)
+}
+
 // PathFunction represents a JSONPath function. Implemented by
 // [github.com/theory/jsonpath/registry.Function].
 type PathFunction interface {