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] 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) before_type_cast = :"#{attr_name}_before_type_cast" raw_value = record.send(before_type_cast) if record.respond_to?(before_type_cast) && record.send(before_type_cast) != value raw_value ||= value if record_attribute_changed_in_place?(record, attr_name) raw_value = value end return if options[:allow_nil] && raw_value.nil? 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 unless raw_value.is_a?(Numeric) value = parse_raw_value_as_a_number(raw_value) end 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 unless value.send(CHECKS[option], option_value) record.errors.add(attr_name, option, filtered_options(value).merge!(count: option_value)) end end end end protected def is_number?(raw_value) !parse_raw_value_as_a_number(raw_value).nil? rescue ArgumentError, TypeError false end def parse_raw_value_as_a_number(raw_value) Kernel.Float(raw_value) if raw_value !~ /\A0[xX]/ end def is_integer?(raw_value) /\A[+-]?\d+\z/ === 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 private 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 only_integer # is +false+) or applying it to the regular expression /\A[\+\-]?\d+\Z/ # (if only_integer is set to +true+). # # class Person < ActiveRecord::Base # validates_numericality_of :value, on: :create # end # # Configuration options: # * :message - A custom error message (default is: "is not a number"). # * :only_integer - Specifies whether the value has to be an # integer, e.g. an integral value (default is +false+). # * :allow_nil - Skip validation if attribute is +nil+ (default is # +false+). Notice that for fixnum and float columns empty strings are # converted to +nil+. # * :greater_than - Specifies the value must be greater than the # supplied value. # * :greater_than_or_equal_to - Specifies the value must be # greater than or equal the supplied value. # * :equal_to - Specifies the value must be equal to the supplied # value. # * :less_than - Specifies the value must be less than the # supplied value. # * :less_than_or_equal_to - Specifies the value must be less # than or equal the supplied value. # * :other_than - Specifies the value must be other than the # supplied value. # * :odd - Specifies the value must be an odd number. # * :even - 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 ActiveModel::Validation#validates for more information # # The following checks can also be supplied with a proc or a symbol which # corresponds to a method: # # * :greater_than # * :greater_than_or_equal_to # * :equal_to # * :less_than # * :less_than_or_equal_to # * :only_integer # # 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