From de547576c93a070ab912939e95d98e322995a335 Mon Sep 17 00:00:00 2001 From: xdrm-brackets Date: Mon, 21 Jun 2021 21:30:33 +0200 Subject: [PATCH] refactor: semantic move 'builtin' into 'validator' --- README.md | 6 ++-- builder_test.go | 18 +++++------ handler_test.go | 14 ++++---- internal/config/config_test.go | 26 +++++++-------- validator/any.go | 24 ++++++++++++++ validator/{builtin => }/any_test.go | 8 ++--- validator/{builtin => }/bool.go | 23 ++++++------- validator/{builtin => }/bool_test.go | 8 ++--- validator/builtin/any.go | 26 --------------- validator/{builtin => }/float.go | 25 +++++++------- validator/{builtin => }/float_test.go | 8 ++--- validator/{builtin => }/int.go | 24 ++++++++------ validator/{builtin => }/int_test.go | 8 ++--- validator/{builtin => }/string.go | 45 ++++++++++++++------------ validator/{builtin => }/string_test.go | 12 +++---- validator/{builtin => }/uint.go | 25 +++++++------- validator/{builtin => }/uint_test.go | 8 ++--- validator/validator.go | 8 ++--- 18 files changed, 165 insertions(+), 151 deletions(-) create mode 100644 validator/any.go rename validator/{builtin => }/any_test.go (86%) rename validator/{builtin => }/bool.go (51%) rename validator/{builtin => }/bool_test.go (90%) delete mode 100644 validator/builtin/any.go rename validator/{builtin => }/float.go (52%) rename validator/{builtin => }/float_test.go (92%) rename validator/{builtin => }/int.go (63%) rename validator/{builtin => }/int_test.go (93%) rename validator/{builtin => }/string.go (63%) rename validator/{builtin => }/string_test.go (93%) rename validator/{builtin => }/uint.go (65%) rename validator/{builtin => }/uint_test.go (93%) diff --git a/README.md b/README.md index 467fbc1..d0dd2d2 100644 --- a/README.md +++ b/README.md @@ -96,9 +96,9 @@ func main() { builder := &aicra.Builder{} // add custom type validators - builder.Validate(builtin.BoolDataType{}) - builder.Validate(builtin.UintDataType{}) - builder.Validate(builtin.StringDataType{}) + builder.Validate(validator.BoolDataType{}) + builder.Validate(validator.UintDataType{}) + builder.Validate(validator.StringDataType{}) // load your configuration config, err := os.Open("api.json") diff --git a/builder_test.go b/builder_test.go index 457449b..fbbebe0 100644 --- a/builder_test.go +++ b/builder_test.go @@ -8,26 +8,26 @@ import ( "testing" "github.com/xdrm-io/aicra/api" - "github.com/xdrm-io/aicra/validator/builtin" + "github.com/xdrm-io/aicra/validator" ) func addBuiltinTypes(b *Builder) error { - if err := b.Validate(builtin.AnyDataType{}); err != nil { + if err := b.Validate(validator.AnyType{}); err != nil { return err } - if err := b.Validate(builtin.BoolDataType{}); err != nil { + if err := b.Validate(validator.BoolType{}); err != nil { return err } - if err := b.Validate(builtin.FloatDataType{}); err != nil { + if err := b.Validate(validator.FloatType{}); err != nil { return err } - if err := b.Validate(builtin.IntDataType{}); err != nil { + if err := b.Validate(validator.IntType{}); err != nil { return err } - if err := b.Validate(builtin.StringDataType{}); err != nil { + if err := b.Validate(validator.StringType{}); err != nil { return err } - if err := b.Validate(builtin.UintDataType{}); err != nil { + if err := b.Validate(validator.UintType{}); err != nil { return err } return nil @@ -35,7 +35,7 @@ func addBuiltinTypes(b *Builder) error { func TestAddType(t *testing.T) { builder := &Builder{} - err := builder.Validate(builtin.BoolDataType{}) + err := builder.Validate(validator.BoolType{}) if err != nil { t.Fatalf("unexpected error: %s", err) } @@ -43,7 +43,7 @@ func TestAddType(t *testing.T) { if err != nil { t.Fatalf("unexpected error: %s", err) } - err = builder.Validate(builtin.FloatDataType{}) + err = builder.Validate(validator.FloatType{}) if err != errLateType { t.Fatalf("expected <%v> got <%v>", errLateType, err) } diff --git a/handler_test.go b/handler_test.go index 51e9719..fe3327e 100644 --- a/handler_test.go +++ b/handler_test.go @@ -12,26 +12,26 @@ import ( "github.com/xdrm-io/aicra" "github.com/xdrm-io/aicra/api" - "github.com/xdrm-io/aicra/validator/builtin" + "github.com/xdrm-io/aicra/validator" ) func addBuiltinTypes(b *aicra.Builder) error { - if err := b.Validate(builtin.AnyDataType{}); err != nil { + if err := b.Validate(validator.AnyType{}); err != nil { return err } - if err := b.Validate(builtin.BoolDataType{}); err != nil { + if err := b.Validate(validator.BoolType{}); err != nil { return err } - if err := b.Validate(builtin.FloatDataType{}); err != nil { + if err := b.Validate(validator.FloatType{}); err != nil { return err } - if err := b.Validate(builtin.IntDataType{}); err != nil { + if err := b.Validate(validator.IntType{}); err != nil { return err } - if err := b.Validate(builtin.StringDataType{}); err != nil { + if err := b.Validate(validator.StringType{}); err != nil { return err } - if err := b.Validate(builtin.UintDataType{}); err != nil { + if err := b.Validate(validator.UintType{}); err != nil { return err } return nil diff --git a/internal/config/config_test.go b/internal/config/config_test.go index 2bf019f..5db787c 100644 --- a/internal/config/config_test.go +++ b/internal/config/config_test.go @@ -8,7 +8,7 @@ import ( "strings" "testing" - "github.com/xdrm-io/aicra/validator/builtin" + "github.com/xdrm-io/aicra/validator" ) func TestLegalServiceName(t *testing.T) { @@ -239,7 +239,7 @@ func TestParamEmptyRenameNoRename(t *testing.T) { } ]`) srv := &Server{} - srv.Validators = append(srv.Validators, builtin.AnyDataType{}) + srv.Validators = append(srv.Validators, validator.AnyType{}) err := srv.Parse(r) if err != nil { t.Errorf("unexpected error: '%s'", err) @@ -275,8 +275,8 @@ func TestOptionalParam(t *testing.T) { } ]`) srv := &Server{} - srv.Validators = append(srv.Validators, builtin.AnyDataType{}) - srv.Validators = append(srv.Validators, builtin.BoolDataType{}) + srv.Validators = append(srv.Validators, validator.AnyType{}) + srv.Validators = append(srv.Validators, validator.BoolType{}) err := srv.Parse(r) if err != nil { t.Errorf("unexpected error: '%s'", err) @@ -588,7 +588,7 @@ func TestParseParameters(t *testing.T) { t.Run(fmt.Sprintf("method.%d", i), func(t *testing.T) { srv := &Server{} - srv.Validators = append(srv.Validators, builtin.AnyDataType{}) + srv.Validators = append(srv.Validators, validator.AnyType{}) err := srv.Parse(strings.NewReader(test.Raw)) if err == nil && test.Error != nil { @@ -827,8 +827,8 @@ func TestServiceCollision(t *testing.T) { t.Run(fmt.Sprintf("method.%d", i), func(t *testing.T) { srv := &Server{} - srv.Validators = append(srv.Validators, builtin.StringDataType{}) - srv.Validators = append(srv.Validators, builtin.UintDataType{}) + srv.Validators = append(srv.Validators, validator.StringType{}) + srv.Validators = append(srv.Validators, validator.UintType{}) err := srv.Parse(strings.NewReader(test.Config)) if err == nil && test.Error != nil { @@ -997,9 +997,9 @@ func TestMatchSimple(t *testing.T) { t.Run(fmt.Sprintf("method.%d", i), func(t *testing.T) { srv := &Server{} - srv.Validators = append(srv.Validators, builtin.AnyDataType{}) - srv.Validators = append(srv.Validators, builtin.IntDataType{}) - srv.Validators = append(srv.Validators, builtin.BoolDataType{}) + srv.Validators = append(srv.Validators, validator.AnyType{}) + srv.Validators = append(srv.Validators, validator.IntType{}) + srv.Validators = append(srv.Validators, validator.BoolType{}) err := srv.Parse(strings.NewReader(test.Config)) if err != nil { @@ -1081,9 +1081,9 @@ func TestFindPriority(t *testing.T) { t.Run(fmt.Sprintf("method.%d", i), func(t *testing.T) { srv := &Server{} - srv.Validators = append(srv.Validators, builtin.AnyDataType{}) - srv.Validators = append(srv.Validators, builtin.IntDataType{}) - srv.Validators = append(srv.Validators, builtin.BoolDataType{}) + srv.Validators = append(srv.Validators, validator.AnyType{}) + srv.Validators = append(srv.Validators, validator.IntType{}) + srv.Validators = append(srv.Validators, validator.BoolType{}) err := srv.Parse(strings.NewReader(test.Config)) if err != nil { diff --git a/validator/any.go b/validator/any.go new file mode 100644 index 0000000..c9b2ef0 --- /dev/null +++ b/validator/any.go @@ -0,0 +1,24 @@ +package validator + +import ( + "reflect" +) + +// AnyType makes the "any" type available in the aicra configuration +// It considers valid any value +type AnyType struct{} + +// GoType returns the interface{} type +func (AnyType) GoType() reflect.Type { + return reflect.TypeOf(interface{}(nil)) +} + +// Validator that considers any value valid +func (AnyType) Validator(typename string, avail ...Type) ValidateFunc { + if typename != "any" { + return nil + } + return func(value interface{}) (interface{}, bool) { + return value, true + } +} diff --git a/validator/builtin/any_test.go b/validator/any_test.go similarity index 86% rename from validator/builtin/any_test.go rename to validator/any_test.go index ab7a681..d612047 100644 --- a/validator/builtin/any_test.go +++ b/validator/any_test.go @@ -1,16 +1,16 @@ -package builtin_test +package validator_test import ( "fmt" "testing" - "github.com/xdrm-io/aicra/validator/builtin" + "github.com/xdrm-io/aicra/validator" ) func TestAny_AvailableTypes(t *testing.T) { t.Parallel() - dt := builtin.AnyDataType{} + dt := validator.AnyType{} tests := []struct { Type string @@ -47,7 +47,7 @@ func TestAny_AlwaysTrue(t *testing.T) { const typeName = "any" - validator := builtin.AnyDataType{}.Validator(typeName) + validator := validator.AnyType{}.Validator(typeName) if validator == nil { t.Errorf("expect %q to be handled", typeName) t.Fail() diff --git a/validator/builtin/bool.go b/validator/bool.go similarity index 51% rename from validator/builtin/bool.go rename to validator/bool.go index e5bd9df..9a93069 100644 --- a/validator/builtin/bool.go +++ b/validator/bool.go @@ -1,23 +1,24 @@ -package builtin +package validator import ( "reflect" - - "github.com/xdrm-io/aicra/validator" ) -// BoolDataType is what its name tells -type BoolDataType struct{} +// BoolType makes the "bool" type available in the aicra configuration +// It considers valid: +// - booleans +// - strings containing "true" or "false" +// - []byte containing "true" or "false" +type BoolType struct{} -// GoType returns the type of data -func (BoolDataType) GoType() reflect.Type { +// GoType returns the `bool` type +func (BoolType) GoType() reflect.Type { return reflect.TypeOf(true) } -// Validator returns the validator -func (BoolDataType) Validator(typeName string, registry ...validator.Type) validator.ValidateFunc { - // nothing if type not handled - if typeName != "bool" { +// Validator for bool values +func (BoolType) Validator(typename string, avail ...Type) ValidateFunc { + if typename != "bool" { return nil } diff --git a/validator/builtin/bool_test.go b/validator/bool_test.go similarity index 90% rename from validator/builtin/bool_test.go rename to validator/bool_test.go index 1d59ec9..8600d34 100644 --- a/validator/builtin/bool_test.go +++ b/validator/bool_test.go @@ -1,16 +1,16 @@ -package builtin_test +package validator_test import ( "fmt" "testing" - "github.com/xdrm-io/aicra/validator/builtin" + "github.com/xdrm-io/aicra/validator" ) func TestBool_AvailableTypes(t *testing.T) { t.Parallel() - dt := builtin.BoolDataType{} + dt := validator.BoolType{} tests := []struct { Type string @@ -49,7 +49,7 @@ func TestBool_Values(t *testing.T) { const typeName = "bool" - validator := builtin.BoolDataType{}.Validator(typeName) + validator := validator.BoolType{}.Validator(typeName) if validator == nil { t.Errorf("expect %q to be handled", typeName) t.Fail() diff --git a/validator/builtin/any.go b/validator/builtin/any.go deleted file mode 100644 index 36a3e5a..0000000 --- a/validator/builtin/any.go +++ /dev/null @@ -1,26 +0,0 @@ -package builtin - -import ( - "reflect" - - "github.com/xdrm-io/aicra/validator" -) - -// AnyDataType is what its name tells -type AnyDataType struct{} - -// GoType returns the type of data -func (AnyDataType) GoType() reflect.Type { - return reflect.TypeOf(interface{}(nil)) -} - -// Validator returns the validator -func (AnyDataType) Validator(typeName string, registry ...validator.Type) validator.ValidateFunc { - // nothing if type not handled - if typeName != "any" { - return nil - } - return func(value interface{}) (interface{}, bool) { - return value, true - } -} diff --git a/validator/builtin/float.go b/validator/float.go similarity index 52% rename from validator/builtin/float.go rename to validator/float.go index 0789444..b6d7e53 100644 --- a/validator/builtin/float.go +++ b/validator/float.go @@ -1,24 +1,27 @@ -package builtin +package validator import ( "encoding/json" "reflect" - - "github.com/xdrm-io/aicra/validator" ) -// FloatDataType is what its name tells -type FloatDataType struct{} +// FloatType makes the "float" (or "float64") type available in the aicra configuration +// It considers valid: +// - float64 +// - int (since it does not overflow) +// - uint (since it does not overflow) +// - strings containing json-compatible floats +// - []byte containing json-compatible floats +type FloatType struct{} -// GoType returns the type of data -func (FloatDataType) GoType() reflect.Type { +// GoType returns the `float64` type +func (FloatType) GoType() reflect.Type { return reflect.TypeOf(float64(0)) } -// Validator returns the validator -func (FloatDataType) Validator(typeName string, registry ...validator.Type) validator.ValidateFunc { - // nothing if type not handled - if typeName != "float64" && typeName != "float" { +// Validator for float64 values +func (FloatType) Validator(typename string, avail ...Type) ValidateFunc { + if typename != "float64" && typename != "float" { return nil } return func(value interface{}) (interface{}, bool) { diff --git a/validator/builtin/float_test.go b/validator/float_test.go similarity index 92% rename from validator/builtin/float_test.go rename to validator/float_test.go index 924036e..b965441 100644 --- a/validator/builtin/float_test.go +++ b/validator/float_test.go @@ -1,17 +1,17 @@ -package builtin_test +package validator_test import ( "fmt" "math" "testing" - "github.com/xdrm-io/aicra/validator/builtin" + "github.com/xdrm-io/aicra/validator" ) func TestFloat64_AvailableTypes(t *testing.T) { t.Parallel() - dt := builtin.FloatDataType{} + dt := validator.FloatType{} tests := []struct { Type string @@ -56,7 +56,7 @@ func TestFloat64_Values(t *testing.T) { const typeName = "float" - validator := builtin.FloatDataType{}.Validator(typeName) + validator := validator.FloatType{}.Validator(typeName) if validator == nil { t.Errorf("expect %q to be handled", typeName) t.Fail() diff --git a/validator/builtin/int.go b/validator/int.go similarity index 63% rename from validator/builtin/int.go rename to validator/int.go index 1d0ad00..d7ec83c 100644 --- a/validator/builtin/int.go +++ b/validator/int.go @@ -1,25 +1,29 @@ -package builtin +package validator import ( "encoding/json" "math" "reflect" - - "github.com/xdrm-io/aicra/validator" ) -// IntDataType is what its name tells -type IntDataType struct{} +// IntType makes the "int" type available in the aicra configuration +// It considers valid: +// - int +// - float64 (since it does not overflow) +// - uint (since it does not overflow) +// - strings containing json-compatible integers +// - []byte containing json-compatible integers +type IntType struct{} -// GoType returns the type of data -func (IntDataType) GoType() reflect.Type { +// GoType returns the `int` type +func (IntType) GoType() reflect.Type { return reflect.TypeOf(int(0)) } -// Validator returns the validator -func (IntDataType) Validator(typeName string, registry ...validator.Type) validator.ValidateFunc { +// Validator for int values +func (IntType) Validator(typename string, avail ...Type) ValidateFunc { // nothing if type not handled - if typeName != "int" { + if typename != "int" { return nil } diff --git a/validator/builtin/int_test.go b/validator/int_test.go similarity index 93% rename from validator/builtin/int_test.go rename to validator/int_test.go index cffea8f..14dc515 100644 --- a/validator/builtin/int_test.go +++ b/validator/int_test.go @@ -1,17 +1,17 @@ -package builtin_test +package validator_test import ( "fmt" "math" "testing" - "github.com/xdrm-io/aicra/validator/builtin" + "github.com/xdrm-io/aicra/validator" ) func TestInt_AvailableTypes(t *testing.T) { t.Parallel() - dt := builtin.IntDataType{} + dt := validator.IntType{} tests := []struct { Type string @@ -50,7 +50,7 @@ func TestInt_Values(t *testing.T) { const typeName = "int" - validator := builtin.IntDataType{}.Validator(typeName) + validator := validator.IntType{}.Validator(typeName) if validator == nil { t.Errorf("expect %q to be handled", typeName) t.Fail() diff --git a/validator/builtin/string.go b/validator/string.go similarity index 63% rename from validator/builtin/string.go rename to validator/string.go index 50544a7..307c7cd 100644 --- a/validator/builtin/string.go +++ b/validator/string.go @@ -1,32 +1,37 @@ -package builtin +package validator import ( "reflect" "regexp" "strconv" - - "github.com/xdrm-io/aicra/validator" ) -var fixedLengthRegex = regexp.MustCompile(`^string\((\d+)\)$`) -var variableLengthRegex = regexp.MustCompile(`^string\((\d+), ?(\d+)\)$`) +var ( + fixedLengthRegex = regexp.MustCompile(`^string\((\d+)\)$`) + variableLengthRegex = regexp.MustCompile(`^string\((\d+), ?(\d+)\)$`) +) -// StringDataType is what its name tells -type StringDataType struct{} +// StringType makes the types beloz available in the aicra configuration: +// - "string" considers any string valid +// - "string(n)" considers any string with an exact size of `n` valid +// - "string(a,b)" considers any string with a size between `a` and `b` valid +// > for the last one, `a` and `b` are included in the valid sizes +type StringType struct{} -// GoType returns the type of data -func (StringDataType) GoType() reflect.Type { +// GoType returns the `string` type +func (StringType) GoType() reflect.Type { return reflect.TypeOf(string("")) } -// Validator returns the validator. -// availables type names are : `string`, `string(length)` and `string(minLength, maxLength)`. -func (s StringDataType) Validator(typeName string, registry ...validator.Type) validator.ValidateFunc { - simple := typeName == "string" - fixedLengthMatches := fixedLengthRegex.FindStringSubmatch(typeName) - variableLengthMatches := variableLengthRegex.FindStringSubmatch(typeName) +// Validator for strings with any/fixed/bound sizes +func (s StringType) Validator(typename string, avail ...Type) ValidateFunc { + var ( + simple = (typename == "string") + fixedLengthMatches = fixedLengthRegex.FindStringSubmatch(typename) + variableLengthMatches = variableLengthRegex.FindStringSubmatch(typename) + ) - // nothing if type not handled + // ignore unknown typename if !simple && fixedLengthMatches == nil && variableLengthMatches == nil { return nil } @@ -40,7 +45,7 @@ func (s StringDataType) Validator(typeName string, registry ...validator.Type) v if fixedLengthMatches != nil { exLen, ok := s.getFixedLength(fixedLengthMatches) if !ok { - mustFail = true + return nil } min = exLen max = exLen @@ -49,7 +54,7 @@ func (s StringDataType) Validator(typeName string, registry ...validator.Type) v } else if variableLengthMatches != nil { exMin, exMax, ok := s.getVariableLength(variableLengthMatches) if !ok { - mustFail = true + return nil } min = exMin max = exMax @@ -84,7 +89,7 @@ func (s StringDataType) Validator(typeName string, registry ...validator.Type) v } // getFixedLength returns the fixed length from regex matches and a success state. -func (StringDataType) getFixedLength(regexMatches []string) (int, bool) { +func (StringType) getFixedLength(regexMatches []string) (int, bool) { // incoherence error if regexMatches == nil || len(regexMatches) < 2 { return 0, false @@ -100,7 +105,7 @@ func (StringDataType) getFixedLength(regexMatches []string) (int, bool) { } // getVariableLength returns the length min and max from regex matches and a success state. -func (StringDataType) getVariableLength(regexMatches []string) (int, int, bool) { +func (StringType) getVariableLength(regexMatches []string) (int, int, bool) { // incoherence error if regexMatches == nil || len(regexMatches) < 3 { return 0, 0, false diff --git a/validator/builtin/string_test.go b/validator/string_test.go similarity index 93% rename from validator/builtin/string_test.go rename to validator/string_test.go index 7b91b2d..0a038ef 100644 --- a/validator/builtin/string_test.go +++ b/validator/string_test.go @@ -1,16 +1,16 @@ -package builtin_test +package validator_test import ( "fmt" "testing" - "github.com/xdrm-io/aicra/validator/builtin" + "github.com/xdrm-io/aicra/validator" ) func TestString_AvailableTypes(t *testing.T) { t.Parallel() - dt := builtin.StringDataType{} + dt := validator.StringType{} tests := []struct { Type string @@ -75,7 +75,7 @@ func TestString_AnyLength(t *testing.T) { const typeName = "string" - validator := builtin.StringDataType{}.Validator(typeName) + validator := validator.StringType{}.Validator(typeName) if validator == nil { t.Errorf("expect %q to be handled", typeName) t.Fail() @@ -133,7 +133,7 @@ func TestString_FixedLength(t *testing.T) { for i, test := range tests { t.Run(fmt.Sprintf("%d", i), func(t *testing.T) { - validator := builtin.StringDataType{}.Validator(test.Type) + validator := validator.StringType{}.Validator(test.Type) if validator == nil { t.Errorf("expect %q to be handled", test.Type) t.Fail() @@ -194,7 +194,7 @@ func TestString_VariableLength(t *testing.T) { for i, test := range tests { t.Run(fmt.Sprintf("%d", i), func(t *testing.T) { - validator := builtin.StringDataType{}.Validator(test.Type) + validator := validator.StringType{}.Validator(test.Type) if validator == nil { t.Errorf("expect %q to be handled", test.Type) t.Fail() diff --git a/validator/builtin/uint.go b/validator/uint.go similarity index 65% rename from validator/builtin/uint.go rename to validator/uint.go index d6e25cf..0df72f4 100644 --- a/validator/builtin/uint.go +++ b/validator/uint.go @@ -1,25 +1,28 @@ -package builtin +package validator import ( "encoding/json" "math" "reflect" - - "github.com/xdrm-io/aicra/validator" ) -// UintDataType is what its name tells -type UintDataType struct{} +// UintType makes the "uint" type available in the aicra configuration +// It considers valid: +// - uint +// - int (since it does not overflow) +// - float64 (since it does not overflow) +// - strings containing json-compatible integers +// - []byte containing json-compatible integers +type UintType struct{} -// GoType returns the type of data -func (UintDataType) GoType() reflect.Type { +// GoType returns the `uint` type +func (UintType) GoType() reflect.Type { return reflect.TypeOf(uint(0)) } -// Validator returns the validator -func (UintDataType) Validator(typeName string, registry ...validator.Type) validator.ValidateFunc { - // nothing if type not handled - if typeName != "uint" { +// Validator for uint values +func (UintType) Validator(other string, avail ...Type) ValidateFunc { + if other != "uint" { return nil } diff --git a/validator/builtin/uint_test.go b/validator/uint_test.go similarity index 93% rename from validator/builtin/uint_test.go rename to validator/uint_test.go index 9893264..4fc9be9 100644 --- a/validator/builtin/uint_test.go +++ b/validator/uint_test.go @@ -1,17 +1,17 @@ -package builtin_test +package validator_test import ( "fmt" "math" "testing" - "github.com/xdrm-io/aicra/validator/builtin" + "github.com/xdrm-io/aicra/validator" ) func TestUint_AvailableTypes(t *testing.T) { t.Parallel() - dt := builtin.UintDataType{} + dt := validator.UintType{} tests := []struct { Type string @@ -50,7 +50,7 @@ func TestUint_Values(t *testing.T) { const typeName = "uint" - validator := builtin.UintDataType{}.Validator(typeName) + validator := validator.UintType{}.Validator(typeName) if validator == nil { t.Errorf("expect %q to be handled", typeName) t.Fail() diff --git a/validator/validator.go b/validator/validator.go index 574f966..fa3d389 100644 --- a/validator/validator.go +++ b/validator/validator.go @@ -37,17 +37,17 @@ type Type interface { // - `VarcharType.Validator("varchar(1,3)")` validates any string // with a length between 1 and 3 // - // The `registry` argument represents all other available Types. It allows a + // The `avail` argument represents all other available Types. It allows a // Type to use other available Types internally. // // recursive example: slices - // - `SliceType.Validator("[]int", reg...)` validates a slice containing + // - `SliceType.Validator("[]int", avail...)` validates a slice containing // values that are valide to the `IntType` - // - `SliceType.Validator("[]varchar", reg...)` validates a slice containing + // - `SliceType.Validator("[]varchar", avail...)` validates a slice containing // values that are valid to the `VarcharType` // // and so on.. this works for maps, structs, etc - Validator(typename string, registry ...Type) ValidateFunc + Validator(typename string, avail ...Type) ValidateFunc // GoType must return the go type associated with the output type of ValidateFunc. // It is used to define handlers' signature from the configuration file.