text

package
v0.24.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 9, 2026 License: Apache-2.0 Imports: 24 Imported by: 0

Documentation

Overview

schema/text/text.go

Index

Constants

View Source 
const (
	CodeRequired = "string.required"
	CodeType     = "string.type"

	CodeLen = "string.len"
	CodeMin = "string.min"
	CodeMax = "string.max"

	CodeEq  = "string.eq"
	CodeNe  = "string.ne"
	CodeEqI = "string.eq_ignore_case"
	CodeNeI = "string.ne_ignore_case"

	CodeOneOf = "text.oneof"

	CodeContains      = "string.contains"
	CodeExcludes      = "string.excludes"
	CodeStartsWith    = "string.startswith"
	CodeNotStartsWith = "string.not_startswith"
	CodeEndsWith      = "string.endswith"
	CodeNotEndsWith   = "string.not_endswith"

	CodeLowercase = "string.lowercase"
	CodeUppercase = "string.uppercase"

	CodePattern = "string.pattern"

	CodeEmail      = "string.email"
	CodeURL        = "string.url"
	CodeHTTPURL    = "string.http_url"
	CodeURI        = "string.uri"
	CodeURNRFC2141 = "string.urn_rfc2141"

	CodeFile     = "string.file"
	CodeFilePath = "string.filepath"
	CodeDir      = "string.dir"
	CodeDirPath  = "string.dirpath"
	CodeImage    = "string.image"

	CodeUUID  = "string.uuid"
	CodeUUID3 = "string.uuid3"
	CodeUUID4 = "string.uuid4"
	CodeUUID5 = "string.uuid5"

	CodeIP       = "string.ip"
	CodeIPv4     = "string.ipv4"
	CodeIPv6     = "string.ipv6"
	CodeCIDR     = "string.cidr"
	CodeMAC      = "string.mac"
	CodeHostname = "string.hostname"
	CodeFQDN     = "string.fqdn"
	CodePort     = "string.port"

	CodeNumeric     = "string.numeric"
	CodeNumber      = "string.number"
	CodeHexadecimal = "string.hexadecimal"
	CodeHexColor    = "string.hexcolor"
	CodeRGB         = "string.rgb"
	CodeRGBA        = "string.rgba"
	CodeHSL         = "string.hsl"
	CodeHSLA        = "string.hsla"

	CodeBase64       = "string.base64"
	CodeBase64URL    = "string.base64url"
	CodeBase64RawURL = "string.base64rawurl"
	CodeDataURI      = "string.datauri"
	CodeASCII        = "string.ascii"
	CodePrintASCII   = "string.printascii"
	CodeMultibyte    = "string.multibyte"

	CodeCreditCard   = "string.credit_card"
	CodeLuhnChecksum = "string.luhn_checksum"

	CodeISBN   = "string.isbn"
	CodeISBN10 = "string.isbn10"
	CodeISBN13 = "string.isbn13"
	CodeISSN   = "string.issn"

	CodeE164   = "string.e164"
	CodeSemVer = "string.semver"
	CodeCVE    = "string.cve"

	CodeMD4        = "string.md4"
	CodeMD5        = "string.md5"
	CodeSHA1       = "string.sha1"
	CodeSHA224     = "string.sha224"
	CodeSHA256     = "string.sha256"
	CodeSHA384     = "string.sha384"
	CodeSHA512     = "string.sha512"
	CodeSHA512224  = "string.sha512_224"
	CodeSHA512256  = "string.sha512_256"
	CodeSHA3224    = "string.sha3_224"
	CodeSHA3256    = "string.sha3_256"
	CodeSHA3384    = "string.sha3_384"
	CodeSHA3512    = "string.sha3_512"
	CodeRIPEMD160  = "string.ripemd160"
	CodeBLAKE2B256 = "string.blake2b_256"
	CodeBLAKE2B384 = "string.blake2b_384"
	CodeBLAKE2B512 = "string.blake2b_512"
	CodeBLAKE2S256 = "string.blake2s_256"
)

Variables

View Source 
var Msg = struct {
	ASCII         string
	Base64        string
	Base64RawURL  string
	Base64URL     string
	BLAKE2B256    string
	BLAKE2B384    string
	BLAKE2B512    string
	BLAKE2S256    string
	CIDR          string
	Contains      string
	CreditCard    string
	CVE           string
	DataURI       string
	Dir           string
	DirPath       string
	E164          string
	Email         string
	EndsWith      string
	Eq            string
	EqIgnoreCase  string
	Excludes      string
	File          string
	FilePath      string
	FQDN          string
	HexColor      string
	Hexadecimal   string
	Hostname      string
	HSL           string
	HSLA          string
	HTTPURL       string
	Image         string
	IP            string
	IPv4          string
	IPv6          string
	ISBN          string
	ISBN10        string
	ISBN13        string
	ISSN          string
	Len           string
	Lowercase     string
	LuhnChecksum  string
	MAC           string
	Max           string
	MD4           string
	MD5           string
	Min           string
	Multibyte     string
	Ne            string
	NeIgnoreCase  string
	NotEndsWith   string
	NotStartsWith string
	Number        string
	Numeric       string
	OneOf         string
	Pattern       string
	Port          string
	PrintASCII    string
	RGB           string
	RGBA          string
	RIPEMD160     string
	SemVer        string
	SHA1          string
	SHA224        string
	SHA256        string
	SHA3224       string
	SHA3256       string
	SHA3384       string
	SHA3512       string
	SHA384        string
	SHA512        string
	SHA512224     string
	SHA512256     string
	StartsWith    string
	Uppercase     string
	URI           string
	URL           string
	URNRFC2141    string
	UUID          string
	UUID3         string
	UUID4         string
	UUID5         string
}{
	ASCII:         "invalid ascii",
	Base64:        "invalid base64",
	Base64RawURL:  "invalid base64rawurl",
	Base64URL:     "invalid base64url",
	BLAKE2B256:    "invalid blake2b-256",
	BLAKE2B384:    "invalid blake2b-384",
	BLAKE2B512:    "invalid blake2b-512",
	BLAKE2S256:    "invalid blake2s-256",
	CIDR:          "invalid cidr",
	Contains:      "must contain",
	CreditCard:    "invalid credit card",
	CVE:           "invalid cve",
	DataURI:       "invalid data uri",
	Dir:           "invalid dir",
	DirPath:       "invalid dirpath",
	E164:          "invalid e164",
	Email:         "invalid email",
	EndsWith:      "must end with",
	Eq:            "must be equal",
	EqIgnoreCase:  "must be equal (ignore case)",
	Excludes:      "must not contain",
	File:          "invalid file",
	FilePath:      "invalid filepath",
	FQDN:          "invalid fqdn",
	HexColor:      "invalid hex color",
	Hexadecimal:   "invalid hexadecimal",
	Hostname:      "invalid hostname",
	HSL:           "invalid hsl",
	HSLA:          "invalid hsla",
	HTTPURL:       "invalid http url",
	Image:         "invalid image",
	IP:            "invalid ip",
	IPv4:          "invalid ipv4",
	IPv6:          "invalid ipv6",
	ISBN:          "invalid isbn",
	ISBN10:        "invalid isbn10",
	ISBN13:        "invalid isbn13",
	ISSN:          "invalid issn",
	Len:           "invalid length",
	Lowercase:     "must be lowercase",
	LuhnChecksum:  "invalid luhn checksum",
	MAC:           "invalid mac",
	Max:           "too long",
	MD4:           "invalid md4",
	MD5:           "invalid md5",
	Min:           "too short",
	Multibyte:     "invalid multibyte",
	Ne:            "must not be equal",
	NeIgnoreCase:  "must not be equal (ignore case)",
	NotEndsWith:   "must not end with",
	NotStartsWith: "must not start with",
	Number:        "invalid number",
	Numeric:       "invalid numeric",
	OneOf:         "not allowed",
	Pattern:       "does not match pattern",
	Port:          "invalid port",
	PrintASCII:    "invalid printascii",
	RGB:           "invalid rgb",
	RGBA:          "invalid rgba",
	RIPEMD160:     "invalid ripemd160",
	SemVer:        "invalid semver",
	SHA1:          "invalid sha1",
	SHA224:        "invalid sha224",
	SHA256:        "invalid sha256",
	SHA3224:       "invalid sha3-224",
	SHA3256:       "invalid sha3-256",
	SHA3384:       "invalid sha3-384",
	SHA3512:       "invalid sha3-512",
	SHA384:        "invalid sha384",
	SHA512:        "invalid sha512",
	SHA512224:     "invalid sha512/224",
	SHA512256:     "invalid sha512/256",
	StartsWith:    "must start with",
	Uppercase:     "must be uppercase",
	URI:           "invalid uri",
	URL:           "invalid url",
	URNRFC2141:    "invalid urn",
	UUID:          "invalid uuid",
	UUID3:         "invalid uuid3",
	UUID4:         "invalid uuid4",
	UUID5:         "invalid uuid5",
}
View Source 
var Rule = struct {
	ASCII         func(code string) ruleset.Rule[string]
	Base64        func(code string) ruleset.Rule[string]
	Base64RawURL  func(code string) ruleset.Rule[string]
	Base64URL     func(code string) ruleset.Rule[string]
	BLAKE2B_256   func(code string) ruleset.Rule[string]
	BLAKE2B_384   func(code string) ruleset.Rule[string]
	BLAKE2B_512   func(code string) ruleset.Rule[string]
	BLAKE2S_256   func(code string) ruleset.Rule[string]
	CIDR          func(code string) ruleset.Rule[string]
	Contains      func(code string, needle string) ruleset.Rule[string]
	CreditCard    func(code string) ruleset.Rule[string]
	CVE           func(code string) ruleset.Rule[string]
	DataURI       func(code string) ruleset.Rule[string]
	Dir           func(code string) ruleset.Rule[string]
	DirPath       func(code string) ruleset.Rule[string]
	E164          func(code string) ruleset.Rule[string]
	Email         func(code string) ruleset.Rule[string]
	EndsWith      func(code string, suffix string) ruleset.Rule[string]
	Eq            func(code string, expected string) ruleset.Rule[string]
	EqIgnoreCase  func(code string, expected string) ruleset.Rule[string]
	Excludes      func(code string, needle string) ruleset.Rule[string]
	File          func(code string) ruleset.Rule[string]
	FilePath      func(code string) ruleset.Rule[string]
	FQDN          func(code string) ruleset.Rule[string]
	HexColor      func(code string) ruleset.Rule[string]
	Hexadecimal   func(code string) ruleset.Rule[string]
	Hostname      func(code string) ruleset.Rule[string]
	HSL           func(code string) ruleset.Rule[string]
	HSLA          func(code string) ruleset.Rule[string]
	HTTPURL       func(code string) ruleset.Rule[string]
	Image         func(code string) ruleset.Rule[string]
	IP            func(code string) ruleset.Rule[string]
	IPv4          func(code string) ruleset.Rule[string]
	IPv6          func(code string) ruleset.Rule[string]
	ISBN          func(code string) ruleset.Rule[string]
	ISBN10        func(code string) ruleset.Rule[string]
	ISBN13        func(code string) ruleset.Rule[string]
	ISSN          func(code string) ruleset.Rule[string]
	Len           func(code string, expected int) ruleset.Rule[string]
	Lowercase     func(code string) ruleset.Rule[string]
	LuhnChecksum  func(code string) ruleset.Rule[string]
	MAC           func(code string) ruleset.Rule[string]
	Max           func(code string, max int) ruleset.Rule[string]
	MD4           func(code string) ruleset.Rule[string]
	MD5           func(code string) ruleset.Rule[string]
	Min           func(code string, min int) ruleset.Rule[string]
	Multibyte     func(code string) ruleset.Rule[string]
	Ne            func(code string, disallowed string) ruleset.Rule[string]
	NeIgnoreCase  func(code string, disallowed string) ruleset.Rule[string]
	NotEndsWith   func(code string, suffix string) ruleset.Rule[string]
	NotStartsWith func(code string, prefix string) ruleset.Rule[string]
	Number        func(code string) ruleset.Rule[string]
	Numeric       func(code string) ruleset.Rule[string]
	OneOf         func(code string, values ...string) ruleset.Rule[string]
	Pattern       func(code string, patterns ...*regexp.Regexp) ruleset.Rule[string]
	Port          func(code string) ruleset.Rule[string]
	PrintASCII    func(code string) ruleset.Rule[string]
	RGB           func(code string) ruleset.Rule[string]
	RGBA          func(code string) ruleset.Rule[string]
	RIPEMD160     func(code string) ruleset.Rule[string]
	SemVer        func(code string) ruleset.Rule[string]
	SHA1          func(code string) ruleset.Rule[string]
	SHA224        func(code string) ruleset.Rule[string]
	SHA256        func(code string) ruleset.Rule[string]
	SHA3_224      func(code string) ruleset.Rule[string]
	SHA3_256      func(code string) ruleset.Rule[string]
	SHA3_384      func(code string) ruleset.Rule[string]
	SHA3_512      func(code string) ruleset.Rule[string]
	SHA384        func(code string) ruleset.Rule[string]
	SHA512        func(code string) ruleset.Rule[string]
	SHA512_224    func(code string) ruleset.Rule[string]
	SHA512_256    func(code string) ruleset.Rule[string]
	StartsWith    func(code string, prefix string) ruleset.Rule[string]
	Uppercase     func(code string) ruleset.Rule[string]
	URI           func(code string) ruleset.Rule[string]
	URL           func(code string) ruleset.Rule[string]
	URNRFC2141    func(code string) ruleset.Rule[string]
	UUID          func(code string) ruleset.Rule[string]
	UUID3         func(code string) ruleset.Rule[string]
	UUID4         func(code string) ruleset.Rule[string]
	UUID5         func(code string) ruleset.Rule[string]
}{
	ASCII: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.ASCII, func(actual string) (bool, types.AnyMap) {
			return asciiRegex.MatchString(actual), types.AnyMap{"actual": actual}
		})
	},
	Base64: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.Base64, func(actual string) (bool, types.AnyMap) {
			_, err := base64.StdEncoding.DecodeString(actual)
			return err == nil, types.AnyMap{"actual": actual}
		})
	},
	Base64RawURL: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.Base64RawURL, func(actual string) (bool, types.AnyMap) {
			_, err := base64.RawURLEncoding.DecodeString(actual)
			return err == nil, types.AnyMap{"actual": actual}
		})
	},
	Base64URL: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.Base64URL, func(actual string) (bool, types.AnyMap) {
			_, err := base64.URLEncoding.DecodeString(actual)
			return err == nil, types.AnyMap{"actual": actual}
		})
	},
	BLAKE2B_256: func(code string) ruleset.Rule[string] {
		return digestRule(code, Msg.BLAKE2B256, 32)
	},
	BLAKE2B_384: func(code string) ruleset.Rule[string] {
		return digestRule(code, Msg.BLAKE2B384, 48)
	},
	BLAKE2B_512: func(code string) ruleset.Rule[string] {
		return digestRule(code, Msg.BLAKE2B512, 64)
	},
	BLAKE2S_256: func(code string) ruleset.Rule[string] {
		return digestRule(code, Msg.BLAKE2S256, 32)
	},
	CIDR: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.CIDR, func(actual string) (bool, types.AnyMap) {
			_, _, err := net.ParseCIDR(actual)
			return err == nil, types.AnyMap{"actual": actual}
		})
	},
	Contains: func(code string, needle string) ruleset.Rule[string] {
		return newRule(code, Msg.Contains, func(actual string) (bool, types.AnyMap) {
			if strings.Contains(actual, needle) {
				return true, nil
			}
			return false, types.AnyMap{"expected": needle, "actual": actual}
		})
	},
	CreditCard: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.CreditCard, func(actual string) (bool, types.AnyMap) {
			digits, ok := digitsForChecksum(actual, true)
			if !ok || len(digits) < 12 || len(digits) > 19 {
				return false, types.AnyMap{"actual": actual}
			}
			return luhnValid(digits), types.AnyMap{"actual": actual}
		})
	},
	CVE: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.CVE, func(actual string) (bool, types.AnyMap) {
			return cveRegex.MatchString(actual), types.AnyMap{"actual": actual}
		})
	},
	DataURI: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.DataURI, func(actual string) (bool, types.AnyMap) {
			if !strings.HasPrefix(actual, "data:") {
				return false, types.AnyMap{"actual": actual}
			}
			commaIndex := strings.IndexByte(actual, ',')
			if commaIndex < 0 {
				return false, types.AnyMap{"actual": actual}
			}
			meta := actual[len("data:"):commaIndex]
			data := actual[commaIndex+1:]
			var ok bool
			if strings.Contains(meta, ";base64") {
				_, err := base64.StdEncoding.DecodeString(data)
				if err == nil {
					ok = true
				} else {
					_, err = base64.RawStdEncoding.DecodeString(data)
					ok = err == nil
				}
			} else {
				_, err := url.PathUnescape(data)
				ok = err == nil
			}
			return ok, types.AnyMap{"actual": actual}
		})
	},
	Dir: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.Dir, func(actual string) (bool, types.AnyMap) {
			if !isValidPath(actual) {
				return false, types.AnyMap{"actual": actual}
			}
			info, err := os.Stat(actual)
			if err != nil {
				return false, types.AnyMap{"actual": actual}
			}
			return info.IsDir(), types.AnyMap{"actual": actual}
		})
	},
	DirPath: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.DirPath, func(actual string) (bool, types.AnyMap) {
			if !isValidPath(actual) {
				return false, types.AnyMap{"actual": actual}
			}
			info, err := os.Stat(actual)
			if err == nil && info.IsDir() {
				return true, types.AnyMap{"actual": actual}
			}
			if len(actual) > 0 {
				last := actual[len(actual)-1]
				if last == '/' || last == '\\' {
					return true, types.AnyMap{"actual": actual}
				}
			}
			return false, types.AnyMap{"actual": actual}
		})
	},
	E164: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.E164, func(actual string) (bool, types.AnyMap) {
			return e164Regex.MatchString(actual), types.AnyMap{"actual": actual}
		})
	},
	Email: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.Email, func(actual string) (bool, types.AnyMap) {
			if actual == "" || strings.TrimSpace(actual) != actual {
				return false, types.AnyMap{"actual": actual}
			}
			parsed, err := mail.ParseAddress(actual)
			ok := err == nil && parsed != nil && parsed.Address == actual
			return ok, types.AnyMap{"actual": actual}
		})
	},
	EndsWith: func(code string, suffix string) ruleset.Rule[string] {
		return newRule(code, Msg.EndsWith, func(actual string) (bool, types.AnyMap) {
			if strings.HasSuffix(actual, suffix) {
				return true, nil
			}
			return false, types.AnyMap{"expected": suffix, "actual": actual}
		})
	},
	Eq: func(code string, expected string) ruleset.Rule[string] {
		return newRule(code, Msg.Eq, func(actual string) (bool, types.AnyMap) {
			if actual == expected {
				return true, nil
			}
			return false, types.AnyMap{"expected": expected, "actual": actual}
		})
	},
	EqIgnoreCase: func(code string, expected string) ruleset.Rule[string] {
		return newRule(code, "must be equal (ignore case)", func(actual string) (bool, types.AnyMap) {
			if strings.EqualFold(actual, expected) {
				return true, nil
			}
			return false, types.AnyMap{"expected": expected, "actual": actual}
		})
	},
	Excludes: func(code string, needle string) ruleset.Rule[string] {
		return newRule(code, Msg.Excludes, func(actual string) (bool, types.AnyMap) {
			if !strings.Contains(actual, needle) {
				return true, nil
			}
			return false, types.AnyMap{"expected": needle, "actual": actual}
		})
	},
	File: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.File, func(actual string) (bool, types.AnyMap) {
			return isFile(actual), types.AnyMap{"actual": actual}
		})
	},
	FilePath: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.FilePath, func(actual string) (bool, types.AnyMap) {
			return isValidPath(actual), types.AnyMap{"actual": actual}
		})
	},
	FQDN: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.FQDN, func(actual string) (bool, types.AnyMap) {
			return isHostname(actual, true), types.AnyMap{"actual": actual}
		})
	},
	HexColor: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.HexColor, func(actual string) (bool, types.AnyMap) {
			if actual == "" {
				return false, types.AnyMap{"actual": actual}
			}
			return hexColorRegex.MatchString(actual), types.AnyMap{"actual": actual}
		})
	},
	Hexadecimal: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.Hexadecimal, func(actual string) (bool, types.AnyMap) {
			return hexadecimalRegex.MatchString(actual), types.AnyMap{"actual": actual}
		})
	},
	Hostname: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.Hostname, func(actual string) (bool, types.AnyMap) {
			return isHostname(actual, false), types.AnyMap{"actual": actual}
		})
	},
	HSL: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.HSL, func(actual string) (bool, types.AnyMap) {
			match := hslRegex.FindStringSubmatch(actual)
			if match == nil || len(match) != 4 {
				return false, types.AnyMap{"actual": actual}
			}
			if !parseIntRange(match[1], 0, 360) {
				return false, types.AnyMap{"actual": actual}
			}
			if !parseIntRange(match[2], 0, 100) {
				return false, types.AnyMap{"actual": actual}
			}
			if !parseIntRange(match[3], 0, 100) {
				return false, types.AnyMap{"actual": actual}
			}
			return true, types.AnyMap{"actual": actual}
		})
	},
	HSLA: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.HSLA, func(actual string) (bool, types.AnyMap) {
			match := hslaRegex.FindStringSubmatch(actual)
			if match == nil || len(match) != 5 {
				return false, types.AnyMap{"actual": actual}
			}
			if !parseIntRange(match[1], 0, 360) {
				return false, types.AnyMap{"actual": actual}
			}
			if !parseIntRange(match[2], 0, 100) {
				return false, types.AnyMap{"actual": actual}
			}
			if !parseIntRange(match[3], 0, 100) {
				return false, types.AnyMap{"actual": actual}
			}
			if !parseFloatRange(match[4], 0, 1) {
				return false, types.AnyMap{"actual": actual}
			}
			return true, types.AnyMap{"actual": actual}
		})
	},
	HTTPURL: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.HTTPURL, func(actual string) (bool, types.AnyMap) {
			if actual == "" {
				return false, types.AnyMap{"actual": actual}
			}
			parsed, err := url.Parse(actual)
			ok := err == nil && parsed != nil && (parsed.Scheme == "http" || parsed.Scheme == "https") && parsed.Host != ""
			return ok, types.AnyMap{"actual": actual}
		})
	},
	Image: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.Image, func(actual string) (bool, types.AnyMap) {
			if !isFile(actual) {
				return false, types.AnyMap{"actual": actual}
			}
			file, err := os.Open(actual)
			if err != nil {
				return false, types.AnyMap{"actual": actual}
			}
			defer file.Close()
			_, _, err = image.DecodeConfig(file)
			return err == nil, types.AnyMap{"actual": actual}
		})
	},
	IP: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.IP, func(actual string) (bool, types.AnyMap) {
			return net.ParseIP(actual) != nil, types.AnyMap{"actual": actual}
		})
	},
	IPv4: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.IPv4, func(actual string) (bool, types.AnyMap) {
			parsed := net.ParseIP(actual)
			return parsed != nil && parsed.To4() != nil, types.AnyMap{"actual": actual}
		})
	},
	IPv6: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.IPv6, func(actual string) (bool, types.AnyMap) {
			parsed := net.ParseIP(actual)
			return parsed != nil && parsed.To4() == nil, types.AnyMap{"actual": actual}
		})
	},
	ISBN: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.ISBN, func(actual string) (bool, types.AnyMap) {
			return isISBN10(actual) || isISBN13(actual), types.AnyMap{"actual": actual}
		})
	},
	ISBN10: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.ISBN10, func(actual string) (bool, types.AnyMap) {
			return isISBN10(actual), types.AnyMap{"actual": actual}
		})
	},
	ISBN13: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.ISBN13, func(actual string) (bool, types.AnyMap) {
			return isISBN13(actual), types.AnyMap{"actual": actual}
		})
	},
	ISSN: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.ISSN, func(actual string) (bool, types.AnyMap) {
			var b strings.Builder
			b.Grow(len(actual))
			for i := 0; i < len(actual); i++ {
				ch := actual[i]
				if (ch >= '0' && ch <= '9') || ch == 'X' || ch == 'x' {
					b.WriteByte(ch)
				} else if ch == '-' || ch == ' ' {
					continue
				}
			}
			cleaned := b.String()
			if len(cleaned) != 8 {
				return false, types.AnyMap{"actual": actual}
			}
			sum := 0
			for i := 0; i < 7; i++ {
				ch := cleaned[i]
				if ch < '0' || ch > '9' {
					return false, types.AnyMap{"actual": actual}
				}
				sum += int(ch-'0') * (8 - i)
			}
			remainder := sum % 11
			check := (11 - remainder) % 11
			var expected byte
			if check == 10 {
				expected = 'X'
			} else {
				expected = byte('0' + check)
			}
			last := cleaned[7]
			if last == 'x' {
				last = 'X'
			}
			return last == expected, types.AnyMap{"actual": actual}
		})
	},
	Len: func(code string, expected int) ruleset.Rule[string] {
		return newRule(code, Msg.Len, func(actual string) (bool, types.AnyMap) {
			actualLen := len(actual)
			if actualLen == expected {
				return true, nil
			}
			return false, types.AnyMap{"expected": expected, "actual": actualLen}
		})
	},
	Lowercase: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.Lowercase, func(actual string) (bool, types.AnyMap) {
			if actual == strings.ToLower(actual) {
				return true, nil
			}
			return false, types.AnyMap{"actual": actual}
		})
	},
	LuhnChecksum: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.LuhnChecksum, func(actual string) (bool, types.AnyMap) {
			digits, ok := digitsForChecksum(actual, true)
			if !ok || len(digits) < 2 {
				return false, types.AnyMap{"actual": actual}
			}
			return luhnValid(digits), types.AnyMap{"actual": actual}
		})
	},
	MAC: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.MAC, func(actual string) (bool, types.AnyMap) {
			_, err := net.ParseMAC(actual)
			return err == nil, types.AnyMap{"actual": actual}
		})
	},
	Max: func(code string, max int) ruleset.Rule[string] {
		return newRule(code, Msg.Max, func(actual string) (bool, types.AnyMap) {
			actualLen := len(actual)
			if actualLen <= max {
				return true, nil
			}
			return false, types.AnyMap{"max": max, "actual": actualLen}
		})
	},
	MD4: func(code string) ruleset.Rule[string] {
		return digestRule(code, Msg.MD4, 16)
	},
	MD5: func(code string) ruleset.Rule[string] {
		return digestRule(code, Msg.MD5, 16)
	},
	Min: func(code string, min int) ruleset.Rule[string] {
		return newRule(code, Msg.Min, func(actual string) (bool, types.AnyMap) {
			actualLen := len(actual)
			if actualLen >= min {
				return true, nil
			}
			return false, types.AnyMap{"min": min, "actual": actualLen}
		})
	},
	Multibyte: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.Multibyte, func(actual string) (bool, types.AnyMap) {
			return multibyteRegex.MatchString(actual), types.AnyMap{"actual": actual}
		})
	},
	Ne: func(code string, disallowed string) ruleset.Rule[string] {
		return newRule(code, Msg.Ne, func(actual string) (bool, types.AnyMap) {
			if actual != disallowed {
				return true, nil
			}
			return false, types.AnyMap{"expected": disallowed, "actual": actual}
		})
	},
	NeIgnoreCase: func(code string, disallowed string) ruleset.Rule[string] {
		return newRule(code, "must not be equal (ignore case)", func(actual string) (bool, types.AnyMap) {
			if !strings.EqualFold(actual, disallowed) {
				return true, nil
			}
			return false, types.AnyMap{"expected": disallowed, "actual": actual}
		})
	},
	NotEndsWith: func(code string, suffix string) ruleset.Rule[string] {
		return newRule(code, Msg.NotEndsWith, func(actual string) (bool, types.AnyMap) {
			if !strings.HasSuffix(actual, suffix) {
				return true, nil
			}
			return false, types.AnyMap{"expected": suffix, "actual": actual}
		})
	},
	NotStartsWith: func(code string, prefix string) ruleset.Rule[string] {
		return newRule(code, Msg.NotStartsWith, func(actual string) (bool, types.AnyMap) {
			if !strings.HasPrefix(actual, prefix) {
				return true, nil
			}
			return false, types.AnyMap{"expected": prefix, "actual": actual}
		})
	},
	Number: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.Number, func(actual string) (bool, types.AnyMap) {
			if actual == "" {
				return false, types.AnyMap{"actual": actual}
			}
			parsed, err := strconv.ParseFloat(actual, 64)
			ok := err == nil && !math.IsNaN(parsed) && !math.IsInf(parsed, 0)
			return ok, types.AnyMap{"actual": actual}
		})
	},
	Numeric: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.Numeric, func(actual string) (bool, types.AnyMap) {
			return numericRegex.MatchString(actual), types.AnyMap{"actual": actual}
		})
	},
	OneOf: func(code string, values ...string) ruleset.Rule[string] {
		allowed := make(map[string]struct{}, len(values))
		for _, v := range values {
			allowed[v] = struct{}{}
		}
		return newRule(code, Msg.OneOf, func(actual string) (bool, types.AnyMap) {
			if _, ok := allowed[actual]; ok {
				return true, nil
			}
			return false, types.AnyMap{"allowed": values, "actual": actual}
		})
	},
	Pattern: func(code string, patterns ...*regexp.Regexp) ruleset.Rule[string] {
		patternStrings := make([]string, len(patterns))
		for i, p := range patterns {
			if p != nil {
				patternStrings[i] = p.String()
			}
		}
		return newRule(code, Msg.Pattern, func(actual string) (bool, types.AnyMap) {
			var failed []string
			for i, p := range patterns {
				if p == nil || !p.MatchString(actual) {
					failed = append(failed, patternStrings[i])
				}
			}
			if len(failed) == 0 {
				return true, nil
			}
			return false, types.AnyMap{"patterns": failed, "actual": actual}
		})
	},
	Port: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.Port, func(actual string) (bool, types.AnyMap) {
			if actual == "" || strings.TrimSpace(actual) != actual {
				return false, types.AnyMap{"actual": actual}
			}
			for i := 0; i < len(actual); i++ {
				if actual[i] < '0' || actual[i] > '9' {
					return false, types.AnyMap{"actual": actual}
				}
			}
			port, err := strconv.Atoi(actual)
			ok := err == nil && port >= 0 && port <= 65535
			return ok, types.AnyMap{"actual": actual}
		})
	},
	PrintASCII: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.PrintASCII, func(actual string) (bool, types.AnyMap) {
			return printASCIIRegex.MatchString(actual), types.AnyMap{"actual": actual}
		})
	},
	RGB: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.RGB, func(actual string) (bool, types.AnyMap) {
			match := rgbRegex.FindStringSubmatch(actual)
			if match == nil || len(match) != 4 {
				return false, types.AnyMap{"actual": actual}
			}
			if !parseIntRange(match[1], 0, 255) {
				return false, types.AnyMap{"actual": actual}
			}
			if !parseIntRange(match[2], 0, 255) {
				return false, types.AnyMap{"actual": actual}
			}
			if !parseIntRange(match[3], 0, 255) {
				return false, types.AnyMap{"actual": actual}
			}
			return true, types.AnyMap{"actual": actual}
		})
	},
	RGBA: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.RGBA, func(actual string) (bool, types.AnyMap) {
			match := rgbaRegex.FindStringSubmatch(actual)
			if match == nil || len(match) != 5 {
				return false, types.AnyMap{"actual": actual}
			}
			if !parseIntRange(match[1], 0, 255) {
				return false, types.AnyMap{"actual": actual}
			}
			if !parseIntRange(match[2], 0, 255) {
				return false, types.AnyMap{"actual": actual}
			}
			if !parseIntRange(match[3], 0, 255) {
				return false, types.AnyMap{"actual": actual}
			}
			if !parseFloatRange(match[4], 0, 1) {
				return false, types.AnyMap{"actual": actual}
			}
			return true, types.AnyMap{"actual": actual}
		})
	},
	RIPEMD160: func(code string) ruleset.Rule[string] {
		return digestRule(code, Msg.RIPEMD160, 20)
	},
	SemVer: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.SemVer, func(actual string) (bool, types.AnyMap) {
			match := semVerRegex.FindStringSubmatch(actual)
			if match == nil {
				return false, types.AnyMap{"actual": actual}
			}
			prerelease := match[4]
			if prerelease != "" {
				for _, part := range strings.Split(prerelease, ".") {
					if part == "" {
						return false, types.AnyMap{"actual": actual}
					}
					allDigits := len(part) > 0
					for i := 0; i < len(part); i++ {
						if part[i] < '0' || part[i] > '9' {
							allDigits = false
							break
						}
					}
					if allDigits && len(part) > 1 && part[0] == '0' {
						return false, types.AnyMap{"actual": actual}
					}
				}
			}
			return true, types.AnyMap{"actual": actual}
		})
	},
	SHA1: func(code string) ruleset.Rule[string] {
		return digestRule(code, Msg.SHA1, 20)
	},
	SHA224: func(code string) ruleset.Rule[string] {
		return digestRule(code, Msg.SHA224, 28)
	},
	SHA256: func(code string) ruleset.Rule[string] {
		return digestRule(code, Msg.SHA256, 32)
	},
	SHA3_224: func(code string) ruleset.Rule[string] {
		return digestRule(code, Msg.SHA3224, 28)
	},
	SHA3_256: func(code string) ruleset.Rule[string] {
		return digestRule(code, Msg.SHA3256, 32)
	},
	SHA3_384: func(code string) ruleset.Rule[string] {
		return digestRule(code, Msg.SHA3384, 48)
	},
	SHA3_512: func(code string) ruleset.Rule[string] {
		return digestRule(code, Msg.SHA3512, 64)
	},
	SHA384: func(code string) ruleset.Rule[string] {
		return digestRule(code, Msg.SHA384, 48)
	},
	SHA512: func(code string) ruleset.Rule[string] {
		return digestRule(code, Msg.SHA512, 64)
	},
	SHA512_224: func(code string) ruleset.Rule[string] {
		return digestRule(code, Msg.SHA512224, 28)
	},
	SHA512_256: func(code string) ruleset.Rule[string] {
		return digestRule(code, Msg.SHA512256, 32)
	},
	StartsWith: func(code string, prefix string) ruleset.Rule[string] {
		return newRule(code, Msg.StartsWith, func(actual string) (bool, types.AnyMap) {
			if strings.HasPrefix(actual, prefix) {
				return true, nil
			}
			return false, types.AnyMap{"expected": prefix, "actual": actual}
		})
	},
	Uppercase: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.Uppercase, func(actual string) (bool, types.AnyMap) {
			if actual == strings.ToUpper(actual) {
				return true, nil
			}
			return false, types.AnyMap{"actual": actual}
		})
	},
	URI: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.URI, func(actual string) (bool, types.AnyMap) {
			if actual == "" {
				return false, types.AnyMap{"actual": actual}
			}
			_, err := url.ParseRequestURI(actual)
			return err == nil, types.AnyMap{"actual": actual}
		})
	},
	URL: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.URL, func(actual string) (bool, types.AnyMap) {
			if actual == "" {
				return false, types.AnyMap{"actual": actual}
			}
			parsed, err := url.Parse(actual)
			ok := err == nil && parsed != nil && parsed.Scheme != "" && parsed.Host != ""
			return ok, types.AnyMap{"actual": actual}
		})
	},
	URNRFC2141: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.URNRFC2141, func(actual string) (bool, types.AnyMap) {
			if actual == "" {
				return false, types.AnyMap{"actual": actual}
			}
			return urnRFC2141Regex.MatchString(actual), types.AnyMap{"actual": actual}
		})
	},
	UUID: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.UUID, func(actual string) (bool, types.AnyMap) {
			return uuidRegex.MatchString(actual), types.AnyMap{"actual": actual}
		})
	},
	UUID3: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.UUID3, func(actual string) (bool, types.AnyMap) {
			return uuid3Regex.MatchString(actual), types.AnyMap{"actual": actual}
		})
	},
	UUID4: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.UUID4, func(actual string) (bool, types.AnyMap) {
			return uuid4Regex.MatchString(actual), types.AnyMap{"actual": actual}
		})
	},
	UUID5: func(code string) ruleset.Rule[string] {
		return newRule(code, Msg.UUID5, func(actual string) (bool, types.AnyMap) {
			return uuid5Regex.MatchString(actual), types.AnyMap{"actual": actual}
		})
	},
}

Functions

This section is empty.

Types

type Schema 

type Schema struct {
	// contains filtered or unexported fields
}

func New 

func New() *Schema

func (*Schema) ASCII 

func (s *Schema) ASCII() *Schema

func (*Schema) BLAKE2B_256 

func (s *Schema) BLAKE2B_256() *Schema

func (*Schema) BLAKE2B_384 

func (s *Schema) BLAKE2B_384() *Schema

func (*Schema) BLAKE2B_512 

func (s *Schema) BLAKE2B_512() *Schema

func (*Schema) BLAKE2S_256 

func (s *Schema) BLAKE2S_256() *Schema

func (*Schema) Base64 

func (s *Schema) Base64() *Schema

func (*Schema) Base64RawURL 

func (s *Schema) Base64RawURL() *Schema

func (*Schema) Base64RawUrl 

func (s *Schema) Base64RawUrl() *Schema

func (*Schema) Base64URL 

func (s *Schema) Base64URL() *Schema

func (*Schema) Base64Url 

func (s *Schema) Base64Url() *Schema

func (*Schema) Blake2b256 

func (s *Schema) Blake2b256() *Schema

func (*Schema) Blake2b384 

func (s *Schema) Blake2b384() *Schema

func (*Schema) Blake2b512 

func (s *Schema) Blake2b512() *Schema

func (*Schema) Blake2s256 

func (s *Schema) Blake2s256() *Schema

func (*Schema) CIDR 

func (s *Schema) CIDR() *Schema

func (*Schema) CVE 

func (s *Schema) CVE() *Schema

func (*Schema) Contains 

func (s *Schema) Contains(value string) *Schema

func (*Schema) CreditCard 

func (s *Schema) CreditCard() *Schema

func (*Schema) Custom 

func (s *Schema) Custom(ruleFn ruleset.RuleFn[string]) *Schema

func (*Schema) DataURI 

func (s *Schema) DataURI() *Schema

func (*Schema) Default 

func (s *Schema) Default(value string) *Schema

func (*Schema) DefaultFunc 

func (s *Schema) DefaultFunc(fn func() string) *Schema

func (*Schema) Dir 

func (s *Schema) Dir() *Schema

func (*Schema) DirPath 

func (s *Schema) DirPath() *Schema

func (*Schema) Dirpath 

func (s *Schema) Dirpath() *Schema

func (*Schema) E164 

func (s *Schema) E164() *Schema

func (*Schema) Email 

func (s *Schema) Email() *Schema

func (*Schema) EndsWith 

func (s *Schema) EndsWith(value string) *Schema

func (*Schema) Enum added in v0.10.0 

func (s *Schema) Enum(values ...any) *Schema

func (*Schema) Eq 

func (s *Schema) Eq(value string) *Schema

func (*Schema) EqIgnoreCase 

func (s *Schema) EqIgnoreCase(value string) *Schema

func (*Schema) Excludes 

func (s *Schema) Excludes(value string) *Schema

func (*Schema) FQDN 

func (s *Schema) FQDN() *Schema

func (*Schema) File 

func (s *Schema) File() *Schema

func (*Schema) FilePath 

func (s *Schema) FilePath() *Schema

func (*Schema) Filepath 

func (s *Schema) Filepath() *Schema

func (*Schema) HSL 

func (s *Schema) HSL() *Schema

func (*Schema) HSLA 

func (s *Schema) HSLA() *Schema

func (*Schema) HTTPURL 

func (s *Schema) HTTPURL() *Schema

func (*Schema) HexColor 

func (s *Schema) HexColor() *Schema

func (*Schema) Hexadecimal 

func (s *Schema) Hexadecimal() *Schema

func (*Schema) Hostname 

func (s *Schema) Hostname() *Schema

func (*Schema) HttpURL 

func (s *Schema) HttpURL() *Schema

func (*Schema) IP 

func (s *Schema) IP() *Schema

func (*Schema) IPv4 

func (s *Schema) IPv4() *Schema

func (*Schema) IPv6 

func (s *Schema) IPv6() *Schema

func (*Schema) ISBN 

func (s *Schema) ISBN() *Schema

func (*Schema) ISBN10 

func (s *Schema) ISBN10() *Schema

func (*Schema) ISBN13 

func (s *Schema) ISBN13() *Schema

func (*Schema) ISSN 

func (s *Schema) ISSN() *Schema

func (*Schema) Image 

func (s *Schema) Image() *Schema

func (*Schema) IsDefault 

func (s *Schema) IsDefault() *Schema

func (*Schema) Len 

func (s *Schema) Len(length int) *Schema

func (*Schema) Lowercase 

func (s *Schema) Lowercase() *Schema

func (*Schema) LuhnChecksum 

func (s *Schema) LuhnChecksum() *Schema

func (*Schema) MAC 

func (s *Schema) MAC() *Schema

func (*Schema) MD4 

func (s *Schema) MD4() *Schema

func (*Schema) MD5 

func (s *Schema) MD5() *Schema

func (*Schema) Max 

func (s *Schema) Max(length int) *Schema

func (*Schema) Min 

func (s *Schema) Min(length int) *Schema

func (*Schema) Multibyte 

func (s *Schema) Multibyte() *Schema

func (*Schema) Ne 

func (s *Schema) Ne(value string) *Schema

func (*Schema) NeIgnoreCase 

func (s *Schema) NeIgnoreCase(value string) *Schema

func (*Schema) NotEndsWith 

func (s *Schema) NotEndsWith(value string) *Schema

func (*Schema) NotStartsWith 

func (s *Schema) NotStartsWith(value string) *Schema

func (*Schema) Number 

func (s *Schema) Number() *Schema

func (*Schema) Numeric 

func (s *Schema) Numeric() *Schema

func (*Schema) OneOf 

func (s *Schema) OneOf(values ...string) *Schema

func (*Schema) OutputType 

func (s *Schema) OutputType() reflect.Type

func (*Schema) Pattern 

func (s *Schema) Pattern(values ...string) *Schema

Pattern accepts one or more regex strings (AND semantics: all must match). Passing zero args removes any previously set pattern rule. Invalid regex strings are silently skipped; if all are invalid the call is a no-op. Go uses RE2 which has no lookaheads — use multiple patterns instead of a single complex lookahead regex (e.g. password rules: one pattern per character class).

func (*Schema) PatternRegexp 

func (s *Schema) PatternRegexp(values ...*regexp.Regexp) *Schema

PatternRegexp accepts one or more compiled regexps (AND semantics: all must match). Nil values are ignored. Passing zero non-nil args removes the pattern rule.

func (*Schema) Port 

func (s *Schema) Port() *Schema

func (*Schema) PrintASCII 

func (s *Schema) PrintASCII() *Schema

func (*Schema) RGB 

func (s *Schema) RGB() *Schema

func (*Schema) RGBA 

func (s *Schema) RGBA() *Schema

func (*Schema) RIPEMD160 

func (s *Schema) RIPEMD160() *Schema

func (*Schema) Required 

func (s *Schema) Required() *Schema

func (*Schema) SHA1 

func (s *Schema) SHA1() *Schema

func (*Schema) SHA3_224 

func (s *Schema) SHA3_224() *Schema

func (*Schema) SHA3_256 

func (s *Schema) SHA3_256() *Schema

func (*Schema) SHA3_384 

func (s *Schema) SHA3_384() *Schema

func (*Schema) SHA3_512 

func (s *Schema) SHA3_512() *Schema

func (*Schema) SHA224 

func (s *Schema) SHA224() *Schema

func (*Schema) SHA256 

func (s *Schema) SHA256() *Schema

func (*Schema) SHA384 

func (s *Schema) SHA384() *Schema

func (*Schema) SHA512 

func (s *Schema) SHA512() *Schema

func (*Schema) SHA512_224 

func (s *Schema) SHA512_224() *Schema

func (*Schema) SHA512_256 

func (s *Schema) SHA512_256() *Schema

func (*Schema) SHA3224 

func (s *Schema) SHA3224() *Schema

func (*Schema) SHA3256 

func (s *Schema) SHA3256() *Schema

func (*Schema) SHA3384 

func (s *Schema) SHA3384() *Schema

func (*Schema) SHA3512 

func (s *Schema) SHA3512() *Schema

func (*Schema) SHA512224 

func (s *Schema) SHA512224() *Schema

func (*Schema) SHA512256 

func (s *Schema) SHA512256() *Schema

func (*Schema) SemVer 

func (s *Schema) SemVer() *Schema

func (*Schema) Semver 

func (s *Schema) Semver() *Schema

func (*Schema) StartsWith 

func (s *Schema) StartsWith(value string) *Schema

func (*Schema) URI 

func (s *Schema) URI() *Schema

func (*Schema) URL 

func (s *Schema) URL() *Schema

func (*Schema) URNRFC2141 

func (s *Schema) URNRFC2141() *Schema

func (*Schema) UUID 

func (s *Schema) UUID() *Schema

func (*Schema) UUID3 

func (s *Schema) UUID3() *Schema

func (*Schema) UUID4 

func (s *Schema) UUID4() *Schema

func (*Schema) UUID5 

func (s *Schema) UUID5() *Schema

func (*Schema) Uppercase 

func (s *Schema) Uppercase() *Schema

func (*Schema) UrnRFC2141 

func (s *Schema) UrnRFC2141() *Schema

func (*Schema) Validate 

func (s *Schema) Validate(input any, optionList ...schema.Option) (string, error)

func (*Schema) ValidateAny 

func (s *Schema) ValidateAny(input any, options schema.Options) (any, error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.