Make it possible to create custom errors

Author: mjarkk

create_error.go

@@ -0,0 +1,34 @@
+package laravalidate
+
+import "sort"
+
+func CreateGoError(errors map[string]string) error {
+	return createCustomError(GoMode, errors)
+}
+
+func CreateJsonError(errors map[string]string) error {
+	return createCustomError(JsonMode, errors)
+}
+
+func createCustomError(mode Mode, errors map[string]string) error {
+	fieldErrors := []FieldErrors{}
+	for key, message := range errors {
+		fieldErrors = append(fieldErrors, FieldErrors{
+			Path: key,
+			Errors: []FieldValidatorError{{
+				Rule:    "custom",
+				Message: message,
+			}},
+		})
+	}
+
+	sort.Slice(fieldErrors, func(i, j int) bool {
+		return fieldErrors[i].Path < fieldErrors[j].Path
+	})
+
+	return &ValidationError{
+		Mode:     mode,
+		Language: nil, // Maybe we should do something with this?
+		Errors:   fieldErrors,
+	}
+}

error.go

@@ -23,9 +23,8 @@ func (v *ValidationError) Error() string {
 }
 
 type FieldErrors struct {
-	Path     string                `json:"goPath"`
-	JsonPath string                `json:"jsonPath"`
-	Errors   []FieldValidatorError `json:"errors"`
+	Path   string                `json:"path"`
+	Errors []FieldValidatorError `json:"errors"`
 }
 
 type FieldValidatorError struct {
@@ -73,9 +72,6 @@ func (e *ValidationError) ToLaravelError() *LaravelValidationError {
 
 	for _, entry := range e.Errors {
 		path := entry.Path
-		if e.Mode == JsonMode {
-			path = entry.JsonPath
-		}
 
 		errorMessages := []string{}
 		for _, validatorError := range entry.Errors {

laravalidate.go

@@ -260,10 +260,14 @@ func (v *Validator) Validate(stack Stack, value *reflect.Value, valueType reflec
 	}
 
 	goPath, jsonPath := stack.ToPaths()
+	path := goPath
+	if v.mode == JsonMode {
+		path = jsonPath
+	}
+
 	v.errors = append(v.errors, FieldErrors{
-		Path:     goPath,
-		JsonPath: jsonPath,
-		Errors:   errors,
+		Path:   path,
+		Errors: errors,
 	})
 }
 
@@ -426,7 +430,7 @@ func (v *Validator) field(stack Stack, path string) *Needle {
 		pathParts = append(pathParts, part)
 	}
 
-	if relativity == 0 || relativity > len(stack) {
+	if relativity == 0 || len(stack) == 0 || relativity > len(stack) {
 		// Absolute path
 		return resolveWithValue(v.inputValue, pathParts)
 	}
@@ -439,170 +443,3 @@ func (v *Validator) field(stack Stack, path string) *Needle {
 
 	return resolveWithValue(*stackElement.Parent, pathParts)
 }
-
-func resolveWithValue(value reflect.Value, path []string) *Needle {
-	if len(path) == 0 {
-		valueType := value.Type()
-
-		return &Needle{
-			Value: &value,
-			Type:  valueType,
-		}
-	}
-
-	for value.Kind() == reflect.Ptr {
-		if value.IsNil() {
-			return resolveWithType(value.Type().Elem(), path)
-		}
-		value = value.Elem()
-	}
-
-	needle := path[0]
-	path = path[1:]
-
-	if needle == "" {
-		return nil
-	}
-
-	kind := value.Kind()
-	switch kind {
-	case reflect.Struct:
-		field, ok := value.Type().FieldByName(needle)
-		if !ok {
-			return nil
-		}
-
-		return resolveWithValue(value.FieldByIndex(field.Index), path)
-	case reflect.Slice, reflect.Array:
-		needleNumber, err := strconv.Atoi(needle)
-		if err != nil {
-			return nil
-		}
-
-		if kind == reflect.Slice && value.IsNil() {
-			return resolveWithType(value.Type().Elem(), path)
-		}
-
-		if needleNumber < 0 || needleNumber >= value.Len() {
-			return nil
-		}
-
-		return resolveWithValue(value.Index(needleNumber), path)
-	case reflect.Map:
-		var key reflect.Value
-		keySet := false
-		valueType := value.Type()
-		keyKind := valueType.Key().Kind()
-
-		switch keyKind {
-		case reflect.Bool:
-			if needle == "true" {
-				key = reflect.ValueOf(true)
-				keySet = true
-			} else if needle == "false" {
-				key = reflect.ValueOf(false)
-				keySet = true
-			}
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			index, err := strconv.ParseInt(needle, 10, 64)
-			if err != nil {
-				return nil
-			}
-
-			switch keyKind {
-			case reflect.Int:
-				key = reflect.ValueOf(int(index))
-			case reflect.Int8:
-				if int64(int8(index)) != index {
-					return nil
-				}
-				key = reflect.ValueOf(int8(index))
-			case reflect.Int16:
-				if int64(int16(index)) != index {
-					return nil
-				}
-				key = reflect.ValueOf(int16(index))
-			case reflect.Int32:
-				if int64(int32(index)) != index {
-					return nil
-				}
-				key = reflect.ValueOf(int32(index))
-			case reflect.Int64:
-				key = reflect.ValueOf(int64(index))
-			}
-		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			index, err := strconv.ParseUint(needle, 10, 64)
-			if err != nil {
-				return nil
-			}
-
-			switch keyKind {
-			case reflect.Uint:
-				key = reflect.ValueOf(int(index))
-			case reflect.Int8:
-				if uint64(uint8(index)) != index {
-					return nil
-				}
-				key = reflect.ValueOf(int8(index))
-			case reflect.Uint16:
-				if uint64(uint16(index)) != index {
-					return nil
-				}
-				key = reflect.ValueOf(int16(index))
-			case reflect.Uint32:
-				if uint64(uint32(index)) != index {
-					return nil
-				}
-				key = reflect.ValueOf(int32(index))
-			case reflect.Uint64:
-				key = reflect.ValueOf(int64(index))
-			}
-		case reflect.String:
-			key = reflect.ValueOf(needle)
-			keySet = true
-		}
-
-		if !keySet {
-			return nil
-		}
-		field := value.MapIndex(key)
-		if field.Kind() == reflect.Invalid {
-			return resolveWithType(valueType.Elem(), path)
-		}
-
-		return resolveWithValue(field, path)
-	default:
-		return nil
-	}
-}
-
-func resolveWithType(valueType reflect.Type, path []string) *Needle {
-	if len(path) == 0 {
-		return &Needle{
-			Type: valueType,
-		}
-	}
-
-	for valueType.Kind() == reflect.Ptr {
-		valueType = valueType.Elem()
-	}
-
-	needle := path[0]
-	path = path[1:]
-
-	if needle == "" {
-		return nil
-	}
-
-	kind := valueType.Kind()
-	switch kind {
-	case reflect.Struct:
-		field, ok := valueType.FieldByName(needle)
-		if !ok {
-			return nil
-		}
-		return resolveWithType(field.Type, path)
-	}
-
-	return nil
-}

laravalidate_test.go

@@ -134,8 +134,7 @@ func TestErrorMessages(t *testing.T) {
 	assert.Len(t, typedErr.Errors, 1)
 
 	firstErr := typedErr.Errors[0]
-	assert.Equal(t, "Message", firstErr.Path)
-	assert.Equal(t, "message", firstErr.JsonPath)
+	assert.Equal(t, "message", firstErr.Path)
 	assert.Len(t, firstErr.Errors, 1)
 
 	firstValidatorErr := firstErr.Errors[0]
@@ -178,7 +177,6 @@ func TestCustomErrorMessages(t *testing.T) {
 
 	firstErr := typedErr.Errors[0]
 	assert.Equal(t, "Inner.0.Inner2.Inner3", firstErr.Path)
-	assert.Equal(t, "Inner.0.Inner2.Inner3", firstErr.JsonPath)
 	assert.Len(t, firstErr.Errors, 1)
 
 	firstValidatorErr := firstErr.Errors[0]