activerecord 6.0.0 → 6.1.3

data/lib/active_record/attribute_methods/dirty.rb

@@ -49,7 +49,7 @@ module ActiveRecord
       # +to+ When passed, this method will return false unless the value was
       # changed to the given value
       def saved_change_to_attribute?(attr_name, **options)
-        mutations_before_last_save.changed?(attr_name.to_s, options)
+        mutations_before_last_save.changed?(attr_name.to_s, **options)
       end
 
       # Returns the change to an attribute during the last save. If the
@@ -89,7 +89,7 @@ module ActiveRecord
       # This method is useful in validations and before callbacks to determine
       # if the next call to +save+ will change a particular attribute. It can be
       # invoked as +will_save_change_to_name?+ instead of
-      # <tt>will_save_change_to_attribute("name")</tt>.
+      # <tt>will_save_change_to_attribute?("name")</tt>.
       #
       # ==== Options
       #
@@ -99,7 +99,7 @@ module ActiveRecord
       # +to+ When passed, this method will return false unless the value will be
       # changed to the given value
       def will_save_change_to_attribute?(attr_name, **options)
-        mutations_from_database.changed?(attr_name.to_s, options)
+        mutations_from_database.changed?(attr_name.to_s, **options)
       end
 
       # Returns the change to an attribute that will be persisted during the
@@ -156,16 +156,6 @@ module ActiveRecord
       end
 
       private
-        def mutations_from_database
-          sync_with_transaction_state if @transaction_state&.finalized?
-          super
-        end
-
-        def mutations_before_last_save
-          sync_with_transaction_state if @transaction_state&.finalized?
-          super
-        end
-
         def write_attribute_without_type_cast(attr_name, value)
           result = super
           clear_attribute_change(attr_name)

data/lib/active_record/attribute_methods/primary_key.rb

@@ -31,7 +31,7 @@ module ActiveRecord
 
       # Returns the primary key column's value before type cast.
       def id_before_type_cast
-        read_attribute_before_type_cast(@primary_key)
+        attribute_before_type_cast(@primary_key)
       end
 
       # Returns the primary key column's previous value.
@@ -44,14 +44,17 @@ module ActiveRecord
         attribute_in_database(@primary_key)
       end
 
-      private
+      def id_for_database # :nodoc:
+        @attributes[@primary_key].value_for_database
+      end
 
+      private
         def attribute_method?(attr_name)
           attr_name == "id" || super
         end
 
         module ClassMethods
-          ID_ATTRIBUTE_METHODS = %w(id id= id? id_before_type_cast id_was id_in_database).to_set
+          ID_ATTRIBUTE_METHODS = %w(id id= id? id_before_type_cast id_was id_in_database id_for_database).to_set
 
           def instance_method_already_implemented?(method_name)
             super || primary_key && ID_ATTRIBUTE_METHODS.include?(method_name)
@@ -120,7 +123,6 @@ module ActiveRecord
           end
 
           private
-
             def suppress_composite_primary_key(pk)
               return pk unless pk.is_a?(Array)
 

data/lib/active_record/attribute_methods/query.rb

@@ -17,7 +17,7 @@ module ActiveRecord
         when false, nil  then false
         else
           if !type_for_attribute(attr_name) { false }
-            if Numeric === value || value !~ /[^0-9]/
+            if Numeric === value || !value.match?(/[^0-9]/)
               !value.to_i.zero?
             else
               return false if ActiveModel::Type::Boolean::FALSE_VALUES.include?(value)
@@ -31,11 +31,8 @@ module ActiveRecord
         end
       end
 
-      private
-        # Dispatch target for <tt>*?</tt> attribute methods.
-        def attribute?(attribute_name)
-          query_attribute(attribute_name)
-        end
+      alias :attribute? :query_attribute
+      private :attribute?
     end
   end
 end

data/lib/active_record/attribute_methods/read.rb

@@ -7,17 +7,14 @@ module ActiveRecord
 
       module ClassMethods # :nodoc:
         private
-
-          def define_method_attribute(name)
+          def define_method_attribute(name, owner:)
             ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
-              generated_attribute_methods, name
+              owner, name
             ) do |temp_method_name, attr_name_expr|
-              generated_attribute_methods.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-                def #{temp_method_name}
-                  name = #{attr_name_expr}
-                  _read_attribute(name) { |n| missing_attribute(n, caller) }
-                end
-              RUBY
+              owner <<
+                "def #{temp_method_name}" <<
+                "  _read_attribute(#{attr_name_expr}) { |n| missing_attribute(n, caller) }" <<
+                "end"
             end
           end
       end
@@ -30,14 +27,13 @@ module ActiveRecord
         name = self.class.attribute_aliases[name] || name
 
         name = @primary_key if name == "id" && @primary_key
-        _read_attribute(name, &block)
+        @attributes.fetch_value(name, &block)
       end
 
       # This method exists to avoid the expensive primary_key check internally, without
       # breaking compatibility with the read_attribute API
       def _read_attribute(attr_name, &block) # :nodoc
-        sync_with_transaction_state if @transaction_state&.finalized?
-        @attributes.fetch_value(attr_name.to_s, &block)
+        @attributes.fetch_value(attr_name, &block)
       end
 
       alias :attribute :_read_attribute

data/lib/active_record/attribute_methods/serialization.rb

@@ -41,6 +41,12 @@ module ActiveRecord
         # * +class_name_or_coder+ - Optional, a coder object, which responds to +.load+ and +.dump+
         #   or a class name that the object type should be equal to.
         #
+        # ==== Options
+        #
+        # +default+ The default value to use when no value is provided. If this option
+        # is not passed, the previous default value (if any) will be used.
+        # Otherwise, the default will be +nil+.
+        #
         # ==== Example
         #
         #   # Serialize a preferences attribute.
@@ -57,7 +63,7 @@ module ActiveRecord
         #   class User < ActiveRecord::Base
         #     serialize :preferences, Hash
         #   end
-        def serialize(attr_name, class_name_or_coder = Object)
+        def serialize(attr_name, class_name_or_coder = Object, **options)
           # When ::JSON is used, force it to go through the Active Support JSON encoder
           # to ensure special objects (e.g. Active Record models) are dumped correctly
           # using the #as_json hook.
@@ -69,17 +75,16 @@ module ActiveRecord
             Coders::YAMLColumn.new(attr_name, class_name_or_coder)
           end
 
-          decorate_attribute_type(attr_name, :serialize) do |type|
-            if type_incompatible_with_serialize?(type, class_name_or_coder)
-              raise ColumnNotSerializableError.new(attr_name, type)
+          decorate_attribute_type(attr_name.to_s, **options) do |cast_type|
+            if type_incompatible_with_serialize?(cast_type, class_name_or_coder)
+              raise ColumnNotSerializableError.new(attr_name, cast_type)
             end
 
-            Type::Serialized.new(type, coder)
+            Type::Serialized.new(cast_type, coder)
           end
         end
 
         private
-
           def type_incompatible_with_serialize?(type, class_name)
             type.is_a?(ActiveRecord::Type::Json) && class_name == ::JSON ||
               type.respond_to?(:type_cast_array, true) && class_name == ::Array

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -1,9 +1,15 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/object/try"
+
 module ActiveRecord
   module AttributeMethods
     module TimeZoneConversion
       class TimeZoneConverter < DelegateClass(Type::Value) # :nodoc:
+        def self.new(subtype)
+          self === subtype ? subtype : super
+        end
+
         def deserialize(value)
           convert_time_to_time_zone(super)
         end
@@ -25,7 +31,6 @@ module ActiveRecord
         end
 
         private
-
           def convert_time_to_time_zone(value)
             return if value.nil?
 
@@ -63,22 +68,14 @@ module ActiveRecord
       end
 
       module ClassMethods # :nodoc:
-        private
-
-          def inherited(subclass)
-            super
-            # We need to apply this decorator here, rather than on module inclusion. The closure
-            # created by the matcher would otherwise evaluate for `ActiveRecord::Base`, not the
-            # sub class being decorated. As such, changes to `time_zone_aware_attributes`, or
-            # `skip_time_zone_conversion_for_attributes` would not be picked up.
-            subclass.class_eval do
-              matcher = ->(name, type) { create_time_zone_conversion_attribute?(name, type) }
-              decorate_matching_attribute_types(matcher, "_time_zone_conversion") do |type|
-                TimeZoneConverter.new(type)
-              end
-            end
+        def define_attribute(name, cast_type, **)
+          if create_time_zone_conversion_attribute?(name, cast_type)
+            cast_type = TimeZoneConverter.new(cast_type)
           end
+          super
+        end
 
+        private
           def create_time_zone_conversion_attribute?(name, cast_type)
             enabled_for_column = time_zone_aware_attributes &&
               !skip_time_zone_conversion_for_attributes.include?(name.to_sym)

data/lib/active_record/attribute_methods/write.rb

@@ -11,17 +11,14 @@ module ActiveRecord
 
       module ClassMethods # :nodoc:
         private
-
-          def define_method_attribute=(name)
+          def define_method_attribute=(name, owner:)
             ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
-              generated_attribute_methods, name, writer: true,
+              owner, name, writer: true,
             ) do |temp_method_name, attr_name_expr|
-              generated_attribute_methods.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-                def #{temp_method_name}(value)
-                  name = #{attr_name_expr}
-                  _write_attribute(name, value)
-                end
-              RUBY
+              owner <<
+                "def #{temp_method_name}(value)" <<
+                "  _write_attribute(#{attr_name_expr}, value)" <<
+                "end"
             end
           end
       end
@@ -34,27 +31,21 @@ module ActiveRecord
         name = self.class.attribute_aliases[name] || name
 
         name = @primary_key if name == "id" && @primary_key
-        _write_attribute(name, value)
+        @attributes.write_from_user(name, value)
       end
 
       # This method exists to avoid the expensive primary_key check internally, without
       # breaking compatibility with the write_attribute API
       def _write_attribute(attr_name, value) # :nodoc:
-        sync_with_transaction_state if @transaction_state&.finalized?
-        @attributes.write_from_user(attr_name.to_s, value)
-        value
+        @attributes.write_from_user(attr_name, value)
       end
 
+      alias :attribute= :_write_attribute
+      private :attribute=
+
       private
         def write_attribute_without_type_cast(attr_name, value)
-          sync_with_transaction_state if @transaction_state&.finalized?
-          @attributes.write_cast_value(attr_name.to_s, value)
-          value
-        end
-
-        # Dispatch target for <tt>*=</tt> attribute methods.
-        def attribute=(attribute_name, value)
-          _write_attribute(attribute_name, value)
+          @attributes.write_cast_value(attr_name, value)
         end
     end
   end

data/lib/active_record/attributes.rb

@@ -12,6 +12,9 @@ module ActiveRecord
     end
 
     module ClassMethods
+      ##
+      # :call-seq: attribute(name, cast_type = nil, **options)
+      #
       # Defines an attribute with a type on this model. It will override the
       # type of existing attributes if needed. This allows control over how
       # values are converted to and from SQL when assigned to a model. It also
@@ -170,7 +173,7 @@ module ActiveRecord
       #   class Money < Struct.new(:amount, :currency)
       #   end
       #
-      #   class MoneyType < Type::Value
+      #   class MoneyType < ActiveRecord::Type::Value
       #     def initialize(currency_converter:)
       #       @currency_converter = currency_converter
       #     end
@@ -205,13 +208,13 @@ module ActiveRecord
       # tracking is performed. The methods +changed?+ and +changed_in_place?+
       # will be called from ActiveModel::Dirty. See the documentation for those
       # methods in ActiveModel::Type::Value for more details.
-      def attribute(name, cast_type = Type::Value.new, **options)
+      def attribute(name, cast_type = nil, **options, &block)
         name = name.to_s
         reload_schema_from_cache
 
         self.attributes_to_define_after_schema_loads =
           attributes_to_define_after_schema_loads.merge(
-            name => [cast_type, options]
+            name => [cast_type || block, options]
           )
       end
 
@@ -246,16 +249,11 @@ module ActiveRecord
       def load_schema! # :nodoc:
         super
         attributes_to_define_after_schema_loads.each do |name, (type, options)|
-          if type.is_a?(Symbol)
-            type = ActiveRecord::Type.lookup(type, **options.except(:default))
-          end
-
-          define_attribute(name, type, **options.slice(:default))
+          define_attribute(name, _lookup_cast_type(name, type, options), **options.slice(:default))
         end
       end
 
       private
-
         NO_DEFAULT_PROVIDED = Object.new # :nodoc:
         private_constant :NO_DEFAULT_PROVIDED
 
@@ -274,6 +272,32 @@ module ActiveRecord
           end
           _default_attributes[name] = default_attribute
         end
+
+        def decorate_attribute_type(attr_name, **default)
+          type, options = attributes_to_define_after_schema_loads[attr_name]
+
+          default.with_defaults!(default: options[:default]) if options&.key?(:default)
+
+          attribute(attr_name, **default) do |cast_type|
+            if type && !type.is_a?(Proc)
+              cast_type = _lookup_cast_type(attr_name, type, options)
+            end
+
+            yield cast_type
+          end
+        end
+
+        def _lookup_cast_type(name, type, options)
+          case type
+          when Symbol
+            adapter_name = ActiveRecord::Type.adapter_name_from(self)
+            ActiveRecord::Type.lookup(type, **options.except(:default), adapter: adapter_name)
+          when Proc
+            type[type_for_attribute(name)]
+          else
+            type || type_for_attribute(name)
+          end
+        end
     end
   end
 end

data/lib/active_record/autosave_association.rb

@@ -29,9 +29,9 @@ module ActiveRecord
   # == Callbacks
   #
   # Association with autosave option defines several callbacks on your
-  # model (before_save, after_create, after_update). Please note that
+  # model (around_save, before_save, after_create, after_update). Please note that
   # callbacks are executed in the order they were defined in
-  # model. You should avoid modifying the association content, before
+  # model. You should avoid modifying the association content before
   # autosave callbacks are executed. Placing your callbacks after
   # associations is usually a good practice.
   #
@@ -91,8 +91,9 @@ module ActiveRecord
   #   post.save # => saves both post and comment
   #
   #   post = Post.create(title: 'ruby rocks')
-  #   post.comments.create(body: 'hello world')
-  #   post.save # => saves both post and comment
+  #   comment = post.comments.create(body: 'hello world')
+  #   comment.body = 'hi everyone'
+  #   post.save # => saves post, but not comment
   #
   # When <tt>:autosave</tt> is true all children are saved, no matter whether they
   # are new records or not:
@@ -102,11 +103,10 @@ module ActiveRecord
   #   end
   #
   #   post = Post.create(title: 'ruby rocks')
-  #   post.comments.create(body: 'hello world')
-  #   post.comments[0].body = 'hi everyone'
+  #   comment = post.comments.create(body: 'hello world')
+  #   comment.body = 'hi everyone'
   #   post.comments.build(body: "good morning.")
-  #   post.title += "!"
-  #   post.save # => saves both post and comments.
+  #   post.save # => saves post and both comments.
   #
   # Destroying one of the associated models as part of the parent's save action
   # is as simple as marking it for destruction:
@@ -127,6 +127,14 @@ module ActiveRecord
   # Now it _is_ removed from the database:
   #
   #   Comment.find_by(id: id).nil? # => true
+  #
+  # === Caveats
+  #
+  # Note that autosave will only trigger for already-persisted association records
+  # if the records themselves have been changed. This is to protect against
+  # <tt>SystemStackError</tt> caused by circular association validations. The one
+  # exception is if a custom validation context is used, in which case the validations
+  # will always fire on the associated records.
   module AutosaveAssociation
     extend ActiveSupport::Concern
 
@@ -147,9 +155,23 @@ module ActiveRecord
 
     module ClassMethods # :nodoc:
       private
+        if Module.method(:method_defined?).arity == 1 # MRI 2.5 and older
+          using Module.new {
+            refine Module do
+              def method_defined?(method, inherit = true)
+                if inherit
+                  super(method)
+                else
+                  instance_methods(false).include?(method.to_sym)
+                end
+              end
+            end
+          }
+        end
 
         def define_non_cyclic_method(name, &block)
-          return if instance_methods(false).include?(name)
+          return if method_defined?(name, false)
+
           define_method(name) do |*args|
             result = true; @_already_called ||= {}
             # Loop prevention for validation of associations
@@ -181,8 +203,7 @@ module ActiveRecord
           save_method = :"autosave_associated_records_for_#{reflection.name}"
 
           if reflection.collection?
-            before_save :before_save_collection_association
-            after_save :after_save_collection_association
+            around_save :around_save_collection_association
 
             define_non_cyclic_method(save_method) { save_collection_association(reflection) }
             # Doesn't use after_save as that would save associations added in after_create/after_update twice
@@ -267,12 +288,11 @@ module ActiveRecord
     end
 
     private
-
       # Returns the record for an association collection that should be validated
       # or saved. If +autosave+ is +false+ only new records will be returned,
       # unless the parent is/was a new record itself.
       def associated_records_to_validate_or_save(association, new_record, autosave)
-        if new_record
+        if new_record || custom_validation_context?
           association && association.target
         elsif autosave
           association.target.find_all(&:changed_for_autosave?)
@@ -281,8 +301,9 @@ module ActiveRecord
         end
       end
 
-      # go through nested autosave associations that are loaded in memory (without loading
-      # any new ones), and return true if is changed for autosave
+      # Go through nested autosave associations that are loaded in memory (without loading
+      # any new ones), and return true if any are changed for autosave.
+      # Returns false if already called to prevent an infinite loop.
       def nested_records_changed_for_autosave?
         @_nested_records_changed_for_autosave_already_called ||= false
         return false if @_nested_records_changed_for_autosave_already_called
@@ -304,7 +325,7 @@ module ActiveRecord
       def validate_single_association(reflection)
         association = association_instance_get(reflection.name)
         record      = association && association.reader
-        association_valid?(reflection, record) if record && record.changed_for_autosave?
+        association_valid?(reflection, record) if record && (record.changed_for_autosave? || custom_validation_context?)
       end
 
       # Validate the associated records if <tt>:validate</tt> or
@@ -324,27 +345,22 @@ module ActiveRecord
       def association_valid?(reflection, record, index = nil)
         return true if record.destroyed? || (reflection.options[:autosave] && record.marked_for_destruction?)
 
-        context = validation_context unless [:create, :update].include?(validation_context)
+        context = validation_context if custom_validation_context?
 
         unless valid = record.valid?(context)
           if reflection.options[:autosave]
             indexed_attribute = !index.nil? && (reflection.options[:index_errors] || ActiveRecord::Base.index_nested_attribute_errors)
 
-            record.errors.each do |attribute, message|
+            record.errors.group_by_attribute.each { |attribute, errors|
               attribute = normalize_reflection_attribute(indexed_attribute, reflection, index, attribute)
-              errors[attribute] << message
-              errors[attribute].uniq!
-            end
-
-            record.errors.details.each_key do |attribute|
-              reflection_attribute =
-                normalize_reflection_attribute(indexed_attribute, reflection, index, attribute).to_sym
 
-              record.errors.details[attribute].each do |error|
-                errors.details[reflection_attribute] << error
-                errors.details[reflection_attribute].uniq!
-              end
-            end
+              errors.each { |error|
+                self.errors.import(
+                  error,
+                  attribute: attribute
+                )
+              }
+            }
           else
             errors.add(reflection.name)
           end
@@ -360,14 +376,15 @@ module ActiveRecord
         end
       end
 
-      # Is used as a before_save callback to check while saving a collection
+      # Is used as an around_save callback to check while saving a collection
       # association whether or not the parent was a new record before saving.
-      def before_save_collection_association
-        @new_record_before_save = new_record?
-      end
+      def around_save_collection_association
+        previously_new_record_before_save = (@new_record_before_save ||= false)
+        @new_record_before_save = !previously_new_record_before_save && new_record?
 
-      def after_save_collection_association
-        @new_record_before_save = false
+        yield
+      ensure
+        @new_record_before_save = previously_new_record_before_save
       end
 
       # Saves any new associated records, or all loaded autosave associations if
@@ -440,13 +457,13 @@ module ActiveRecord
           if autosave && record.marked_for_destruction?
             record.destroy
           elsif autosave != false
-            key = reflection.options[:primary_key] ? send(reflection.options[:primary_key]) : id
+            key = reflection.options[:primary_key] ? public_send(reflection.options[:primary_key]) : id
 
-            if (autosave && record.changed_for_autosave?) || new_record? || record_changed?(reflection, record, key)
+            if (autosave && record.changed_for_autosave?) || record_changed?(reflection, record, key)
               unless reflection.through_reflection
                 record[reflection.foreign_key] = key
                 if inverse_reflection = reflection.inverse_of
-                  record.association(inverse_reflection.name).loaded!
+                  record.association(inverse_reflection.name).inversed_from(self)
                 end
               end
 
@@ -468,7 +485,7 @@ module ActiveRecord
       def association_foreign_key_changed?(reflection, record, key)
         return false if reflection.through_reflection?
 
-        record.has_attribute?(reflection.foreign_key) && record[reflection.foreign_key] != key
+        record._has_attribute?(reflection.foreign_key) && record._read_attribute(reflection.foreign_key) != key
       end
 
       # Saves the associated record if it's new or <tt>:autosave</tt> is enabled.
@@ -489,7 +506,7 @@ module ActiveRecord
             saved = record.save(validate: !autosave) if record.new_record? || (autosave && record.changed_for_autosave?)
 
             if association.updated?
-              association_id = record.send(reflection.options[:primary_key] || :id)
+              association_id = record.public_send(reflection.options[:primary_key] || :id)
               self[reflection.foreign_key] = association_id
               association.loaded!
             end
@@ -499,10 +516,12 @@ module ActiveRecord
         end
       end
 
+      def custom_validation_context?
+        validation_context && [:create, :update].exclude?(validation_context)
+      end
+
       def _ensure_no_duplicate_errors
-        errors.messages.each_key do |attribute|
-          errors[attribute].uniq!
-        end
+        errors.uniq!
       end
   end
 end