omg-activemodel 8.0.0.alpha1

data/lib/active_model/validations/confirmation.rb

@@ -0,0 +1,80 @@
+# 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.public_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.attr_reader(*attributes.filter_map do |attribute|
+            :"#{attribute}_confirmation" unless klass.method_defined?(:"#{attribute}_confirmation")
+          end)
+
+          klass.attr_writer(*attributes.filter_map do |attribute|
+            :"#{attribute}_confirmation" unless klass.method_defined?(:"#{attribute}_confirmation=")
+          end)
+        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 ActiveModel::Validations::ClassMethods#validates for more information.
+      def validates_confirmation_of(*attr_names)
+        validates_with ConfirmationValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/active_model/validations/exclusion.rb

@@ -0,0 +1,49 @@
+# 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 ActiveModel::Validations::ClassMethods#validates for more information.
+      def validates_exclusion_of(*attr_names)
+        validates_with ExclusionValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/active_model/validations/format.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "active_model/validations/resolve_value"
+
+module ActiveModel
+  module Validations
+    class FormatValidator < EachValidator # :nodoc:
+      include ResolveValue
+
+      def validate_each(record, attribute, value)
+        if options[:with]
+          regexp = resolve_value(record, options[:with])
+          record_error(record, attribute, :with, value) unless regexp.match?(value.to_s)
+        elsif options[:without]
+          regexp = resolve_value(record, options[: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 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 ActiveModel::Validations::ClassMethods#validates for more information.
+      def validates_format_of(*attr_names)
+        validates_with FormatValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/active_model/validations/helper_methods.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Validations
+    module HelperMethods # :nodoc:
+      private
+        def _merge_attributes(attr_names)
+          options = attr_names.extract_options!.symbolize_keys
+          attr_names.flatten!
+          options[:attributes] = attr_names
+          options
+        end
+    end
+  end
+end

data/lib/active_model/validations/inclusion.rb

@@ -0,0 +1,47 @@
+# 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 :role, in: %w( admin contributor )
+      #     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 ActiveModel::Validations::ClassMethods#validates for more information.
+      def validates_inclusion_of(*attr_names)
+        validates_with InclusionValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/active_model/validations/length.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "active_model/validations/resolve_value"
+
+module ActiveModel
+  module Validations
+    class LengthValidator < EachValidator # :nodoc:
+      include ResolveValue
+
+      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] = range.min if range.begin
+          options[:maximum] = (range.exclude_end? ? range.end - 1 : range.end) if range.end
+        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 == -Float::INFINITY ||
+                  value.is_a?(Symbol) || value.is_a?(Proc)
+            raise ArgumentError, ":#{key} must be a non-negative 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)
+            check_value = resolve_value(record, check_value)
+            next if value_length.public_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 ActiveModel::Validations::ClassMethods#validates 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/lib/active_model/validations/numericality.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require "active_model/validations/comparability"
+require "active_model/validations/resolve_value"
+require "bigdecimal/util"
+
+module ActiveModel
+  module Validations
+    class NumericalityValidator < EachValidator # :nodoc:
+      include Comparability
+      include ResolveValue
+
+      RANGE_CHECKS = { in: :in? }
+      NUMBER_CHECKS = { odd: :odd?, even: :even? }
+
+      RESERVED_OPTIONS = COMPARE_CHECKS.keys + NUMBER_CHECKS.keys + RANGE_CHECKS.keys + [:only_integer, :only_numeric]
+
+      INTEGER_REGEX = /\A[+-]?\d+\z/
+
+      HEXADECIMAL_REGEX = /\A[+-]?0[xX]/
+
+      def check_validity!
+        options.slice(*COMPARE_CHECKS.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
+
+        options.slice(*RANGE_CHECKS.keys).each do |option, value|
+          unless value.is_a?(Range)
+            raise ArgumentError, ":#{option} must be a range"
+          end
+        end
+      end
+
+      def validate_each(record, attr_name, value, precision: Float::DIG, scale: nil)
+        unless is_number?(value, precision, scale)
+          record.errors.add(attr_name, :not_a_number, **filtered_options(value))
+          return
+        end
+
+        if allow_only_integer?(record) && !is_integer?(value)
+          record.errors.add(attr_name, :not_an_integer, **filtered_options(value))
+          return
+        end
+
+        value = parse_as_number(value, precision, scale)
+
+        options.slice(*RESERVED_OPTIONS).each do |option, option_value|
+          if NUMBER_CHECKS.include?(option)
+            unless value.to_i.public_send(NUMBER_CHECKS[option])
+              record.errors.add(attr_name, option, **filtered_options(value))
+            end
+          elsif RANGE_CHECKS.include?(option)
+            unless value.public_send(RANGE_CHECKS[option], option_value)
+              record.errors.add(attr_name, option, **filtered_options(value).merge!(count: option_value))
+            end
+          elsif COMPARE_CHECKS.include?(option)
+            option_value = option_as_number(record, option_value, precision, scale)
+            unless value.public_send(COMPARE_CHECKS[option], option_value)
+              record.errors.add(attr_name, option, **filtered_options(value).merge!(count: option_value))
+            end
+          end
+        end
+      end
+
+    private
+      def option_as_number(record, option_value, precision, scale)
+        parse_as_number(resolve_value(record, option_value), precision, scale)
+      end
+
+      def parse_as_number(raw_value, precision, scale)
+        if raw_value.is_a?(Float)
+          parse_float(raw_value, precision, scale)
+        elsif raw_value.is_a?(BigDecimal)
+          round(raw_value, scale)
+        elsif raw_value.is_a?(Numeric)
+          raw_value
+        elsif is_integer?(raw_value)
+          raw_value.to_i
+        elsif !is_hexadecimal_literal?(raw_value)
+          parse_float(Kernel.Float(raw_value), precision, scale)
+        end
+      end
+
+      def parse_float(raw_value, precision, scale)
+        round(raw_value, scale).to_d(precision)
+      end
+
+      def round(raw_value, scale)
+        scale ? raw_value.round(scale) : raw_value
+      end
+
+      def is_number?(raw_value, precision, scale)
+        if options[:only_numeric] && !raw_value.is_a?(Numeric)
+          return false
+        end
+
+        !parse_as_number(raw_value, precision, scale).nil?
+      rescue ArgumentError, TypeError
+        false
+      end
+
+      def is_integer?(raw_value)
+        INTEGER_REGEX.match?(raw_value.to_s)
+      end
+
+      def is_hexadecimal_literal?(raw_value)
+        HEXADECIMAL_REGEX.match?(raw_value.to_s)
+      end
+
+      def filtered_options(value)
+        filtered = options.except(*RESERVED_OPTIONS)
+        filtered[:value] = value
+        filtered
+      end
+
+      def allow_only_integer?(record)
+        resolve_value(record, options[:only_integer])
+      end
+
+      def prepare_value_for_validation(value, record, attr_name)
+        return value if record_attribute_changed_in_place?(record, attr_name)
+
+        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.public_send(:"#{attr_name}_before_type_cast")
+          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
+      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+). Precision of +Kernel.Float+ values are guaranteed up to 15
+      # digits.
+      #
+      #   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 (default is +false+).
+      # * <tt>:only_numeric</tt> - Specifies whether the value has to be an
+      #   instance of Numeric (default is +false+). The default behavior is to
+      #   attempt parsing the value if it is a String.
+      # * <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. The default error message for this option is _"must be
+      #   greater than %{count}"_.
+      # * <tt>:greater_than_or_equal_to</tt> - Specifies the value must be
+      #   greater than or equal the supplied value. The default error message
+      #   for this option is _"must be greater than or equal to %{count}"_.
+      # * <tt>:equal_to</tt> - Specifies the value must be equal to the supplied
+      #   value. The default error message for this option is _"must be equal to
+      #   %{count}"_.
+      # * <tt>:less_than</tt> - Specifies the value must be less than the
+      #   supplied value. The default error message for this option is _"must be
+      #   less than %{count}"_.
+      # * <tt>:less_than_or_equal_to</tt> - Specifies the value must be less
+      #   than or equal the supplied value. The default error message for this
+      #   option is _"must be less than or equal to %{count}"_.
+      # * <tt>:other_than</tt> - Specifies the value must be other than the
+      #   supplied value. The default error message for this option is _"must be
+      #   other than %{count}"_.
+      # * <tt>:odd</tt> - Specifies the value must be an odd number. The default
+      #   error message for this option is _"must be odd"_.
+      # * <tt>:even</tt> - Specifies the value must be an even number. The
+      #   default error message for this option is _"must be even"_.
+      # * <tt>:in</tt> - Check that the value is within a range. The default
+      #   error message for this option is _"must be in %{count}"_.
+      #
+      # There is also a list of default options supported by every validator:
+      # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+ .
+      # See ActiveModel::Validations::ClassMethods#validates 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>
+      # * <tt>:other_than</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