improve solution

Author: peczenyj

README.md

@@ -262,7 +262,7 @@ validate := validator.New(validator.WithRequiredStructEnabled())
 | excluded_without | Excluded Without |
 | excluded_without_all | Excluded Without All |
 | unique | Unique |
-| validateFn | Verify if the method `Validate() error` does not return an error |
+| validateFn | Verify if the method `Validate() error` does not return an error (or any specified method) |
 
 
 #### Aliases:

_examples/validate_fn/go.mod

@@ -0,0 +1,18 @@
+module github.com/peczenyj/validator/_examples/validate_fn
+
+go 1.20
+
+replace github.com/go-playground/validator/v10 => ../../../validator
+
+require github.com/go-playground/validator/v10 v10.26.0
+
+require (
+	github.com/gabriel-vasile/mimetype v1.4.8 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/leodido/go-urn v1.4.0 // indirect
+	golang.org/x/crypto v0.33.0 // indirect
+	golang.org/x/net v0.34.0 // indirect
+	golang.org/x/sys v0.30.0 // indirect
+	golang.org/x/text v0.22.0 // indirect
+)

_examples/validate_fn/go.sum

@@ -0,0 +1,21 @@
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/gabriel-vasile/mimetype v1.4.8 h1:FfZ3gj38NjllZIeJAmMhr+qKL8Wu+nOoI3GqacKw1NM=
+github.com/gabriel-vasile/mimetype v1.4.8/go.mod h1:ByKUIKGjh1ODkGM1asKUbQZOLGrPjydw3hYPU2YU9t8=
+github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
+github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
+github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
+github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
+github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
+github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
+github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus=
+golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M=
+golang.org/x/net v0.34.0 h1:Mb7Mrk043xzHgnRM88suvJFwzVrRfHEHJEl5/71CKw0=
+golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
+golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
+golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
+golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

_examples/validate_fn/main.go

@@ -0,0 +1,52 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/go-playground/validator/v10"
+)
+
+type Enum uint8
+
+const (
+	Zero Enum = iota
+	One
+	Two
+)
+
+func (e Enum) NotZero() bool {
+	return e != Zero
+}
+
+func (e *Enum) Validate() error {
+	if e == nil {
+		return errors.New("can't be nil")
+	}
+
+	return nil
+}
+
+type Struct struct {
+	Foo *Enum `validate:"validateFn"`         //uses Validate() error by default
+	Bar Enum  `validate:"validateFn=NotZero"` // uses NotZero() bool
+}
+
+func main() {
+	validate := validator.New()
+
+	var x Struct
+
+	if err := validate.Struct(x); err != nil {
+		fmt.Printf("Expected Err(s):\n%+v\n", err)
+	}
+
+	x = Struct{
+		Foo: new(Enum),
+		Bar: One,
+	}
+
+	if err := validate.Struct(x); err != nil {
+		fmt.Printf("Unexpected Err(s):\n%+v\n", err)
+	}
+}

baked_in.go

@@ -2,10 +2,12 @@ package validator
 
 import (
 	"bytes"
+	"cmp"
 	"context"
 	"crypto/sha256"
 	"encoding/hex"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io/fs"
 	"net"
@@ -3049,27 +3051,58 @@ func isEIN(fl FieldLevel) bool {
 }
 
 func isValidateFn(fl FieldLevel) bool {
-	if instance, ok := tryConvertFieldTo[interface{ Validate() error }](fl.Field()); ok {
-		return instance.Validate() == nil
+	const defaultParam = `Validate`
+
+	field := fl.Field()
+	param := cmp.Or(fl.Param(), defaultParam)
+
+	ok, err := tryCallValidateFn(field, param)
+	if err != nil {
+		panic(err)
 	}
 
-	return false
+	return ok
 }
 
-func tryConvertFieldTo[V any](field reflect.Value) (v V, ok bool) {
-	v, ok = convertFieldTo[V](field)
-	if !ok && field.CanAddr() {
-		v, ok = convertFieldTo[V](field.Addr())
+var (
+	errMethodNotFound          = errors.New(`method not found`)
+	errMethodReturnNoValues    = errors.New(`method return o values (void)`)
+	errMethodReturnInvalidType = errors.New(`method should return invalid type`)
+)
+
+func tryCallValidateFn(field reflect.Value, methodName string) (bool, error) {
+	method := field.MethodByName(methodName)
+	if !method.IsValid() {
+		method = field.Addr().MethodByName(methodName)
 	}
 
-	return v, ok
-}
+	if !method.IsValid() {
+		return false, fmt.Errorf("unable to call %q on type %q: %w",
+			methodName, field.Type().String(), errMethodNotFound)
+	}
 
-func convertFieldTo[V any](field reflect.Value) (v V, ok bool) {
-	if v, ok = field.Interface().(V); ok {
-		return v, ok
+	returnValues := method.Call([]reflect.Value{})
+	if len(returnValues) == 0 {
+		return false, fmt.Errorf("unable to use result of method %q on type %q: %w",
+			methodName, field.Type().String(), errMethodReturnNoValues)
 	}
 
-	var zero V
-	return zero, false
+	firstReturnValue := returnValues[0]
+
+	switch firstReturnValue.Kind() {
+	case reflect.Bool:
+		return firstReturnValue.Bool(), nil
+	case reflect.Interface:
+		errorType := reflect.TypeOf((*error)(nil)).Elem()
+
+		if firstReturnValue.Type().Implements(errorType) {
+			return firstReturnValue.IsNil(), nil
+		}
+
+		return false, fmt.Errorf("unable to use result of method %q on type %q: %w (got interface %v expect error)",
+			methodName, field.Type().String(), errMethodReturnInvalidType, firstReturnValue.Type().String())
+	default:
+		return false, fmt.Errorf("unable to use result of method %q on type %q: %w (got %v expect error or bool)",
+			methodName, field.Type().String(), errMethodReturnInvalidType, firstReturnValue.Type().String())
+	}
 }

doc.go

@@ -758,11 +758,18 @@ in a field of the struct specified via a parameter.
 
 # ValidateFn
 
-This validates that an object respects the interface `Validate() error` and
-the method `Validate` does not return an error.
+This validates that an object responds to a method that can return error or bool.
+By default it expects an interface `Validate() error` and check that the method
+does not return an error. Other methods can be specified using two signatures:
+If the method returns an error, it check if the return value is nil.
+If the method returns a boolean, it checks if the value is true.
 
+	// to use the default method Validate() error
 	Usage: validateFn
 
+	// to use the custom method IsValid() bool (or error)
+	Usage: validateFn=IsValid
+
 # Alpha Only
 
 This validates that a string value contains ASCII alpha characters only

validator_test.go

@@ -14162,7 +14162,11 @@ func (r *NotRed) Validate() error {
 	return nil
 }
 
-func TestIsValid(t *testing.T) {
+func (r NotRed) IsNotRed() bool {
+	return r.Color != "red"
+}
+
+func TestValidateFn(t *testing.T) {
 	t.Run("using pointer", func(t *testing.T) {
 		validate := New()
 
@@ -14223,4 +14227,32 @@ func TestIsValid(t *testing.T) {
 		Equal(t, fe.Namespace(), "Test2.Inner")
 		Equal(t, fe.Tag(), "validateFn")
 	})
+
+	t.Run("using struct with custom function", func(t *testing.T) {
+		validate := New()
+
+		type Test2 struct {
+			String string
+			Inner  NotRed `validate:"validateFn=IsNotRed"`
+		}
+
+		var tt2 Test2
+
+		errs := validate.Struct(&tt2)
+		Equal(t, errs, nil)
+
+		tt2.Inner = NotRed{Color: "blue"}
+
+		errs = validate.Struct(&tt2)
+		Equal(t, errs, nil)
+
+		tt2.Inner = NotRed{Color: "red"}
+		errs = validate.Struct(&tt2)
+		NotEqual(t, errs, nil)
+
+		fe := errs.(ValidationErrors)[0]
+		Equal(t, fe.Field(), "Inner")
+		Equal(t, fe.Namespace(), "Test2.Inner")
+		Equal(t, fe.Tag(), "validateFn")
+	})
 }