validation_kit 1.0.5 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff3e9944d7507b5b68ac90c343eb6e95ee9c8219b9f210dcdf843352c72ac39d
-  data.tar.gz: 57c6162bd4b136b247c7c15857fcde816e65a592a5dfcff2f793bb8719fb060a
+  metadata.gz: 48f6bae26b123232914da0c154b955798b82233cf152c9c0c823f0f223289956
+  data.tar.gz: 55a3a8f8458f886adbcfb3e2dceb84d7900f206bc0c491d18203dc193ae755e3
 SHA512:
-  metadata.gz: 686fc83cb5b88630d36ff2ceccc260e889f6800100700d8420b6a49d2702ffe5887892016fe219126ada9b656b2d671ca00f6fb991c5c5ba2dad0be84bba3016
-  data.tar.gz: 831b93a7ec64043a9aaf43e2b050d4a93c0f050cda66dd378764857aad36bb09ffeba0fc59086dd19e2581e2227a9cd02c62c5f46f6bedd55dcbbe952d45accd
+  metadata.gz: 81cb679e9504f56963681edf741dd33c93c370664dc9e33c376923c934487a78f8d1e189f0506124889070fa62f3447c05978d8abffc2f5abf71094c4e53eafb
+  data.tar.gz: b8baa82c5421ae9388f1b36f12be7214613ad7948b8ac2bf5c1e8074a8e768a43a7ec1fa15466c3e06758bdbe58a7428d30a305559468f36be7eb0ac480596ff

data/CHANGELOG.md

@@ -0,0 +1,80 @@
+# Changelog
+
+## 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,173 @@
+# 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
+```
+
+## 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 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.                                                       |
+
+## 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 (`"VIC"`, `"QLD"`, …; default NSW/ACT, `02`). |
+
+## 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
+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
+```
+
+## 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)
+```
+
+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: "Enter your email address"
+            first_name:
+              all_caps: "Your first name cannot be in all caps"
+```
+
+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`      | "%{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.
+
+## 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/email_validator/email_validator.rb

@@ -1,21 +1,13 @@
+# 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
-
-    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
+    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
 
     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 EMAIL_ADDRESS_RE.match?(value.to_s)
+
+      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: "%{item} cannot be in all caps"
+      all_lowercase: "%{item} 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: "%{item} ne peut pas être en majuscules"
+      all_lowercase: "%{item} ne peut pas être en minuscules"

data/lib/validation_kit/mixed_case_validator/mixed_case_validator.rb

@@ -1,42 +1,40 @@
+# 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
+      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

data/lib/validation_kit/phone_validator/phone_validator.rb

@@ -1,123 +1,116 @@
+# frozen_string_literal: true
+
 module ValidationKit
   class PhoneValidator < ActiveModel::EachValidator
     def regex_for_country(country_code)
+      country_code = country_code.to_s.strip.upcase
+
       if country_code.blank?
         nil
-      elsif ["AU"].include?(country_code)
-        /(^(1300|1800|1900|1902)\d{6}$)|(^([0]?[1|2|3|7|8])?[1-9][0-9]{7}$)|(^13\d{4}$)|(^[0]?4\d{8}$)/
-      elsif ["US", "CA"].include?(country_code)
-        /^1?[2-9]\d{2}[2-9]\d{2}\d{4}/
-      else
-        nil
+      elsif country_code == "AU"
+        /\A(?:(?:1300|1800|1900|1902)\d{6}|(?:0?[12378])?[1-9][0-9]{7}|13\d{4}|0?4\d{8})\z/
+      elsif %w[US CA].include?(country_code)
+        /\A1?[2-9]\d{2}[2-9]\d{2}\d{4}/
       end
     end
 
     def validate_each(record, attribute, value)
-      if options[:country].is_a?(String)
-        country = options[:country]
-      elsif options[:country].is_a?(Symbol) && record.respond_to?(options[:country])
-        country = record.send(options[:country])
-      elsif record.respond_to?(:country)
-        country = record.send(:country)
-      else
-        country = false
-      end
+      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
 
       return unless country
-      current_regex = regex_for_country(country)
-      return unless current_regex
 
-      new_value = value.to_s.gsub(/[^0-9]/, '')
-      new_value ||= ''
+      # accept "us", :US, " US " as well as "US"
+      country = country.to_s.strip.upcase
+      return if country.empty?
 
-      model_name = record.class.to_s
+      current_regex = regex_for_country(country)
+      return unless current_regex
 
-      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'])
+      new_value = value.to_s.gsub(/[^0-9]/, "")
 
-      unless (options[:allow_blank] && new_value.blank?) || new_value =~ current_regex
-        record.errors.add(attribute, message)
-      else
+      # 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)
         if options[:set]
           formatted_phone = format_as_phone(value, country, options[:area_key])
           if formatted_phone.nil?
-            record.errors.add(attribute, message)
+            record.errors.add(attribute, :invalid, message: options[:message])
           else
-            record.send(attribute.to_s + '=', formatted_phone)
+            record.public_send("#{attribute}=", formatted_phone)
           end
-        end # options
-      end # unless
+        end
+      else
+        record.errors.add(attribute, :invalid, message: options[:message])
+      end
     end
 
     def format_as_phone(arg, country_code = nil, area_key = nil)
-      return nil if (arg.blank? or country_code.blank? or !regex_for_country(country_code))
+      country_code = country_code.to_s.strip.upcase
+      return nil if arg.blank? || country_code.blank? || !regex_for_country(country_code)
 
-      number = arg.gsub(/[^0-9]/, '')
+      arg = arg.to_s
+      number = arg.gsub(/[^0-9]/, "")
 
       if country_code == "AU"
-        if number =~ /^(1300|1800|1900|1902)\d{6}$/
-          number.insert(4, ' ').insert(8, ' ')
-        elsif number =~ /^([0]?[1|2|3|7|8])?[1-9][0-9]{7}$/
-          if number =~ /^[1-9][0-9]{7}$/
-            number = number.insert(0, area_code_for_key(area_key))
-          end
-          number = number.insert(0, '0') if number =~ /^[1|2|3|7|8][1-9][0-9]{7}$/
-
-          number.insert(0, '(').insert(3, ') ').insert(9, ' ')
-        elsif number =~ /^13\d{4}$/
-          number.insert(2, ' ').insert(5, ' ')
-        elsif number =~ /^[0]?4\d{8}$/
-          number = number.insert(0, '0') if number =~ /^4\d{8}$/
-
-          number.insert(4, ' ').insert(8, ' ')
-        else
-          number
+        case number
+        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, "0") if /\A[12378][1-9][0-9]{7}\z/.match?(number)
+
+          number.insert(0, "(").insert(3, ") ").insert(9, " ")
+        when /\A13\d{4}\z/
+          number.insert(2, " ").insert(5, " ")
+        when /\A0?4\d{8}\z/
+          number.insert(0, "0") if /\A4\d{8}\z/.match?(number)
+
+          number.insert(4, " ").insert(8, " ")
         end
-      elsif ["CA", "US"].include?(country_code)
-        digit_count = number.length
+      elsif %w[CA US].include?(country_code)
         # if it's too short
-        if digit_count < 10
-          return number
-        end
+        return nil if number.length < 10
 
-        # strip off any leading ones
-        if number[0..0] == "1"
-          number = number[1..10]
-        end
+        # strip off the leading 1 (country code); any digits beyond ten are an extension
+        leading_one = number.length > 10 && number.start_with?("1")
+        number = number[1..] if leading_one
 
         area_code = number[0..2]
         exchange = number[3..5]
         sln = number[6..9]
 
-        if digit_count == 10
+        if number.length == 10
           extension = nil
         else
-          # save everything after the SLN as extension
-          sln_index = arg.index(sln)
-          # if something went wrong, return nil so we can error out
-          # i.e. 519 444 000 ext 123 would cause sln to be 0001, which is not found
-          # in the original string
-          return nil if sln_index.nil?
-          extension = " %s" % arg[(sln_index+4)..-1].strip
+          # 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}"
         end
 
-        "(%s) %s-%s%s" % [area_code, exchange, sln, extension]
+        "(#{area_code}) #{exchange}-#{sln}#{extension}"
       end
     end
 
     def area_code_for_key(key)
       case key
-        when 'NSW' then '02'
-        when 'ACT' then '02'
-        when 'VIC' then '03'
-        when 'TAS' then '03'
-        when 'QLD' then '07'
-        when 'SA'  then '08'
-        when 'NT'  then '08'
-        when 'WA'  then '08'
+      when "VIC", "TAS" then "03"
+      when "QLD" then "07"
+      when "SA", "NT", "WA" then "08"
       else
-        '02'
+        "02" # NSW, ACT, and the default
       end
     end
   end

data/lib/validation_kit/postal_code_validator/postal_code_validator.rb

@@ -1,88 +1,94 @@
+# frozen_string_literal: true
+
 module ValidationKit
   class PostalCodeValidator < ActiveModel::EachValidator
     def postal_code_regex_for_country(country_code)
+      country_code = country_code.to_s.strip.upcase
+
       if country_code.blank?
         nil
-      elsif ["AU", "NZ"].include?(country_code)
-        /\d{4}/
-      elsif ["US"].include?(country_code)
-        /\d{5}(-\d{4})?/
-      elsif ["CA"].include?(country_code)
-        /[ABCEGHJKLMNPRSTVXY]\d[ABCEGHJKLMNPRSTWVXYZ]\d[ABCEGHJKLMNPRSTWVXYZ]\d/
-      else
-        nil
+      elsif %w[AU NZ].include?(country_code)
+        /\A\d{4}\z/
+      elsif country_code == "US"
+        /\A\d{5}(?:-?\d{4})?\z/
+      elsif country_code == "CA"
+        /\A[ABCEGHJKLMNPRSTVXY]\d[ABCEGHJKLMNPRSTWVXYZ] ?\d[ABCEGHJKLMNPRSTWVXYZ]\d\z/
+      elsif %w[UK GB].include?(country_code)
+        /\A(?:[A-Z]{1,2}\d[A-Z\d]? ?\d[A-Z]{2}|GIR ?0AA)\z/
       end
     end
 
     def disallowed_characters_for_country(country_code)
+      country_code = country_code.to_s.strip.upcase
+
       if country_code.blank?
         nil
-      elsif ["US", "AU", "NZ"].include?(country_code)
+      elsif %w[US AU NZ].include?(country_code)
         /[^0-9]/
-      elsif ["CA", "UK"].include?(country_code)
+      elsif %w[CA UK GB].include?(country_code)
         /[^0-9A-Z]/
-      else
-        nil
       end
     end
 
     def validate_each(record, attribute, value)
-      if options[:country].is_a?(String)
-        country = options[:country]
-      elsif options[:country].is_a?(Symbol) and record.respond_to?(options[:country])
-        country = record.send(options[:country])
-      elsif record.respond_to?(:country)
-        country = record.send(:country)
-      else
-        country = false
-      end
+      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
 
       return unless country
+
+      # accept "us", :US, " US " as well as "US"
+      country = country.to_s.strip.upcase
+      return if country.empty?
+
       current_regex = postal_code_regex_for_country(country)
       return unless current_regex
-      disallowed_characters = disallowed_characters_for_country(country)
 
-      new_value = value.nil? ? "" : value.upcase.gsub(disallowed_characters, '')
+      disallowed_characters = disallowed_characters_for_country(country)
 
-      model_name = record.class.to_s
+      new_value = value.to_s.upcase.gsub(disallowed_characters, "")
 
-      unless (options[:allow_blank] && new_value.blank?) || new_value =~ current_regex
-        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)
+      # 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)
+        if options[:set]
+          record.public_send("#{attribute}=", format_as_postal_code(new_value, country, disallowed_characters))
+        end
       else
-        record.send(attribute.to_s + '=',
-          format_as_postal_code(new_value, country, disallowed_characters)
-        ) if options[:set]
+        record.errors.add(attribute, :invalid, message: options[:message])
       end
     end
 
     def format_as_postal_code(arg, country_code, disallowed_characters)
-      return nil if (arg.blank? or country_code.blank? or !postal_code_regex_for_country(country_code))
+      country_code = country_code.to_s.strip.upcase
+      return nil if arg.blank? || country_code.blank? || !postal_code_regex_for_country(country_code)
 
-      postal_code = arg.gsub(disallowed_characters, '')
+      postal_code = arg.to_s.gsub(disallowed_characters, "")
 
-      if ["US"].include?(country_code)
+      if country_code == "US"
         digit_count = postal_code.length
         if digit_count == 5
-          return postal_code
+          postal_code
         elsif digit_count == 9
-          return "%s-%s" % [postal_code[0..4], postal_code[5..8]]
-        else
-          return nil
+          "#{postal_code[0..4]}-#{postal_code[5..8]}"
         end
 
-      elsif ["AU", "NZ"].include?(country_code)
+      elsif %w[AU NZ].include?(country_code)
         postal_code
 
-      elsif ["CA"].include?(country_code)
-        fsa = postal_code[0..2]
-        lda = postal_code[3..5]
+      elsif country_code == "CA"
+        # forward sortation area, then local delivery unit
+        "#{postal_code[0..2]} #{postal_code[3..5]}"
 
-        postal_code = "%s %s" % [fsa, lda]
-        postal_code.upcase
+      elsif %w[UK GB].include?(country_code)
+        # the inward code is always the last three characters
+        "#{postal_code[0...-3]} #{postal_code[-3..]}"
       end
     end
   end

data/lib/validation_kit/version.rb

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

data/lib/validation_kit.rb

@@ -1,10 +1,34 @@
+# frozen_string_literal: true
+
+require "active_model"
+require "active_support/core_ext/string/inflections"
 require "validation_kit/version"
 
+module ValidationKit
+  VALIDATORS = {} # rubocop:disable Style/MutableConstant -- filled below, then frozen
+
+  # Lets `validates :email, email: true` (and phone:, postal_code:,
+  # mixed_case:) find this gem's validators. Rails resolves those keys with
+  # const_get on the model, and Ruby only calls const_missing once normal
+  # lookup -- including autoloading an app's own app/validators/*.rb -- has
+  # failed, so an app's validator of the same name always wins.
+  module ValidatorLookup
+    def const_missing(name)
+      VALIDATORS.fetch(name) { super }
+    end
+  end
+end
+
 lib_path = File.dirname(__FILE__)
-validators = Dir[File.join(lib_path, '**', '*_validator.rb')]
-validators.each do |v|
-  require v
-  validator_class = File.basename(v, '.rb').camelize
-  validator = "ValidationKit::#{validator_class}".constantize
-  ActiveModel::Validations.const_set(validator_class, validator)
+Dir[File.join(lib_path, "**", "*_validator.rb")].each do |path|
+  require path
+  name = File.basename(path, ".rb").camelize
+  ValidationKit::VALIDATORS[name.to_sym] = ValidationKit.const_get(name)
 end
+ValidationKit::VALIDATORS.freeze
+
+ActiveModel::Validations::ClassMethods.include(ValidationKit::ValidatorLookup)
+
+# Put the bundled translations first in the load path so an app's own
+# locale files (which Rails appends later) can override them.
+I18n.load_path.unshift(*Dir[File.join(lib_path, "validation_kit", "**", "locales", "*.yml")])

metadata

@@ -1,16 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: validation_kit
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 2.0.0
 platform: ruby
 authors:
 - Wes Morgan
 - Paul Schreiber
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-19 00:00:00.000000000 Z
-dependencies: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
 description: A collection of various validators for Rails forms
 email:
 - wes@turbovote.org
@@ -19,26 +32,25 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- Gemfile
-- Rakefile
+- CHANGELOG.md
+- LICENSE
+- README.md
 - lib/validation_kit.rb
-- lib/validation_kit/email_validator/README
 - lib/validation_kit/email_validator/email_validator.rb
-- lib/validation_kit/mixed_case_validator/README
 - lib/validation_kit/mixed_case_validator/config/locales/en.yml
 - lib/validation_kit/mixed_case_validator/config/locales/fr.yml
 - lib/validation_kit/mixed_case_validator/mixed_case_validator.rb
-- lib/validation_kit/phone_validator/README
 - lib/validation_kit/phone_validator/phone_validator.rb
-- lib/validation_kit/postal_code_validator/README
 - lib/validation_kit/postal_code_validator/postal_code_validator.rb
 - lib/validation_kit/version.rb
-- validation_kit.gemspec
-homepage: https://github.com/turbovote/validation_kit
-licenses: []
-metadata: {}
-post_install_message: 
+homepage: https://github.com/paulschreiber/validation_kit
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/paulschreiber/validation_kit
+  bug_tracker_uri: https://github.com/paulschreiber/validation_kit/issues
+  changelog_uri: https://github.com/paulschreiber/validation_kit/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -46,16 +58,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: validation_kit
-rubygems_version: 2.7.3
-signing_key: 
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Handy validations for Rails forms
 test_files: []

data/.gitignore

@@ -1,4 +0,0 @@
-*.gem
-.bundle
-Gemfile.lock
-pkg/*

data/Gemfile

@@ -1,4 +0,0 @@
-source "http://rubygems.org"
-
-# Specify your gem's dependencies in validation_kit.gemspec
-gemspec

data/Rakefile

@@ -1 +0,0 @@
-require "bundler/gem_tasks"

data/lib/validation_kit/email_validator/README

@@ -1,32 +0,0 @@
-validates_as_email
-==================
-
-Validation module for email addresses.
-
-Installation
-============
-
-You can install the plugin the traditional way. Go to your application root
-and do:
-
-  script/plugin install git://github.com/paulschreiber/validates_as_email.git
-
-Example
-=======
-
-class Person < ActiveRecord::Base
-  validates_as_email :email
-end
-
-p = Person.new(:email => "Bob")
-p.valid?   # false
-
-p = Person.new(:email => "joe@foobar.com")
-p.valid?   # true
-
-Just like with built-in ActiveRecord validations, you can optionally supply a :message parameter with a custom error. Or, you can use Rails' built-in localization system and 
-
-
-= License
-
-Copyright (c) 2010 Paul Schreiber, released under the MIT license

data/lib/validation_kit/mixed_case_validator/README

@@ -1,59 +0,0 @@
-Validates Mixed Case Of
-=======================
-
-When validating a string item, ensure it is not all in capital or lowercase letters.
-
-Example
-=======
-
-class Person < ActiveRecord::Base
-	validates_mixed_case_of :firstname
-end
-
-p = Person.new(:firstname => "BOB")
-p.valid?   # false
-p = Person.new(:firstname => "Bob")
-p.valid?   # true
-
-Attribute Names
-===============
-Attribute names are looked up using Rails' I18n system. Create a hierarchy like so:
-
-en:
-  activerecord:
-    models:
-      attributes:
-        person:
-            firstname: "first name"
-
-Alternately, pass in the :attribute_name option:
-
-class Person < ActiveRecord::Base
-	validates_mixed_case_of :firstname, :attribute_name => "first name"
-end
-
-
-Error Messages
-==============
-Error messages follow the standard ActiveRecord lookup method.
-
-You'll likely error messages can be customized like so:
-
-en:
-  activerecord:
-    errors:
-      models:
-        attributes:
-          person:
-            firstname:
-              all_caps: "first name should not be in all caps"
-
-Alternatively, pass in tje :all_caps option:
-
-class Person < ActiveRecord::Base
-	validates_mixed_case_of :firstname, :all_caps => "don't shout at me, bro"
-end
-
-
-
-Copyright 2011 Paul Schreiber, released under the MIT license

data/lib/validation_kit/phone_validator/README

@@ -1,69 +0,0 @@
-validates_as_phone
-==================
-
-
-Strict validation module for phone numbers that supports classifications and
-areas.
-
-= General usage
-
-== Installation
-
-You can install the plugin the traditional way. Go to your application root
-and do:
-
-  script/plugin install git://github.com/paulschreiber/validates_as_phone.git
-
-== Validate your model attributes
-
-Example:
-
-There are three ways to specify the country:
- (1) Pass the country name in as a string parameter (:country => "CA")
- class Person < ActiveRecord::Base
-   validates_as_phone :phone, :country => "CA", :allow_blank => true, :set => true
- end
-
- (2) Create an attribute (country field) named foo in your object, and pass in a reference to foo:
-
- class Person < ActiveRecord::Base
-   validates_as_phone :phone, :country => :foo
- end
-
- (3) Create an attribute named country it in your object, i.e. Person#country
-     i.e. country is the default name for your country field, and the validator tries that automatically
-
- class Person < ActiveRecord::Base
-   validates_as_phone :phone
- end
-
-The :set parameter tells the validator to reformat the phone number (change punctuation and spacing) in to a standard format.
-
-
-Supported countries are Canada (CA), the United States (US) and Australia (AU).
-
-
-= License
-
-Written by Kristina Lim (http://i-think.com.ph/kristina/)
-
-Copyright (c) 2008 Syndeo Media
-http://syndeomedia.com
-
-US and Canada support added by Paul Schreiber (http://paulschreiber.com/)
-Last modified 07 September 2010
-Extension support added 17 November 2010
-
-= Contributing
-
-If you wish to contribute to the project, you may contact the author through:
-
-'kristinasyndeomediacom'.insert(8, '@').insert(20, '.')
-
-= Acknowledgements
-
-This plugin is named after the validates_as_phone plugin of Jerrod Blavos
-(http://code.google.com/p/validates-as-phone/). Admittedly, this plugin was
-built over the latter, but as the purposes of this plugin is more complex than
-that of the minimal one, practically all of the code has been written over by
-now.

data/lib/validation_kit/postal_code_validator/README

@@ -1,44 +0,0 @@
-validates_as_postal_code
-=====================
-
-Strict validation module for postal and zip codes.
-
-= General usage
-
-== Installation
-
-You can install the plugin the traditional way. Go to your application root
-and do:
-
-  script/plugin install git://github.com/paulschreiber/validates_as_postal_code.git
-
-== Validate your model attributes
-
-Example:
-
-There are three ways to specify the country:
- (1) Pass the country name in as a string parameter (:country => "CA")
- class Person < ActiveRecord::Base
-   validates_as_postal_code :postal_code, :country => "CA", :allow_blank => true
- end
-
- (2) Create an attribute (country field) named foo in your object, and pass in a reference to foo:
- class Person < ActiveRecord::Base
-   validates_as_postal_code :postal_code, :country => :foo
- end
-
- (3) Create an attribute named country it in your object, i.e. Person#country
-     i.e. country is the default name for your country field, and the validator tries that automatically
-
- class Person < ActiveRecord::Base
-   validates_as_postal_code :postal_code
- end
-
-The :set parameter tells the validator to reformat the postal_code number (change punctuation and spacing) in to a standard format.
-
-Supported countries are Canada (CA), the United States (US), Australia (AU), New Zealand (NZ). :set only works for Canada and the US; it's ignored for other countries.
-
-
-= License
-
-Copyright (c) 2010 Paul Schreiber, released under the MIT license

data/validation_kit.gemspec

@@ -1,21 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "validation_kit/version"
-
-Gem::Specification.new do |s|
-  s.name        = "validation_kit"
-  s.version     = ValidationKit::VERSION
-  s.authors     = ["Wes Morgan", "Paul Schreiber"]
-  s.email       = ["wes@turbovote.org", "paulschreiber@gmail.com"]
-  s.homepage    = "https://github.com/turbovote/validation_kit"
-  s.summary     = %q{Handy validations for Rails forms}
-  s.description = %q{A collection of various validators for Rails forms}
-
-  s.rubyforge_project = "validation_kit"
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-
-end