add default

README.md

@@ -29,7 +29,7 @@
 | Name			| Description											| Status |
 |---------------|-------------------------------------------------------|--------|
 | required		| not nil or zero value									| ✅		|
-| default		| default value											| ⌛		|
+| default		| default value											| ✅		|
 | enum			| one of a set of options								| ⌛		|
 
 ### String

rule.go

@@ -12,6 +12,7 @@ type Rule interface {
 	Validate(
 		schema map[string]string,
 		parent reflect.Value,
+		// _type reflect.Type,
 		value reflect.Value,
-	) []error
+	) (reflect.Value, []error)
 }

rules/default.go

@@ -0,0 +1,70 @@
+package rules
+
+import (
+	"errors"
+	"reflect"
+	"strconv"
+)
+
+type Default struct{}
+
+func (self Default) Select(schema map[string]string, parent reflect.Value, value reflect.Value) bool {
+	return true
+}
+
+func (self Default) Validate(schema map[string]string, parent reflect.Value, value reflect.Value) (reflect.Value, []error) {
+	errs := []error{}
+	config, ok := schema["default"]
+
+	if !ok || config == "" {
+		errs = append(errs, errors.New("config is required"))
+		return value, errs
+	}
+
+	if value.Kind() == reflect.Pointer && value.IsZero() {
+		t := value.Type()
+		ptr := reflect.New(t.Elem())
+
+		if t.Elem().ConvertibleTo(reflect.TypeFor[int]()) {
+			v, err := strconv.ParseInt(config, 10, 64)
+
+			if err != nil {
+				errs = append(errs, errors.New("config must be an int"))
+			}
+
+			ptr.Elem().Set(reflect.ValueOf(v).Convert(t.Elem()))
+			return ptr, errs
+		}
+
+		if t.Elem().ConvertibleTo(reflect.TypeFor[float64]()) {
+			v, err := strconv.ParseFloat(config, 64)
+
+			if err != nil {
+				errs = append(errs, errors.New("config must be an float"))
+			}
+
+			ptr.Elem().Set(reflect.ValueOf(v).Convert(t.Elem()))
+			return ptr, errs
+		}
+
+		if t.Elem().Kind() == reflect.Bool {
+			v, err := strconv.ParseBool(config)
+
+			if err != nil {
+				errs = append(errs, errors.New("config must be a bool"))
+			}
+
+			ptr.Elem().SetBool(v)
+			return ptr, errs
+		}
+
+		if t.Elem().Kind() == reflect.String {
+			ptr.Elem().SetString(config)
+			return ptr, errs
+		}
+
+		errs = append(errs, errors.New("default can only be used on primitive types"))
+	}
+
+	return value, errs
+}

rules/default_test.go

@@ -0,0 +1,125 @@
+package rules_test
+
+import (
+	"testing"
+
+	"github.com/aacebo/owl"
+)
+
+func Test_Default(t *testing.T) {
+	t.Run("should error on no config", func(t *testing.T) {
+		errs := owl.Validate(struct {
+			A *string `json:"a" owl:"default"`
+		}{})
+
+		if len(errs) == 0 {
+			t.Error("should have error")
+		}
+	})
+
+	t.Run("should error on type mismatch", func(t *testing.T) {
+		errs := owl.Validate(struct {
+			A *int `json:"a" owl:"default=abc"`
+		}{})
+
+		if len(errs) == 0 {
+			t.Error("should have error")
+		}
+	})
+
+	t.Run("should succeed with int", func(t *testing.T) {
+		v := struct {
+			A *int `json:"a" owl:"default=123"`
+		}{}
+
+		errs := owl.Validate(&v)
+
+		if len(errs) > 0 {
+			t.Error(errs)
+		}
+
+		if v.A == nil || *v.A != 123 {
+			t.Error("should set default value")
+		}
+	})
+
+	t.Run("should succeed with int64", func(t *testing.T) {
+		v := struct {
+			A *int64 `json:"a" owl:"default=123"`
+		}{}
+
+		errs := owl.Validate(&v)
+
+		if len(errs) > 0 {
+			t.Error(errs)
+		}
+
+		if v.A == nil || *v.A != 123 {
+			t.Error("should set default value")
+		}
+	})
+
+	t.Run("should succeed with float32", func(t *testing.T) {
+		v := struct {
+			A *float32 `json:"a" owl:"default=123"`
+		}{}
+
+		errs := owl.Validate(&v)
+
+		if len(errs) > 0 {
+			t.Error(errs)
+		}
+
+		if v.A == nil || *v.A != 123 {
+			t.Error("should set default value")
+		}
+	})
+
+	t.Run("should succeed with float64", func(t *testing.T) {
+		v := struct {
+			A *float64 `json:"a" owl:"default=123"`
+		}{}
+
+		errs := owl.Validate(&v)
+
+		if len(errs) > 0 {
+			t.Error(errs)
+		}
+
+		if v.A == nil || *v.A != 123 {
+			t.Error("should set default value")
+		}
+	})
+
+	t.Run("should succeed with uint", func(t *testing.T) {
+		v := struct {
+			A *uint `json:"a" owl:"default=123"`
+		}{}
+
+		errs := owl.Validate(&v)
+
+		if len(errs) > 0 {
+			t.Error(errs)
+		}
+
+		if v.A == nil || *v.A != 123 {
+			t.Error("should set default value")
+		}
+	})
+
+	t.Run("should succeed with string", func(t *testing.T) {
+		v := struct {
+			A *string `json:"a" owl:"default=123"`
+		}{}
+
+		errs := owl.Validate(&v)
+
+		if len(errs) > 0 {
+			t.Error(errs)
+		}
+
+		if v.A == nil || *v.A != "123" {
+			t.Error("should set default value")
+		}
+	})
+}

rules/format.go

@@ -15,13 +15,13 @@ func (self Format) Select(schema map[string]string, parent reflect.Value, value
 	return value.Kind() == reflect.String
 }
 
-func (self Format) Validate(schema map[string]string, parent reflect.Value, value reflect.Value) []error {
+func (self Format) Validate(schema map[string]string, parent reflect.Value, value reflect.Value) (reflect.Value, []error) {
 	errs := []error{}
 	config, ok := schema["format"]
 
 	if !ok {
 		errs = append(errs, errors.New("empty config"))
-		return errs
+		return value, errs
 	}
 
 	if !self.HasFormat(config) {
@@ -30,12 +30,12 @@ func (self Format) Validate(schema map[string]string, parent reflect.Value, valu
 			config,
 		)))
 
-		return errs
+		return value, errs
 	}
 
 	if err := self.Format(config, value.String()); err != nil {
 		errs = append(errs, err)
 	}
 
-	return errs
+	return value, errs
 }

rules/max.go

@@ -13,12 +13,12 @@ func (self Max) Select(schema map[string]string, parent reflect.Value, value ref
 	return value.CanFloat() || value.CanConvert(floatType) || value.Kind() == reflect.String
 }
 
-func (self Max) Validate(schema map[string]string, parent reflect.Value, value reflect.Value) []error {
+func (self Max) Validate(schema map[string]string, parent reflect.Value, value reflect.Value) (reflect.Value, []error) {
 	errs := []error{}
 
 	if _, ok := schema["max"]; !ok {
 		errs = append(errs, errors.New("must be greater than or equal to 0"))
-		return errs
+		return value, errs
 	}
 
 	if value.Kind() == reflect.String {
@@ -28,18 +28,18 @@ func (self Max) Validate(schema map[string]string, parent reflect.Value, value r
 	return self.validateNumber(schema, value)
 }
 
-func (self Max) validateNumber(schema map[string]string, value reflect.Value) []error {
+func (self Max) validateNumber(schema map[string]string, value reflect.Value) (reflect.Value, []error) {
 	errs := []error{}
 	max, err := strconv.ParseFloat(schema["max"], 64)
 
 	if err != nil {
 		errs = append(errs, err)
-		return errs
+		return value, errs
 	}
 
 	if max < 0 {
 		errs = append(errs, errors.New("must be greater than or equal to 0"))
-		return errs
+		return value, errs
 	}
 
 	if v, ok := schema["min"]; ok {
@@ -62,21 +62,21 @@ func (self Max) validateNumber(schema map[string]string, value reflect.Value) []
 		)))
 	}
 
-	return errs
+	return value, errs
 }
 
-func (self Max) validateString(schema map[string]string, value reflect.Value) []error {
+func (self Max) validateString(schema map[string]string, value reflect.Value) (reflect.Value, []error) {
 	errs := []error{}
 	max, err := strconv.ParseInt(schema["max"], 10, 64)
 
 	if err != nil {
 		errs = append(errs, err)
-		return errs
+		return value, errs
 	}
 
 	if max < 0 {
 		errs = append(errs, errors.New("config must be greater than or equal to 0"))
-		return errs
+		return value, errs
 	}
 
 	if v, ok := schema["min"]; ok {
@@ -96,5 +96,5 @@ func (self Max) validateString(schema map[string]string, value reflect.Value) []
 		)))
 	}
 
-	return errs
+	return value, errs
 }

rules/min.go

@@ -15,13 +15,13 @@ func (self Min) Select(schema map[string]string, parent reflect.Value, value ref
 	return value.CanFloat() || value.CanConvert(floatType) || value.Kind() == reflect.String
 }
 
-func (self Min) Validate(schema map[string]string, parent reflect.Value, value reflect.Value) []error {
+func (self Min) Validate(schema map[string]string, parent reflect.Value, value reflect.Value) (reflect.Value, []error) {
 	errs := []error{}
 	config, ok := schema["min"]
 
 	if !ok {
 		errs = append(errs, errors.New("must be greater than or equal to 0"))
-		return errs
+		return value, errs
 	}
 
 	if value.Kind() == reflect.String {
@@ -31,18 +31,18 @@ func (self Min) Validate(schema map[string]string, parent reflect.Value, value r
 	return self.validateNumber(config, value)
 }
 
-func (self Min) validateNumber(config string, value reflect.Value) []error {
+func (self Min) validateNumber(config string, value reflect.Value) (reflect.Value, []error) {
 	errs := []error{}
 	min, err := strconv.ParseFloat(config, 64)
 
 	if err != nil {
 		errs = append(errs, err)
-		return errs
+		return value, errs
 	}
 
 	if min < 0 {
 		errs = append(errs, errors.New("must be greater than or equal to 0"))
-		return errs
+		return value, errs
 	}
 
 	if value.Kind() != reflect.Float64 && value.CanConvert(floatType) {
@@ -57,21 +57,21 @@ func (self Min) validateNumber(config string, value reflect.Value) []error {
 		)))
 	}
 
-	return errs
+	return value, errs
 }
 
-func (self Min) validateString(config string, value reflect.Value) []error {
+func (self Min) validateString(config string, value reflect.Value) (reflect.Value, []error) {
 	errs := []error{}
 	min, err := strconv.ParseInt(config, 10, 64)
 
 	if err != nil {
 		errs = append(errs, err)
-		return errs
+		return value, errs
 	}
 
 	if min < 0 {
 		errs = append(errs, errors.New("config must be greater than or equal to 0"))
-		return errs
+		return value, errs
 	}
 
 	if min > int64(value.Len()) {
@@ -83,5 +83,5 @@ func (self Min) validateString(config string, value reflect.Value) []error {
 		)))
 	}
 
-	return errs
+	return value, errs
 }