adding isInArray and the isNotInArray and IsNotIn

validator/is.go

@@ -93,6 +93,50 @@ func IsIn(allowedValues ...interface{}) ValidatorFunc {
 	}
 }
 
+// IsNotIn checks if a value is not in a predefined list of disallowed values.
+func IsNotIn(disallowedValues ...interface{}) ValidatorFunc {
+	return func(value interface{}) error {
+		for _, disallowed := range disallowedValues {
+			if value == disallowed {
+				return fmt.Errorf("value must not be one of %v", disallowedValues)
+			}
+		}
+		return nil
+	}
+}
+
+// IsInArray checks if a value is in an array.
+func IsInArray(array interface{}) ValidatorFunc {
+	return func(value interface{}) error {
+		arr := reflect.ValueOf(array)
+		if arr.Kind() != reflect.Slice && arr.Kind() != reflect.Array {
+			return fmt.Errorf("expected an array or slice, got %T", array)
+		}
+		for i := 0; i < arr.Len(); i++ {
+			if arr.Index(i).Interface() == value {
+				return nil
+			}
+		}
+		return fmt.Errorf("value must be one of %v", array)
+	}
+}
+
+// IsNotInArray checks if a value is not in an array.
+func IsNotInArray(array interface{}) ValidatorFunc {
+	return func(value interface{}) error {
+		arr := reflect.ValueOf(array)
+		if arr.Kind() != reflect.Slice && arr.Kind() != reflect.Array {
+			return fmt.Errorf("expected an array or slice, got %T", array)
+		}
+		for i := 0; i < arr.Len(); i++ {
+			if arr.Index(i).Interface() == value {
+				return fmt.Errorf("value must not be one of %v", array)
+			}
+		}
+		return nil
+	}
+}
+
 // IsString checks if a value is a string.
 func IsString(value interface{}) error {
 	if reflect.TypeOf(value).Kind() != reflect.String {

validator/is_test.go

@@ -113,7 +113,62 @@ func TestIsIn(t *testing.T) {
 		})
 	}
 }
+func TestIsNotIn(t *testing.T) {
+	isNotIn := IsNotIn("apple", "banana", "cherry")
+	tests := []struct {
+		name  string
+		input interface{}
+		error error
+	}{
+		{"valid value", "grape", nil},
+		{"invalid value", "apple", errors.New("value must not be one of [apple banana cherry]")},
+		{"wrong type", 123, nil},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			err := isNotIn(test.input)
+			require.Equal(t, test.error, err)
+		})
+	}
+}
+
+func TestIsInArray(t *testing.T) {
+	isInArray := IsInArray([]string{"apple", "banana", "cherry"})
+	tests := []struct {
+		name  string
+		input interface{}
+		error error
+	}{
+		{"valid value", "apple", nil},
+		{"invalid value", "grape", errors.New("value must be one of [apple banana cherry]")},
+		{"wrong type", 123, errors.New("value must be one of [apple banana cherry]")},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			err := isInArray(test.input)
+			require.Equal(t, test.error, err)
+		})
+	}
+}
 
+func TestIsNotInArray(t *testing.T) {
+	isNotInArray := IsNotInArray([]string{"apple", "banana", "cherry"})
+	tests := []struct {
+		name  string
+		input interface{}
+		error error
+	}{
+		{"valid value", "grape", nil},
+		{"invalid value", "apple", errors.New("value must not be one of [apple banana cherry]")},
+		{"wrong type", 123, nil}, // Or errors.New("value must not be one of [apple banana cherry]") if strict
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			err := isNotInArray(test.input)
+			require.Equal(t, test.error, err)
+		})
+	}
+}
 func TestIsString(t *testing.T) {
 	tests := []struct {
 		name  string

validator/transformers_test.go

@@ -171,6 +171,7 @@ func TestReplace(t *testing.T) {
 		expected interface{}
 	}{
 		{"foo bar", "bar bar"},
+		{"foo bar foo", "bar bar bar"},
 		{"hello world", "hello world"},
 		{123, 123}, // Non-string input
 	}