Feat: Add NoneOf Validation (#1554)

## Fixes Or Enhances
Addresses issue #1552

**Make sure that you've checked the boxes below before you submit PR:**
- [x] Tests exist or have been written that cover this particular
change.

@go-playground/validator-maintainers

Author: Carmen-Shannon

README.md

@@ -255,6 +255,7 @@ validate := validator.New(validator.WithRequiredStructEnabled())
 | max | Maximum |
 | min | Minimum |
 | oneof | One Of |
+| noneof | None Of |
 | required | Required |
 | required_if | Required If |
 | required_unless | Required Unless |

baked_in.go

@@ -17,6 +17,7 @@ import (
 	"os"
 	"reflect"
 	"runtime"
+	"slices"
 	"strconv"
 	"strings"
 	"sync"
@@ -217,6 +218,8 @@ var (
 		"unique":                        isUnique,
 		"oneof":                         isOneOf,
 		"oneofci":                       isOneOfCI,
+		"noneof":                        isNoneOf,
+		"noneofci":                      isNoneOfCI,
 		"html":                          isHTML,
 		"html_encoded":                  isHTMLEncoded,
 		"url_encoded":                   isURLEncoded,
@@ -307,12 +310,8 @@ func isOneOf(fl FieldLevel) bool {
 	default:
 		panic(fmt.Sprintf("Bad field type %s", field.Type()))
 	}
-	for i := 0; i < len(vals); i++ {
-		if vals[i] == v {
-			return true
-		}
-	}
-	return false
+
+	return slices.Contains(vals, v)
 }
 
 // isOneOfCI is the validation function for validating if the current field's value is one of the provided string values (case insensitive).
@@ -323,13 +322,20 @@ func isOneOfCI(fl FieldLevel) bool {
 	if field.Kind() != reflect.String {
 		panic(fmt.Sprintf("Bad field type %s", field.Type()))
 	}
-	v := field.String()
-	for _, val := range vals {
-		if strings.EqualFold(val, v) {
-			return true
-		}
-	}
-	return false
+
+	return slices.ContainsFunc(vals, func(val string) bool {
+		return strings.EqualFold(val, field.String())
+	})
+}
+
+// isNoneOf validates that the current field's value is not one of the provided string or integer values
+func isNoneOf(fl FieldLevel) bool {
+	return !isOneOf(fl)
+}
+
+// isNoneOfCI validates that the current field's value is not one of the provided string values (case insensitive)
+func isNoneOfCI(fl FieldLevel) bool {
+	return !isOneOfCI(fl)
 }
 
 // isUnique is the validation function for validating if each array|slice|map value is unique

benchmarks_test.go

@@ -1099,6 +1099,30 @@ func BenchmarkOneofParallel(b *testing.B) {
 	})
 }
 
+type TestNoneOf struct {
+	Color string `validate:"noneof=red green"`
+}
+
+func BenchmarkNoneOf(b *testing.B) {
+	w := &TestNoneOf{Color: "blue"}
+	val := New()
+	for i := 0; i < b.N; i++ {
+		_ = val.Struct(w)
+	}
+}
+
+func BenchmarkNoneOfParallel(b *testing.B) {
+	w := &TestNoneOf{Color: "blue"}
+	val := New()
+
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			_ = val.Struct(w)
+		}
+	})
+}
+
 type T struct{}
 
 func (*T) Validate() error { return errors.New("ops") }

doc.go

@@ -546,6 +546,24 @@ Works the same as oneof but is case insensitive and therefore only accepts strin
 	Usage: oneofci=red green
 	       oneofci='red green' 'blue yellow'
 
+# None Of
+
+For strings, ints, and uints, noneof will ensure that the value is not one of
+the values in the parameter. The parameter should be a list of values separated by whitespace.
+Values may be strings or numbers. To inversely match strings with spaces in them, include the target string between single quotes.
+Kind of like an 'enum'.
+
+	Usage: noneof=red green
+	       noneof='red green' 'blue yellow'
+		   noneof=5 7 9
+
+
+# None Of Case Insensitive
+Works the same as noneof but is case insensitive and therefore only accepts strings.
+
+	Usage: noneofci=red green
+	       noneofci='red green' 'blue yellow'
+
 # Greater Than
 
 For numbers, this will ensure that the value is greater than the

validator_test.go

@@ -5883,6 +5883,133 @@ func TestOneOfCIValidation(t *testing.T) {
 	Equal(t, panicCount, len(panicSpecs))
 }
 
+func TestNoneOfValidation(t *testing.T) {
+	validate := New()
+
+	passSpecs := []struct {
+		f any
+		t string
+	}{
+		{f: "", t: "noneof=red green"},
+		{f: "yellow", t: "noneof=red green"},
+		{f: "green", t: "noneof='red green' blue"},
+		{f: 5, t: "noneof=red green"},
+		{f: 6, t: "noneof=red green"},
+		{f: 6, t: "noneof=7"},
+		{f: int8(5), t: "noneof=red green"},
+		{f: int16(5), t: "noneof=red green"},
+		{f: int32(5), t: "noneof=red green"},
+		{f: int64(5), t: "noneof=red green"},
+		{f: uint(6), t: "noneof=7"},
+		{f: uint8(6), t: "noneof=7"},
+		{f: uint16(6), t: "noneof=7"},
+		{f: uint32(6), t: "noneof=7"},
+		{f: uint64(6), t: "noneof=7"},
+	}
+	for _, spec := range passSpecs {
+		t.Logf("%#v", spec)
+		errs := validate.Var(spec.f, spec.t)
+		Equal(t, errs, nil)
+	}
+
+	failSpecs := []struct {
+		f any
+		t string
+	}{
+		{f: "red", t: "noneof=red green"},
+		{f: "green", t: "noneof=red green"},
+		{f: "red green", t: "noneof='red green' blue'"},
+		{f: "blue", t: "noneof='red green' blue'"},
+		{f: 5, t: "noneof=5 6"},
+		{f: 6, t: "noneof=5 6"},
+		{f: int8(6), t: "noneof=5 6"},
+		{f: int16(6), t: "noneof=5 6"},
+		{f: int32(6), t: "noneof=5 6"},
+		{f: int64(6), t: "noneof=5 6"},
+		{f: uint(6), t: "noneof=5 6"},
+		{f: uint8(6), t: "noneof=5 6"},
+		{f: uint16(6), t: "noneof=5 6"},
+		{f: uint32(6), t: "noneof=5 6"},
+		{f: uint64(6), t: "noneof=5 6"},
+	}
+	for _, spec := range failSpecs {
+		t.Logf("%#v", spec)
+		errs := validate.Var(spec.f, spec.t)
+		AssertError(t, errs, "", "", "", "", "noneof")
+	}
+
+	PanicMatches(t, func() {
+		_ = validate.Var(3.14, "noneof=red green")
+	}, "Bad field type float64")
+}
+
+func TestNoneOfCIValidation(t *testing.T) {
+	validate := New()
+
+	passSpecs := []struct {
+		f any
+		t string
+	}{
+		{f: "", t: "noneofci=red green"},
+		{f: "yellow", t: "noneofci=red green"},
+		{f: "green", t: "noneofci='red yellow' blue"},
+		{f: "RED", t: "noneofci=blue green"},
+		{f: "RED", t: "noneofci=BLUE GREEN"},
+		{f: "ReD", t: "noneofci=BLUE GREEN"},
+		{f: "gReEn", t: "noneofci=rEd BlUe"},
+		{f: "red Green", t: "noneofci='BLUE YELLOW' Orange"},
+		{f: "Red green", t: "noneofci='Blue Yellow' ORANGE"},
+		{f: "rEd GrEeN", t: "noneofci='bLuE YeLlOw' OrAnGe"},
+		{f: "BlUe", t: "noneofci='RED GREEN' Yellow"},
+		{f: "bLuE", t: "noneofci='red green' YELLOW"},
+	}
+	for _, spec := range passSpecs {
+		t.Logf("%#v", spec)
+		errs := validate.Var(spec.f, spec.t)
+		Equal(t, errs, nil)
+	}
+
+	failSpecs := []struct {
+		f any
+		t string
+	}{
+		{f: "red", t: "noneofci=red green"},
+		{f: "green", t: "noneofci=red green"},
+		{f: "red green", t: "noneofci='red green' blue'"},
+	}
+	for _, spec := range failSpecs {
+		t.Logf("%#v", spec)
+		errs := validate.Var(spec.f, spec.t)
+		AssertError(t, errs, "", "", "", "", "noneofci")
+	}
+
+	panicSpecs := []struct {
+		f any
+		t string
+	}{
+		{f: 3.14, t: "noneofci=red green"},
+		{f: 5, t: "noneofci=red green"},
+		{f: int8(5), t: "noneofci=red green"},
+		{f: int16(5), t: "noneofci=red green"},
+		{f: int32(5), t: "noneofci=red green"},
+		{f: int64(5), t: "noneofci=red green"},
+		{f: uint(5), t: "noneofci=red green"},
+		{f: uint8(5), t: "noneofci=red green"},
+		{f: uint16(5), t: "noneofci=red green"},
+		{f: uint32(5), t: "noneofci=red green"},
+		{f: uint64(5), t: "noneofci=red green"},
+	}
+	panicCount := 0
+	for _, spec := range panicSpecs {
+		t.Logf("%#v", spec)
+		PanicMatches(t, func() {
+			_ = validate.Var(spec.f, spec.t)
+		}, fmt.Sprintf("Bad field type %T", spec.f))
+		panicCount++
+	}
+	Equal(t, panicCount, len(panicSpecs))
+}
+
 func TestBase32Validation(t *testing.T) {
 	validate := New()