validation_kit 1.0.5 → 2.0.1

data/lib/validation_kit/phone_validator/phone_validator.rb

@@ -1,123 +1,145 @@
+# frozen_string_literal: true
+
 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
+
       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 = country_for(record)
       return unless country
+
+      # accept "us", :US, " US " as well as "US"
+      country = country.to_s.strip.upcase
+      return if country.empty?
+
       current_regex = regex_for_country(country)
       return unless current_regex
 
-      new_value = value.to_s.gsub(/[^0-9]/, '')
-      new_value ||= ''
-
-      model_name = record.class.to_s
+      new_value = value.to_s.gsub(/[^0-9]/, "")
 
-      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'])
+      # 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.
+      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)
 
-      unless (options[:allow_blank] && new_value.blank?) || new_value =~ current_regex
-        record.errors.add(attribute, message)
-      else
+      if valid
         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))
+      # 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)
 
-      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) 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, unless they're unmarked (UNMARKED_US_CA_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
-          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
+        # 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
 
-        "(%s) %s-%s%s" % [area_code, exchange, sln, extension]
+        "(#{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 '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'
-      else
-        '02'
+      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

@@ -1,88 +1,87 @@
+# frozen_string_literal: true
+
 module ValidationKit
   class PostalCodeValidator < ActiveModel::EachValidator
+    include CountryOption
+
     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 = country_for(record)
       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.1"
 end

data/lib/validation_kit.rb

@@ -1,10 +1,35 @@
+# frozen_string_literal: true
+
+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
+
+  # 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.1
 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,26 @@ 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/country_option.rb
 - 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 +59,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.10
 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