omg_validator 0.0.6.2 → 0.0.7

data/doc/top-level-namespace.html

@@ -6,7 +6,7 @@
 <title>
   Top Level Namespace
   
-    &mdash; Documentation by YARD 0.7.4
+    &mdash; Documentation by YARD 0.7.5
   
 </title>
 
@@ -91,12 +91,14 @@
 
 
 
+
+
 </div>
     
     <div id="footer">
-  Generated on Fri Mar 30 11:50:31 2012 by 
+  Generated on Thu Apr  5 00:05:42 2012 by 
   <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
-  0.7.4 (ruby-1.9.2).
+  0.7.5 (ruby-1.9.2).
 </div>
 
   </body>

data/lib/omg_validator.rb

@@ -14,9 +14,12 @@ require "omg_validator/validators/alpha_validator"
 require "omg_validator/validators/date_validator"
 require "omg_validator/validators/decimal_validator"
 require "omg_validator/validators/email_validator"
+require "omg_validator/validators/url_validator"
+require "omg_validator/validators/ip_address_validator"
 require "omg_validator/validators/integer_validator"
 require "omg_validator/validators/numeric_validator"
 require "omg_validator/validators/phone_number_validator"
 require "omg_validator/validators/postal_code_validator"
 require "omg_validator/validators/postal_or_zip_code_validator"
+require "omg_validator/validators/strong_password_validator"
 require "omg_validator/validators/zip_code_validator"

data/lib/omg_validator/validators/alpha_dash_validator.rb

@@ -3,6 +3,9 @@ module OmgValidator
     # Checks whether input only contains alpha-numberic characters and dashes
     #
     # validates :perma_link, alpha_dash: true
+    #
+    # matches: alpha-dash-23, ll2-ada, 343, Dfsdf, -,
+    # does not match: $10.00, sub.domain, id=343, (232)
     class AlphaDashValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
         return nil if value.nil?

data/lib/omg_validator/validators/alpha_numeric_validator.rb

@@ -3,6 +3,9 @@ module OmgValidator
     # Checks whether input only contains alpha-numberic characters
     #
     # validates :title, alpha_numberic: true
+    #
+    # matches: alpha23, Testing, 343, hello,
+    # does not match: 324-343, alpha-dash, id=343, (232)
     class AlphaNumericValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
         return nil if value.nil?

data/lib/omg_validator/validators/alpha_validator.rb

@@ -3,6 +3,9 @@ module OmgValidator
     # Checks whether input only contains alphabetic characters
     #
     # validates :name, alpha: true
+    #
+    # matches: alpha, testing, Hello,
+    # does not match: sub.domain, alpha-dash, id=343, (232)
     class AlphaValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
         return nil if value.nil?

data/lib/omg_validator/validators/decimal_validator.rb

@@ -3,6 +3,9 @@ module OmgValidator
     # Checks whether input is a valid floating point number
     #
     # validates :total_value, decimal: true
+    #
+    # matches: 10.00, -23.12, 9.99, 1.9002302
+    # does not match: 123, 99, -23, 1,000
     class DecimalValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
         return nil if value.nil?

data/lib/omg_validator/validators/email_validator.rb

@@ -3,10 +3,13 @@ module OmgValidator
     # Checks whether input is a valid email address
     #
     # validates :email, email: true
+    #
+    # matches: email@domain.com, my_user@domain.edu.org, sub.domain@ohyeah.com,
+    # does not match: mail@you@rock.com, domain.com
     class EmailValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
         return nil if value.nil?
-        reg = /\A[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]+\z/
+        reg = /^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]+$/
         unless reg.match(value)
           record.errors[attribute] = "must be a valid email address"
         end

data/lib/omg_validator/validators/integer_validator.rb

@@ -3,6 +3,9 @@ module OmgValidator
     # Checks whether input is a valid integer
     #
     # validates :count, integer: true
+    #
+    # matches: 10, 20, 2323, -20, 10000000,
+    # does not match: 10.50, -22.21, 1,000, ten
     class IntegerValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
         return nil if value.nil?

data/lib/omg_validator/validators/ip_address_validator.rb

@@ -3,10 +3,13 @@ module OmgValidator
     # Checks whether input is a valid IP Address
     #
     # validates :ip_address, ip_adress: true
+    #
+    # matches: 101.101.102.123, 9.199.22.212, 255.255.255.0, 127.0.0.1
+    # does not match: 101.101.102.565, 255.256.256.0, 90.0.0, 12.12.54.34.123
     class IpAddressValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
         return nil if value.nil?
-        reg = '/\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b/'
+        reg = /^\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$\b/
         unless reg.match(value)
           record.errors[attribute] = "must be a valid IP address"
         end

data/lib/omg_validator/validators/numeric_validator.rb

@@ -3,6 +3,9 @@ module OmgValidator
     # Checks whether input is a valid number
     #
     # validates :count, number: true
+    #
+    # matches: 123, 523.12, -23, -23.12
+    # does not match: six, 23.23.12, 1,000
     class NumericValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
         return nil if value.nil?

data/lib/omg_validator/validators/phone_number_validator.rb

@@ -4,10 +4,13 @@ module OmgValidator
     # Currently only supports American and Canadian formats
     #
     # validates :phone, phone_number: true
+    #
+    # matches: 2342343423, 1-800-232-1232, 100-232-2322, 1905-232-2323,
+    # does not match: 3434343434343, 333333333, 905-232-23239, (111) 232-2322
     class PhoneNumberValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
         return nil if value.nil?
-        reg = /^(1?(-?\d{3})-?)?(\d{3})(-?\d{4})$/
+        reg = /^(\d[ -\.]?)?(\d{3}[ -\.]?)?\d{3}[ -\.]?\d{4}(x\d+)?$/
         unless reg.match(value)
           record.errors[attribute] = "must be a valid phone number"
         end

data/lib/omg_validator/validators/postal_code_validator.rb

@@ -3,6 +3,9 @@ module OmgValidator
     # Checks whether input is a valid postal code
     #
     # validates :postal_code, postal_code: true
+    #
+    # matches: L2J 4T5, l2a 9d1, h2o 4g1, h2o4g1
+    # does not match: z2n 1n3, aan 2j2, LL2J 4T5, 5j4 f1d
     class PostalCodeValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
         return nil if value.nil?

data/lib/omg_validator/validators/postal_or_zip_code_validator.rb

@@ -3,6 +3,9 @@ module OmgValidator
     # Checks whether input is a valid postal code or a valid zip code
     #
     # validates :zip_code, postal_or_zip_code: true
+    #
+    # matches: L2J 4T5, l2a 9d1, h2o 4g1, h2o4g1, 90210, 20037-8001, 12345
+    # does not match: z2n 1n3, aan 2j2, LL2J 4T5, 123456, 20037-001, 207-01
     class PostalOrZipCodeValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
         return nil if value.nil?

data/lib/omg_validator/validators/strong_password_validator.rb

@@ -1,15 +1,18 @@
 module OmgValidator
   module Validators
     # Checks whether password input is a strong password
-    # Must contain a least one number, one lower case letter and one upper case letter
+    # Must contain a least one number, one lower case letter and one upper case letter and must be at least 8 characters
     #
     # validates :password, strong_password: true
+    #
+    # matches: ASdj3j3jsS, 8#adCje3, pwd#fdJa9, To34zNbsr30,
+    # does not match: password, sdfsdfs3, Jsdsdsdj, G3hn$h
     class StrongPasswordValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
         return nil if value.nil?
-        reg = '/^\w*(?=\w*\d)(?=\w*[a-z])(?=\w*[A-Z])\w*$/'
+        reg = /(?=^.{8,}$)((?=.*\d)|(?=.*\W+))(?![.\n])(?=.*[A-Z])(?=.*[a-z]).*$/
         unless reg.match(value)
-          record.errors[attribute] = "must contain at least a number, a lower case letter, and a upper case letter"
+          record.errors[attribute] = "must contain at least a number, a lower case letter, a upper case letter and must be at least 8 characters"
         end
       end
     end

data/lib/omg_validator/validators/url_validator.rb

@@ -4,10 +4,13 @@ module OmgValidator
     # Supports the protocols: http, https and ftp
     #
     # validates :url, url: true
-    class UrlValidator < ActiveModel::EachValidator
+    #
+    # matches: http://www.example.com, www.example.com, example.com, sub.example.com
+    # does not match: @asd.com, domain.c, domain.asd., amasd@asd.com.a
+  class UrlValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
         return nil if value.nil?
-        reg = '`.*?((http|ftp|https)://[\w#$&+,\/:;=?@.-]+)[^\w#$&+,\/:;=?@.-]*?`i'
+        reg = /^((https?):\/\/)?([a-z\d]+([\-\.][a-z\d]+)*\.[a-z]{2,6})((:(\d{1,5}))?(\/.*)?)?$/
         unless reg.match(value)
           record.errors[attribute] = "must be a valid url"
         end

data/lib/omg_validator/validators/zip_code_validator.rb

@@ -3,6 +3,9 @@ module OmgValidator
     # Checks whether input is a valid zip code
     #
     # validates :zip_code, zip_code: true
+    #
+    # matches: 90210, 20037-8001, 12345
+    # does not match: 123456, 20037-001, 207-01
     class ZipCodeValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
         return nil if value.nil?

data/lib/omg_validator/version.rb

@@ -1,4 +1,4 @@
 module OmgValidator
   #Version of Gem
-  VERSION = "0.0.6.2"
+  VERSION = "0.0.7"
 end

data/test/dummy/app/models/thing.rb

@@ -0,0 +1,32 @@
+require 'active_model'
+
+class Thing
+  include ActiveModel::Validations
+
+  attr_accessor :alpha, :alpha_numeric, :alpha_dash, :zip_code, :postal_or_zip_code, :postal_code,
+    :decimal, :integer, :numeric, :email, :ip_address, :url, :phone, :password, :date
+
+  validates :alpha, alpha: true
+  validates :alpha_numeric, alpha_numeric: true
+  validates :alpha_dash, alpha_dash: true
+  validates :zip_code, zip_code: true
+  validates :postal_or_zip_code, postal_or_zip_code: true
+  validates :postal_code, postal_code: true
+  validates :decimal, decimal: true
+  validates :integer, integer: true
+  validates :numeric, numeric: true
+  validates :email, email: true
+  validates :ip_address, ip_address: true
+  validates :url, url: true
+  validates :phone, phone_number: true
+  validates :password, strong_password: true
+  validates :date, date: true
+
+  def initialize(options = {})
+    @alpha = options[:alpha] unless options[:alpha].nil?
+    @alpha_numeric = options[:alpha_numeric] unless options[:alpha_numeric].nil?
+    @alpha_dash = options[:alpha_dash] unless options[:alpha_dash].nil?
+    @zip_code = options[:zip_code] unless options[:zip_code].nil?
+    @postal_or_zip_code = options[:postal_or_zip_code] unless options[:postal_or_zip_code].nil?
+  end
+end

data/test/dummy/config/environments/test.rb

@@ -27,7 +27,7 @@ Dummy::Application.configure do
   # Tell Action Mailer not to deliver emails to the real world.
   # The :test delivery method accumulates sent emails in the
   # ActionMailer::Base.deliveries array.
-  config.action_mailer.delivery_method = :test
+  #config.action_mailer.delivery_method = :test
 
   # Use SQL instead of Active Record's schema dumper when creating the test database.
   # This is necessary if your schema can't be completely dumped by the schema dumper,

data/test/omg_validator_test.rb

@@ -1,7 +1,255 @@
 require 'test_helper'
 
 class OmgValidatorTest < ActiveSupport::TestCase
+  def setup
+    @thing = nil
+    @thing = Thing.new({
+                           alpha: Things.alphas[:valid].sample,
+                           alpha_numeric: Things.alpha_numerics[:valid].sample,
+                           alpha_dash: Things.alpha_dashes[:valid].sample,
+                           zip_code: Things.zip_codes[:valid].sample,
+                           postal_or_zip_code: Things.postal_codes[:valid].sample
+                       })
+  end
+
+  def teardown
+    @thing = nil
+  end
+
   test "truth" do
     assert_kind_of Module, OmgValidator
   end
+
+  # alpha
+  test "thing should be invalid if alpha contains non-alpha characters" do
+    Things.alphas[:invalid].each do |alpha|
+      @thing.alpha = alpha
+      assert !@thing.valid?, "#{alpha} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  test "thing should be valid if alpha contains only alpha characters" do
+    Things.alphas[:valid].each do |alpha|
+      @thing.alpha = alpha
+      assert @thing.valid?, "#{alpha} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  # alpha numeric
+  test "thing should be invalid if alpha_numeric contains non-alpha-numeric characters" do
+    Things.alpha_numerics[:invalid].each do |alpha_numeric|
+      @thing.alpha_numeric = alpha_numeric
+      assert !@thing.valid?, "#{alpha_numeric} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+
+  test "thing should be valid if alpha_numeric contains only alpha-numeric characters" do
+    Things.alpha_numerics[:valid].each do |alpha_numeric|
+      @thing.alpha_numeric = alpha_numeric
+      assert @thing.valid?, "#{alpha_numeric} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  # alpha dash
+  test "thing should be invalid if alpha_dash contains non-alpha-numeric-dashes characters" do
+    Things.alpha_dashes[:invalid].each do |alpha_dash|
+      @thing.alpha_dash = alpha_dash
+      assert !@thing.valid?, "#{alpha_dash} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  test "thing should be valid if alpha_dash contains only alpha-numeric-dashes characters" do
+    Things.alpha_dashes[:valid].each do |alpha_dash|
+      @thing.alpha_dash = alpha_dash
+      assert @thing.valid? "#{alpha_dash} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  test "thing should be valid if alpha_dash contains only alpha or dash characters" do
+    Things.alpha_dashes[:valid].each do |alpha_dash|
+      @thing.alpha_dash = alpha_dash
+      assert @thing.valid?, "#{alpha_dash} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  # zip code
+  test "thing should be invalid if zip_code is not a valid zip_code" do
+    Things.zip_codes[:invalid].each do |zip|
+      @thing.zip_code = zip
+      assert !@thing.valid?, "#{zip} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  test "thing should be valid if zip_code is a valid zip code" do
+    Things.zip_codes[:valid].each do |zip|
+      @thing.zip_code = zip
+      assert @thing.valid?, "#{zip} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  # postal or zip code
+  test "thing should be invalid if postal_or_zip_code is not a valid postal or zip code" do
+    Things.postal_codes[:invalid].concat(Things.zip_codes[:invalid]).each do |zip_or_postal|
+      @thing.postal_or_zip_code = zip_or_postal
+      assert !@thing.valid?, "#{zip_or_postal} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  test "thing should be valid if postal_or_zip_code is a valid postal or zip code" do
+    Things.postal_codes[:valid].concat(Things.zip_codes[:valid]).each do |zip_or_postal|
+      @thing.postal_or_zip_code = zip_or_postal
+      assert @thing.valid?, "#{zip_or_postal} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  # postal code
+  test "thing should be valid if postal_code is a valid postal code" do
+    Things.postal_codes[:valid].each do |code|
+      @thing.postal_code = code
+      assert @thing.valid?, "#{code} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  test "thing should be invalid if postal_code is not a valid postal code" do
+    Things.postal_codes[:invalid].each do |code|
+      @thing.postal_code = code
+      assert !@thing.valid?, "#{code} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  # decimals
+  test "thing should be valid if decimal is a valid decimal" do
+    Things.decimals[:valid].each do |decimal|
+      @thing.decimal = decimal
+      assert @thing.valid?, "#{decimal} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  test "thing should be invalid if decimal is not a valid decimal" do
+    Things.decimals[:invalid].each do |decimal|
+      @thing.decimal = decimal
+      assert !@thing.valid?, "#{decimal} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  # integer
+  test "thing should be valid if integer is a valid integer" do
+    Things.integers[:valid].each do |integer|
+      @thing.integer = integer
+      assert @thing.valid?, "#{integer} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  test "thing should be invalid if integer is not a valid integer" do
+    Things.integers[:invalid].each do |integer|
+      @thing.integer = integer
+      assert !@thing.valid?, "#{integer} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  # numeric
+  test "thing should be valid if numeric is a valid numeric" do
+    Things.numeric[:valid].each do |numeric|
+      @thing.numeric = numeric
+      assert @thing.valid?, "#{numeric} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  test "thing should be invalid if numeric is not a valid numeric" do
+    Things.numeric[:invalid].each do |numeric|
+      @thing.numeric = numeric
+      assert !@thing.valid?, "#{numeric} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  # email
+  test "thing should be valid if email is a valid email" do
+    Things.emails[:valid].each do |email|
+      @thing.email = email
+      assert @thing.valid?, "#{email} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  test "thing should be invalid if email is not a valid email" do
+    Things.emails[:invalid].each do |email|
+      @thing.email = email
+      assert !@thing.valid?, "#{email} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  # ip address
+  test "thing should be valid if ip_address is a valid ip address" do
+    Things.ip_addresses[:valid].each do |ip|
+      @thing.ip_address = ip
+      assert @thing.valid?, "#{ip} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  test "thing should be invalid if ip_address is not a valid ip address" do
+    Things.ip_addresses[:invalid].each do |ip|
+      @thing.ip_address = ip
+      assert !@thing.valid?, "#{ip} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  # url
+  test "thing should be valid if url is a valid url" do
+    Things.urls[:valid].each do |url|
+      @thing.url = url
+      assert @thing.valid?, "#{url} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  test "thing should be invalid if url is not a valid url" do
+    Things.urls[:invalid].each do |url|
+      @thing.url = url
+      assert !@thing.valid?, "#{url} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  # phone number
+  test "thing should be valid if phone is a valid phone number" do
+    Things.phone_numbers[:valid].each do |phone|
+      @thing.phone = phone
+      assert @thing.valid?, "#{phone} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  test "thing should be invalid if phone is not a valid phone number" do
+    Things.phone_numbers[:invalid].each do |phone|
+      @thing.phone = phone
+      assert !@thing.valid?, "#{phone} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  # strong password
+  test "thing should be valid if password is a valid strong password" do
+    Things.strong_passwords[:valid].each do |password|
+      @thing.password = password
+      assert @thing.valid?, "#{password} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  test "thing should be invalid if password is not a valid strong password" do
+    Things.strong_passwords[:invalid].each do |password|
+      @thing.password = password
+      assert !@thing.valid?, "#{password} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  # date
+  test "thing should be valid if date is a valid date" do
+    Things.dates[:valid].each do |date|
+      @thing.date = date
+      assert @thing.valid?, "#{date} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
+
+  test "thing should be invalid if date is not a valid date" do
+    Things.dates[:invalid].each do |date|
+      @thing.date = date
+      assert !@thing.valid?, "#{date} - #{@thing.errors.full_messages.join("\n")}"
+    end
+  end
 end