Support setting formatter function for specific type of params (#19)

* Support setting formatter function for specific type of params

* Refactor readme

* Add tests

Author: tiendc

README.md

@@ -127,6 +127,27 @@ go get github.com/tiendc/go-validator
     }
 ```
 
+#### Custom error param formatter
+
+```go
+    errs := Validate(
+        NumLT(&budget, 1000000).OnError(
+            SetField("Budget", nil),
+        ),
+    )
+
+    // e.BuildDetail() may produce message `Budget must be less than 1000000`,
+    // but you may want a message like: `Budget must be less than 1,000,000`.
+    // Let's use a custom formatter
+
+    errs := Validate(
+        NumLT(&budget, 1000000).OnError(
+            SetField("Budget", nil),
+            SetNumParamFormatter(NewDecimalFormatFunc('.', ',', "%f")),
+        ),
+    )
+```
+
 ## Contributing
 
 - You are welcome to make pull requests for new functions and bug fixes.

error_formatter.go

@@ -186,6 +186,8 @@ func NewTypedParamFormatter() TypedParamFormatter {
 // To attach this formatter to Error object:
 //   - err.TypedParamFormatter().SetNumFormatFunc(NewDecimalNumFormatFunc())
 //   - err.TypedParamFormatter().SetNumFormatFunc(NewDecimalNumFormatFunc("%.5f"))
+//
+// Deprecated: use NewDecimalFormatFunc instead
 func NewDecimalNumFormatFunc(floatFmt ...string) FormatFunc {
 	return func(v reflect.Value) string {
 		var s string
@@ -204,6 +206,28 @@ func NewDecimalNumFormatFunc(floatFmt ...string) FormatFunc {
 	}
 }
 
+// NewDecimalFormatFunc returns a FormatFunc which can format and group digits of decimal or integer
+// For example: '12345' -> '12,345', '12345.6789' -> '12,345.6789'
+// To attach this formatter to Error object:
+//   - err.TypedParamFormatter().SetNumFormatFunc(NewDecimalFormatFunc('.', ',', "%.2f"))
+func NewDecimalFormatFunc(fractionSep, groupSep byte, floatFmt string) FormatFunc {
+	return func(v reflect.Value) string {
+		var s string
+		// nolint: exhaustive
+		switch v.Kind() {
+		case reflect.Float64, reflect.Float32:
+			fmtStr := floatFmt
+			if fmtStr == "" {
+				fmtStr = "%f"
+			}
+			s = fmt.Sprintf(fmtStr, v.Interface())
+		default:
+			s = fmt.Sprintf("%v", v.Interface())
+		}
+		return gofn.NumberFmtGroup(s, fractionSep, groupSep)
+	}
+}
+
 // NewSliceFormatFunc create a new func for formatting a slice
 // Sample arguments: leftWrap "[", rightWrap "]", elemSep ", "
 func NewSliceFormatFunc(

error_formatter_test.go

@@ -84,6 +84,15 @@ func Test_NewDecimalNumFormatFunc(t *testing.T) {
 	assert.Equal(t, "1,234,567.12346", fmtFunc(reflect.ValueOf(1234567.1234567)))
 }
 
+func Test_NewDecimalFormatFunc(t *testing.T) {
+	fmtFunc := NewDecimalFormatFunc('.', ',', "")
+	assert.Equal(t, "12,345", fmtFunc(reflect.ValueOf(12345)))
+	assert.Equal(t, "1,234,567.123457", fmtFunc(reflect.ValueOf(1234567.1234567)))
+	fmtFunc = NewDecimalFormatFunc('.', ',', "%.5f")
+	assert.Equal(t, "12,345", fmtFunc(reflect.ValueOf(12345)))
+	assert.Equal(t, "1,234,567.12346", fmtFunc(reflect.ValueOf(1234567.1234567)))
+}
+
 func Test_errorBuildDetail(t *testing.T) {
 	err := NewError().
 		SetCustomKey("customKey").

errors.go

@@ -197,7 +197,8 @@ func (e *errorImpl) TypedParamFormatter() TypedParamFormatter {
 	if e.paramsFormatter == nil {
 		return nil
 	}
-	return e.paramsFormatter.(TypedParamFormatter) // nolint: forcetypeassert
+	typedFmt, _ := e.paramsFormatter.(TypedParamFormatter)
+	return typedFmt
 }
 
 func (e *errorImpl) SetParamFormatter(formatter ErrorParamFormatter) Error {
@@ -287,3 +288,59 @@ func SetParamFormatter(formatter ErrorParamFormatter) ErrorMod {
 		_ = err.SetParamFormatter(formatter)
 	}
 }
+
+func SetNumParamFormatter(formatFunc FormatFunc) ErrorMod {
+	return func(err Error) {
+		getTypedParamFormatterOrPanic(err).SetNumFormatFunc(formatFunc)
+	}
+}
+
+func SetStrParamFormatter(formatFunc FormatFunc) ErrorMod {
+	return func(err Error) {
+		getTypedParamFormatterOrPanic(err).SetStrFormatFunc(formatFunc)
+	}
+}
+
+func SetBoolParamFormatter(formatFunc FormatFunc) ErrorMod {
+	return func(err Error) {
+		getTypedParamFormatterOrPanic(err).SetBoolFormatFunc(formatFunc)
+	}
+}
+
+func SetSliceParamFormatter(formatFunc FormatFunc) ErrorMod {
+	return func(err Error) {
+		getTypedParamFormatterOrPanic(err).SetSliceFormatFunc(formatFunc)
+	}
+}
+
+func SetMapParamFormatter(formatFunc FormatFunc) ErrorMod {
+	return func(err Error) {
+		getTypedParamFormatterOrPanic(err).SetMapFormatFunc(formatFunc)
+	}
+}
+
+func SetStructParamFormatter(formatFunc FormatFunc) ErrorMod {
+	return func(err Error) {
+		getTypedParamFormatterOrPanic(err).SetStructFormatFunc(formatFunc)
+	}
+}
+
+func SetPtrParamFormatter(formatFunc FormatFunc) ErrorMod {
+	return func(err Error) {
+		getTypedParamFormatterOrPanic(err).SetPtrFormatFunc(formatFunc)
+	}
+}
+
+func SetCustomParamFormatter(formatFunc FormatFunc) ErrorMod {
+	return func(err Error) {
+		getTypedParamFormatterOrPanic(err).SetCustomFormatFunc(formatFunc)
+	}
+}
+
+func getTypedParamFormatterOrPanic(err Error) TypedParamFormatter {
+	formatter := err.TypedParamFormatter()
+	if formatter == nil {
+		panic("error does not have a TypedParamFormatter attached")
+	}
+	return formatter
+}

errors_test.go

@@ -1,9 +1,11 @@
 package validation
 
 import (
+	"reflect"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/tiendc/gofn"
 )
 
 func Test_ErrorMod(t *testing.T) {
@@ -25,6 +27,33 @@ func Test_ErrorMod(t *testing.T) {
 	SetParamFormatter(nil)(err)
 	assert.Nil(t, err.ParamFormatter())
 	assert.Nil(t, err.TypedParamFormatter())
+	SetParamFormatter(NewTypedParamFormatter())(err)
+	assert.NotNil(t, err.ParamFormatter())
+	assert.NotNil(t, err.TypedParamFormatter())
+
+	SetNumParamFormatter(func(reflect.Value) string { return "num" })(err)
+	SetStrParamFormatter(func(reflect.Value) string { return "str" })(err)
+	SetBoolParamFormatter(func(reflect.Value) string { return "bool" })(err)
+	SetSliceParamFormatter(func(reflect.Value) string { return "slice" })(err)
+	SetMapParamFormatter(func(reflect.Value) string { return "map" })(err)
+	SetStructParamFormatter(func(reflect.Value) string { return "struct" })(err)
+	SetPtrParamFormatter(func(reflect.Value) string { return "ptr" })(err)
+	SetCustomParamFormatter(func(reflect.Value) string { return "custom" })(err)
+	assert.Equal(t, "num", err.TypedParamFormatter().Format("k", 123))
+	assert.Equal(t, "str", err.TypedParamFormatter().Format("k", "123"))
+	assert.Equal(t, "bool", err.TypedParamFormatter().Format("k", true))
+	assert.Equal(t, "slice", err.TypedParamFormatter().Format("k", []int{123}))
+	assert.Equal(t, "map", err.TypedParamFormatter().Format("k", map[string]any{}))
+	assert.Equal(t, "struct", err.TypedParamFormatter().Format("k", struct{}{}))
+	assert.Equal(t, "ptr", err.TypedParamFormatter().Format("k", gofn.New(123)))
+	assert.Equal(t, "custom", err.TypedParamFormatter().Format("k", func() {}))
+
+	defer func() {
+		e := recover()
+		assert.Equal(t, "error does not have a TypedParamFormatter attached", e)
+	}()
+	SetParamFormatter(nil)(err)
+	SetNumParamFormatter(func(reflect.Value) string { return "num" })(err)
 }
 
 func Test_Field_Path(t *testing.T) {