Added alphanumspace string validator (#1484)

## Fixes Or Enhances


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

I’ve been using this package in several projects at our company.
Yesterday, while searching for a validation tag that supports
alphanumeric characters and spaces for Go structs, I was unable to find
an existing one. To address this, I created a regex pattern that allows
alphabets, numbers, and spaces.

This pull request adds that regex-based validation tag to the package,
extending its functionality for common text fields requiring
alphanumeric and space support.

Summary of Changes
Added a new regex validation tag supporting alphabets, numbers, and
spaces

Included documentation and tests for the new tag

Author: haribabuk113

README.md

@@ -137,6 +137,7 @@ validate := validator.New(validator.WithRequiredStructEnabled())
 | alpha | Alpha Only |
 | alphaspace | Alpha Space |
 | alphanum | Alphanumeric |
+| alphanumspace | Alphanumeric Space |
 | alphanumunicode | Alphanumeric Unicode |
 | alphaunicode | Alpha Unicode |
 | ascii | ASCII |

baked_in.go

@@ -120,6 +120,7 @@ var (
 		"alpha":                         isAlpha,
 		"alphaspace":                    isAlphaSpace,
 		"alphanum":                      isAlphanum,
+		"alphanumspace":                 isAlphaNumericSpace,
 		"alphaunicode":                  isAlphaUnicode,
 		"alphanumunicode":               isAlphanumUnicode,
 		"boolean":                       isBoolean,
@@ -1782,6 +1783,11 @@ func isAlphaSpace(fl FieldLevel) bool {
 	return alphaSpaceRegex().MatchString(fl.Field().String())
 }
 
+// isAlphaNumericSpace is the validation function for validating if the current field's value is a valid alphanumeric value with spaces.
+func isAlphaNumericSpace(fl FieldLevel) bool {
+	return alphanNumericSpaceRegex().MatchString(fl.Field().String())
+}
+
 // isAlphaUnicode is the validation function for validating if the current field's value is a valid alpha unicode value.
 func isAlphaUnicode(fl FieldLevel) bool {
 	return alphaUnicodeRegex().MatchString(fl.Field().String())

doc.go

@@ -789,6 +789,12 @@ This validates that a string value contains ASCII alphanumeric characters only
 
 	Usage: alphanum
 
+# Alphanumeric Space
+
+This validates that a string value contains ASCII alphanumeric characters and spaces only
+
+	Usage: alphanumspace
+
 # Alpha Unicode
 
 This validates that a string value contains unicode alpha characters only

regexes.go

@@ -9,6 +9,7 @@ const (
 	alphaRegexString                 = "^[a-zA-Z]+$"
 	alphaSpaceRegexString            = "^[a-zA-Z ]+$"
 	alphaNumericRegexString          = "^[a-zA-Z0-9]+$"
+	alphaNumericSpaceRegexString     = "^[a-zA-Z0-9 ]+$"
 	alphaUnicodeRegexString          = "^[\\p{L}]+$"
 	alphaUnicodeNumericRegexString   = "^[\\p{L}\\p{N}]+$"
 	numericRegexString               = "^[-+]?[0-9]+(?:\\.[0-9]+)?$"
@@ -96,6 +97,7 @@ func lazyRegexCompile(str string) func() *regexp.Regexp {
 var (
 	alphaRegex                 = lazyRegexCompile(alphaRegexString)
 	alphaSpaceRegex            = lazyRegexCompile(alphaSpaceRegexString)
+	alphanNumericSpaceRegex    = lazyRegexCompile(alphaNumericSpaceRegexString)
 	alphaNumericRegex          = lazyRegexCompile(alphaNumericRegexString)
 	alphaUnicodeRegex          = lazyRegexCompile(alphaUnicodeRegexString)
 	alphaUnicodeNumericRegex   = lazyRegexCompile(alphaUnicodeNumericRegexString)

validator_test.go

@@ -9100,6 +9100,73 @@ func TestAlphaSpace(t *testing.T) {
 	AssertError(t, errs, "", "", "", "", "alphaspace")
 }
 
+func TestAlphaNumericSpace(t *testing.T) {
+	validate := New()
+
+	s := "abcd 123"
+	errs := validate.Var(s, "alphanumspace")
+	Equal(t, errs, nil)
+
+	s = "  "
+	errs = validate.Var(s, "alphanumspace")
+	Equal(t, errs, nil)
+
+	s = "abc123"
+	errs = validate.Var(s, "alphanumspace")
+	Equal(t, errs, nil)
+
+	s = "123"
+	errs = validate.Var(s, "alphanumspace")
+	Equal(t, errs, nil)
+
+	s = "abc"
+	errs = validate.Var(s, "alphanumspace")
+	Equal(t, errs, nil)
+
+	s = "áçć 123"
+	errs = validate.Var(s, "alphanumspace")
+	NotEqual(t, errs, nil)
+	AssertError(t, errs, "", "", "", "", "alphanumspace")
+
+	s = "日本 123"
+	errs = validate.Var(s, "alphanumspace")
+	NotEqual(t, errs, nil)
+	AssertError(t, errs, "", "", "", "", "alphanumspace")
+
+	s = "abc!"
+	errs = validate.Var(s, "alphanumspace")
+	NotEqual(t, errs, nil)
+	AssertError(t, errs, "", "", "", "", "alphanumspace")
+
+	s = "abc\t123"
+	errs = validate.Var(s, "alphanumspace")
+	NotEqual(t, errs, nil)
+	AssertError(t, errs, "", "", "", "", "alphanumspace")
+
+	s = "abc\n123"
+	errs = validate.Var(s, "alphanumspace")
+	NotEqual(t, errs, nil)
+	AssertError(t, errs, "", "", "", "", "alphanumspace")
+
+	s = "abc-123"
+	errs = validate.Var(s, "alphanumspace")
+	NotEqual(t, errs, nil)
+	AssertError(t, errs, "", "", "", "", "alphanumspace")
+
+	s = "abc🙂123"
+	errs = validate.Var(s, "alphanumspace")
+	NotEqual(t, errs, nil)
+	AssertError(t, errs, "", "", "", "", "alphanumspace")
+
+	errs = validate.Var(1, "alphanumspace")
+	NotEqual(t, errs, nil)
+	AssertError(t, errs, "", "", "", "", "alphanumspace")
+
+	errs = validate.Var(1.23, "alphanumspace")
+	NotEqual(t, errs, nil)
+	AssertError(t, errs, "", "", "", "", "alphanumspace")
+}
+
 func TestStructStringValidation(t *testing.T) {
 	validate := New()