feat: Upgrading to a more recent version of golang, any over interface

elliotcourant · elliotcourant · commit d29ab7b7b249 · 2025-01-23T18:36:57.000-06:00
diff --git a/absent.go b/absent.go
@@ -25,7 +25,7 @@ type absentRule struct {
 }
 
 // Validate checks if the given value is valid or not.
-func (r absentRule) Validate(value interface{}) error {
+func (r absentRule) Validate(value any) error {
 	if r.condition {
 		value, isNil := Indirect(value)
 		if !r.skipNil && !isNil || r.skipNil && !isNil && !IsEmpty(value) {
diff --git a/date.go b/date.go
@@ -79,7 +79,7 @@ func (r DateRule) Max(max time.Time) DateRule {
 }
 
 // Validate checks if the given value is a valid date.
-func (r DateRule) Validate(value interface{}) error {
+func (r DateRule) Validate(value any) error {
 	value, isNil := Indirect(value)
 	if isNil || IsEmpty(value) {
 		return nil
diff --git a/each.go b/each.go
@@ -26,12 +26,12 @@ type EachRule struct {
 }
 
 // Validate loops through the given iterable and calls the Ozzo Validate() method for each value.
-func (r EachRule) Validate(value interface{}) error {
-	return r.ValidateWithContext(nil, value)
+func (r EachRule) Validate(value any) error {
+	return r.ValidateWithContext(context.TODO(), value)
 }
 
 // ValidateWithContext loops through the given iterable and calls the Ozzo ValidateWithContext() method for each value.
-func (r EachRule) ValidateWithContext(ctx context.Context, value interface{}) error {
+func (r EachRule) ValidateWithContext(ctx context.Context, value any) error {
 	errs := Errors{}
 
 	v := reflect.ValueOf(value)
diff --git a/error.go b/error.go
@@ -20,16 +20,16 @@ type (
 		Code() string
 		Message() string
 		SetMessage(string) Error
-		Params() map[string]interface{}
-		SetParams(map[string]interface{}) Error
+		Params() map[string]any
+		SetParams(map[string]any) Error
 	}
 
 	// ErrorObject is the default validation error
 	// that implements the Error interface.
 	ErrorObject struct {
 		code    string
 		message string
-		params  map[string]interface{}
+		params  map[string]any
 	}
 
 	// Errors represents the validation errors that are indexed by struct field names, map or slice keys.
@@ -69,23 +69,23 @@ func (e ErrorObject) Code() string {
 }
 
 // SetParams set the error's params.
-func (e ErrorObject) SetParams(params map[string]interface{}) Error {
+func (e ErrorObject) SetParams(params map[string]any) Error {
 	e.params = params
 	return e
 }
 
 // AddParam add parameter to the error's parameters.
-func (e ErrorObject) AddParam(name string, value interface{}) Error {
+func (e ErrorObject) AddParam(name string, value any) Error {
 	if e.params == nil {
-		e.params = make(map[string]interface{})
+		e.params = make(map[string]any)
 	}
 
 	e.params[name] = value
 	return e
 }
 
 // Params returns the error's params.
-func (e ErrorObject) Params() map[string]interface{} {
+func (e ErrorObject) Params() map[string]any {
 	return e.params
 }
 
diff --git a/go.mod b/go.mod
@@ -1,8 +1,14 @@
 module github.com/monetr/validation
 
-go 1.13
+go 1.22
 
 require (
 	github.com/asaskevich/govalidator v0.0.0-20200108200545-475eaeb16496
 	github.com/stretchr/testify v1.4.0
 )
+
+require (
+	github.com/davecgh/go-spew v1.1.0 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	gopkg.in/yaml.v2 v2.2.2 // indirect
+)
diff --git a/go.sum b/go.sum
@@ -4,7 +4,6 @@ github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
diff --git a/in.go b/in.go
@@ -15,7 +15,7 @@ var ErrInInvalid = NewError("validation_in_invalid", "must be a valid value")
 // reflect.DeepEqual() will be used to determine if two values are equal.
 // For more details please refer to https://golang.org/pkg/reflect/#DeepEqual
 // An empty value is considered valid. Use the Required rule to make sure a value is not empty.
-func In(values ...interface{}) InRule {
+func In(values ...any) InRule {
 	return InRule{
 		elements: values,
 		err:      ErrInInvalid,
@@ -24,12 +24,12 @@ func In(values ...interface{}) InRule {
 
 // InRule is a validation rule that validates if a value can be found in the given list of values.
 type InRule struct {
-	elements []interface{}
+	elements []any
 	err      Error
 }
 
 // Validate checks if the given value is valid or not.
-func (r InRule) Validate(value interface{}) error {
+func (r InRule) Validate(value any) error {
 	value, isNil := Indirect(value)
 	if isNil || IsEmpty(value) {
 		return nil
diff --git a/is/rules.go b/is/rules.go
@@ -275,7 +275,7 @@ func isDomain(value string) bool {
 
 func isUTFNumeric(value string) bool {
 	for _, c := range value {
-		if unicode.IsNumber(c) == false {
+		if !unicode.IsNumber(c) {
 			return false
 		}
 	}
diff --git a/length.go b/length.go
@@ -50,7 +50,7 @@ type LengthRule struct {
 }
 
 // Validate checks if the given value is valid or not.
-func (r LengthRule) Validate(value interface{}) error {
+func (r LengthRule) Validate(value any) error {
 	value, isNil := Indirect(value)
 	if isNil || IsEmpty(value) {
 		return nil
@@ -100,5 +100,5 @@ func buildLengthRuleError(min, max int) (err Error) {
 		err = ErrLengthEmptyRequired
 	}
 
-	return err.SetParams(map[string]interface{}{"min": min, "max": max})
+	return err.SetParams(map[string]any{"min": min, "max": max})
 }
diff --git a/match.go b/match.go
@@ -28,7 +28,7 @@ type MatchRule struct {
 }
 
 // Validate checks if the given value is valid or not.
-func (r MatchRule) Validate(value interface{}) error {
+func (r MatchRule) Validate(value any) error {
 	value, isNil := Indirect(value)
 	if isNil {
 		return nil
diff --git a/minmax.go b/minmax.go
@@ -23,7 +23,7 @@ var (
 
 // ThresholdRule is a validation rule that checks if a value satisfies the specified threshold requirement.
 type ThresholdRule struct {
-	threshold interface{}
+	threshold any
 	operator  int
 	err       Error
 }
@@ -40,7 +40,7 @@ const (
 // Note that the value being checked and the threshold value must be of the same type.
 // Only int, uint, float and time.Time types are supported.
 // An empty value is considered valid. Please use the Required rule to make sure a value is not empty.
-func Min(min interface{}) ThresholdRule {
+func Min(min any) ThresholdRule {
 	return ThresholdRule{
 		threshold: min,
 		operator:  greaterEqualThan,
@@ -54,7 +54,7 @@ func Min(min interface{}) ThresholdRule {
 // Note that the value being checked and the threshold value must be of the same type.
 // Only int, uint, float and time.Time types are supported.
 // An empty value is considered valid. Please use the Required rule to make sure a value is not empty.
-func Max(max interface{}) ThresholdRule {
+func Max(max any) ThresholdRule {
 	return ThresholdRule{
 		threshold: max,
 		operator:  lessEqualThan,
@@ -64,18 +64,19 @@ func Max(max interface{}) ThresholdRule {
 
 // Exclusive sets the comparison to exclude the boundary value.
 func (r ThresholdRule) Exclusive() ThresholdRule {
-	if r.operator == greaterEqualThan {
+	switch r.operator {
+	case greaterEqualThan:
 		r.operator = greaterThan
 		r.err = ErrMinGreaterThanRequired
-	} else if r.operator == lessEqualThan {
+	case lessEqualThan:
 		r.operator = lessThan
 		r.err = ErrMaxLessThanRequired
 	}
 	return r
 }
 
 // Validate checks if the given value is valid or not.
-func (r ThresholdRule) Validate(value interface{}) error {
+func (r ThresholdRule) Validate(value any) error {
 	value, isNil := Indirect(value)
 	if isNil || IsEmpty(value) {
 		return nil
@@ -127,7 +128,7 @@ func (r ThresholdRule) Validate(value interface{}) error {
 		return fmt.Errorf("type not supported: %v", rv.Type())
 	}
 
-	return r.err.SetParams(map[string]interface{}{"threshold": r.threshold})
+	return r.err.SetParams(map[string]any{"threshold": r.threshold})
 }
 
 // Error sets the error message for the rule.
diff --git a/multipleof.go b/multipleof.go
@@ -10,7 +10,7 @@ var ErrMultipleOfInvalid = NewError("validation_multiple_of_invalid", "must be m
 
 // MultipleOf returns a validation rule that checks if a value is a multiple of the "base" value.
 // Note that "base" should be of integer type.
-func MultipleOf(base interface{}) MultipleOfRule {
+func MultipleOf(base any) MultipleOfRule {
 	return MultipleOfRule{
 		base: base,
 		err:  ErrMultipleOfInvalid,
@@ -19,7 +19,7 @@ func MultipleOf(base interface{}) MultipleOfRule {
 
 // MultipleOfRule is a validation rule that checks if a value is a multiple of the "base" value.
 type MultipleOfRule struct {
-	base interface{}
+	base any
 	err  Error
 }
 
@@ -36,7 +36,7 @@ func (r MultipleOfRule) ErrorObject(err Error) MultipleOfRule {
 }
 
 // Validate checks if the value is a multiple of the "base" value.
-func (r MultipleOfRule) Validate(value interface{}) error {
+func (r MultipleOfRule) Validate(value any) error {
 	rv := reflect.ValueOf(r.base)
 	switch rv.Kind() {
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
@@ -61,5 +61,5 @@ func (r MultipleOfRule) Validate(value interface{}) error {
 		return fmt.Errorf("type not supported: %v", rv.Type())
 	}
 
-	return r.err.SetParams(map[string]interface{}{"base": r.base})
+	return r.err.SetParams(map[string]any{"base": r.base})
 }
diff --git a/not_in.go b/not_in.go
@@ -10,7 +10,7 @@ var ErrNotInInvalid = NewError("validation_not_in_invalid", "must not be in list
 // NotIn returns a validation rule that checks if a value is absent from the given list of values.
 // Note that the value being checked and the possible range of values must be of the same type.
 // An empty value is considered valid. Use the Required rule to make sure a value is not empty.
-func NotIn(values ...interface{}) NotInRule {
+func NotIn(values ...any) NotInRule {
 	return NotInRule{
 		elements: values,
 		err:      ErrNotInInvalid,
@@ -19,12 +19,12 @@ func NotIn(values ...interface{}) NotInRule {
 
 // NotInRule is a validation rule that checks if a value is absent from the given list of values.
 type NotInRule struct {
-	elements []interface{}
+	elements []any
 	err      Error
 }
 
 // Validate checks if the given value is valid or not.
-func (r NotInRule) Validate(value interface{}) error {
+func (r NotInRule) Validate(value any) error {
 	value, isNil := Indirect(value)
 	if isNil || IsEmpty(value) {
 		return nil
diff --git a/not_nil.go b/not_nil.go
@@ -17,7 +17,7 @@ type notNilRule struct {
 }
 
 // Validate checks if the given value is valid or not.
-func (r notNilRule) Validate(value interface{}) error {
+func (r notNilRule) Validate(value any) error {
 	_, isNil := Indirect(value)
 	if isNil {
 		if r.err != nil {
diff --git a/required.go b/required.go
@@ -32,7 +32,7 @@ type RequiredRule struct {
 }
 
 // Validate checks if the given value is valid or not.
-func (r RequiredRule) Validate(value interface{}) error {
+func (r RequiredRule) Validate(value any) error {
 	if r.condition {
 		value, isNil := Indirect(value)
 		if r.skipNil && !isNil && IsEmpty(value) || !r.skipNil && (isNil || IsEmpty(value)) {
diff --git a/string.go b/string.go
@@ -45,7 +45,7 @@ func (r StringRule) ErrorObject(err Error) StringRule {
 }
 
 // Validate checks if the given value is valid or not.
-func (r StringRule) Validate(value interface{}) error {
+func (r StringRule) Validate(value any) error {
 	value, isNil := Indirect(value)
 	if isNil || IsEmpty(value) {
 		return nil
diff --git a/struct.go b/struct.go
@@ -26,7 +26,7 @@ type (
 
 	// FieldRules represents a rule set associated with a struct field.
 	FieldRules struct {
-		fieldPtr interface{}
+		fieldPtr any
 		rules    []Rule
 	}
 )
@@ -59,15 +59,15 @@ func (e ErrFieldNotFound) Error() string {
 //	// Value: the length must be between 5 and 10.
 //
 // An error will be returned if validation fails.
-func ValidateStruct(structPtr interface{}, fields ...*FieldRules) error {
-	return ValidateStructWithContext(nil, structPtr, fields...)
+func ValidateStruct(structPtr any, fields ...*FieldRules) error {
+	return ValidateStructWithContext(context.TODO(), structPtr, fields...)
 }
 
 // ValidateStructWithContext validates a struct with the given context.
 // The only difference between ValidateStructWithContext and ValidateStruct is that the former will
 // validate struct fields with the provided context.
 // Please refer to ValidateStruct for the detailed instructions on how to use this function.
-func ValidateStructWithContext(ctx context.Context, structPtr interface{}, fields ...*FieldRules) error {
+func ValidateStructWithContext(ctx context.Context, structPtr any, fields ...*FieldRules) error {
 	value := reflect.ValueOf(structPtr)
 	if value.Kind() != reflect.Ptr || !value.IsNil() && value.Elem().Kind() != reflect.Struct {
 		// must be a pointer to a struct
@@ -121,7 +121,7 @@ func ValidateStructWithContext(ctx context.Context, structPtr interface{}, field
 
 // Field specifies a struct field and the corresponding validation rules.
 // The struct field must be specified as a pointer to it.
-func Field(fieldPtr interface{}, rules ...Rule) *FieldRules {
+func Field(fieldPtr any, rules ...Rule) *FieldRules {
 	return &FieldRules{
 		fieldPtr: fieldPtr,
 		rules:    rules,
diff --git a/util.go b/util.go
@@ -131,7 +131,7 @@ func IsEmpty(value interface{}) bool {
 // the Value() method instead. A boolean value is also returned to indicate if
 // the value is nil or not (only applicable to interface, pointer, map, and slice).
 // If the value is neither an interface nor a pointer, it will be returned back.
-func Indirect(value interface{}) (interface{}, bool) {
+func Indirect(value any) (any, bool) {
 	rv := reflect.ValueOf(value)
 	kind := rv.Kind()
 	switch kind {
@@ -155,7 +155,7 @@ func Indirect(value interface{}) (interface{}, bool) {
 	return value, false
 }
 
-func indirectValuer(valuer driver.Valuer) (interface{}, bool) {
+func indirectValuer(valuer driver.Valuer) (any, bool) {
 	if value, err := valuer.Value(); value != nil && err == nil {
 		return Indirect(value)
 	}
diff --git a/when.go b/when.go
@@ -19,12 +19,12 @@ type WhenRule struct {
 }
 
 // Validate checks if the condition is true and if so, it validates the value using the specified rules.
-func (r WhenRule) Validate(value interface{}) error {
-	return r.ValidateWithContext(nil, value)
+func (r WhenRule) Validate(value any) error {
+	return r.ValidateWithContext(context.TODO(), value)
 }
 
 // ValidateWithContext checks if the condition is true and if so, it validates the value using the specified rules.
-func (r WhenRule) ValidateWithContext(ctx context.Context, value interface{}) error {
+func (r WhenRule) ValidateWithContext(ctx context.Context, value any) error {
 	if r.condition {
 		if ctx == nil {
 			return Validate(value, r.rules...)

Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ type absentRule struct {`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`// Validate checks if the given value is valid or not.`
`28`		`-func (r absentRule) Validate(value interface{}) error {`
	`28`	`+func (r absentRule) Validate(value any) error {`
`29`	`29`	`if r.condition {`
`30`	`30`	`value, isNil := Indirect(value)`
`31`	`31`	`if !r.skipNil && !isNil \|\| r.skipNil && !isNil && !IsEmpty(value) {`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ func (r DateRule) Max(max time.Time) DateRule {`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`// Validate checks if the given value is a valid date.`
`82`		`-func (r DateRule) Validate(value interface{}) error {`
	`82`	`+func (r DateRule) Validate(value any) error {`
`83`	`83`	`value, isNil := Indirect(value)`
`84`	`84`	`if isNil \|\| IsEmpty(value) {`
`85`	`85`	`return nil`
Original file line number	Diff line number	Diff line change
`@@ -26,12 +26,12 @@ type EachRule struct {`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`// Validate loops through the given iterable and calls the Ozzo Validate() method for each value.`
`29`		`-func (r EachRule) Validate(value interface{}) error {`
`30`		`- return r.ValidateWithContext(nil, value)`
	`29`	`+func (r EachRule) Validate(value any) error {`
	`30`	`+ return r.ValidateWithContext(context.TODO(), value)`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`// ValidateWithContext loops through the given iterable and calls the Ozzo ValidateWithContext() method for each value.`
`34`		`-func (r EachRule) ValidateWithContext(ctx context.Context, value interface{}) error {`
	`34`	`+func (r EachRule) ValidateWithContext(ctx context.Context, value any) error {`
`35`	`35`	`errs := Errors{}`
`36`	`36`
`37`	`37`	`v := reflect.ValueOf(value)`
Original file line number	Diff line number	Diff line change
`@@ -275,7 +275,7 @@ func isDomain(value string) bool {`
`275`	`275`
`276`	`276`	`func isUTFNumeric(value string) bool {`
`277`	`277`	`for _, c := range value {`
`278`		`- if unicode.IsNumber(c) == false {`
	`278`	`+ if !unicode.IsNumber(c) {`
`279`	`279`	`return false`
`280`	`280`	`}`
`281`	`281`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ type LengthRule struct {`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`// Validate checks if the given value is valid or not.`
`53`		`-func (r LengthRule) Validate(value interface{}) error {`
	`53`	`+func (r LengthRule) Validate(value any) error {`
`54`	`54`	`value, isNil := Indirect(value)`
`55`	`55`	`if isNil \|\| IsEmpty(value) {`
`56`	`56`	`return nil`
`@@ -100,5 +100,5 @@ func buildLengthRuleError(min, max int) (err Error) {`
`100`	`100`	`err = ErrLengthEmptyRequired`
`101`	`101`	`}`
`102`	`102`
`103`		`- return err.SetParams(map[string]interface{}{"min": min, "max": max})`
	`103`	`+ return err.SetParams(map[string]any{"min": min, "max": max})`
`104`	`104`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ type MatchRule struct {`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`// Validate checks if the given value is valid or not.`
`31`		`-func (r MatchRule) Validate(value interface{}) error {`
	`31`	`+func (r MatchRule) Validate(value any) error {`
`32`	`32`	`value, isNil := Indirect(value)`
`33`	`33`	`if isNil {`
`34`	`34`	`return nil`