Class: ActiveModel::Validations::NumericalityValidator

### Home Classes Methods

### In Files

- lib/active_model/validations/numericality.rb

### Parent

EachValidator

### Methods

- #check_validity!
- #filtered_options
- #parse_raw_value_as_a_number
- #parse_raw_value_as_an_integer
- #validate_each

### Class/Module Index

Quicksearch

- ActiveModel
- ActiveModel::AttributeMethods
- ActiveModel::AttributeMethods::ClassMethods
- ActiveModel::AttributeMethods::ClassMethods::AttributeMethodMatcher
- ActiveModel::BlockValidator
- ActiveModel::Callbacks
- ActiveModel::Conversion
- ActiveModel::Dirty
- ActiveModel::EachValidator
- ActiveModel::Errors
- ActiveModel::Lint
- ActiveModel::Lint::Tests
- ActiveModel::MassAssignmentSecurity
- ActiveModel::MassAssignmentSecurity::BlackList
- ActiveModel::MassAssignmentSecurity::ClassMethods
- ActiveModel::MassAssignmentSecurity::Error
- ActiveModel::MassAssignmentSecurity::LoggerSanitizer
- ActiveModel::MassAssignmentSecurity::PermissionSet
- ActiveModel::MassAssignmentSecurity::Sanitizer
- ActiveModel::MassAssignmentSecurity::StrictSanitizer
- ActiveModel::MassAssignmentSecurity::WhiteList
- ActiveModel::MissingAttributeError
- ActiveModel::Name
- ActiveModel::Naming
- ActiveModel::Observer
- ActiveModel::ObserverArray
- ActiveModel::Observing
- ActiveModel::Observing::ClassMethods
- ActiveModel::SecurePassword
- ActiveModel::SecurePassword::ClassMethods
- ActiveModel::SecurePassword::InstanceMethodsOnActivation
- ActiveModel::Serialization
- ActiveModel::Serializers
- ActiveModel::Serializers::JSON
- ActiveModel::Serializers::Xml
- ActiveModel::StrictValidationFailed
- ActiveModel::Translation
- ActiveModel::Validations
- ActiveModel::Validations::AcceptanceValidator
- ActiveModel::Validations::Callbacks
- ActiveModel::Validations::Callbacks::ClassMethods
- ActiveModel::Validations::ClassMethods
- ActiveModel::Validations::ConfirmationValidator
- ActiveModel::Validations::ExclusionValidator
- ActiveModel::Validations::FormatValidator
- ActiveModel::Validations::HelperMethods
- ActiveModel::Validations::InclusionValidator
- ActiveModel::Validations::LengthValidator
- ActiveModel::Validations::NumericalityValidator
- ActiveModel::Validations::PresenceValidator
- ActiveModel::Validations::WithValidator
- ActiveModel::Validator

No matching classes.

# ActiveModel::Validations::NumericalityValidator

### Constants

CHECKS
RESERVED_OPTIONS

### Public Instance Methods

check_validity!() click to toggle source

    # File lib/active_model/validations/numericality.rb, line 11
    def check_validity!
      keys = CHECKS.keys - [:odd, :even]
      options.slice(*keys).each do |option, value|
        next if 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

validate_each(record, attr_name, value) click to toggle source

    # File lib/active_model/validations/numericality.rb, line 19
    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.to_sym)
      raw_value ||= value

      return if options[:allow_nil] && raw_value.nil?

      unless value = parse_raw_value_as_a_number(raw_value)
        record.errors.add(attr_name, :not_a_number, filtered_options(raw_value))
        return
      end

      if options[:only_integer]
        unless value = parse_raw_value_as_an_integer(raw_value)
          record.errors.add(attr_name, :not_an_integer, filtered_options(raw_value))
          return
        end
      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
          option_value = option_value.call(record) if option_value.is_a?(Proc)
          option_value = record.send(option_value) if option_value.is_a?(Symbol)

          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 Instance Methods

filtered_options(value) click to toggle source

    # File lib/active_model/validations/numericality.rb, line 75
    def filtered_options(value)
      options.except(*RESERVED_OPTIONS).merge!(:value => value)
    end

parse_raw_value_as_a_number(raw_value) click to toggle source

    # File lib/active_model/validations/numericality.rb, line 58
    def parse_raw_value_as_a_number(raw_value)
      case raw_value
      when /\A0[xX]/
        nil
      else
        begin
          Kernel.Float(raw_value)
        rescue ArgumentError, TypeError
          nil
        end
      end
    end

parse_raw_value_as_an_integer(raw_value) click to toggle source

    # File lib/active_model/validations/numericality.rb, line 71
    def parse_raw_value_as_an_integer(raw_value)
      raw_value.to_i if raw_value.to_s =~ /\A[+-]?\d+\Z/
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.