validation_kit 1.0.5 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff3e9944d7507b5b68ac90c343eb6e95ee9c8219b9f210dcdf843352c72ac39d
-  data.tar.gz: 57c6162bd4b136b247c7c15857fcde816e65a592a5dfcff2f793bb8719fb060a
+  metadata.gz: 83f8486330f7a2179f4655e0cd938355d9b79c9b96279238829b4c3c7a860151
+  data.tar.gz: 479ec62978042d99be1efb5985c3efad7e18615f5450374cd131ebd2a907ff06
 SHA512:
-  metadata.gz: 686fc83cb5b88630d36ff2ceccc260e889f6800100700d8420b6a49d2702ffe5887892016fe219126ada9b656b2d671ca00f6fb991c5c5ba2dad0be84bba3016
-  data.tar.gz: 831b93a7ec64043a9aaf43e2b050d4a93c0f050cda66dd378764857aad36bb09ffeba0fc59086dd19e2581e2227a9cd02c62c5f46f6bedd55dcbbe952d45accd
+  metadata.gz: b2940c397a76ebedbcbcb9802081159eb58b837c7284a6f77e5487081164b23447a30092485b7e765c295af88e8fdb6ba6fd5aac355cf46a1795b7beaad451fd
+  data.tar.gz: 5d59577b6a5d73bb96f1063b1d8b8125856d23d4d48d01c7e67584a47067e3df43054db60aa768c4c1b2bf175eea8fff8198000f8d1f0262b2175b3470c59d25

data/CHANGELOG.md

@@ -0,0 +1,150 @@
+# Changelog
+
+## 2.0.1 (2026-10-02)
+
+### Breaking changes
+
+- The email length limits (254 characters in all, 64 before the `@`) now count
+  every character, as RFC 5321 does, including the quotes around a quoted local
+  part and each backslash escape. So a quoted local part of 63 characters plus
+  its quotes, which used to pass, is now too long. The limits are checked by
+  the validator and the new `ValidationKit::EmailValidator.valid_address?`, not
+  by `EMAIL_ADDRESS_RE`: code that uses the regex directly no longer gets them,
+  and should call `valid_address?` instead.
+- An `area_key:` that isn't an Australian state or territory (NSW, ACT, VIC,
+  TAS, QLD, SA, NT, WA, in any case) now raises `ArgumentError` when the model
+  is defined, and `format_as_phone` raises for one too. It used to silently add
+  the NSW/ACT area code (02), so `"Victoria"` or a typo stored a wrong number.
+  Leaving `area_key:` out still means NSW/ACT.
+- A symbol `country:` option that's neither a method on the model nor a
+  two-letter country code (such as a misspelled method name,
+  `country: :billing_contry`) now raises `ArgumentError` when validating. It
+  used to fall back to the model's `country` method, or skip validation
+  silently.
+- The bundled mixed case messages no longer start with the attribute's name, so
+  `full_messages` names it once ("First name cannot be in all caps", not "First
+  name First name cannot be in all caps"), like Rails' own messages:
+  - `errors[:first_name]` is now `["cannot be in all caps"]`. Code that shows
+    `errors[attribute]` on its own should use `full_messages_for` instead.
+  - `attribute_name:` no longer changes the default message. `full_messages`
+    uses the attribute's translated name (`human_attribute_name`) instead; to
+    rename it, translate the attribute. `attribute_name:` still fills in
+    `%{item}` in custom messages and translations, which keep working.
+  - Apps that set `errors.format` to `"%{message}"` to hide the doubled name now
+    get messages with no name at all, and can drop that setting.
+
+### Changed
+
+- US and Canadian phone numbers with extra digits right after the number and no
+  extension marker in front of them (any letter, as in `x`, `ext` or
+  `extension`, or `#`, `＃` or `№`) are now invalid, with or without `set:`. A
+  mistyped number such as `212-555-12345` used to pass, and `set:` stored it as
+  `(212) 555-1234 5`. This includes non-ASCII digits such as `５`.
+- Without `set:`, a US or Canadian number with letters among its first ten
+  digits (`519 444 000 ext 123`) is now invalid, as it already was with `set:`.
+- With `set:`, a stored extension no longer keeps a leading `,` or `;` or
+  surrounding spaces (including non-breaking ones): `212-555-1234, ext 5`
+  becomes `(212) 555-1234 ext 5`. An extension written with non-ASCII digits
+  (`x５`) is kept instead of being dropped. Other marked extensions (`x5`,
+  `ext. 99`, `(x5)`, `#5`, …) are stored as before.
+### Fixed
+
+- The email validator still backtracked catastrophically on input with quote
+  characters, despite the 2.0.0 fix: `'a"' * 28 + "@"` (57 characters) took
+  about a minute to reject. The two length checks at the start of the regex
+  caused it; they're now plain length checks, and that input fails in well
+  under a millisecond.
+- Email addresses with non-ASCII letters that case-fold to ASCII ones, such as
+  `a@ſx.com`, are rejected, like every other non-ASCII address.
+- `country: :CA` (or `:ca`) now validates as Canada, as the README says. A
+  symbol was only ever treated as a method name, so without a `CA` method the
+  validator used the model's `country` method instead, or skipped validation
+  silently.
+- The phone validator's `area_key:` (and `format_as_phone`'s area key) now
+  accepts Australian states in any case, as a string or symbol. `:vic` or
+  `"vic"` used to silently get the NSW/ACT area code (02).
+
+### Documentation
+
+- The README's error-type example used `errors.added?(:first_name, :all_caps)`,
+  which is always false for mixed case errors because they carry an `item:`
+  option. It now uses `of_kind?`, and explains when `added?` needs `item:`.
+
+## 2.0.0 (2026-10-01)
+
+### Breaking changes
+
+- **Ruby 3.4+ and activemodel 7.2+ are required.** The gem now declares its
+  activemodel dependency and loads without Rails.
+- **Errors are added by type instead of as translated strings.** All four
+  validators call `errors.add(attribute, :invalid)` (mixed case:
+  `:all_caps` / `:all_lowercase`), so `errors.added?(:email, :invalid)` and
+  `errors.details` work, and ActiveModel does the message lookup.
+  - Existing `activerecord.errors.models.<model>.attributes.<attribute>.<type>`
+    translations keep working.
+  - Non-ActiveRecord models now look under `activemodel.*` instead of
+    `activerecord.*`, and fall back to Rails' "is invalid".
+  - A `message:` (or `all_caps:` / `all_lowercase:`) option now takes
+    precedence over translations, as it does for Rails' own validators.
+  - The bundled mixed case messages moved from `activerecord.errors.messages`
+    to `errors.messages`.
+- **`ActiveModel::Validations::EmailValidator` (and `PhoneValidator`,
+  `PostalCodeValidator`, `MixedCaseValidator`) no longer exist.** Use
+  `ValidationKit::EmailValidator` and so on. `validates :email, email: true`
+  is unchanged, and an app's own validator with the same name now takes
+  precedence over the gem's.
+- **`MixedCaseValidator::ALL_CAPS` / `ALL_LOWERCASE`** are now the symbols
+  `:all_caps` / `:all_lowercase` instead of `1` / `-1`.
+- **Validation is stricter**, so some values that used to pass are now
+  invalid:
+  - postal codes of the wrong length (e.g. a 7-digit US ZIP code)
+  - email addresses containing a newline
+  - phone and postal input that's blank once cleaned up (e.g. `"n/a"`), even
+    with `allow_blank`
+- **`format_as_phone` returns `nil`** for numbers it can't format, instead of
+  the raw digits.
+
+### Fixed
+
+- The email regex no longer backtracks catastrophically: crafted input that
+  took over a minute to reject now fails in under a millisecond.
+- Postal codes of the wrong length were accepted and then replaced with `nil`
+  by `set:`.
+- With `allow_blank`, junk phone and postal input was accepted and replaced
+  with `""` or `nil`.
+- US/CA numbers with a leading 1 (`1-212-555-1234`) were stored with a
+  trailing space.
+- Phone extensions could be taken from the wrong part of the input when the
+  last four digits appeared earlier in it.
+- Country codes in lowercase or as symbols (`"us"`, `:US`) silently skipped
+  validation.
+- Integer values (e.g. a ZIP code from an integer column) raised instead of
+  validating.
+- Mixed case errors were missing the attribute name and ignored the
+  `attribute_name:` option, and the bundled English and French messages were
+  never loaded.
+- Values with no letters (`"123"`) or in scripts without case failed as "all
+  caps", and short accented names skipped the check.
+- A stray `|` in the AU phone regex character classes.
+
+### Added
+
+- UK postcode validation and formatting (`UK` or `GB`).
+- `source_code_uri`, `bug_tracker_uri`, and `changelog_uri` gemspec metadata,
+  and a declared MIT license.
+
+### Documentation
+
+- One `README.md` replaces the per-validator READMEs, with current usage,
+  options, and a translation key reference. Added `LICENSE` and this
+  changelog.
+
+### Internal
+
+- Minitest suite, CI on Ruby 3.4/4.0 against activemodel 7.2/8.0/8.1,
+  rubocop, Dependabot, and a trusted publishing release workflow. The gem now
+  packages only `lib/`, `README.md`, `LICENSE`, and `CHANGELOG.md`.
+
+## 1.0.5
+
+Last release before 2.0.0.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2008-2026 The validation_kit contributors (see README.md)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,200 @@
+# validation_kit
+
+ActiveModel validators for email addresses, phone numbers, postal codes, and
+mixed-case text.
+
+## Installation
+
+Add the gem to your Gemfile:
+
+```ruby
+gem "validation_kit"
+```
+
+The validators are available in any class that includes
+`ActiveModel::Validations`, including ActiveRecord models. If your app defines
+its own validator with the same name (e.g. `app/validators/email_validator.rb`),
+yours is used instead.
+
+## Email
+
+Validates that an attribute is an email address.
+
+```ruby
+class Person < ActiveRecord::Base
+  validates :email, email: true
+end
+
+Person.new(email: "Bob").valid?            # => false
+Person.new(email: "joe@foobar.com").valid? # => true
+```
+
+Addresses are limited to 254 characters, and 64 before the `@` (RFC 5321). To
+check an address outside a model, use
+`ValidationKit::EmailValidator.valid_address?("joe@foobar.com")`.
+
+## Mixed case
+
+Validates that a string isn't all capitals or all lowercase. Values with fewer
+than three letters that have a case are skipped, so initials, digits, and
+scripts without case (e.g. Chinese) never fail.
+
+```ruby
+class Person < ActiveRecord::Base
+  validates :first_name, mixed_case: true
+end
+
+Person.new(first_name: "BOB").valid? # => false, "First name cannot be in all caps"
+Person.new(first_name: "bob").valid? # => false, "First name cannot be in all lowercase"
+Person.new(first_name: "Bob").valid? # => true
+```
+
+| Option            | Description                                                                                                                                                                            |
+| ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `attribute_name:` | Name for `%{item}` in a custom message, used when the attribute has no translation (a translation wins). It doesn’t change `full_messages`, which use the attribute’s translated name. |
+| `all_caps:`       | Custom message for all-caps values.                                                                                                                                                    |
+| `all_lowercase:`  | Custom message for all-lowercase values.                                                                                                                                               |
+
+## Phone
+
+Strict validation for phone numbers in the United States (`US`), Canada
+(`CA`), and Australia (`AU`).
+
+```ruby
+class Person < ActiveRecord::Base
+  validates :phone, phone: { country: "US", set: true }, allow_blank: true
+end
+```
+
+| Option      | Description                                                                                                                                                                                                                                                                                                                             |
+| ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `country:`  | See [Specifying the country](#specifying-the-country).                                                                                                                                                                                                                                                                                  |
+| `set:`      | Reformat the stored value: `"1-212-555-1234 x5"` becomes `"(212) 555-1234 x5"`, `"0298765432"` becomes `"(02) 9876 5432"`.                                                                                                                                                                                                              |
+| `area_key:` | For Australian landlines entered without an area code, the state whose area code to add: `NSW`, `ACT`, `VIC`, `TAS`, `QLD`, `SA`, `NT` or `WA`, in any case, as a string or symbol (`"VIC"`, `:qld`). It's always a fixed state, not a method name. Leave it out (or blank) for NSW/ACT (`02`); any other value raises `ArgumentError`. |
+
+A US or Canadian number may end with an extension, which needs a marker in
+front of its digits: any letter (as in `x`, `ext` or `extension`), or `#`, `＃`
+or `№` (`"212-555-1234 ext 5"`). Digits right after the number with no marker,
+as in `"212-555-12345"`, make it invalid.
+
+## Postal code
+
+Strict validation for postal and ZIP codes in the United States (`US`), Canada
+(`CA`), the United Kingdom (`UK` or `GB`), Australia (`AU`), and New Zealand
+(`NZ`).
+
+```ruby
+class Person < ActiveRecord::Base
+  validates :postal_code, postal_code: { country: "CA", set: true }, allow_blank: true
+end
+```
+
+| Option     | Description                                                                                                             |
+| ---------- | ----------------------------------------------------------------------------------------------------------------------- |
+| `country:` | See [Specifying the country](#specifying-the-country).                                                                  |
+| `set:`     | Reformat the stored value: Canadian and UK codes get a space (`K1A 0B1`, `SW1A 1AA`), US ZIP+4 a hyphen (`10001-1234`). |
+
+## Specifying the country
+
+The phone and postal code validators need a country. Country codes are
+case-insensitive (`"CA"`, `"ca"`, or `:CA`), and validation is skipped when the
+country isn't supported.
+
+```ruby
+# A fixed country code, as a string or a two-letter symbol
+validates :phone, phone: { country: "CA" }
+validates :phone, phone: { country: :ca }
+
+# The name of a method on your model that returns the country code
+validates :phone, phone: { country: :billing_country }
+
+# Neither: the validator calls your model's country method
+validates :phone, phone: true
+```
+
+A symbol is a method name if your model has that public method; otherwise a
+two-letter symbol is a country code. Any other symbol (such as a misspelled
+method name) raises `ArgumentError` when validating, rather than skipping
+validation. Two things that check can't catch: a misspelled two-letter method
+name is read as a country code (and skipped if that country isn't supported),
+and with `allow_nil:` or `allow_blank:` it only runs once the attribute has a
+value.
+
+## Error messages
+
+Errors are added with standard types, so the usual ActiveModel tools work:
+
+```ruby
+person.errors.of_kind?(:email, :invalid)        # email, phone, postal code
+person.errors.of_kind?(:first_name, :all_caps)  # mixed case (also :all_lowercase)
+```
+
+`of_kind?` checks the attribute and error type. `added?` also compares the
+error's options, and mixed case errors carry an `item:` option (the
+attribute's name, for messages that use `%{item}`; see
+[Translation keys](#translation-keys) for how it's chosen), so for them
+`added?` only matches if you pass the same `item:`.
+
+Pass `message:` (or `all_caps:` / `all_lowercase:` for mixed case) for a custom
+message, or translate it like any other Rails validation error:
+
+```yaml
+en:
+  activerecord:
+    errors:
+      models:
+        person:
+          attributes:
+            email:
+              invalid: "doesn’t look like an email address"
+            first_name:
+              all_caps: "can’t be all capitals"
+```
+
+Like Rails’ own messages, these leave out the attribute’s name, because
+`full_messages` adds it: "First name can’t be all capitals". Use `activemodel`
+instead of `activerecord` for classes that aren't ActiveRecord models. The gem includes English and French messages for the
+mixed case errors.
+
+## Translation keys
+
+Each validator adds an error of the type below. Rails looks up its message in
+this order, using the first key it finds. These are the keys for an
+ActiveRecord model `Person`; use `activemodel` instead of `activerecord` for
+other ActiveModel classes:
+
+1. `activerecord.errors.models.person.attributes.<attribute>.<type>`
+2. `activerecord.errors.models.person.<type>`
+3. `activerecord.errors.messages.<type>`
+4. `errors.attributes.<attribute>.<type>`
+5. `errors.messages.<type>`
+
+A `message:` option (or `all_caps:` / `all_lowercase:`) skips the lookup.
+
+| Validator     | Error type       | Default message (en)         | Default message (fr)                       |
+| ------------- | ---------------- | ---------------------------- | ------------------------------------------ |
+| `email`       | `:invalid`       | "is invalid" (from Rails)    | from Rails' locale files (e.g. rails-i18n) |
+| `phone`       | `:invalid`       | "is invalid" (from Rails)    | from Rails' locale files (e.g. rails-i18n) |
+| `postal_code` | `:invalid`       | "is invalid" (from Rails)    | from Rails' locale files (e.g. rails-i18n) |
+| `mixed_case`  | `:all_caps`      | "cannot be in all caps"      | "ne peut pas être en majuscules"           |
+| `mixed_case`  | `:all_lowercase` | "cannot be in all lowercase" | "ne peut pas être en minuscules"           |
+
+Like Rails' own messages, the mixed case messages leave out the attribute's
+name, which `full_messages` adds: "First name cannot be in all caps". A custom
+message or translation can include it as `%{item}`: the attribute's
+translation at `activerecord.attributes.person.<attribute>`, then the
+`attribute_name:` option, then the humanized attribute name.
+
+## Credits
+
+- **Email, mixed case, and postal code validators:** [Paul Schreiber](https://paulschreiber.com/), 2010–2011.
+- **Phone validator:** written by Kristina Lim, copyright © 2008 Syndeo
+  Media. Paul Schreiber added US
+  and Canada support (September 2010) and extension support (November 2010).
+  It is named after, and was originally built on, Jerrod Blavos's
+  [validates_as_phone](https://code.google.com/archive/p/validates-as-phone/) plugin.
+- **Gem:** co-authored by Wes Morgan.
+
+## License
+
+Released under the MIT License. See [LICENSE](LICENSE).

data/lib/validation_kit/country_option.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ValidationKit
+  # The country: option shared by the phone and postal code validators.
+  module CountryOption
+    private
+
+    # The country code to validate against, or nil to skip validation:
+    # - a String is the code itself ("CA")
+    # - a Symbol is the name of a method on the record that returns the code
+    #   (:billing_country); if there's no such method, a two-letter symbol is
+    #   the code itself (:CA), and anything else is a mistake, so it raises
+    #   rather than silently skipping validation
+    # - without the option, the record's country method, if it has one
+    def country_for(record)
+      option = options[:country]
+
+      case option
+      when String
+        option
+      when Symbol
+        if record.respond_to?(option)
+          record.public_send(option)
+        elsif option.match?(/\A[a-z]{2}\z/i)
+          option
+        else
+          raise ArgumentError, "country: #{option.inspect} is neither a public method on " \
+                               "#{record.class.name || record.class.inspect} nor a two-letter country code"
+        end
+      else
+        record.country if record.respond_to?(:country)
+      end
+    end
+  end
+end

data/lib/validation_kit/email_validator/email_validator.rb

@@ -1,21 +1,34 @@
+# frozen_string_literal: true
+
 module ValidationKit
   class EmailValidator < ActiveModel::EachValidator
-    # This hangs ruby if you have more than one validates_as_email rule in the same object
-    # Commenting it out for now
-    # Using the one found at <http://fightingforalostcause.net/misc/2006/compare-email-regex.php>
-    # EMAIL_ADDRESS_RE = /^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?$/i
+    # RFC 5321's length limits: the whole address, and the part before the @.
+    # They're checked in validate_each rather than as lookaheads at the start of
+    # EMAIL_ADDRESS_RE, where they backtracked exponentially on input like
+    # 'a"a"a"…@' (about a minute for 57 characters).
+    MAX_LENGTH = 254
+    MAX_LOCAL_PART_LENGTH = 64
+
+    # The address syntax only; validate_each also applies the length limits.
+    EMAIL_ADDRESS_RE = /\A(?:(?:[\x21\x23-\x27\x2A\x2B\x2D\x2F-\x39\x3D\x3F\x5E-\x7E]+)|(?:\x22(?:[\x01-\x08\x0B\x0C\x0E-\x1F\x21\x23-\x5B\x5D-\x7F]|(?:\x5C[\x00-\x7F]))*\x22))(?:\.(?:(?:[\x21\x23-\x27\x2A\x2B\x2D\x2F-\x39\x3D\x3F\x5E-\x7E]+)|(?:\x22(?:[\x01-\x08\x0B\x0C\x0E-\x1F\x21\x23-\x5B\x5D-\x7F]|(?:\x5C[\x00-\x7F]))*\x22)))*@(?:(?:(?!.*[^.]{64,})(?:(?:xn--)?[a-z0-9]+(?:-[a-z0-9]+)*\.){1,126}(?:(?:[a-z][a-z0-9]*)|(?:(?:xn--)[a-z0-9]+))(?:-[a-z0-9]+)*)|(?:\[(?:(?:IPv6:(?:(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){7})|(?:(?!(?:.*[a-f0-9][:\]]){7,})(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,5})?::(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,5})?)))|(?:(?:IPv6:(?:(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){5}:)|(?:(?!(?:.*[a-f0-9]:){5,})(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,3})?::(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,3}:)?)))?(?:(?:25[0-5])|(?:2[0-4][0-9])|(?:1[0-9]{2})|(?:[1-9]?[0-9]))(?:\.(?:(?:25[0-5])|(?:2[0-4][0-9])|(?:1[0-9]{2})|(?:[1-9]?[0-9]))){3}))\]))\z/i
 
-    EMAIL_ADDRESS_RE = /^(?!(?:(?:\x22?\x5C[\x00-\x7E]\x22?)|(?:\x22?[^\x5C\x22]\x22?)){255,})(?!(?:(?:\x22?\x5C[\x00-\x7E]\x22?)|(?:\x22?[^\x5C\x22]\x22?)){65,}@)(?:(?:[\x21\x23-\x27\x2A\x2B\x2D\x2F-\x39\x3D\x3F\x5E-\x7E]+)|(?:\x22(?:[\x01-\x08\x0B\x0C\x0E-\x1F\x21\x23-\x5B\x5D-\x7F]|(?:\x5C[\x00-\x7F]))*\x22))(?:\.(?:(?:[\x21\x23-\x27\x2A\x2B\x2D\x2F-\x39\x3D\x3F\x5E-\x7E]+)|(?:\x22(?:[\x01-\x08\x0B\x0C\x0E-\x1F\x21\x23-\x5B\x5D-\x7F]|(?:\x5C[\x00-\x7F]))*\x22)))*@(?:(?:(?!.*[^.]{64,})(?:(?:(?:xn--)?[a-z0-9]+(?:-[a-z0-9]+)*\.){1,126}){1,}(?:(?:[a-z][a-z0-9]*)|(?:(?:xn--)[a-z0-9]+))(?:-[a-z0-9]+)*)|(?:\[(?:(?:IPv6:(?:(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){7})|(?:(?!(?:.*[a-f0-9][:\]]){7,})(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,5})?::(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,5})?)))|(?:(?:IPv6:(?:(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){5}:)|(?:(?!(?:.*[a-f0-9]:){5,})(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,3})?::(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,3}:)?)))?(?:(?:25[0-5])|(?:2[0-4][0-9])|(?:1[0-9]{2})|(?:[1-9]?[0-9]))(?:\.(?:(?:25[0-5])|(?:2[0-4][0-9])|(?:1[0-9]{2})|(?:[1-9]?[0-9]))){3}))\]))$/i
+    # Whether address is a valid email address: the syntax and the length
+    # limits. For use outside a model; EMAIL_ADDRESS_RE alone skips the limits.
+    def self.valid_address?(address)
+      address = address.to_s
+      # The syntax is ASCII-only, but the regex's /i matching would also let
+      # Unicode case-folded letters (ſ, the Kelvin sign) through as s and k.
+      return false unless address.ascii_only?
+      return false if address.length > MAX_LENGTH
+
+      # The domain can't contain an @, so the last one ends the local part.
+      address.rpartition("@").first.length <= MAX_LOCAL_PART_LENGTH && EMAIL_ADDRESS_RE.match?(address)
+    end
 
     def validate_each(record, attribute, value)
-      unless EMAIL_ADDRESS_RE.match(value)
-        model_name = record.class.to_s
-        message = I18n.t("activerecord.errors.models.#{model_name.underscore}.attributes.#{attribute}.invalid",
-                         :default => [:"activerecord.errors.models.#{model_name.underscore}.invalid",
-                                      options[:message],
-                                      :'activerecord.errors.messages.invalid'])
-        record.errors.add(attribute, message)
-      end
+      return if self.class.valid_address?(value)
+
+      record.errors.add(attribute, :invalid, message: options[:message])
     end
   end
 end

data/lib/validation_kit/mixed_case_validator/config/locales/en.yml

@@ -1,6 +1,5 @@
 en:
-  activerecord:
-    errors:
-      messages:
-        all_caps: "%{item} cannot be in all caps"
-        all_lowercase: "%{item} cannot be in all lowercase"
+  errors:
+    messages:
+      all_caps: "cannot be in all caps"
+      all_lowercase: "cannot be in all lowercase"

data/lib/validation_kit/mixed_case_validator/config/locales/fr.yml

@@ -1,6 +1,5 @@
 fr:
-  activerecord:
-    errors:
-      messages:
-        all_caps: "%{item} ne peut pas être en majuscules"
-        all_lowercase: "%{item} ne peut pas être en minuscules"
+  errors:
+    messages:
+      all_caps: "ne peut pas être en majuscules"
+      all_lowercase: "ne peut pas être en minuscules"

data/lib/validation_kit/mixed_case_validator/mixed_case_validator.rb

@@ -1,42 +1,43 @@
+# frozen_string_literal: true
+
 module ValidationKit
   class MixedCaseValidator < ActiveModel::EachValidator
-    ALL_CAPS = 1
-    ALL_LOWERCASE = -1
+    # Error types, also used as the I18n keys and option names for custom messages.
+    ALL_CAPS = :all_caps
+    ALL_LOWERCASE = :all_lowercase
 
     def validate_each(record, attribute, value)
       return if value.nil?
-      return if value.gsub(/\W/, "").size < 3 # skip very short words
-      error = nil
-
-      if (value.upcase == value)
-        error = ALL_CAPS
-      elsif (value.downcase == value)
-        error = ALL_LOWERCASE
-      end
 
-      return if error.nil?
+      # Only letters that have a case count, so digits, punctuation, and
+      # scripts without case (e.g. Chinese) never trigger an error.
+      upper = value.to_s.scan(/\p{Lu}/).size
+      lower = value.to_s.scan(/\p{Ll}/).size
+      return if upper + lower < 3 # skip very short words
 
-      model_name = record.class.to_s
+      error = if lower.zero?
+                ALL_CAPS
+              elsif upper.zero?
+                ALL_LOWERCASE
+              end
 
-      item_name = I18n.t("activerecord.attributes.#{model_name.underscore}.#{attribute}",
-                         :default => nil) or options[:attribute_name] or attribute
+      return if error.nil?
 
-      if error == ALL_CAPS
-       message = I18n.t("activerecord.errors.models.#{model_name.underscore}.attributes.#{attribute}.all_caps",
-                   :item => item_name,
-                   :default => [:"activerecord.errors.models.#{model_name.underscore}.all_caps",
-                                options[:all_caps],
-                                :'activerecord.errors.messages.all_caps'])
-      elsif error == ALL_LOWERCASE
-        message = I18n.t("activerecord.errors.models.#{model_name.underscore}.attributes.#{attribute}.all_lowercase",
-                    :item => item_name,
-                    :default => [:"activerecord.errors.models.#{model_name.underscore}.all_lowercase",
-                                 options[:all_lowercase],
-                                 :'activerecord.errors.messages.all_lowercase'])
-      end
+      # The bundled messages leave the name to full_messages, like Rails' own.
+      # item: is still passed for custom messages and translations that use
+      # %{item}.
+      record.errors.add(attribute, error, item: item_name(record, attribute), message: options[error])
+    end
 
-      record.errors.add(attribute, message)
+    private
 
+    # A translated attribute name wins, then the :attribute_name option, then
+    # the humanized attribute name.
+    def item_name(record, attribute)
+      scope = [record.class.i18n_scope, :attributes, record.class.model_name.i18n_key]
+      I18n.t(attribute, scope:, default: nil) ||
+        options[:attribute_name] ||
+        record.class.human_attribute_name(attribute)
     end
   end
 end