validation_kit 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48f6bae26b123232914da0c154b955798b82233cf152c9c0c823f0f223289956
-  data.tar.gz: 55a3a8f8458f886adbcfb3e2dceb84d7900f206bc0c491d18203dc193ae755e3
+  metadata.gz: 83f8486330f7a2179f4655e0cd938355d9b79c9b96279238829b4c3c7a860151
+  data.tar.gz: 479ec62978042d99be1efb5985c3efad7e18615f5450374cd131ebd2a907ff06
 SHA512:
-  metadata.gz: 81cb679e9504f56963681edf741dd33c93c370664dc9e33c376923c934487a78f8d1e189f0506124889070fa62f3447c05978d8abffc2f5abf71094c4e53eafb
-  data.tar.gz: b8baa82c5421ae9388f1b36f12be7214613ad7948b8ac2bf5c1e8074a8e768a43a7ec1fa15466c3e06758bdbe58a7428d30a305559468f36be7eb0ac480596ff
+  metadata.gz: b2940c397a76ebedbcbcb9802081159eb58b837c7284a6f77e5487081164b23447a30092485b7e765c295af88e8fdb6ba6fd5aac355cf46a1795b7beaad451fd
+  data.tar.gz: 5d59577b6a5d73bb96f1063b1d8b8125856d23d4d48d01c7e67584a47067e3df43054db60aa768c4c1b2bf175eea8fff8198000f8d1f0262b2175b3470c59d25

data/CHANGELOG.md

@@ -1,5 +1,75 @@
 # 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

data/README.md

@@ -29,6 +29,10 @@ 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
@@ -45,11 +49,11 @@ Person.new(first_name: "bob").valid? # => false, "First name cannot be in all lo
 Person.new(first_name: "Bob").valid? # => true
 ```
 
-| Option            | Description                                                                                    |
-| ----------------- | ---------------------------------------------------------------------------------------------- |
-| `attribute_name:` | Name to use in the message. Defaults to the translated attribute name, then the humanized one. |
-| `all_caps:`       | Custom message for all-caps values.                                                            |
-| `all_lowercase:`  | Custom message for all-lowercase values.                                                       |
+| 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
 
@@ -62,11 +66,16 @@ class Person < ActiveRecord::Base
 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 (`"VIC"`, `"QLD"`, …; default NSW/ACT, `02`). |
+| 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
 
@@ -92,8 +101,9 @@ case-insensitive (`"CA"`, `"ca"`, or `:CA`), and validation is skipped when the
 country isn't supported.
 
 ```ruby
-# A fixed country code
+# 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 }
@@ -102,15 +112,29 @@ validates :phone, phone: { country: :billing_country }
 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.added?(:email, :invalid)        # email, phone, postal code
-person.errors.added?(:first_name, :all_caps)  # mixed case (also :all_lowercase)
+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:
 
@@ -122,13 +146,14 @@ en:
         person:
           attributes:
             email:
-              invalid: "Enter your email address"
+              invalid: "doesn’t look like an email address"
             first_name:
-              all_caps: "Your first name cannot be in all caps"
+              all_caps: "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
+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
@@ -146,17 +171,19 @@ other ActiveModel classes:
 
 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`      | "%{item} cannot be in all caps"      | "%{item} ne peut pas être en majuscules"   |
-| `mixed_case`  | `:all_lowercase` | "%{item} cannot be in all lowercase" | "%{item} ne peut pas être en minuscules"   |
-
-For mixed case, `%{item}` is the attribute's name: its translation at
-`activerecord.attributes.person.<attribute>`, then the `attribute_name:`
-option, then the humanized attribute name.
+| 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
 

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

@@ -2,10 +2,31 @@
 
 module ValidationKit
   class EmailValidator < ActiveModel::EachValidator
-    EMAIL_ADDRESS_RE = /\A(?!(?:(?:\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}(?:(?:[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
+    # 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
+
+    # 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)
-      return if EMAIL_ADDRESS_RE.match?(value.to_s)
+      return if self.class.valid_address?(value)
 
       record.errors.add(attribute, :invalid, message: options[:message])
     end

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

@@ -1,5 +1,5 @@
 en:
   errors:
     messages:
-      all_caps: "%{item} cannot be in all caps"
-      all_lowercase: "%{item} cannot be in all lowercase"
+      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,5 +1,5 @@
 fr:
   errors:
     messages:
-      all_caps: "%{item} ne peut pas être en majuscules"
-      all_lowercase: "%{item} ne peut pas être en minuscules"
+      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

@@ -23,6 +23,9 @@ module ValidationKit
 
       return if error.nil?
 
+      # 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
 

data/lib/validation_kit/phone_validator/phone_validator.rb

@@ -2,6 +2,26 @@
 
 module ValidationKit
   class PhoneValidator < ActiveModel::EachValidator
+    include CountryOption
+
+    # Digits right after a US/CA number with no marker in front of them (any
+    # letter, as in x, ext or extension, or #, ＃ or №): a mistyped number like
+    # 212-555-12345, not an extension. \p{Nd} also catches non-ASCII digits.
+    UNMARKED_US_CA_EXTENSION = /\A[^[:alpha:]#＃№]*\p{Nd}/
+
+    # Australian states and territories (the area_key: values), and the
+    # landline area code each one adds.
+    AU_AREA_CODES = {
+      "NSW" => "02", "ACT" => "02", "VIC" => "03", "TAS" => "03",
+      "QLD" => "07", "SA" => "08", "NT" => "08", "WA" => "08"
+    }.freeze
+
+    # area_key: is a fixed state, so a typo fails when the model is loaded
+    # rather than silently adding the wrong area code.
+    def check_validity!
+      area_code_for_key(options[:area_key])
+    end
+
     def regex_for_country(country_code)
       country_code = country_code.to_s.strip.upcase
 
@@ -15,16 +35,7 @@ module ValidationKit
     end
 
     def validate_each(record, attribute, value)
-      country = if options[:country].is_a?(String)
-                  options[:country]
-                elsif options[:country].is_a?(Symbol) && record.respond_to?(options[:country])
-                  record.public_send(options[:country])
-                elsif record.respond_to?(:country)
-                  record.country
-                else
-                  false
-                end
-
+      country = country_for(record)
       return unless country
 
       # accept "us", :US, " US " as well as "US"
@@ -38,7 +49,12 @@ module ValidationKit
 
       # allow_blank/allow_nil are handled by ActiveModel on the original value,
       # so input that only becomes blank once cleaned up (e.g. "n/a") is invalid.
-      if current_regex.match?(new_value)
+      valid = current_regex.match?(new_value)
+      # The US/CA regex only checks the start of the digits; format_as_phone is
+      # what rejects extra digits that aren't a marked extension.
+      valid &&= !format_as_phone(value, country).nil? if %w[US CA].include?(country)
+
+      if valid
         if options[:set]
           formatted_phone = format_as_phone(value, country, options[:area_key])
           if formatted_phone.nil?
@@ -53,6 +69,8 @@ module ValidationKit
     end
 
     def format_as_phone(arg, country_code = nil, area_key = nil)
+      # Checked first, so a bad key always raises, whatever number is passed.
+      area_code = area_code_for_key(area_key)
       country_code = country_code.to_s.strip.upcase
       return nil if arg.blank? || country_code.blank? || !regex_for_country(country_code)
 
@@ -64,7 +82,7 @@ module ValidationKit
         when /\A(?:1300|1800|1900|1902)\d{6}\z/
           number.insert(4, " ").insert(8, " ")
         when /\A(?:0?[12378])?[1-9][0-9]{7}\z/
-          number.insert(0, area_code_for_key(area_key)) if /\A[1-9][0-9]{7}\z/.match?(number)
+          number.insert(0, area_code) if /\A[1-9][0-9]{7}\z/.match?(number)
           number.insert(0, "0") if /\A[12378][1-9][0-9]{7}\z/.match?(number)
 
           number.insert(0, "(").insert(3, ") ").insert(9, " ")
@@ -79,7 +97,8 @@ module ValidationKit
         # if it's too short
         return nil if number.length < 10
 
-        # strip off the leading 1 (country code); any digits beyond ten are an extension
+        # strip off the leading 1 (country code); any digits beyond ten are an
+        # extension, unless they're unmarked (UNMARKED_US_CA_EXTENSION)
         leading_one = number.length > 10 && number.start_with?("1")
         number = number[1..] if leading_one
 
@@ -87,30 +106,40 @@ module ValidationKit
         exchange = number[3..5]
         sln = number[6..9]
 
-        if number.length == 10
-          extension = nil
-        else
-          # save everything after the last digit of the number as the extension
-          national = arg[/\A(?:\D*\d){#{leading_one ? 11 : 10}}/]
-          # if letters appear among those digits, the extension's digits were
-          # counted as part of the number (e.g. 519 444 000 ext 123), so return
-          # nil to error out
-          return nil if national.sub(/\A\D*/, "").match?(/[[:alpha:]]/)
-
-          extension = " #{arg[national.length..].strip}"
+        # everything after the last digit of the number
+        national = arg[/\A(?:\D*\d){#{leading_one ? 11 : 10}}/]
+        rest = arg[national.length..]
+
+        # if letters appear among the number's digits, the extension's digits
+        # were counted as part of the number (e.g. 519 444 000 ext 123), so
+        # return nil to error out
+        return nil if number.length > 10 && national.sub(/\A\D*/, "").match?(/[[:alpha:]]/)
+
+        # Text after the number with no digits in it (e.g. "(cell)") is dropped;
+        # with digits, it's the extension, if they're marked as one.
+        extension = nil
+        if rest.match?(/\p{Nd}/)
+          return nil if UNMARKED_US_CA_EXTENSION.match?(rest)
+
+          # [[:space:]] also covers non-breaking spaces, which strip doesn't
+          extension = " #{rest.strip.sub(/\A[[:space:],;]+/, "").sub(/[[:space:]]+\z/, "")}"
         end
 
         "(#{area_code}) #{exchange}-#{sln}#{extension}"
       end
     end
 
+    # key is an AU state, in any case, as a string or symbol (always the state
+    # itself, never a method name); nil or blank means NSW/ACT. Anything else
+    # raises, rather than silently adding the NSW/ACT code (02) to, say, a
+    # Victorian number.
     def area_code_for_key(key)
-      case key
-      when "VIC", "TAS" then "03"
-      when "QLD" then "07"
-      when "SA", "NT", "WA" then "08"
-      else
-        "02" # NSW, ACT, and the default
+      state = key.to_s.strip.upcase
+      return AU_AREA_CODES["NSW"] if state.empty?
+
+      AU_AREA_CODES.fetch(state) do
+        raise ArgumentError, "area_key: #{key.inspect} isn't an Australian state or territory " \
+                             "(#{AU_AREA_CODES.keys.join(", ")})"
       end
     end
   end

data/lib/validation_kit/postal_code_validator/postal_code_validator.rb

@@ -2,6 +2,8 @@
 
 module ValidationKit
   class PostalCodeValidator < ActiveModel::EachValidator
+    include CountryOption
+
     def postal_code_regex_for_country(country_code)
       country_code = country_code.to_s.strip.upcase
 
@@ -31,16 +33,7 @@ module ValidationKit
     end
 
     def validate_each(record, attribute, value)
-      country = if options[:country].is_a?(String)
-                  options[:country]
-                elsif options[:country].is_a?(Symbol) && record.respond_to?(options[:country])
-                  record.public_send(options[:country])
-                elsif record.respond_to?(:country)
-                  record.country
-                else
-                  false
-                end
-
+      country = country_for(record)
       return unless country
 
       # accept "us", :US, " US " as well as "US"

data/lib/validation_kit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ValidationKit
-  VERSION = "2.0.0"
+  VERSION = "2.0.1"
 end

data/lib/validation_kit.rb

@@ -3,6 +3,7 @@
 require "active_model"
 require "active_support/core_ext/string/inflections"
 require "validation_kit/version"
+require "validation_kit/country_option"
 
 module ValidationKit
   VALIDATORS = {} # rubocop:disable Style/MutableConstant -- filled below, then frozen

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: validation_kit
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Wes Morgan
@@ -36,6 +36,7 @@ files:
 - LICENSE
 - README.md
 - lib/validation_kit.rb
+- lib/validation_kit/country_option.rb
 - lib/validation_kit/email_validator/email_validator.rb
 - lib/validation_kit/mixed_case_validator/config/locales/en.yml
 - lib/validation_kit/mixed_case_validator/config/locales/fr.yml
@@ -65,7 +66,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.20
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Handy validations for Rails forms
 test_files: []