go/aicra
go
/
aicra
0
1
Fork 0
Code Issues Pull Requests Releases 3 Wiki Activity

refactor: semantic move 'builtin' into 'validator'

This commit is contained in:
Adrien Marquès 2021-06-21 21:30:33 +02:00
parent defa2c3645
commit de547576c9
Signed by: xdrm-brackets
GPG Key ID: D75243CA236D825E
18 changed files with 165 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
README.md
View File

@ -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")

18
builder_test.go
View File

@ -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)
}

14
handler_test.go
View File

@ -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

26
internal/config/config_test.go
View File

@ -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 {

24
validator/any.go Normal file
View File

@ -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
}
}

8
validator/builtin/any_test.go → validator/any_test.go
View File

@ -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()

23
validator/builtin/bool.go → validator/bool.go
View File

@ -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
}

8
validator/builtin/bool_test.go → validator/bool_test.go
View File

@ -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()

26
validator/builtin/any.go
View File

@ -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
}
}

25
validator/builtin/float.go → validator/float.go
View File

@ -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) {

8
validator/builtin/float_test.go → validator/float_test.go
View File

@ -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()

24
validator/builtin/int.go → validator/int.go
View File

@ -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
}

8
validator/builtin/int_test.go → validator/int_test.go
View File

@ -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()

45
validator/builtin/string.go → validator/string.go
View File

@ -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

12
validator/builtin/string_test.go → validator/string_test.go
View File

@ -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()

25
validator/builtin/uint.go → validator/uint.go
View File

@ -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
}

8
validator/builtin/uint_test.go → validator/uint_test.go
View File

@ -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()

8
validator/validator.go
View File

@ -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.