ric 0.13.0 → 0.14.0

data/vendor/bundle/ruby/2.5.0/gems/activemodel-5.2.3/lib/active_model/validations/clusivity.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/range"
-
-module ActiveModel
-  module Validations
-    module Clusivity #:nodoc:
-      ERROR_MESSAGE = "An object with the method #include? or a proc, lambda or symbol is required, " \
-                      "and must be supplied as the :in (or :within) option of the configuration hash"
-
-      def check_validity!
-        unless delimiter.respond_to?(:include?) || delimiter.respond_to?(:call) || delimiter.respond_to?(:to_sym)
-          raise ArgumentError, ERROR_MESSAGE
-        end
-      end
-
-    private
-
-      def include?(record, value)
-        members = if delimiter.respond_to?(:call)
-          delimiter.call(record)
-        elsif delimiter.respond_to?(:to_sym)
-          record.send(delimiter)
-        else
-          delimiter
-        end
-
-        members.send(inclusion_method(members), value)
-      end
-
-      def delimiter
-        @delimiter ||= options[:in] || options[:within]
-      end
-
-      # In Ruby 2.2 <tt>Range#include?</tt> on non-number-or-time-ish ranges checks all
-      # possible values in the range for equality, which is slower but more accurate.
-      # <tt>Range#cover?</tt> uses the previous logic of comparing a value with the range
-      # endpoints, which is fast but is only accurate on Numeric, Time, Date,
-      # or DateTime ranges.
-      def inclusion_method(enumerable)
-        if enumerable.is_a? Range
-          case enumerable.first
-          when Numeric, Time, DateTime, Date
-            :cover?
-          else
-            :include?
-          end
-        else
-          :include?
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/activemodel-5.2.3/lib/active_model/validations/confirmation.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  module Validations
-    class ConfirmationValidator < EachValidator # :nodoc:
-      def initialize(options)
-        super({ case_sensitive: true }.merge!(options))
-        setup!(options[:class])
-      end
-
-      def validate_each(record, attribute, value)
-        unless (confirmed = record.send("#{attribute}_confirmation")).nil?
-          unless confirmation_value_equal?(record, attribute, value, confirmed)
-            human_attribute_name = record.class.human_attribute_name(attribute)
-            record.errors.add(:"#{attribute}_confirmation", :confirmation, options.except(:case_sensitive).merge!(attribute: human_attribute_name))
-          end
-        end
-      end
-
-      private
-        def setup!(klass)
-          klass.send(:attr_reader, *attributes.map do |attribute|
-            :"#{attribute}_confirmation" unless klass.method_defined?(:"#{attribute}_confirmation")
-          end.compact)
-
-          klass.send(:attr_writer, *attributes.map do |attribute|
-            :"#{attribute}_confirmation" unless klass.method_defined?(:"#{attribute}_confirmation=")
-          end.compact)
-        end
-
-        def confirmation_value_equal?(record, attribute, value, confirmed)
-          if !options[:case_sensitive] && value.is_a?(String)
-            value.casecmp(confirmed) == 0
-          else
-            value == confirmed
-          end
-        end
-    end
-
-    module HelperMethods
-      # Encapsulates the pattern of wanting to validate a password or email
-      # address field with a confirmation.
-      #
-      #   Model:
-      #     class Person < ActiveRecord::Base
-      #       validates_confirmation_of :user_name, :password
-      #       validates_confirmation_of :email_address,
-      #                                 message: 'should match confirmation'
-      #     end
-      #
-      #   View:
-      #     <%= password_field "person", "password" %>
-      #     <%= password_field "person", "password_confirmation" %>
-      #
-      # The added +password_confirmation+ attribute is virtual; it exists only
-      # as an in-memory attribute for validating the password. To achieve this,
-      # the validation adds accessors to the model for the confirmation
-      # attribute.
-      #
-      # NOTE: This check is performed only if +password_confirmation+ is not
-      # +nil+. To require confirmation, make sure to add a presence check for
-      # the confirmation attribute:
-      #
-      #   validates_presence_of :password_confirmation, if: :password_changed?
-      #
-      # Configuration options:
-      # * <tt>:message</tt> - A custom error message (default is: "doesn't match
-      #   <tt>%{translated_attribute_name}</tt>").
-      # * <tt>:case_sensitive</tt> - Looks for an exact match. Ignored by
-      #   non-text columns (+true+ by default).
-      #
-      # There is also a list of default options supported by every validator:
-      # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See <tt>ActiveModel::Validations#validates</tt> for more information
-      def validates_confirmation_of(*attr_names)
-        validates_with ConfirmationValidator, _merge_attributes(attr_names)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/activemodel-5.2.3/lib/active_model/validations/exclusion.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require "active_model/validations/clusivity"
-
-module ActiveModel
-  module Validations
-    class ExclusionValidator < EachValidator # :nodoc:
-      include Clusivity
-
-      def validate_each(record, attribute, value)
-        if include?(record, value)
-          record.errors.add(attribute, :exclusion, options.except(:in, :within).merge!(value: value))
-        end
-      end
-    end
-
-    module HelperMethods
-      # Validates that the value of the specified attribute is not in a
-      # particular enumerable object.
-      #
-      #   class Person < ActiveRecord::Base
-      #     validates_exclusion_of :username, in: %w( admin superuser ), message: "You don't belong here"
-      #     validates_exclusion_of :age, in: 30..60, message: 'This site is only for under 30 and over 60'
-      #     validates_exclusion_of :format, in: %w( mov avi ), message: "extension %{value} is not allowed"
-      #     validates_exclusion_of :password, in: ->(person) { [person.username, person.first_name] },
-      #                            message: 'should not be the same as your username or first name'
-      #     validates_exclusion_of :karma, in: :reserved_karmas
-      #   end
-      #
-      # Configuration options:
-      # * <tt>:in</tt> - An enumerable object of items that the value shouldn't
-      #   be part of. This can be supplied as a proc, lambda or symbol which returns an
-      #   enumerable. If the enumerable is a numerical, time or datetime range the test
-      #   is performed with <tt>Range#cover?</tt>, otherwise with <tt>include?</tt>. When
-      #   using a proc or lambda the instance under validation is passed as an argument.
-      # * <tt>:within</tt> - A synonym(or alias) for <tt>:in</tt>
-      #   <tt>Range#cover?</tt>, otherwise with <tt>include?</tt>.
-      # * <tt>:message</tt> - Specifies a custom error message (default is: "is
-      #   reserved").
-      #
-      # There is also a list of default options supported by every validator:
-      # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See <tt>ActiveModel::Validations#validates</tt> for more information
-      def validates_exclusion_of(*attr_names)
-        validates_with ExclusionValidator, _merge_attributes(attr_names)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/activemodel-5.2.3/lib/active_model/validations/format.rb

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  module Validations
-    class FormatValidator < EachValidator # :nodoc:
-      def validate_each(record, attribute, value)
-        if options[:with]
-          regexp = option_call(record, :with)
-          record_error(record, attribute, :with, value) if value.to_s !~ regexp
-        elsif options[:without]
-          regexp = option_call(record, :without)
-          record_error(record, attribute, :without, value) if regexp.match?(value.to_s)
-        end
-      end
-
-      def check_validity!
-        unless options.include?(:with) ^ options.include?(:without)  # ^ == xor, or "exclusive or"
-          raise ArgumentError, "Either :with or :without must be supplied (but not both)"
-        end
-
-        check_options_validity :with
-        check_options_validity :without
-      end
-
-      private
-
-        def option_call(record, name)
-          option = options[name]
-          option.respond_to?(:call) ? option.call(record) : option
-        end
-
-        def record_error(record, attribute, name, value)
-          record.errors.add(attribute, :invalid, options.except(name).merge!(value: value))
-        end
-
-        def check_options_validity(name)
-          if option = options[name]
-            if option.is_a?(Regexp)
-              if options[:multiline] != true && regexp_using_multiline_anchors?(option)
-                raise ArgumentError, "The provided regular expression is using multiline anchors (^ or $), " \
-                "which may present a security risk. Did you mean to use \\A and \\z, or forgot to add the " \
-                ":multiline => true option?"
-              end
-            elsif !option.respond_to?(:call)
-              raise ArgumentError, "A regular expression or a proc or lambda must be supplied as :#{name}"
-            end
-          end
-        end
-
-        def regexp_using_multiline_anchors?(regexp)
-          source = regexp.source
-          source.start_with?("^") || (source.end_with?("$") && !source.end_with?("\\$"))
-        end
-    end
-
-    module HelperMethods
-      # Validates whether the value of the specified attribute is of the correct
-      # form, going by the regular expression provided. You can require that the
-      # attribute matches the regular expression:
-      #
-      #   class Person < ActiveRecord::Base
-      #     validates_format_of :email, with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i, on: :create
-      #   end
-      #
-      # Alternatively, you can require that the specified attribute does _not_
-      # match the regular expression:
-      #
-      #   class Person < ActiveRecord::Base
-      #     validates_format_of :email, without: /NOSPAM/
-      #   end
-      #
-      # You can also provide a proc or lambda which will determine the regular
-      # expression that will be used to validate the attribute.
-      #
-      #   class Person < ActiveRecord::Base
-      #     # Admin can have number as a first letter in their screen name
-      #     validates_format_of :screen_name,
-      #                         with: ->(person) { person.admin? ? /\A[a-z0-9][a-z0-9_\-]*\z/i : /\A[a-z][a-z0-9_\-]*\z/i }
-      #   end
-      #
-      # Note: use <tt>\A</tt> and <tt>\z</tt> to match the start and end of the
-      # string, <tt>^</tt> and <tt>$</tt> match the start/end of a line.
-      #
-      # Due to frequent misuse of <tt>^</tt> and <tt>$</tt>, you need to pass
-      # the <tt>multiline: true</tt> option in case you use any of these two
-      # anchors in the provided regular expression. In most cases, you should be
-      # using <tt>\A</tt> and <tt>\z</tt>.
-      #
-      # You must pass either <tt>:with</tt> or <tt>:without</tt> as an option.
-      # In addition, both must be a regular expression or a proc or lambda, or
-      # else an exception will be raised.
-      #
-      # Configuration options:
-      # * <tt>:message</tt> - A custom error message (default is: "is invalid").
-      # * <tt>:with</tt> - Regular expression that if the attribute matches will
-      #   result in a successful validation. This can be provided as a proc or
-      #   lambda returning regular expression which will be called at runtime.
-      # * <tt>:without</tt> - Regular expression that if the attribute does not
-      #   match will result in a successful validation. This can be provided as
-      #   a proc or lambda returning regular expression which will be called at
-      #   runtime.
-      # * <tt>:multiline</tt> - Set to true if your regular expression contains
-      #   anchors that match the beginning or end of lines as opposed to the
-      #   beginning or end of the string. These anchors are <tt>^</tt> and <tt>$</tt>.
-      #
-      # There is also a list of default options supported by every validator:
-      # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See <tt>ActiveModel::Validations#validates</tt> for more information
-      def validates_format_of(*attr_names)
-        validates_with FormatValidator, _merge_attributes(attr_names)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/activemodel-5.2.3/lib/active_model/validations/inclusion.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require "active_model/validations/clusivity"
-
-module ActiveModel
-  module Validations
-    class InclusionValidator < EachValidator # :nodoc:
-      include Clusivity
-
-      def validate_each(record, attribute, value)
-        unless include?(record, value)
-          record.errors.add(attribute, :inclusion, options.except(:in, :within).merge!(value: value))
-        end
-      end
-    end
-
-    module HelperMethods
-      # Validates whether the value of the specified attribute is available in a
-      # particular enumerable object.
-      #
-      #   class Person < ActiveRecord::Base
-      #     validates_inclusion_of :gender, in: %w( m f )
-      #     validates_inclusion_of :age, in: 0..99
-      #     validates_inclusion_of :format, in: %w( jpg gif png ), message: "extension %{value} is not included in the list"
-      #     validates_inclusion_of :states, in: ->(person) { STATES[person.country] }
-      #     validates_inclusion_of :karma, in: :available_karmas
-      #   end
-      #
-      # Configuration options:
-      # * <tt>:in</tt> - An enumerable object of available items. This can be
-      #   supplied as a proc, lambda or symbol which returns an enumerable. If the
-      #   enumerable is a numerical, time or datetime range the test is performed
-      #   with <tt>Range#cover?</tt>, otherwise with <tt>include?</tt>. When using
-      #   a proc or lambda the instance under validation is passed as an argument.
-      # * <tt>:within</tt> - A synonym(or alias) for <tt>:in</tt>
-      # * <tt>:message</tt> - Specifies a custom error message (default is: "is
-      #   not included in the list").
-      #
-      # There is also a list of default options supported by every validator:
-      # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See <tt>ActiveModel::Validations#validates</tt> for more information
-      def validates_inclusion_of(*attr_names)
-        validates_with InclusionValidator, _merge_attributes(attr_names)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/activemodel-5.2.3/lib/active_model/validations/length.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  module Validations
-    class LengthValidator < EachValidator # :nodoc:
-      MESSAGES  = { is: :wrong_length, minimum: :too_short, maximum: :too_long }.freeze
-      CHECKS    = { is: :==, minimum: :>=, maximum: :<= }.freeze
-
-      RESERVED_OPTIONS = [:minimum, :maximum, :within, :is, :too_short, :too_long]
-
-      def initialize(options)
-        if range = (options.delete(:in) || options.delete(:within))
-          raise ArgumentError, ":in and :within must be a Range" unless range.is_a?(Range)
-          options[:minimum], options[:maximum] = range.min, range.max
-        end
-
-        if options[:allow_blank] == false && options[:minimum].nil? && options[:is].nil?
-          options[:minimum] = 1
-        end
-
-        super
-      end
-
-      def check_validity!
-        keys = CHECKS.keys & options.keys
-
-        if keys.empty?
-          raise ArgumentError, "Range unspecified. Specify the :in, :within, :maximum, :minimum, or :is option."
-        end
-
-        keys.each do |key|
-          value = options[key]
-
-          unless (value.is_a?(Integer) && value >= 0) || value == Float::INFINITY || value.is_a?(Symbol) || value.is_a?(Proc)
-            raise ArgumentError, ":#{key} must be a nonnegative Integer, Infinity, Symbol, or Proc"
-          end
-        end
-      end
-
-      def validate_each(record, attribute, value)
-        value_length = value.respond_to?(:length) ? value.length : value.to_s.length
-        errors_options = options.except(*RESERVED_OPTIONS)
-
-        CHECKS.each do |key, validity_check|
-          next unless check_value = options[key]
-
-          if !value.nil? || skip_nil_check?(key)
-            case check_value
-            when Proc
-              check_value = check_value.call(record)
-            when Symbol
-              check_value = record.send(check_value)
-            end
-            next if value_length.send(validity_check, check_value)
-          end
-
-          errors_options[:count] = check_value
-
-          default_message = options[MESSAGES[key]]
-          errors_options[:message] ||= default_message if default_message
-
-          record.errors.add(attribute, MESSAGES[key], errors_options)
-        end
-      end
-
-      private
-        def skip_nil_check?(key)
-          key == :maximum && options[:allow_nil].nil? && options[:allow_blank].nil?
-        end
-    end
-
-    module HelperMethods
-      # Validates that the specified attributes match the length restrictions
-      # supplied. Only one constraint option can be used at a time apart from
-      # +:minimum+ and +:maximum+ that can be combined together:
-      #
-      #   class Person < ActiveRecord::Base
-      #     validates_length_of :first_name, maximum: 30
-      #     validates_length_of :last_name, maximum: 30, message: "less than 30 if you don't mind"
-      #     validates_length_of :fax, in: 7..32, allow_nil: true
-      #     validates_length_of :phone, in: 7..32, allow_blank: true
-      #     validates_length_of :user_name, within: 6..20, too_long: 'pick a shorter name', too_short: 'pick a longer name'
-      #     validates_length_of :zip_code, minimum: 5, too_short: 'please enter at least 5 characters'
-      #     validates_length_of :smurf_leader, is: 4, message: "papa is spelled with 4 characters... don't play me."
-      #     validates_length_of :words_in_essay, minimum: 100, too_short: 'Your essay must be at least 100 words.'
-      #
-      #     private
-      #
-      #     def words_in_essay
-      #       essay.scan(/\w+/)
-      #     end
-      #   end
-      #
-      # Constraint options:
-      #
-      # * <tt>:minimum</tt> - The minimum size of the attribute.
-      # * <tt>:maximum</tt> - The maximum size of the attribute. Allows +nil+ by
-      #   default if not used with +:minimum+.
-      # * <tt>:is</tt> - The exact size of the attribute.
-      # * <tt>:within</tt> - A range specifying the minimum and maximum size of
-      #   the attribute.
-      # * <tt>:in</tt> - A synonym (or alias) for <tt>:within</tt>.
-      #
-      # Other options:
-      #
-      # * <tt>:allow_nil</tt> - Attribute may be +nil+; skip validation.
-      # * <tt>:allow_blank</tt> - Attribute may be blank; skip validation.
-      # * <tt>:too_long</tt> - The error message if the attribute goes over the
-      #   maximum (default is: "is too long (maximum is %{count} characters)").
-      # * <tt>:too_short</tt> - The error message if the attribute goes under the
-      #   minimum (default is: "is too short (minimum is %{count} characters)").
-      # * <tt>:wrong_length</tt> - The error message if using the <tt>:is</tt>
-      #   method and the attribute is the wrong size (default is: "is the wrong
-      #   length (should be %{count} characters)").
-      # * <tt>:message</tt> - The error message to use for a <tt>:minimum</tt>,
-      #   <tt>:maximum</tt>, or <tt>:is</tt> violation. An alias of the appropriate
-      #   <tt>too_long</tt>/<tt>too_short</tt>/<tt>wrong_length</tt> message.
-      #
-      # There is also a list of default options supported by every validator:
-      # +:if+, +:unless+, +:on+ and +:strict+.
-      # See <tt>ActiveModel::Validations#validates</tt> for more information
-      def validates_length_of(*attr_names)
-        validates_with LengthValidator, _merge_attributes(attr_names)
-      end
-
-      alias_method :validates_size_of, :validates_length_of
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/activemodel-5.2.3/lib/active_model/validations/numericality.rb

@@ -1,189 +0,0 @@
-# frozen_string_literal: true
-
-require "bigdecimal/util"
-
-module ActiveModel
-  module Validations
-    class NumericalityValidator < EachValidator # :nodoc:
-      CHECKS = { greater_than: :>, greater_than_or_equal_to: :>=,
-                 equal_to: :==, less_than: :<, less_than_or_equal_to: :<=,
-                 odd: :odd?, even: :even?, other_than: :!= }.freeze
-
-      RESERVED_OPTIONS = CHECKS.keys + [:only_integer]
-
-      INTEGER_REGEX = /\A[+-]?\d+\z/
-
-      def check_validity!
-        keys = CHECKS.keys - [:odd, :even]
-        options.slice(*keys).each do |option, value|
-          unless value.is_a?(Numeric) || value.is_a?(Proc) || value.is_a?(Symbol)
-            raise ArgumentError, ":#{option} must be a number, a symbol or a proc"
-          end
-        end
-      end
-
-      def validate_each(record, attr_name, value)
-        came_from_user = :"#{attr_name}_came_from_user?"
-
-        if record.respond_to?(came_from_user)
-          if record.public_send(came_from_user)
-            raw_value = record.read_attribute_before_type_cast(attr_name)
-          elsif record.respond_to?(:read_attribute)
-            raw_value = record.read_attribute(attr_name)
-          end
-        else
-          before_type_cast = :"#{attr_name}_before_type_cast"
-          if record.respond_to?(before_type_cast)
-            raw_value = record.public_send(before_type_cast)
-          end
-        end
-        raw_value ||= value
-
-        if record_attribute_changed_in_place?(record, attr_name)
-          raw_value = value
-        end
-
-        unless is_number?(raw_value)
-          record.errors.add(attr_name, :not_a_number, filtered_options(raw_value))
-          return
-        end
-
-        if allow_only_integer?(record) && !is_integer?(raw_value)
-          record.errors.add(attr_name, :not_an_integer, filtered_options(raw_value))
-          return
-        end
-
-        value = parse_as_number(raw_value)
-
-        options.slice(*CHECKS.keys).each do |option, option_value|
-          case option
-          when :odd, :even
-            unless value.to_i.send(CHECKS[option])
-              record.errors.add(attr_name, option, filtered_options(value))
-            end
-          else
-            case option_value
-            when Proc
-              option_value = option_value.call(record)
-            when Symbol
-              option_value = record.send(option_value)
-            end
-
-            option_value = parse_as_number(option_value)
-
-            unless value.send(CHECKS[option], option_value)
-              record.errors.add(attr_name, option, filtered_options(value).merge!(count: option_value))
-            end
-          end
-        end
-      end
-
-    private
-
-      def is_number?(raw_value)
-        !parse_as_number(raw_value).nil?
-      rescue ArgumentError, TypeError
-        false
-      end
-
-      def parse_as_number(raw_value)
-        if raw_value.is_a?(Float)
-          raw_value.to_d
-        elsif raw_value.is_a?(Numeric)
-          raw_value
-        elsif is_integer?(raw_value)
-          raw_value.to_i
-        elsif !is_hexadecimal_literal?(raw_value)
-          Kernel.Float(raw_value).to_d
-        end
-      end
-
-      def is_integer?(raw_value)
-        INTEGER_REGEX === raw_value.to_s
-      end
-
-      def is_hexadecimal_literal?(raw_value)
-        /\A0[xX]/ === raw_value.to_s
-      end
-
-      def filtered_options(value)
-        filtered = options.except(*RESERVED_OPTIONS)
-        filtered[:value] = value
-        filtered
-      end
-
-      def allow_only_integer?(record)
-        case options[:only_integer]
-        when Symbol
-          record.send(options[:only_integer])
-        when Proc
-          options[:only_integer].call(record)
-        else
-          options[:only_integer]
-        end
-      end
-
-      def record_attribute_changed_in_place?(record, attr_name)
-        record.respond_to?(:attribute_changed_in_place?) &&
-          record.attribute_changed_in_place?(attr_name.to_s)
-      end
-    end
-
-    module HelperMethods
-      # Validates whether the value of the specified attribute is numeric by
-      # trying to convert it to a float with Kernel.Float (if <tt>only_integer</tt>
-      # is +false+) or applying it to the regular expression <tt>/\A[\+\-]?\d+\z/</tt>
-      # (if <tt>only_integer</tt> is set to +true+).
-      #
-      #   class Person < ActiveRecord::Base
-      #     validates_numericality_of :value, on: :create
-      #   end
-      #
-      # Configuration options:
-      # * <tt>:message</tt> - A custom error message (default is: "is not a number").
-      # * <tt>:only_integer</tt> - Specifies whether the value has to be an
-      #   integer, e.g. an integral value (default is +false+).
-      # * <tt>:allow_nil</tt> - Skip validation if attribute is +nil+ (default is
-      #   +false+). Notice that for Integer and Float columns empty strings are
-      #   converted to +nil+.
-      # * <tt>:greater_than</tt> - Specifies the value must be greater than the
-      #   supplied value.
-      # * <tt>:greater_than_or_equal_to</tt> - Specifies the value must be
-      #   greater than or equal the supplied value.
-      # * <tt>:equal_to</tt> - Specifies the value must be equal to the supplied
-      #   value.
-      # * <tt>:less_than</tt> - Specifies the value must be less than the
-      #   supplied value.
-      # * <tt>:less_than_or_equal_to</tt> - Specifies the value must be less
-      #   than or equal the supplied value.
-      # * <tt>:other_than</tt> - Specifies the value must be other than the
-      #   supplied value.
-      # * <tt>:odd</tt> - Specifies the value must be an odd number.
-      # * <tt>:even</tt> - Specifies the value must be an even number.
-      #
-      # There is also a list of default options supported by every validator:
-      # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+ .
-      # See <tt>ActiveModel::Validations#validates</tt> for more information
-      #
-      # The following checks can also be supplied with a proc or a symbol which
-      # corresponds to a method:
-      #
-      # * <tt>:greater_than</tt>
-      # * <tt>:greater_than_or_equal_to</tt>
-      # * <tt>:equal_to</tt>
-      # * <tt>:less_than</tt>
-      # * <tt>:less_than_or_equal_to</tt>
-      # * <tt>:only_integer</tt>
-      #
-      # For example:
-      #
-      #   class Person < ActiveRecord::Base
-      #     validates_numericality_of :width, less_than: ->(person) { person.height }
-      #     validates_numericality_of :width, greater_than: :minimum_weight
-      #   end
-      def validates_numericality_of(*attr_names)
-        validates_with NumericalityValidator, _merge_attributes(attr_names)
-      end
-    end
-  end
-end