missing_validators 1.1.0 → 2.0.0

data/lib/missing_validators/validators/inequality_validator.rb

@@ -1,29 +1,13 @@
-# Allows to check if the value of a specific attribute is not equal to
-# the value of another attribute of an object.
+# Checks if the value of an attribute is equal to a value or proc result.
 #
-# @example Validate that flight origin is not the same as its destination.
-#   class Flight << ActiveRecord::Base
-#     attr_accessor :origin, :destination
-#     validates :origin, inequality: { to: :destination }
-#   end
-class InequalityValidator < ActiveModel::EachValidator
-  # Checks if an attribute value is unequal to another attrubute value.
-  #
-  # @param [Object] record object to validate
-  # @param [String] attribute name of the object attribute to validate
-  # @param [Object] value attribute value
-  def validate_each(record, attribute, value)
-    unequal_to = options[:to]
+class InequalityValidator < EqualityValidator
+  private
 
-    unequal_to_value = if unequal_to.respond_to?(:call)
-      options[:to].call(record)
-    else
-      record.send(unequal_to.to_sym)
-    end
+  def compare_value(value, reference_value)
+    value != reference_value
+  end
 
-    if unequal_to.present? && value == unequal_to_value
-      message = options[:message] || I18n.t('errors.messages.inequality', attr: unequal_to)
-      record.errors[attribute] << message
-    end
+  def translation_key
+    'errors.messages.inequality'
   end
 end

data/lib/missing_validators/validators/latitude_validator.rb

@@ -1,14 +1,14 @@
-# Allows to check if the value of a specific attribute is a valid MAC address.
+# Checks if the value of an attribute is a valid longitude value.
 #
-# @example Validate that the device MAC address is valid.
+# @example Validate that the device latitude is valid.
 #   class Device << ActiveRecord::Base
-#     attr_accessor :lat
-#     validates :lat, latitude: true
+#     attr_accessor :latitude
+#     validates :latitude, latitude: true
 #   end
 class LatitudeValidator < BaseValidator
   private
 
-  def self.valid?(latitude, options)
-    latitude.present? && latitude >= -90 && latitude <= 90
+  def valid?(latitude, _)
+    latitude.present? && latitude.between?(-90, 90)
   end
 end

data/lib/missing_validators/validators/longitude_validator.rb

@@ -1,14 +1,14 @@
-# Allows to check if the value of a specific attribute is a valid MAC address.
+# Checks if the value of an attribute is a valid longitude.
 #
-# @example Validate that the device MAC address is valid.
+# @example Validate that the device longitude is valid.
 #   class Device << ActiveRecord::Base
-#     attr_accessor :lon
-#     validates :lon, longitude: true
+#     attr_accessor :longitude
+#     validates :longitude, longitude: true
 #   end
 class LongitudeValidator < BaseValidator
   private
 
-  def self.valid?(longitude, options)
-    longitude.present? && longitude >= -180 && longitude <= 180
+  def valid?(longitude, _)
+    longitude.present? && longitude.between?(-180, 180)
   end
 end

data/lib/missing_validators/validators/mac_address_validator.rb

@@ -1,4 +1,4 @@
-# Allows to check if the value of a specific attribute is a valid MAC address.
+# Checks if the value of an attribute is a valid MAC address.
 #
 # @example Validate that the device MAC address is valid.
 #   class Device << ActiveRecord::Base
@@ -6,18 +6,18 @@
 #     validates :mac, mac_address: true
 #   end
 class MacAddressValidator < BaseValidator
-  def self.validate_format(mac_address)
-    !!(mac_address =~ /^([\h]{2}:){5}[\h]{2}?$/i) ||            # 08:00:2b:01:02:03
-      !!(mac_address =~ /^([\h]{2}[-|\.|\s]){5}[\h]{2}?$/i) ||  # 08-00-2b-01-02-03 or 08.00.2b.01.02.03
-      !!(mac_address =~ /^([\h]{6})[-|\.][\h]{6}?$/i) ||        # 08002b-010203 or 08002b.010203
-      !!(mac_address =~ /^([\h]{6}):[\h]{6}?$/i) ||             # 08002b:010203
-      !!(mac_address =~ /^([\h]{4}[-|\.|\s]){2}[\h]{4}?$/i) ||  # 0800.2b01.0203 or 0800-2b01-0203 0800 2b01 0203
-      !!(mac_address =~ /^[\h]{12}?$/i)                         # 08002b010203
-  end
-
   private
 
-  def self.valid?(mac_address, options)
-    validate_format(mac_address)
+  MAC_ADDRESS_FORMATS = [
+    /^(\h{2}:){5}\h{2}$/,         # 08:00:2b:01:02:03
+    /^(\h{2}[-|\.|\s]){5}\h{2}$/, # 08-00-2b-01-02-03 08.00.2b.01.02.03
+    /^(\h{6})[-|\.]\h{6}$/,       # 08002b-010203 08002b.010203
+    /^(\h{6}):\h{6}$/,            # 08002b:010203
+    /^(\h{4}[-|\.|\s]){2}\h{4}$/, # 0800.2b01.0203 0800 2b01 0203 0800-2b01-0203
+    /^\h{12}$/                    # 08002b010203
+  ]
+
+  def valid?(mac_address, _)
+    MAC_ADDRESS_FORMATS.any? { |format| (mac_address =~ format).present? }
   end
 end

data/lib/missing_validators/validators/url_validator.rb

@@ -1,5 +1,5 @@
 require 'uri'
-# Allows to check if the value of a specific attribute is a valid URL.
+# Checks if the value of an attribute is a valid URL.
 #
 # @example Validate that the user's blog URL is valid.
 #   class User << ActiveRecord::Base
@@ -13,34 +13,52 @@ class UrlValidator < ActiveModel::EachValidator
   # @param [String] attribute name of the object attribute to validate
   # @param [Object] value attribute value
   def validate_each(record, attribute, value)
-    uri = URI.parse(value)
-    raise URI::InvalidURIError unless valid?(uri, options)
-  rescue URI::InvalidURIError
-    record.errors[attribute] << (options[:message] || I18n.t('errors.messages.url'))
+    uri = parse(value)
+    fail Addressable::URI::InvalidURIError unless valid?(uri, options)
+  rescue
+    record.errors[attribute] << options.fetch(:message) do
+      I18n.t('errors.messages.url')
+    end
   end
 
-  def self.validate_domain(uri, domains)
-    host_downcased = uri.host.to_s.downcase
-    domains.empty? || domains.any? { |domain| host_downcased.end_with?(".#{domain.downcase}") }
+  private
+
+  def parse(url)
+    Addressable::URI.parse(url).tap do |uri|
+      fail Addressable::URI::InvalidURIError if uri.nil? || uri.host.nil?
+    end
   end
 
-  def self.validate_scheme(uri, schemes)
-    scheme_downcased = uri.scheme.to_s.downcase
-    schemes.empty? || schemes.any? { |scheme| scheme_downcased == scheme.to_s.downcase }
+  def validate_host(uri)
+    !uri.host.include?(' ') && \
+      uri.host.include?('.') && \
+      uri.host.split('.').last.length > 1
   end
 
-  def self.validate_root(uri)
-    ['/', ''].include?(uri.path) && uri.query.blank? && uri.fragment.blank?
+  def validate_top_level_domain(uri, *domains)
+    return true if domains.empty?
+
+    host = uri.host.to_s.downcase
+    domains.any? { |domain| host.end_with?(".#{domain.downcase}") }
   end
 
-  private
+  def validate_scheme(uri, *schemes)
+    return true if schemes.empty?
 
-  DEFAULT_SCHEMES = [:http, :https]
+    scheme_downcased = uri.scheme.to_s.downcase
+    schemes.any? { |scheme| scheme_downcased == scheme.to_s.downcase }
+  end
+
+  def validate_root(uri)
+    ['/', ''].include?(uri.path) && \
+      uri.query.blank? && \
+      uri.fragment.blank?
+  end
 
   def valid?(uri, options)
-    uri.kind_of?(URI::Generic) \
-      && self.class.validate_domain(uri, [*(options[:domain])]) \
-      && self.class.validate_scheme(uri, [*(options[:scheme] || UrlValidator::DEFAULT_SCHEMES)]) \
-      && (!!options[:root] ? self.class.validate_root(uri) : true)
+    validate_host(uri) && \
+      validate_top_level_domain(uri, *options[:domain]) && \
+      validate_scheme(uri, *options[:scheme]) && \
+      (options[:root] == true ? validate_root(uri) : true)
   end
 end

data/lib/missing_validators/version.rb

@@ -1,5 +1,5 @@
-# Provides a collection of custom validators that are often required in Rails applications.
+# Collection of custom validators that are often required in Rails apps.
 module MissingValidators
-  # Gem version.
-  VERSION = "1.1.0"
+  # Gem version
+  VERSION = '2.0.0'
 end

data/missing_validators.gemspec

@@ -1,25 +1,29 @@
-# -*- encoding: utf-8 -*-
 require File.expand_path('../lib/missing_validators/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["Andrei Gridnev"]
-  gem.email         = ["andrew.gridnev@gmail.com"]
-  gem.summary       = %q{Adds some handy validators.}
-  gem.description   = %q{Validates email addresses, URLs, IMEI, MAC addresses, latitude, longitude, hex colors and inequality of attributes.}
-  gem.homepage      = "https://github.com/andrewgr/missing_validators/"
+  gem.authors       = ['Andrei Gridnev']
+  gem.email         = ['andrew.gridnev@gmail.com']
+  gem.summary       = 'Adds some handy validators.'
+  gem.description   = 'Validates email addresses, URLs, IMEI, MAC addresses,
+    latitude, longitude, hex colors and (in-)equality of attributes.'
+  gem.homepage      = 'https://github.com/andrewgr/missing_validators/'
   gem.license       = 'MIT'
 
-  gem.files         = `git ls-files`.split($\)
+  gem.files         = `git ls-files`.split($ORS)
   gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.name          = "missing_validators"
-  gem.require_paths = ["lib"]
+  gem.test_files    = gem.files.grep(%r{^spec/})
+  gem.name          = 'missing_validators'
+  gem.require_paths = ['lib']
   gem.version       = MissingValidators::VERSION
 
   gem.add_runtime_dependency 'activemodel'
   gem.add_runtime_dependency 'activesupport'
+  gem.add_runtime_dependency 'addressable', '~> 2.3'
 
-  gem.add_development_dependency 'rspec'
-  gem.add_development_dependency 'shoulda-matchers'
-  gem.add_development_dependency 'codeclimate-test-reporter'
+  gem.add_development_dependency 'rspec', '~> 3'
+  gem.add_development_dependency 'rubocop', '~> 0.30'
+  gem.add_development_dependency 'cane', '~> 2.6', '>= 2.6.1'
+  gem.add_development_dependency 'shoulda', '~> 3.5'
+  gem.add_development_dependency 'shoulda-matchers', '~> 2.8', '>= 2.8.0'
+  gem.add_development_dependency 'codeclimate-test-reporter', '~> 0.4', '>= 0.4.7'
 end

data/spec/spec_helper.rb

@@ -2,8 +2,8 @@ require 'codeclimate-test-reporter'
 CodeClimate::TestReporter.start
 
 require 'missing_validators'
-require 'shoulda/matchers/active_record'
-require 'shoulda-matchers'
+require 'shoulda/matchers'
+require 'shoulda/matchers/integrations/rspec'
 
 I18n.enforce_available_locales = false
-I18n.load_path << File.expand_path("../../config/locales/en.yml", __FILE__)
+I18n.load_path << File.expand_path('../../config/locales/en.yml', __FILE__)

data/spec/validators/color_validator_spec.rb

@@ -1,21 +1,19 @@
 require 'spec_helper'
 
 describe ColorValidator do
-  context "Color has a valid value" do
-    let(:klass) do
-      Class.new do
-        include ActiveModel::Validations
-        attr_accessor :color
-        validates :color, color: true
-      end
+  let(:klass) do
+    Class.new do
+      include ActiveModel::Validations
+      attr_accessor :color
+      validates :color, color: true
     end
+  end
 
-    subject { klass.new }
+  subject { klass.new }
 
-    it { should allow_value("#000000").for(:color) }
-    it { should allow_value("#ab00FF").for(:color) }
+  it { should allow_value('#000000').for(:color) }
+  it { should allow_value('#ab00FF').for(:color) }
 
-    it { should_not allow_value("kk").for(:color) }
-    it { should_not allow_value(0).for(:color) }
-  end
+  it { should_not allow_value('kk').for(:color) }
+  it { should_not allow_value(0).for(:color) }
 end

data/spec/validators/email_validator_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe EmailValidator do
   subject { klass.new }
 
-  context "email has valid format" do
+  context 'email must be in the valid format' do
     let(:klass) do
       Class.new do
         include ActiveModel::Validations
@@ -12,48 +12,58 @@ describe EmailValidator do
       end
     end
 
-    it { should allow_value("super.user@example.com").for(:email) }
-    it { should allow_value("super+user@example.com").for(:email) }
-    it { should_not allow_value("user_example.com").for(:email) }
+    it { should allow_value('super.user@example.com').for(:email) }
+    it { should allow_value('super+user@example.com').for(:email) }
+    it { should_not allow_value('user_example.com').for(:email) }
 
     it { should ensure_valid_email_format_of(:email) }
     it { should_not ensure_valid_email_format_of(:name) }
   end
 
-  context "email is in the specific domain" do
-    context "email domain specified as string" do
+  context 'email must be in the specific domain' do
+    context 'no email domain is specified' do
       let(:klass) do
         Class.new do
           include ActiveModel::Validations
           attr_accessor :email, :name
-          validates :email, email: { domain: "edu" }
+          validates :email, email: { domain: nil }
         end
       end
 
-      it { should allow_value("user@example.edu").for(:email) }
-      it { should_not allow_value("user@example.com").for(:email) }
-
-      it { should ensure_valid_email_format_of(:email) }
-      it { should_not ensure_valid_email_format_of(:name) }
+      it { should allow_value('user@example.edu').for(:email) }
+      it { should allow_value('user@example.com').for(:email) }
     end
 
-    context "email set as an array of strings and symbols" do
+    context 'email domain is specified as string' do
       let(:klass) do
         Class.new do
           include ActiveModel::Validations
           attr_accessor :email, :name
-          validates :email, email: { domain: ['com', :edu, 'Com.Au'] }
+          validates :email, email: { domain: '.edu' }
         end
       end
 
-      it { should allow_value("user@example.com").for(:email) }
-      it { should allow_value("user@example.edu").for(:email) }
-      it { should allow_value("user@example.com.au").for(:email) }
-      it { should allow_value("user@example.Com.Au").for(:email) }
-      it { should_not allow_value("user@example.org").for(:email) }
+      it { should allow_value('user@example.edu').for(:email) }
+      it { should_not allow_value('user@example.com').for(:email) }
+    end
+
+    context 'email domains are specified as an array of strings and symbols' do
+      let(:klass) do
+        Class.new do
+          include ActiveModel::Validations
+          attr_accessor :email, :name
+          validates :email, email: {
+            domain: ['.com', '.edu', '.Com.Au', 'example.org']
+          }
+        end
+      end
 
-      it { should ensure_valid_email_format_of(:email) }
-      it { should_not ensure_valid_email_format_of(:name) }
+      it { should allow_value('user@example.com').for(:email) }
+      it { should allow_value('user@example.edu').for(:email) }
+      it { should allow_value('user@example.org').for(:email) }
+      it { should allow_value('user@example.com.au').for(:email) }
+      it { should allow_value('user@example.Com.Au').for(:email) }
+      it { should_not allow_value('user@example.net').for(:email) }
     end
   end
 end

data/spec/validators/equality_validator_spec.rb

@@ -1,27 +1,19 @@
 require 'spec_helper'
 
 describe EqualityValidator do
+  subject(:model) { klass.new }
 
   describe do
     let(:klass) do
       Class.new do
         include ActiveModel::Validations
-        attr_accessor :attr
-        validates :attr, equality: { to: Proc.new { |o| 'valid value' } }
+        attr_accessor :origin, :destination, :airline
+        validates :origin, equality: { to: 'MOW' }
       end
     end
 
-    subject(:model){ klass.new }
-
-    specify "field is not the same as the result of the validating proc" do
-      model.attr = "invalid value"
-      expect(model).to be_invalid
-    end
-
-    specify "field is the same as the result of the validating proc" do
-      model.attr = "valid value"
-      expect(model).to be_valid
-    end
+    it { should allow_value('MOW').for(:origin) }
+    it { should_not allow_value('NYC').for(:origin) }
   end
 
   describe do
@@ -29,39 +21,34 @@ describe EqualityValidator do
       Class.new do
         include ActiveModel::Validations
         attr_accessor :origin, :destination, :airline
-        validates :origin, equality: { to: :destination }
+        validates :origin, equality: { to: ->(o) { o.destination } }
       end
     end
 
-    subject(:model){ klass.new }
-
-    it { should ensure_equality_of(:origin).to(:destination) }
-    it { should_not ensure_equality_of(:origin).to(:airline) }
-
-    specify "both fields have same values" do
-      model.origin = model.destination = "MOW"
+    specify 'both fields have same values' do
+      model.origin = model.destination = 'MOW'
       expect(model).to be_valid
     end
 
-    specify "fields have different value" do
-      model.origin = "NYC"
-      model.destination = "MOW"
+    specify 'fields have different value' do
+      model.origin = 'NYC'
+      model.destination = 'MOW'
       expect(model).to be_invalid
     end
 
-    specify "first field has value, the second is nil" do
-      model.origin = "NYC"
+    specify 'first field has value, the second is nil' do
+      model.origin = 'NYC'
       model.destination = nil
       expect(model).to be_invalid
     end
 
-    specify "first field is nil, the second has value" do
+    specify 'first field is nil, the second has value' do
       model.origin = nil
-      model.destination = "NYC"
+      model.destination = 'NYC'
       expect(model).to be_invalid
     end
 
-    specify "both fields are nil" do
+    specify 'both fields are nil' do
       model.origin = model.destination = nil
       expect(model).to be_valid
     end