activemodel 5.2.7.1 → 6.1.4.6

data/lib/active_model/validations/numericality.rb

@@ -13,6 +13,8 @@ module ActiveModel
 
       INTEGER_REGEX = /\A[+-]?\d+\z/
 
+      HEXADECIMAL_REGEX = /\A[+-]?0[xX]/
+
       def check_validity!
         keys = CHECKS.keys - [:odd, :even]
         options.slice(*keys).each do |option, value|
@@ -22,44 +24,24 @@ module ActiveModel
         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))
+      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?(raw_value)
-          record.errors.add(attr_name, :not_an_integer, filtered_options(raw_value))
+        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(raw_value)
+        value = parse_as_number(value, precision, scale)
 
         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))
+            unless value.to_i.public_send(CHECKS[option])
+              record.errors.add(attr_name, option, **filtered_options(value))
             end
           else
             case option_value
@@ -69,41 +51,50 @@ module ActiveModel
               option_value = record.send(option_value)
             end
 
-            option_value = parse_as_number(option_value)
+            option_value = parse_as_number(option_value, precision, scale)
 
-            unless value.send(CHECKS[option], option_value)
-              record.errors.add(attr_name, option, filtered_options(value).merge!(count: option_value))
+            unless value.public_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)
+      def parse_as_number(raw_value, precision, scale)
         if raw_value.is_a?(Float)
-          raw_value.to_d
+          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)
-          Kernel.Float(raw_value).to_d
+          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)
+        !parse_as_number(raw_value, precision, scale).nil?
+      rescue ArgumentError, TypeError
+        false
+      end
+
       def is_integer?(raw_value)
-        INTEGER_REGEX === raw_value.to_s
+        INTEGER_REGEX.match?(raw_value.to_s)
       end
 
       def is_hexadecimal_literal?(raw_value)
-        /\A0[xX]/ === raw_value.to_s
+        HEXADECIMAL_REGEX.match?(raw_value.to_s)
       end
 
       def filtered_options(value)
@@ -123,6 +114,27 @@ module ActiveModel
         end
       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)
@@ -133,7 +145,8 @@ module ActiveModel
       # 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+).
+      # (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
@@ -174,6 +187,7 @@ module ActiveModel
       # * <tt>:less_than</tt>
       # * <tt>:less_than_or_equal_to</tt>
       # * <tt>:only_integer</tt>
+      # * <tt>:other_than</tt>
       #
       # For example:
       #

data/lib/active_model/validations/presence.rb

@@ -4,7 +4,7 @@ module ActiveModel
   module Validations
     class PresenceValidator < EachValidator # :nodoc:
       def validate_each(record, attr_name, value)
-        record.errors.add(attr_name, :blank, options) if value.blank?
+        record.errors.add(attr_name, :blank, **options) if value.blank?
       end
     end
 

data/lib/active_model/validations/validates.rb

@@ -12,6 +12,7 @@ module ActiveModel
       #
       # Examples of using the default rails validators:
       #
+      #   validates :username, absence: true
       #   validates :terms, acceptance: true
       #   validates :password, confirmation: true
       #   validates :username, exclusion: { in: %w(admin superuser) }
@@ -27,7 +28,7 @@ module ActiveModel
       #   class EmailValidator < ActiveModel::EachValidator
       #     def validate_each(record, attribute, value)
       #       record.errors.add attribute, (options[:message] || "is not an email") unless
-      #         value =~ /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i
+      #         /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i.match?(value)
       #     end
       #   end
       #
@@ -47,7 +48,7 @@ module ActiveModel
       #
       #     class TitleValidator < ActiveModel::EachValidator
       #       def validate_each(record, attribute, value)
-      #         record.errors.add attribute, "must start with 'the'" unless value =~ /\Athe/i
+      #         record.errors.add attribute, "must start with 'the'" unless /\Athe/i.match?(value)
       #       end
       #     end
       #
@@ -63,7 +64,7 @@ module ActiveModel
       # and strings in shortcut form.
       #
       #   validates :email, format: /@/
-      #   validates :gender, inclusion: %w(male female)
+      #   validates :role, inclusion: %w(admin contributor)
       #   validates :password, length: 6..20
       #
       # When using shortcut form, ranges and arrays are passed to your
@@ -112,15 +113,16 @@ module ActiveModel
         defaults[:attributes] = attributes
 
         validations.each do |key, options|
-          next unless options
           key = "#{key.to_s.camelize}Validator"
 
           begin
-            validator = key.include?("::".freeze) ? key.constantize : const_get(key)
+            validator = key.include?("::") ? key.constantize : const_get(key)
           rescue NameError
             raise ArgumentError, "Unknown validator: '#{key}'"
           end
 
+          next unless options
+
           validates_with(validator, defaults.merge(_parse_validates_options(options)))
         end
       end
@@ -150,7 +152,6 @@ module ActiveModel
       end
 
     private
-
       # When creating custom validators, it might be useful to be able to specify
       # additional default keys. This can be done by overwriting this method.
       def _validates_default_keys

data/lib/active_model/validations.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/array/extract_options"
-require "active_support/core_ext/hash/keys"
-require "active_support/core_ext/hash/except"
 
 module ActiveModel
   # == Active \Model \Validations
@@ -17,7 +15,7 @@ module ActiveModel
   #     attr_accessor :first_name, :last_name
   #
   #     validates_each :first_name, :last_name do |record, attr, value|
-  #       record.errors.add attr, 'starts with z.' if value.to_s[0] == ?z
+  #       record.errors.add attr, "starts with z." if value.start_with?("z")
   #     end
   #   end
   #
@@ -63,7 +61,7 @@ module ActiveModel
       #     attr_accessor :first_name, :last_name
       #
       #     validates_each :first_name, :last_name, allow_blank: true do |record, attr, value|
-      #       record.errors.add attr, 'starts with z.' if value.to_s[0] == ?z
+      #       record.errors.add attr, "starts with z." if value.start_with?("z")
       #     end
       #   end
       #
@@ -165,10 +163,10 @@ module ActiveModel
         if options.key?(:on)
           options = options.dup
           options[:on] = Array(options[:on])
-          options[:if] = Array(options[:if])
-          options[:if].unshift ->(o) {
-            !(options[:on] & Array(o.validation_context)).empty?
-          }
+          options[:if] = [
+            ->(o) { !(options[:on] & Array(o.validation_context)).empty? },
+            *options[:if]
+          ]
         end
 
         set_callback(:validate, *args, options, &block)
@@ -404,7 +402,6 @@ module ActiveModel
     alias :read_attribute_for_validation :send
 
   private
-
     def run_validations!
       _run_validate_callbacks
       errors.empty?

data/lib/active_model/validator.rb

@@ -85,12 +85,12 @@ module ActiveModel
   #
   # It can be useful to access the class that is using that validator when there are prerequisites such
   # as an +attr_accessor+ being present. This class is accessible via <tt>options[:class]</tt> in the constructor.
-  # To setup your validator override the constructor.
+  # To set up your validator override the constructor.
   #
   #   class MyValidator < ActiveModel::Validator
   #     def initialize(options={})
   #       super
-  #       options[:class].send :attr_accessor, :custom_attribute
+  #       options[:class].attr_accessor :custom_attribute
   #     end
   #   end
   class Validator
@@ -149,6 +149,7 @@ module ActiveModel
       attributes.each do |attribute|
         value = record.read_attribute_for_validation(attribute)
         next if (value.nil? && options[:allow_nil]) || (value.blank? && options[:allow_blank])
+        value = prepare_value_for_validation(value, record, attribute)
         validate_each(record, attribute, value)
       end
     end
@@ -164,6 +165,11 @@ module ActiveModel
     # +ArgumentError+ when invalid options are supplied.
     def check_validity!
     end
+
+    private
+      def prepare_value_for_validation(value, record, attr_name)
+        value
+      end
   end
 
   # +BlockValidator+ is a special +EachValidator+ which receives a block on initialization
@@ -175,7 +181,6 @@ module ActiveModel
     end
 
     private
-
       def validate_each(record, attribute, value)
         @block.call(record, attribute, value)
       end

data/lib/active_model.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #--
-# Copyright (c) 2004-2018 David Heinemeier Hansson
+# Copyright (c) 2004-2020 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -53,6 +53,7 @@ module ActiveModel
 
   eager_autoload do
     autoload :Errors
+    autoload :Error
     autoload :RangeError, "active_model/errors"
     autoload :StrictValidationFailed, "active_model/errors"
     autoload :UnknownAttributeError, "active_model/errors"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activemodel
 version: !ruby/object:Gem::Version
-  version: 5.2.7.1
+  version: 6.1.4.6
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-26 00:00:00.000000000 Z
+date: 2022-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.2.7.1
+        version: 6.1.4.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.2.7.1
+        version: 6.1.4.6
 description: A toolkit for building modeling frameworks like Active Record. Rich support
   for attributes, callbacks, validations, serialization, internationalization, and
   testing.
@@ -48,6 +48,7 @@ files:
 - lib/active_model/callbacks.rb
 - lib/active_model/conversion.rb
 - lib/active_model/dirty.rb
+- lib/active_model/error.rb
 - lib/active_model/errors.rb
 - lib/active_model/forbidden_attributes_protection.rb
 - lib/active_model/gem_version.rb
@@ -55,6 +56,7 @@ files:
 - lib/active_model/locale/en.yml
 - lib/active_model/model.rb
 - lib/active_model/naming.rb
+- lib/active_model/nested_error.rb
 - lib/active_model/railtie.rb
 - lib/active_model/secure_password.rb
 - lib/active_model/serialization.rb
@@ -97,12 +99,15 @@ files:
 - lib/active_model/validations/with.rb
 - lib/active_model/validator.rb
 - lib/active_model/version.rb
-homepage: http://rubyonrails.org
+homepage: https://rubyonrails.org
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://github.com/rails/rails/tree/v5.2.7.1/activemodel
-  changelog_uri: https://github.com/rails/rails/blob/v5.2.7.1/activemodel/CHANGELOG.md
+  bug_tracker_uri: https://github.com/rails/rails/issues
+  changelog_uri: https://github.com/rails/rails/blob/v6.1.4.6/activemodel/CHANGELOG.md
+  documentation_uri: https://api.rubyonrails.org/v6.1.4.6/
+  mailing_list_uri: https://discuss.rubyonrails.org/c/rubyonrails-talk
+  source_code_uri: https://github.com/rails/rails/tree/v6.1.4.6/activemodel
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -111,14 +116,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.2
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: A toolkit for building modeling frameworks (part of Rails).