changing validator function parameter to support a Field object

constraints.go

@@ -11,15 +11,15 @@ import (
 Base Constraints for all Data Types
 */
 
-func required(val reflect.Value, typ reflect.Type, param string) error {
-	switch typ.Kind() {
+func required(field field, param string) error {
+	switch field.typ.Kind() {
 	case reflect.String:
 		c, err := convertBool(param)
 		if err != nil {
 			return err
 		}
 		if c == true {
-			in, _ := val.Interface().(string)
+			in, _ := field.value.Interface().(string)
 			if in == "" {
 				return ErrRequired
 			}
@@ -32,38 +32,38 @@ func required(val reflect.Value, typ reflect.Type, param string) error {
 	return nil
 }
 
-func nillable(val reflect.Value, typ reflect.Type, param string) error {
+func nillable(field field, param string) error {
 	return nil
 }
 
-func def(val reflect.Value, typ reflect.Type, param string) error {
+func def(field field, param string) error {
 	return nil
 }
 
 /**
 Numerical Type Constraints
 */
 
-func min(val reflect.Value, typ reflect.Type, param string) error {
-	return checkMin(val, typ, param, false)
+func min(field field, param string) error {
+	return checkMin(field.value, field.typ, param, false)
 }
 
-func max(val reflect.Value, typ reflect.Type, param string) error {
-	return checkMax(val, typ, param, false)
+func max(field field, param string) error {
+	return checkMax(field.value, field.typ, param, false)
 }
 
-func exclusiveMin(val reflect.Value, typ reflect.Type, param string) error {
-	return checkMin(val, typ, param, true)
+func exclusiveMin(field field, param string) error {
+	return checkMin(field.value, field.typ, param, true)
 }
 
-func exclusiveMax(val reflect.Value, typ reflect.Type, param string) error {
-	return checkMax(val, typ, param, true)
+func exclusiveMax(field field, param string) error {
+	return checkMax(field.value, field.typ, param, true)
 }
 
-func multipleOf(val reflect.Value, typ reflect.Type, param string) error {
+func multipleOf(field field, param string) error {
 	// TODO : works only for int as of now
 	valid := true
-	in, _ := val.Interface().(int)
+	in, _ := field.value.Interface().(int)
 	c, err := convertInt(param, 0)
 	cInt := int(c)
 	if err != nil {
@@ -80,31 +80,31 @@ func multipleOf(val reflect.Value, typ reflect.Type, param string) error {
 String Type Constraints
 */
 
-func minLength(val reflect.Value, typ reflect.Type, param string) error {
+func minLength(field field, param string) error {
 	valid := true
 	lc, _ := strconv.Atoi(param)
-	lv := len(fmt.Sprint(val))
+	lv := len(fmt.Sprint(field.value))
 	valid = lv > lc
 	if !valid {
 		return ErrMinLength
 	}
 	return nil
 }
 
-func maxLength(val reflect.Value, typ reflect.Type, param string) error {
+func maxLength(field field, param string) error {
 	valid := true
 	lc, _ := strconv.Atoi(param)
-	lv := len(fmt.Sprint(val))
+	lv := len(fmt.Sprint(field.value))
 	valid = lv < lc
 	if !valid {
 		return ErrMaxLength
 	}
 	return nil
 }
 
-func pattern(val reflect.Value, typ reflect.Type, param string) error {
-	in, _ := val.Interface().(string)
-	if typ.Kind() != reflect.String {
+func pattern(field field, param string) error {
+	in, _ := field.value.Interface().(string)
+	if field.value.Kind() != reflect.String {
 		return ErrNotSupported
 	}
 	re, err := regexp.Compile(param)
@@ -117,14 +117,14 @@ func pattern(val reflect.Value, typ reflect.Type, param string) error {
 	return nil
 }
 
-func enum(val reflect.Value, typ reflect.Type, param string) error {
+func enum(field field, param string) error {
 	flag := false
-	switch typ.Kind() {
+	switch field.value.Kind() {
 	case reflect.Int:
-		input := val.Interface().(int)
+		input := field.value.Interface().(int)
 		flag = checkIfEnumExists(strconv.Itoa(input), param, ",")
 	case reflect.String:
-		input := val.String()
+		input := field.value.String()
 		flag = checkIfEnumExists(input, param, ",")
 	}
 

validate.go

@@ -1,11 +1,12 @@
 package validator
 
 import (
-	"go.nandlabs.io/l3"
 	"reflect"
 	"regexp"
 	"strings"
 	"sync"
+
+	"go.nandlabs.io/l3"
 )
 
 var logger = l3.Get()
@@ -15,7 +16,7 @@ var mapMandatory = map[string]string{
 	"nillable": "nillable",
 }
 
-type StructValidatorFunc func(v reflect.Value, typ reflect.Type, param string) error
+type StructValidatorFunc func(field field, param string) error
 
 type tStruct struct {
 	name  string
@@ -91,17 +92,17 @@ func (sv *StructValidator) Validate(v interface{}) error {
 }
 
 func (sv *StructValidator) validateFields() error {
-	for _, v := range sv.fields.list {
+	for _, field := range sv.fields.list {
 		// check if the constraints tag is present or not, skip any kind of validation for which the constraints are not passed
-		if (reflect.DeepEqual(v.constraints[0], tStruct{})) {
-			logger.InfoF("skipping validation check for field: %s", v.name)
+		if (reflect.DeepEqual(field.constraints[0], tStruct{})) {
+			logger.InfoF("skipping validation check for field: %s", field.name)
 			continue
 		}
-		if err := checkForMandatory(v.constraints); err != nil {
+		if err := checkForMandatory(field.constraints); err != nil {
 			return err
 		}
-		for _, val := range v.constraints {
-			if err := val.fnc(v.value, v.typ, val.value); err != nil {
+		for _, val := range field.constraints {
+			if err := val.fnc(field, val.value); err != nil {
 				return err
 			}
 		}
@@ -122,7 +123,7 @@ func checkForMandatory(constraint []tStruct) error {
 	return nil
 }
 
-//parseTag returns the map of constraints
+// parseTag returns the map of constraints
 func (sv *StructValidator) parseTag(tag string) ([]tStruct, error) {
 	tl := splitUnescapedComma(tag)
 	t := make([]tStruct, 0, len(tl))