Merge branch 'i18n-custom-errors' into v9

Author: Dean Karn

README.md

@@ -5,21 +5,7 @@ based on tags.
 It can also handle Cross-Field and Cross-Struct validation for nested structs
 and has the ability to dive into arrays and maps of any type.
 
-Why not a better error message?
-Because this library intends for you to handle your own error messages.
-
-Why should I handle my own errors?
-Many reasons. We built an internationalized application and needed to know the
-field, and what validation failed so we could provide a localized error.
-
-	if fieldErr.Field() == "Name" {
-		switch fieldErr.Tag()
-		case "required":
-			return "Translated string based on field + error"
-		default:
-		return "Translated string based on field"
-	}
-
+see more examples https://github.com/go-playground/validator/tree/v9/examples
 
 Validation Functions Return Type error
 

doc.go

@@ -5,12 +5,16 @@ import (
 	"fmt"
 	"reflect"
 	"strings"
+
+	"github.com/go-playground/universal-translator"
 )
 
 const (
 	fieldErrMsg = "Key: '%s' Error:Field validation for '%s' failed on the '%s' tag"
 )
 
+type ValidationErrorsTranslations map[string]string
+
 // InvalidValidationError describes an invalid argument passed to
 // `Struct`, `StructExcept`, StructPartial` or `Field`
 type InvalidValidationError struct {
@@ -39,18 +43,40 @@ func (ve ValidationErrors) Error() string {
 
 	buff := bytes.NewBufferString("")
 
-	var err *fieldError
+	var fe *fieldError
 
 	for i := 0; i < len(ve); i++ {
 
-		err = ve[i].(*fieldError)
-		buff.WriteString(err.Error())
+		fe = ve[i].(*fieldError)
+		buff.WriteString(fe.Error())
 		buff.WriteString("\n")
 	}
 
 	return strings.TrimSpace(buff.String())
 }
 
+func (ve ValidationErrors) Translate(ut ut.Translator) ValidationErrorsTranslations {
+
+	trans := make(ValidationErrorsTranslations)
+
+	var fe *fieldError
+
+	for i := 0; i < len(ve); i++ {
+		fe = ve[i].(*fieldError)
+
+		// // in case an Anonymous struct was used, ensure that the key
+		// // would be 'Username' instead of ".Username"
+		// if len(fe.ns) > 0 && fe.ns[:1] == "." {
+		// 	trans[fe.ns[1:]] = fe.Translate(ut)
+		// 	continue
+		// }
+
+		trans[fe.ns] = fe.Translate(ut)
+	}
+
+	return trans
+}
+
 // FieldError contains all functions to get error details
 type FieldError interface {
 
@@ -118,6 +144,13 @@ type FieldError interface {
 	//
 	// // eg. time.Time's type is time.Time
 	Type() reflect.Type
+
+	// returns the FieldError's translated error
+	// from the provided 'ut.Translator' and registered 'TranslationFunc'
+	//
+	// NOTE: is not registered translation can be found it returns the same
+	// as calling fe.Error()
+	Translate(ut ut.Translator) string
 }
 
 // compile time interface checks
@@ -128,6 +161,7 @@ var _ error = new(fieldError)
 // with other properties that may be needed for error message creation
 // it complies with the FieldError interface
 type fieldError struct {
+	v              *Validate
 	tag            string
 	actualTag      string
 	ns             string
@@ -166,8 +200,18 @@ func (fe *fieldError) StructNamespace() string {
 // Field returns the fields name with the tag name taking precedence over the
 // fields actual name.
 func (fe *fieldError) Field() string {
-	// return fe.field
+
 	return fe.ns[len(fe.ns)-int(fe.fieldLen):]
+	// // return fe.field
+	// fld := fe.ns[len(fe.ns)-int(fe.fieldLen):]
+
+	// log.Println("FLD:", fld)
+
+	// if len(fld) > 0 && fld[:1] == "." {
+	// 	return fld[1:]
+	// }
+
+	// return fld
 }
 
 // returns the fields actual name from the struct, when able to determine.
@@ -202,3 +246,23 @@ func (fe *fieldError) Type() reflect.Type {
 func (fe *fieldError) Error() string {
 	return fmt.Sprintf(fieldErrMsg, fe.ns, fe.Field(), fe.tag)
 }
+
+// Translate returns the FieldError's translated error
+// from the provided 'ut.Translator' and registered 'TranslationFunc'
+//
+// NOTE: is not registered translation can be found it returns the same
+// as calling fe.Error()
+func (fe *fieldError) Translate(ut ut.Translator) string {
+
+	m, ok := fe.v.transTagFunc[ut]
+	if !ok {
+		return fe.Error()
+	}
+
+	fn, ok := m[fe.tag]
+	if !ok {
+		return fe.Error()
+	}
+
+	return fn(ut, fe)
+}

errors.go

@@ -0,0 +1,129 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/go-playground/locales/en"
+	"github.com/go-playground/universal-translator"
+	"gopkg.in/go-playground/validator.v9"
+	en_translations "gopkg.in/go-playground/validator.v9/translations/en"
+)
+
+// User contains user information
+type User struct {
+	FirstName      string     `validate:"required"`
+	LastName       string     `validate:"required"`
+	Age            uint8      `validate:"gte=0,lte=130"`
+	Email          string     `validate:"required,email"`
+	FavouriteColor string     `validate:"iscolor"`                // alias for 'hexcolor|rgb|rgba|hsl|hsla'
+	Addresses      []*Address `validate:"required,dive,required"` // a person can have a home and cottage...
+}
+
+// Address houses a users address information
+type Address struct {
+	Street string `validate:"required"`
+	City   string `validate:"required"`
+	Planet string `validate:"required"`
+	Phone  string `validate:"required"`
+}
+
+// use a single instance , it caches struct info
+var (
+	uni      *ut.UniversalTranslator
+	validate *validator.Validate
+)
+
+func main() {
+
+	// NOTE: ommitting allot of error checking for brevity
+
+	en := en.New()
+	uni = ut.New(en, en)
+
+	// this is usually know or extracted from http 'Accept-Language' header
+	// also see uni.FindTranslator(...)
+	trans, _ := uni.GetTranslator("en")
+
+	validate = validator.New()
+	en_translations.RegisterDefaultTranslations(validate, trans)
+
+	translateAll(trans)
+	translateIndividual(trans)
+	translateOverride(trans) // yep you can specify your own in whatever locale you want!
+}
+
+func translateAll(trans ut.Translator) {
+
+	type User struct {
+		Username string `validate:"required"`
+		Tagline  string `validate:"required,lt=10"`
+		Tagline2 string `validate:"required,gt=1"`
+	}
+
+	user := User{
+		Username: "Joeybloggs",
+		Tagline:  "This tagline is way too long.",
+		Tagline2: "1",
+	}
+
+	err := validate.Struct(user)
+	if err != nil {
+
+		// translate all error at once
+		errs := err.(validator.ValidationErrors)
+
+		// returns a map with key = namespace & value = translated error
+		// NOTICE: 2 errors are returned and you'll see something surprising
+		// translations are i18n aware!!!!
+		// eg. '10 characters' vs '1 character'
+		fmt.Println(errs.Translate(trans))
+	}
+}
+
+func translateIndividual(trans ut.Translator) {
+
+	type User struct {
+		Username string `validate:"required"`
+	}
+
+	var user User
+
+	err := validate.Struct(user)
+	if err != nil {
+
+		errs := err.(validator.ValidationErrors)
+
+		for _, e := range errs {
+			// can translate each error one at a time.
+			fmt.Println(e.Translate(trans))
+		}
+	}
+}
+
+func translateOverride(trans ut.Translator) {
+
+	validate.RegisterTranslation("required", trans, func(ut ut.Translator) error {
+		return ut.Add("required", "{0} must have a value!", true) // see universal-translator for details
+	}, func(ut ut.Translator, fe validator.FieldError) string {
+		t, _ := ut.T("required", fe.Field())
+
+		return t
+	})
+
+	type User struct {
+		Username string `validate:"required"`
+	}
+
+	var user User
+
+	err := validate.Struct(user)
+	if err != nil {
+
+		errs := err.(validator.ValidationErrors)
+
+		for _, e := range errs {
+			// can translate each error one at a time.
+			fmt.Println(e.Translate(trans))
+		}
+	}
+}

examples/translations/main.go

@@ -117,6 +117,7 @@ func (v *validate) ReportError(field interface{}, fieldName, structFieldName, ta
 
 		v.errs = append(v.errs,
 			&fieldError{
+				v:              v.v,
 				tag:            tag,
 				actualTag:      tag,
 				ns:             v.str1,
@@ -132,6 +133,7 @@ func (v *validate) ReportError(field interface{}, fieldName, structFieldName, ta
 
 	v.errs = append(v.errs,
 		&fieldError{
+			v:              v.v,
 			tag:            tag,
 			actualTag:      tag,
 			ns:             v.str1,

struct_level.go

@@ -0,0 +1,11 @@
+package validator
+
+import "github.com/go-playground/universal-translator"
+
+// TranslationFunc is the function type used to register or override
+// custom translations
+type TranslationFunc func(ut ut.Translator, fe FieldError) string
+
+// RegisterTranslationsFunc allows for registering of translations
+// for a 'ut.Translator' for use withing the 'TranslationFunc'
+type RegisterTranslationsFunc func(ut ut.Translator) error