support integer types

Makefile

@@ -30,6 +30,7 @@ build: clean
 endtoendtests: build
 	@echo "Running endtoend tests"
 	find tests/endtoend/ -name 'validator__.go' -exec rm \{} \;
+	cd tests/endtoend/generate_tests/; rm -f numeric.go; go run generate_numeric_tests_main.go; mv numeric.go ..
 	$(VALIDGEN_BIN) tests/endtoend
 	cd tests/endtoend; go run .
 

README.md

@@ -59,31 +59,32 @@ The following table shows the validations and possible types, where:
 
 - "I" means "Implemented"
 - "W" means "Will be implemented"
+- "P" means "Partially implemented"
 - "-" means "Will not be implemented"
 
-| Validation/Type | String | Numeric types (uint8 only) | Boolean | Slice | Array | Map | Time | Duration |
-| -               | -      | -                          | -       | -     | -     | -   | -    | -        |
-| eq              | I      | W                          | I       | -     | -     | -   | W    | W        |
-| eq_ignore_case  | I      | -                          | -       | -     | -     | -   | -    | -        |
-| gt              | -      | W                          | -       | -     | -     | -   | W    | W        |
-| gte             | -      | I                          | -       | -     | -     | -   | W    | W        |
-| lt              | -      | W                          | -       | -     | -     | -   | W    | W        |
-| lte             | -      | I                          | -       | -     | -     | -   | W    | W        |
-| neq             | I      | W                          | I       | -     | -     | -   | W    | W        |
-| neq_ignore_case | I      | -                          | -       | -     | -     | -   | -    | -        |
-| len             | I      | -                          | -       | I     | -     | W   | -    | -        |
-| max             | I      | -                          | -       | I     | -     | W   | W    | W        |
-| min             | I      | -                          | -       | I     | -     | W   | W    | W        |
-| in              | I      | W                          | -       | I     | I     | W   | -    | W        |
-| nin             | I      | W                          | -       | I     | I     | W   | -    | W        |
-| required        | I      | W                          | -       | I     | -     | W   | W    | W        |
-| email           | I      | -                          | -       | -     | -     | -   | -    | -        |
-| eqfield         | I      | I                          | I       | -     | -     | -   | W    | W        |
-| neqfield        | I      | I                          | I       | -     | -     | -   | W    | W        |
-| gtefield        | -      | I                          | -       | -     | -     | -   | W    | W        |
-| gtfield         | -      | I                          | -       | -     | -     | -   | W    | W        |
-| ltefield        | -      | I                          | -       | -     | -     | -   | W    | W        |
-| ltfield         | -      | I                          | -       | -     | -     | -   | W    | W        |
+| Validation/Type | String | Numeric types (integers) | Boolean | Slice | Array | Map | Time | Duration |
+| -               | -      | -                        | -       | -     | -     | -   | -    | -        |
+| eq              | I      | I                        | I       | -     | -     | -   | W    | W        |
+| eq_ignore_case  | I      | -                        | -       | -     | -     | -   | -    | -        |
+| gt              | -      | I                        | -       | -     | -     | -   | W    | W        |
+| gte             | -      | I                        | -       | -     | -     | -   | W    | W        |
+| lt              | -      | I                        | -       | -     | -     | -   | W    | W        |
+| lte             | -      | I                        | -       | -     | -     | -   | W    | W        |
+| neq             | I      | I                        | I       | -     | -     | -   | W    | W        |
+| neq_ignore_case | I      | -                        | -       | -     | -     | -   | -    | -        |
+| len             | I      | -                        | -       | I     | -     | W   | -    | -        |
+| max             | I      | -                        | -       | I     | -     | W   | W    | W        |
+| min             | I      | -                        | -       | I     | -     | W   | W    | W        |
+| in              | I      | I                        | -       | I     | I     | W   | -    | W        |
+| nin             | I      | I                        | -       | I     | I     | W   | -    | W        |
+| required        | I      | I                        | -       | I     | -     | W   | W    | W        |
+| email           | I      | -                        | -       | -     | -     | -   | -    | -        |
+| eqfield         | I      | P                        | I       | -     | -     | -   | W    | W        |
+| neqfield        | I      | P                        | I       | -     | -     | -   | W    | W        |
+| gtefield        | -      | P                        | -       | -     | -     | -   | W    | W        |
+| gtfield         | -      | P                        | -       | -     | -     | -   | W    | W        |
+| ltefield        | -      | P                        | -       | -     | -     | -   | W    | W        |
+| ltfield         | -      | P                        | -       | -     | -     | -   | W    | W        |
 
 ## Steps to run the unit tests
 

internal/analyzer/analyzer.go

@@ -78,6 +78,12 @@ func parseFieldValidations(fieldTag string) ([]string, bool) {
 
 func checkForInvalidOperations(structs []*Struct) error {
 
+	structsWithValidation := map[string]bool{}
+
+	for _, st := range structs {
+		structsWithValidation[common.KeyPath(st.PackageName, st.StructName)] = true
+	}
+
 	for _, st := range structs {
 		for i, fd := range st.Fields {
 			for _, val := range st.FieldsValidations[i].Validations {
@@ -87,9 +93,19 @@ func checkForInvalidOperations(structs []*Struct) error {
 					return types.NewValidationError("unsupported operation %s", op)
 				}
 
-				// Check if is a valid operation for this type.
+				// If is a custom struct, check if it has validations.
 				fdType := fd.Type
-				if fdType.IsGoType() && !operations[op].ValidTypes[fdType.ToString()] {
+				if structsWithValidation[fdType.BaseType] {
+					continue
+				}
+
+				// If has a validation, must be for a go type.
+				if !fdType.IsGoType() {
+					return types.NewValidationError("unsupported operation %s with unknown go type %s", op, fdType.BaseType)
+				}
+
+				// Check if is a valid operation for this type.
+				if !operations[op].ValidTypes[fdType.ToNormalizedString()] {
 					return types.NewValidationError("operation %s: invalid %s type", op, fdType.BaseType)
 				}
 			}

internal/analyzer/analyzer_test.go

@@ -30,31 +30,61 @@ func TestAnalyzeStructsWithValidInnerFieldOperations(t *testing.T) {
 			fType: "uint8",
 			op:    "eqfield",
 		},
+		{
+			name:  "valid eqfield between int",
+			fType: "int",
+			op:    "eqfield",
+		},
 		{
 			name:  "valid neqfield between uint8",
 			fType: "uint8",
 			op:    "neqfield",
 		},
+		{
+			name:  "valid neqfield between int",
+			fType: "int",
+			op:    "neqfield",
+		},
 		{
 			name:  "valid gtefield between uint8",
 			fType: "uint8",
 			op:    "gtefield",
 		},
+		{
+			name:  "valid gtefield between int",
+			fType: "int",
+			op:    "gtefield",
+		},
 		{
 			name:  "valid gtfield between uint8",
 			fType: "uint8",
 			op:    "gtfield",
 		},
+		{
+			name:  "valid gtfield between int",
+			fType: "int",
+			op:    "gtfield",
+		},
 		{
 			name:  "valid ltefield between uint8",
 			fType: "uint8",
 			op:    "ltefield",
 		},
+		{
+			name:  "valid ltefield between int",
+			fType: "int",
+			op:    "ltefield",
+		},
 		{
 			name:  "valid ltfield between uint8",
 			fType: "uint8",
 			op:    "ltfield",
 		},
+		{
+			name:  "valid ltfield between int",
+			fType: "int",
+			op:    "ltfield",
+		},
 	}
 
 	for _, tt := range tests {