activerecord 5.0.7.2 → 5.1.0.beta1

data/lib/active_record/attribute_mutation_tracker.rb

@@ -1,7 +1,11 @@
 module ActiveRecord
   class AttributeMutationTracker # :nodoc:
+    OPTION_NOT_GIVEN = Object.new
+
     def initialize(attributes)
       @attributes = attributes
+      @forced_changes = Set.new
+      @deprecated_forced_changes = Set.new
     end
 
     def changed_values
@@ -14,15 +18,29 @@ module ActiveRecord
 
     def changes
       attr_names.each_with_object({}.with_indifferent_access) do |attr_name, result|
-        if changed?(attr_name)
-          result[attr_name] = [attributes[attr_name].original_value, attributes.fetch_value(attr_name)]
+        change = change_to_attribute(attr_name)
+        if change
+          result[attr_name] = change
         end
       end
     end
 
-    def changed?(attr_name)
+    def change_to_attribute(attr_name)
+      if changed?(attr_name)
+        [attributes[attr_name].original_value, attributes.fetch_value(attr_name)]
+      end
+    end
+
+    def any_changes?
+      attr_names.any? { |attr| changed?(attr) } || deprecated_forced_changes.any?
+    end
+
+    def changed?(attr_name, from: OPTION_NOT_GIVEN, to: OPTION_NOT_GIVEN)
       attr_name = attr_name.to_s
-      attributes[attr_name].changed?
+      forced_changes.include?(attr_name) ||
+        attributes[attr_name].changed? &&
+        (OPTION_NOT_GIVEN == from || attributes[attr_name].original_value == from) &&
+        (OPTION_NOT_GIVEN == to || attributes[attr_name].value == to)
     end
 
     def changed_in_place?(attr_name)
@@ -32,30 +50,52 @@ module ActiveRecord
     def forget_change(attr_name)
       attr_name = attr_name.to_s
       attributes[attr_name] = attributes[attr_name].forgetting_assignment
+      forced_changes.delete(attr_name)
+    end
+
+    def original_value(attr_name)
+      attributes[attr_name].original_value
+    end
+
+    def force_change(attr_name)
+      forced_changes << attr_name.to_s
+    end
+
+    def deprecated_force_change(attr_name)
+      deprecated_forced_changes << attr_name.to_s
     end
 
+    # TODO Change this to private once we've dropped Ruby 2.2 support.
+    # Workaround for Ruby 2.2 "private attribute?" warning.
     protected
 
-    attr_reader :attributes
+      attr_reader :attributes, :forced_changes, :deprecated_forced_changes
 
     private
 
-    def attr_names
-      attributes.keys
-    end
+      def attr_names
+        attributes.keys
+      end
   end
 
   class NullMutationTracker # :nodoc:
     include Singleton
 
-    def changed_values
+    def changed_values(*)
       {}
     end
 
-    def changes
+    def changes(*)
       {}
     end
 
+    def change_to_attribute(attr_name)
+    end
+
+    def any_changes?(*)
+      false
+    end
+
     def changed?(*)
       false
     end
@@ -66,5 +106,8 @@ module ActiveRecord
 
     def forget_change(*)
     end
+
+    def original_value(*)
+    end
   end
 end

data/lib/active_record/attribute_set.rb

@@ -1,8 +1,9 @@
-require 'active_record/attribute_set/builder'
+require "active_record/attribute_set/builder"
+require "active_record/attribute_set/yaml_encoder"
 
 module ActiveRecord
   class AttributeSet # :nodoc:
-    delegate :fetch, :except, to: :attributes
+    delegate :each_value, :fetch, to: :attributes
 
     def initialize(attributes)
       @attributes = attributes
@@ -97,14 +98,16 @@ module ActiveRecord
       attributes == other.attributes
     end
 
+    # TODO Change this to private once we've dropped Ruby 2.2 support.
+    # Workaround for Ruby 2.2 "private attribute?" warning.
     protected
 
-    attr_reader :attributes
+      attr_reader :attributes
 
     private
 
-    def initialized_attributes
-      attributes.select { |_, attr| attr.initialized? }
-    end
+      def initialized_attributes
+        attributes.select { |_, attr| attr.initialized? }
+      end
   end
 end

data/lib/active_record/attribute_set/builder.rb

@@ -1,32 +1,37 @@
-require 'active_record/attribute'
+require "active_record/attribute"
 
 module ActiveRecord
   class AttributeSet # :nodoc:
     class Builder # :nodoc:
-      attr_reader :types, :default_attributes
+      attr_reader :types, :always_initialized, :default
 
-      def initialize(types, default_attributes = {})
+      def initialize(types, always_initialized = nil, &default)
         @types = types
-        @default_attributes = default_attributes
+        @always_initialized = always_initialized
+        @default = default
       end
 
       def build_from_database(values = {}, additional_types = {})
-        attributes = LazyAttributeHash.new(types, values, additional_types, default_attributes)
+        if always_initialized && !values.key?(always_initialized)
+          values[always_initialized] = nil
+        end
+
+        attributes = LazyAttributeHash.new(types, values, additional_types, &default)
         AttributeSet.new(attributes)
       end
     end
   end
 
   class LazyAttributeHash # :nodoc:
-    delegate :transform_values, :each_key, :fetch, :except, to: :materialize
+    delegate :transform_values, :each_key, :each_value, :fetch, to: :materialize
 
-    def initialize(types, values, additional_types, default_attributes, delegate_hash = {})
+    def initialize(types, values, additional_types, &default)
       @types = types
       @values = values
       @additional_types = additional_types
       @materialized = false
-      @delegate_hash = delegate_hash
-      @default_attributes = default_attributes
+      @delegate_hash = {}
+      @default = default || proc {}
     end
 
     def key?(key)
@@ -74,59 +79,46 @@ module ActiveRecord
     end
 
     def marshal_dump
-      [@types, @values, @additional_types, @default_attributes, @delegate_hash]
-    end
-
-    def marshal_load(values)
-      if values.is_a?(Hash)
-        empty_hash = {}.freeze
-        initialize(empty_hash, empty_hash, empty_hash, empty_hash, values)
-        @materialized = true
-      else
-        initialize(*values)
-      end
+      materialize
     end
 
-    def encode_with(coder)
-      coder["delegate_hash"] = materialize
-    end
-
-    def init_with(coder)
-      marshal_load(coder["delegate_hash"])
+    def marshal_load(delegate_hash)
+      @delegate_hash = delegate_hash
+      @types = {}
+      @values = {}
+      @additional_types = {}
+      @materialized = true
     end
 
+    # TODO Change this to private once we've dropped Ruby 2.2 support.
+    # Workaround for Ruby 2.2 "private attribute?" warning.
     protected
 
-    attr_reader :types, :values, :additional_types, :delegate_hash, :default_attributes
+      attr_reader :types, :values, :additional_types, :delegate_hash, :default
 
-    def materialize
-      unless @materialized
-        values.each_key { |key| self[key] }
-        types.each_key { |key| self[key] }
-        unless frozen?
-          @materialized = true
+      def materialize
+        unless @materialized
+          values.each_key { |key| self[key] }
+          types.each_key { |key| self[key] }
+          unless frozen?
+            @materialized = true
+          end
         end
+        delegate_hash
       end
-      delegate_hash
-    end
 
     private
 
-    def assign_default_value(name)
-      type = additional_types.fetch(name, types[name])
-      value_present = true
-      value = values.fetch(name) { value_present = false }
-
-      if value_present
-        delegate_hash[name] = Attribute.from_database(name, value, type)
-      elsif types.key?(name)
-        attr = default_attributes[name]
-        if attr
-          delegate_hash[name] = attr.dup
-        else
-          delegate_hash[name] = Attribute.uninitialized(name, type)
+      def assign_default_value(name)
+        type = additional_types.fetch(name, types[name])
+        value_present = true
+        value = values.fetch(name) { value_present = false }
+
+        if value_present
+          delegate_hash[name] = Attribute.from_database(name, value, type)
+        elsif types.key?(name)
+          delegate_hash[name] = default.call(name) || Attribute.uninitialized(name, type)
         end
       end
-    end
   end
 end

data/lib/active_record/attribute_set/yaml_encoder.rb

@@ -0,0 +1,41 @@
+module ActiveRecord
+  class AttributeSet
+    # Attempts to do more intelligent YAML dumping of an
+    # ActiveRecord::AttributeSet to reduce the size of the resulting string
+    class YAMLEncoder # :nodoc:
+      def initialize(default_types)
+        @default_types = default_types
+      end
+
+      def encode(attribute_set, coder)
+        coder["concise_attributes"] = attribute_set.each_value.map do |attr|
+          if attr.type.equal?(default_types[attr.name])
+            attr.with_type(nil)
+          else
+            attr
+          end
+        end
+      end
+
+      def decode(coder)
+        if coder["attributes"]
+          coder["attributes"]
+        else
+          attributes_hash = Hash[coder["concise_attributes"].map do |attr|
+            if attr.type.nil?
+              attr = attr.with_type(default_types[attr.name])
+            end
+            [attr.name, attr]
+          end]
+          AttributeSet.new(attributes_hash)
+        end
+      end
+
+      # TODO Change this to private once we've dropped Ruby 2.2 support.
+      # Workaround for Ruby 2.2 "private attribute?" warning.
+      protected
+
+        attr_reader :default_types
+    end
+  end
+end

data/lib/active_record/attributes.rb

@@ -1,4 +1,4 @@
-require 'active_record/attribute/user_provided_default'
+require "active_record/attribute/user_provided_default"
 
 module ActiveRecord
   # See ActiveRecord::Attributes::ClassMethods for documentation
@@ -116,7 +116,7 @@ module ActiveRecord
       # Users may also define their own custom types, as long as they respond
       # to the methods defined on the value type. The method +deserialize+ or
       # +cast+ will be called on your type object, with raw input from the
-      # database or from your controllers. See ActiveRecord::Type::Value for the
+      # database or from your controllers. See ActiveModel::Type::Value for the
       # expected API. It is recommended that your type objects inherit from an
       # existing type, or from ActiveRecord::Type::Value
       #
@@ -143,7 +143,7 @@ module ActiveRecord
       #   store_listing.price_in_cents # => 1000
       #
       # For more details on creating custom types, see the documentation for
-      # ActiveRecord::Type::Value. For more details on registering your types
+      # ActiveModel::Type::Value. For more details on registering your types
       # to be referenced by a symbol, see ActiveRecord::Type.register. You can
       # also pass a type object directly, in place of a symbol.
       #
@@ -190,8 +190,8 @@ module ActiveRecord
       # The type of an attribute is given the opportunity to change how dirty
       # tracking is performed. The methods +changed?+ and +changed_in_place?+
       # will be called from ActiveModel::Dirty. See the documentation for those
-      # methods in ActiveRecord::Type::Value for more details.
-      def attribute(name, cast_type, **options)
+      # methods in ActiveModel::Type::Value for more details.
+      def attribute(name, cast_type = Type::Value.new, **options)
         name = name.to_s
         reload_schema_from_cache
 
@@ -242,24 +242,24 @@ module ActiveRecord
 
       private
 
-      NO_DEFAULT_PROVIDED = Object.new # :nodoc:
-      private_constant :NO_DEFAULT_PROVIDED
+        NO_DEFAULT_PROVIDED = Object.new # :nodoc:
+        private_constant :NO_DEFAULT_PROVIDED
 
-      def define_default_attribute(name, value, type, from_user:)
-        if value == NO_DEFAULT_PROVIDED
-          default_attribute = _default_attributes[name].with_type(type)
-        elsif from_user
-          default_attribute = Attribute::UserProvidedDefault.new(
-            name,
-            value,
-            type,
-            _default_attributes.fetch(name.to_s) { nil },
-          )
-        else
-          default_attribute = Attribute.from_database(name, value, type)
+        def define_default_attribute(name, value, type, from_user:)
+          if value == NO_DEFAULT_PROVIDED
+            default_attribute = _default_attributes[name].with_type(type)
+          elsif from_user
+            default_attribute = Attribute::UserProvidedDefault.new(
+              name,
+              value,
+              type,
+              _default_attributes.fetch(name.to_s) { nil },
+            )
+          else
+            default_attribute = Attribute.from_database(name, value, type)
+          end
+          _default_attributes[name] = default_attribute
         end
-        _default_attributes[name] = default_attribute
-      end
     end
   end
 end

data/lib/active_record/autosave_association.rb

@@ -154,10 +154,10 @@ module ActiveRecord
             # Loop prevention for validation of associations
             unless @_already_called[name]
               begin
-                @_already_called[name]=true
+                @_already_called[name] = true
                 result = instance_eval(&block)
               ensure
-                @_already_called[name]=false
+                @_already_called[name] = false
               end
             end
 
@@ -267,7 +267,7 @@ module ActiveRecord
     # Returns whether or not this record has been changed in any way (including whether
     # any of its nested autosave associations are likewise changed)
     def changed_for_autosave?
-      new_record? || changed? || marked_for_destruction? || nested_records_changed_for_autosave?
+      new_record? || has_changes_to_save? || marked_for_destruction? || nested_records_changed_for_autosave?
     end
 
     private
@@ -325,12 +325,12 @@ module ActiveRecord
       # Returns whether or not the association is valid and applies any errors to
       # the parent, <tt>self</tt>, if it wasn't. Skips any <tt>:autosave</tt>
       # enabled records if they're marked_for_destruction? or destroyed.
-      def association_valid?(reflection, record, index=nil)
+      def association_valid?(reflection, record, index = nil)
         return true if record.destroyed? || (reflection.options[:autosave] && record.marked_for_destruction?)
 
-        validation_context = self.validation_context unless [:create, :update].include?(self.validation_context)
+        context = validation_context unless [:create, :update].include?(validation_context)
 
-        unless valid = record.valid?(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)
 
@@ -383,6 +383,9 @@ module ActiveRecord
         if association = association_instance_get(reflection.name)
           autosave = reflection.options[:autosave]
 
+          # reconstruct the scope now that we know the owner's id
+          association.reset_scope if association.respond_to?(:reset_scope)
+
           if records = associated_records_to_validate_or_save(association, @new_record_before_save, autosave)
             if autosave
               records_to_destroy = records.select(&:marked_for_destruction?)
@@ -402,15 +405,12 @@ module ActiveRecord
                   association.insert_record(record) unless reflection.nested?
                 end
               elsif autosave
-                saved = record.save(:validate => false)
+                saved = record.save(validate: false)
               end
 
               raise ActiveRecord::Rollback unless saved
             end
           end
-
-          # reconstruct the scope now that we know the owner's id
-          association.reset_scope if association.respond_to?(:reset_scope)
         end
       end
 
@@ -439,7 +439,7 @@ module ActiveRecord
                 record[reflection.foreign_key] = key
               end
 
-              saved = record.save(:validate => !autosave)
+              saved = record.save(validate: !autosave)
               raise ActiveRecord::Rollback if !saved && autosave
               saved
             end
@@ -451,7 +451,7 @@ module ActiveRecord
       def record_changed?(reflection, record, key)
         record.new_record? ||
           (record.has_attribute?(reflection.foreign_key) && record[reflection.foreign_key] != key) ||
-          record.attribute_changed?(reflection.foreign_key)
+          record.will_save_change_to_attribute?(reflection.foreign_key)
       end
 
       # Saves the associated record if it's new or <tt>:autosave</tt> is enabled.
@@ -469,7 +469,7 @@ module ActiveRecord
             self[reflection.foreign_key] = nil
             record.destroy
           elsif autosave != false
-            saved = record.save(:validate => !autosave) if record.new_record? || (autosave && record.changed_for_autosave?)
+            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)