validation_kit 1.0.0

data/.gitignore

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

data/Gemfile

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

data/Rakefile

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

data/lib/validation_kit/validates_as_email/README

@@ -0,0 +1,32 @@
+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/validates_as_email/validates_as_email.rb

@@ -0,0 +1,20 @@
+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
+
+    def validate_each(record, attribute, value)
+      unless EMAIL_ADDRESS_RE.match(value)
+        message = I18n.t("activerecord.errors.models.#{name.underscore}.attributes.#{attr_name}.invalid",
+                         :default => [:"activerecord.errors.models.#{name.underscore}.invalid",
+                                      options[:message],
+                                      :'activerecord.errors.messages.invalid'])
+        record.errors[attribute] << message
+      end
+    end
+  end
+end

data/lib/validation_kit/validates_as_phone/README

@@ -0,0 +1,69 @@
+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/validates_as_phone/validates_as_phone.rb

@@ -0,0 +1,122 @@
+module ValidationKit
+  class PhoneValidator < ActiveModel::EachValidator
+    def regex_for_country(country_code)
+      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
+      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
+
+      next unless country
+      current_regex = regex_for_country(country)
+      next unless current_regex
+
+      new_value = value.to_s.gsub(/[^0-9]/, '')
+      new_value ||= ''
+
+      message = I18n.t("activerecord.errors.models.#{name.underscore}.attributes.#{attr_name}.invalid",
+                       :default => [:"activerecord.errors.models.#{name.underscore}.invalid",
+                       options[:message], :'activerecord.errors.messages.invalid'])
+
+      unless (options[:allow_blank] && new_value.blank?) || new_value =~ current_regex
+        record.errors[attribute] << message
+      else
+        if options[:set]
+          formatted_phone = format_as_phone(value, country, options[:area_key])
+          if formatted_phone.nil?
+            record.errors[attribute] << message
+          else
+            record.send(attr_name.to_s + '=', formatted_phone)
+          end
+        end # options
+      end # unless
+    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))
+
+      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
+        end
+      elsif ["CA", "US"].include?(country_code)
+        digit_count = number.length
+        # if it's too short
+        if digit_count < 10
+          return number
+        end
+
+        # strip off any leading ones
+        if number[0..0] == "1"
+          number = number[1..10]
+        end
+
+        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
+        end
+
+        "(%s) %s-%s%s" % [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'
+      else
+        '02'
+      end
+    end
+  end
+end

data/lib/validation_kit/validates_as_postal_code/README

@@ -0,0 +1,44 @@
+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/lib/validation_kit/validates_as_postal_code/validates_as_postal_code.rb

@@ -0,0 +1,89 @@
+module ValidationKit
+  class PostalCodeValidator < ActiveModel::EachValidator
+
+      def postal_code_regex_for_country(country_code)
+        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
+        end
+      end
+
+      def disallowed_characters_for_country(country_code)
+        if country_code.blank?
+          nil
+        elsif ["US", "AU", "NZ"].include?(country_code)
+          /[^0-9]/
+        elsif ["CA", "UK"].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
+
+        next unless country
+        current_regex = postal_code_regex_for_country(country)
+        next unless current_regex
+        disallowed_characters = disallowed_characters_for_country(country)
+
+        new_value = value.nil? ? "" : value.upcase.gsub(disallowed_characters, '')
+
+        unless (options[:allow_blank] && new_value.blank?) || new_value =~ current_regex
+          message = I18n.t("activerecord.errors.models.#{name.underscore}.attributes.#{attribute}.invalid",
+                           :default => [:"activerecord.errors.models.#{name.underscore}.invalid",
+                                        options[:message],
+                                        :'activerecord.errors.messages.invalid'])
+          record.errors[attribute] << message
+        else
+          record.send(attr_name.to_s + '=',
+            format_as_postal_code(new_value, country, disallowed_characters)
+          ) if options[:set]
+        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))
+
+        postal_code = arg.gsub(disallowed_characters, '')
+
+        if ["US"].include?(country_code)
+          digit_count = postal_code.length
+          if digit_count == 5
+            return postal_code
+          elsif digit_count == 9
+            return "%s-%s" % [postal_code[0..4], postal_code[5..8]]
+          else
+            return nil
+          end
+
+        elsif ["AU", "NZ"].include?(country_code)
+          postal_code
+
+        elsif ["CA"].include?(country_code)
+          fsa = postal_code[0..2]
+          lda = postal_code[3..5]
+
+          postal_code = "%s %s" % [fsa, lda]
+          postal_code.upcase
+        end
+      end
+    end
+  end
+end

data/lib/validation_kit/validates_mixed_case_of/README

@@ -0,0 +1,59 @@
+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/validates_mixed_case_of/config/locales/en.yml

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

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

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

data/lib/validation_kit/validates_mixed_case_of/validates_mixed_case_of.rb

@@ -0,0 +1,40 @@
+module ValidationKit
+  class MixedCaseValidator < ActiveModel::EachValidator
+    ALL_CAPS = 1
+    ALL_LOWERCASE = -1
+
+    def validate_each(record, attribute, value)
+      next if value.nil?
+      next 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
+
+      next if error.nil?
+
+      item_name = I18n.t("activerecord.models.attributes.#{name.underscore}.#{attribute}",
+                         :default => nil) or options[:attribute_name] or attribute
+
+      if error == ALL_CAPS
+       message = I18n.t("activerecord.errors.models.attributes.#{name.underscore}.#{attr_name}.all_caps",
+                   :item => item_name,
+                   :default => [:"activerecord.errors.models.#{name.underscore}.all_caps",
+                                options[:all_caps],
+                                :'activerecord.errors.messages.all_caps'])
+      elsif error == ALL_LOWERCASE
+        message = I18n.t("activerecord.errors.models.attributes.#{name.underscore}.#{attr_name}.all_lowercase",
+                    :item => item_name,
+                    :default => [:"activerecord.errors.models.#{name.underscore}.all_lowercase",
+                                 options[:all_lowercase],
+                                 :'activerecord.errors.messages.all_lowercase'])
+      end
+
+      record.errors[attribute] << message
+
+    end
+  end
+end

data/lib/validation_kit/version.rb

@@ -0,0 +1,3 @@
+module ValidationKit
+  VERSION = "1.0.0"
+end

data/lib/validation_kit.rb

@@ -0,0 +1,8 @@
+require "validation_kit/version"
+
+validators = Dir[File.join(File.expand_path(File.join('..', __FILE__)), '**', '*.rb')]
+validators.each do |v|
+  require v
+end
+
+module ValidationKit; end

data/validation_kit.gemspec

@@ -0,0 +1,21 @@
+# -*- 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", "paul@turbovote.org"]
+  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

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: validation_kit
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Wes Morgan
+- Paul Schreiber
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-08 00:00:00.000000000 Z
+dependencies: []
+description: A collection of various validators for Rails forms
+email:
+- wes@turbovote.org
+- paul@turbovote.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- lib/validation_kit.rb
+- lib/validation_kit/validates_as_email/README
+- lib/validation_kit/validates_as_email/validates_as_email.rb
+- lib/validation_kit/validates_as_phone/README
+- lib/validation_kit/validates_as_phone/validates_as_phone.rb
+- lib/validation_kit/validates_as_postal_code/README
+- lib/validation_kit/validates_as_postal_code/validates_as_postal_code.rb
+- lib/validation_kit/validates_mixed_case_of/README
+- lib/validation_kit/validates_mixed_case_of/config/locales/en.yml
+- lib/validation_kit/validates_mixed_case_of/config/locales/fr.yml
+- lib/validation_kit/validates_mixed_case_of/validates_mixed_case_of.rb
+- lib/validation_kit/version.rb
+- validation_kit.gemspec
+homepage: https://github.com/turbovote/validation_kit
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: validation_kit
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Handy validations for Rails forms
+test_files: []