activerecord 5.0.7 → 5.1.7

data/lib/active_record/associations/association.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/array/wrap'
+require "active_support/core_ext/array/wrap"
 
 module ActiveRecord
   module Associations
@@ -19,7 +19,7 @@ module ActiveRecord
       attr_reader :owner, :target, :reflection
       attr_accessor :inversed
 
-      delegate :options, :to => :reflection
+      delegate :options, to: :reflection
 
       def initialize(owner, reflection)
         reflection.check_validity!
@@ -112,6 +112,15 @@ module ActiveRecord
         record
       end
 
+      # Remove the inverse association, if possible
+      def remove_inverse_instance(record)
+        if invertible_for?(record)
+          inverse = record.association(inverse_reflection_for(record).name)
+          inverse.target = nil
+          inverse.inversed = false
+        end
+      end
+
       # Returns the class of the target. belongs_to polymorphic overrides this to look at the
       # polymorphic_type field on the owner.
       def klass
@@ -176,13 +185,21 @@ module ActiveRecord
       def initialize_attributes(record, except_from_scope_attributes = nil) #:nodoc:
         except_from_scope_attributes ||= {}
         skip_assign = [reflection.foreign_key, reflection.type].compact
-        assigned_keys = record.changed
+        assigned_keys = record.changed_attribute_names_to_save
         assigned_keys += except_from_scope_attributes.keys.map(&:to_s)
         attributes = create_scope.except(*(assigned_keys - skip_assign))
         record.assign_attributes(attributes)
         set_inverse_instance(record)
       end
 
+      def create(attributes = {}, &block)
+        _create_record(attributes, &block)
+      end
+
+      def create!(attributes = {}, &block)
+        _create_record(attributes, true, &block)
+      end
+
       private
 
         def find_target?
@@ -227,7 +244,8 @@ module ActiveRecord
           unless record.is_a?(reflection.klass)
             fresh_class = reflection.class_name.safe_constantize
             unless fresh_class && record.is_a?(fresh_class)
-              message = "#{reflection.class_name}(##{reflection.klass.object_id}) expected, got #{record.class}(##{record.class.object_id})"
+              message = "#{reflection.class_name}(##{reflection.klass.object_id}) expected, "\
+                "got #{record.inspect} which is an instance of #{record.class}(##{record.class.object_id})"
               raise ActiveRecord::AssociationTypeMismatch, message
             end
           end
@@ -255,7 +273,7 @@ module ActiveRecord
         # so that when stale_state is different from the value stored on the last find_target,
         # the target is stale.
         #
-        # This is only relevant to certain associations, which is why it returns nil by default.
+        # This is only relevant to certain associations, which is why it returns +nil+ by default.
         def stale_state
         end
 

data/lib/active_record/associations/association_scope.rb

@@ -21,11 +21,11 @@ module ActiveRecord
         reflection = association.reflection
         scope = klass.unscoped
         owner = association.owner
-        alias_tracker = AliasTracker.create connection, association.klass.table_name, klass.type_caster
+        alias_tracker = AliasTracker.create connection, association.klass.table_name
         chain_head, chain_tail = get_chain(reflection, association, alias_tracker)
 
         scope.extending! reflection.extensions
-        add_constraints(scope, owner, klass, reflection, chain_head, chain_tail)
+        add_constraints(scope, owner, reflection, chain_head, chain_tail)
       end
 
       def join_type
@@ -49,118 +49,132 @@ module ActiveRecord
         binds
       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 :value_transformation
+        attr_reader :value_transformation
 
       private
-      def join(table, constraint)
-        table.create_join(table, table.create_on(constraint), join_type)
-      end
+        def join(table, constraint)
+          table.create_join(table, table.create_on(constraint), join_type)
+        end
 
-      def last_chain_scope(scope, table, reflection, owner, association_klass)
-        join_keys = reflection.join_keys(association_klass)
-        key = join_keys.key
-        foreign_key = join_keys.foreign_key
+        def last_chain_scope(scope, table, reflection, owner)
+          join_keys = reflection.join_keys
+          key = join_keys.key
+          foreign_key = join_keys.foreign_key
 
-        value = transform_value(owner[foreign_key])
-        scope = scope.where(table.name => { key => value })
+          value = transform_value(owner[foreign_key])
+          scope = apply_scope(scope, table, key, value)
 
-        if reflection.type
-          polymorphic_type = transform_value(owner.class.base_class.name)
-          scope = scope.where(table.name => { reflection.type => polymorphic_type })
+          if reflection.type
+            polymorphic_type = transform_value(owner.class.base_class.name)
+            scope = apply_scope(scope, table, reflection.type, polymorphic_type)
+          end
+
+          scope
         end
 
-        scope
-      end
+        def transform_value(value)
+          value_transformation.call(value)
+        end
 
-      def transform_value(value)
-        value_transformation.call(value)
-      end
+        def next_chain_scope(scope, table, reflection, foreign_table, next_reflection)
+          join_keys = reflection.join_keys
+          key = join_keys.key
+          foreign_key = join_keys.foreign_key
 
-      def next_chain_scope(scope, table, reflection, association_klass, foreign_table, next_reflection)
-        join_keys = reflection.join_keys(association_klass)
-        key = join_keys.key
-        foreign_key = join_keys.foreign_key
+          constraint = table[key].eq(foreign_table[foreign_key])
 
-        constraint = table[key].eq(foreign_table[foreign_key])
+          if reflection.type
+            value = transform_value(next_reflection.klass.base_class.name)
+            scope = apply_scope(scope, table, reflection.type, value)
+          end
 
-        if reflection.type
-          value = transform_value(next_reflection.klass.base_class.name)
-          scope = scope.where(table.name => { reflection.type => value })
+          scope.joins!(join(foreign_table, constraint))
         end
 
-        scope = scope.joins(join(foreign_table, constraint))
-      end
+        class ReflectionProxy < SimpleDelegator # :nodoc:
+          attr_accessor :next
+          attr_reader :alias_name
 
-      class ReflectionProxy < SimpleDelegator # :nodoc:
-        attr_accessor :next
-        attr_reader :alias_name
+          def initialize(reflection, alias_name)
+            super(reflection)
+            @alias_name = alias_name
+          end
 
-        def initialize(reflection, alias_name)
-          super(reflection)
-          @alias_name = alias_name
+          def all_includes; nil; end
         end
 
-        def all_includes; nil; end
-      end
-
-      def get_chain(reflection, association, tracker)
-        name = reflection.name
-        runtime_reflection = Reflection::RuntimeReflection.new(reflection, association)
-        previous_reflection = runtime_reflection
-        reflection.chain.drop(1).each do |refl|
-          alias_name = tracker.aliased_table_for(refl.table_name, refl.alias_candidate(name))
-          proxy = ReflectionProxy.new(refl, alias_name)
-          previous_reflection.next = proxy
-          previous_reflection = proxy
+        def get_chain(reflection, association, tracker)
+          name = reflection.name
+          runtime_reflection = Reflection::RuntimeReflection.new(reflection, association)
+          previous_reflection = runtime_reflection
+          reflection.chain.drop(1).each do |refl|
+            alias_name = tracker.aliased_table_for(
+              refl.table_name,
+              refl.alias_candidate(name),
+              refl.klass.type_caster
+            )
+            proxy = ReflectionProxy.new(refl, alias_name)
+            previous_reflection.next = proxy
+            previous_reflection = proxy
+          end
+          [runtime_reflection, previous_reflection]
         end
-        [runtime_reflection, previous_reflection]
-      end
 
-      def add_constraints(scope, owner, association_klass, refl, chain_head, chain_tail)
-        owner_reflection = chain_tail
-        table = owner_reflection.alias_name
-        scope = last_chain_scope(scope, table, owner_reflection, owner, association_klass)
+        def add_constraints(scope, owner, refl, chain_head, chain_tail)
+          owner_reflection = chain_tail
+          table = owner_reflection.alias_name
+          scope = last_chain_scope(scope, table, owner_reflection, owner)
 
-        reflection = chain_head
-        loop do
-          break unless reflection
-          table = reflection.alias_name
-
-          unless reflection == chain_tail
+          reflection = chain_head
+          while reflection
+            table = reflection.alias_name
             next_reflection = reflection.next
-            foreign_table = next_reflection.alias_name
-            scope = next_chain_scope(scope, table, reflection, association_klass, foreign_table, next_reflection)
-          end
 
-          # Exclude the scope of the association itself, because that
-          # was already merged in the #scope method.
-          reflection.constraints.each do |scope_chain_item|
-            item  = eval_scope(reflection.klass, scope_chain_item, owner)
-
-            if scope_chain_item == refl.scope
-              scope.merge! item.except(:where, :includes)
+            unless reflection == chain_tail
+              foreign_table = next_reflection.alias_name
+              scope = next_chain_scope(scope, table, reflection, foreign_table, next_reflection)
             end
 
-            reflection.all_includes do
-              scope.includes! item.includes_values
+            # Exclude the scope of the association itself, because that
+            # was already merged in the #scope method.
+            reflection.constraints.each do |scope_chain_item|
+              item = eval_scope(reflection.klass, table, scope_chain_item, owner)
+
+              if scope_chain_item == refl.scope
+                scope.merge! item.except(:where, :includes)
+              end
+
+              reflection.all_includes do
+                scope.includes! item.includes_values
+              end
+
+              scope.unscope!(*item.unscope_values)
+              scope.where_clause += item.where_clause
+              scope.order_values |= item.order_values
             end
 
-            scope.unscope!(*item.unscope_values)
-            scope.where_clause += item.where_clause
-            scope.order_values |= item.order_values
+            reflection = next_reflection
           end
 
-          reflection = reflection.next
+          scope
         end
 
-        scope
-      end
+        def apply_scope(scope, table, key, value)
+          if scope.table == table
+            scope.where!(key => value)
+          else
+            scope.where!(table.name => { key => value })
+          end
+        end
 
-      def eval_scope(klass, scope, owner)
-        klass.unscoped.instance_exec(owner, &scope)
-      end
+        def eval_scope(klass, table, scope, owner)
+          predicate_builder = PredicateBuilder.new(TableMetadata.new(klass, table))
+          ActiveRecord::Relation.create(klass, table, predicate_builder).instance_exec(owner, &scope)
+        end
     end
   end
 end

data/lib/active_record/associations/belongs_to_association.rb

@@ -2,7 +2,6 @@ module ActiveRecord
   # = Active Record Belongs To Association
   module Associations
     class BelongsToAssociation < SingularAssociation #:nodoc:
-
       def handle_dependency
         target.send(options[:dependent]) if load_target
       end
@@ -22,6 +21,10 @@ module ActiveRecord
         self.target = record
       end
 
+      def default(&block)
+        writer(owner.instance_exec(&block)) if reader.nil?
+      end
+
       def reset
         super
         @updated = false
@@ -44,9 +47,9 @@ module ActiveRecord
         def update_counters(by)
           if require_counter_update? && foreign_key_present?
             if target && !stale_target?
-              target.increment!(reflection.counter_cache_column, by)
+              target.increment!(reflection.counter_cache_column, by, touch: reflection.options[:touch])
             else
-              klass.update_counters(target_id, reflection.counter_cache_column => by)
+              klass.update_counters(target_id, reflection.counter_cache_column => by, touch: reflection.options[:touch])
             end
           end
         end
@@ -62,7 +65,7 @@ module ActiveRecord
         def update_counters_on_replace(record)
           if require_counter_update? && different_target?(record)
             owner.instance_variable_set :@_after_replace_counter_called, true
-            record.increment!(reflection.counter_cache_column)
+            record.increment!(reflection.counter_cache_column, touch: reflection.options[:touch])
             decrement_counters
           end
         end

data/lib/active_record/associations/builder/belongs_to.rb

@@ -5,7 +5,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
     end
 
     def self.valid_options(options)
-      super + [:polymorphic, :touch, :counter_cache, :optional]
+      super + [:polymorphic, :touch, :counter_cache, :optional, :default]
     end
 
     def self.valid_dependent_options
@@ -16,6 +16,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
       super
       add_counter_cache_callbacks(model, reflection) if reflection.options[:counter_cache]
       add_touch_callbacks(model, reflection)         if reflection.options[:touch]
+      add_default_callbacks(model, reflection)       if reflection.options[:default]
     end
 
     def self.define_accessors(mixin, reflection)
@@ -35,17 +36,17 @@ module ActiveRecord::Associations::Builder # :nodoc:
             @_after_create_counter_called = false
           elsif (@_after_replace_counter_called ||= false)
             @_after_replace_counter_called = false
-          elsif attribute_changed?(foreign_key) && !new_record?
+          elsif saved_change_to_attribute?(foreign_key) && !new_record?
             if reflection.polymorphic?
-              model     = attribute(reflection.foreign_type).try(:constantize)
-              model_was = attribute_was(reflection.foreign_type).try(:constantize)
+              model     = attribute_in_database(reflection.foreign_type).try(:constantize)
+              model_was = attribute_before_last_save(reflection.foreign_type).try(:constantize)
             else
               model     = reflection.klass
               model_was = reflection.klass
             end
 
-            foreign_key_was = attribute_was foreign_key
-            foreign_key     = attribute foreign_key
+            foreign_key_was = attribute_before_last_save foreign_key
+            foreign_key     = attribute_in_database foreign_key
 
             if foreign_key && model.respond_to?(:increment_counter)
               model.increment_counter(cache_column, foreign_key)
@@ -70,18 +71,21 @@ module ActiveRecord::Associations::Builder # :nodoc:
       klass.attr_readonly cache_column if klass && klass.respond_to?(:attr_readonly)
     end
 
-    def self.touch_record(o, foreign_key, name, touch, touch_method) # :nodoc:
-      old_foreign_id = o.changed_attributes[foreign_key]
+    def self.touch_record(o, changes, foreign_key, name, touch, touch_method) # :nodoc:
+      old_foreign_id = changes[foreign_key] && changes[foreign_key].first
 
       if old_foreign_id
         association = o.association(name)
         reflection = association.reflection
         if reflection.polymorphic?
-          klass = o.public_send("#{reflection.foreign_type}_was").constantize
+          foreign_type = reflection.foreign_type
+          klass = changes[foreign_type] && changes[foreign_type].first || o.public_send(foreign_type)
+          klass = klass.constantize
         else
           klass = association.klass
         end
-        old_record = klass.find_by(klass.primary_key => old_foreign_id)
+        primary_key = reflection.association_primary_key(klass)
+        old_record = klass.find_by(primary_key => old_foreign_id)
 
         if old_record
           if touch != true
@@ -107,13 +111,23 @@ module ActiveRecord::Associations::Builder # :nodoc:
       n           = reflection.name
       touch       = reflection.options[:touch]
 
-      callback = lambda { |record|
-        BelongsTo.touch_record(record, foreign_key, n, touch, belongs_to_touch_method)
-      }
+      callback = lambda { |changes_method| lambda { |record|
+        BelongsTo.touch_record(record, record.send(changes_method), foreign_key, n, touch, belongs_to_touch_method)
+      }}
+
+      unless reflection.counter_cache_column
+        model.after_create callback.(:saved_changes), if: :saved_changes?
+        model.after_destroy callback.(:changes_to_save)
+      end
 
-      model.after_save    callback, if: :changed?
-      model.after_touch   callback
-      model.after_destroy callback
+      model.after_update callback.(:saved_changes), if: :saved_changes?
+      model.after_touch callback.(:changes_to_save)
+    end
+
+    def self.add_default_callbacks(model, reflection)
+      model.before_validation lambda { |o|
+        o.association(reflection.name).default(&reflection.options[:default])
+      }
     end
 
     def self.add_destroy_callbacks(model, reflection)

data/lib/active_record/associations/builder/collection_association.rb

@@ -1,10 +1,9 @@
 # This class is inherited by the has_many and has_many_and_belongs_to_many association classes
 
-require 'active_record/associations'
+require "active_record/associations"
 
 module ActiveRecord::Associations::Builder # :nodoc:
   class CollectionAssociation < Association #:nodoc:
-
     CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
 
     def self.valid_options(options)

data/lib/active_record/associations/builder/has_and_belongs_to_many.rb

@@ -16,9 +16,9 @@ module ActiveRecord::Associations::Builder # :nodoc:
 
         private
 
-        def klass
-          @lhs_class.send(:compute_type, @rhs_class_name)
-        end
+          def klass
+            @lhs_class.send(:compute_type, @rhs_class_name)
+          end
       end
 
       def self.build(lhs_class, name, options)
@@ -28,7 +28,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
           class_name = options.fetch(:class_name) {
             name.to_s.camelize.singularize
           }
-          KnownClass.new lhs_class, class_name
+          KnownClass.new lhs_class, class_name.to_s
         end
       end
     end
@@ -78,9 +78,9 @@ module ActiveRecord::Associations::Builder # :nodoc:
 
         private
 
-        def self.suppress_composite_primary_key(pk)
-          pk unless pk.is_a?(Array)
-        end
+          def self.suppress_composite_primary_key(pk)
+            pk unless pk.is_a?(Array)
+          end
       }
 
       join_model.name                = "HABTM_#{association_name.to_s.camelize}"
@@ -94,7 +94,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
 
     def middle_reflection(join_model)
       middle_name = [lhs_model.name.downcase.pluralize,
-                     association_name].join('_'.freeze).gsub('::'.freeze, '_'.freeze).to_sym
+                     association_name].join("_".freeze).gsub("::".freeze, "_".freeze).to_sym
       middle_options = middle_options join_model
 
       HasMany.create_reflection(lhs_model,
@@ -105,29 +105,29 @@ module ActiveRecord::Associations::Builder # :nodoc:
 
     private
 
-    def middle_options(join_model)
-      middle_options = {}
-      middle_options[:class_name] = "#{lhs_model.name}::#{join_model.name}"
-      middle_options[:source] = join_model.left_reflection.name
-      if options.key? :foreign_key
-        middle_options[:foreign_key] = options[:foreign_key]
+      def middle_options(join_model)
+        middle_options = {}
+        middle_options[:class_name] = "#{lhs_model.name}::#{join_model.name}"
+        middle_options[:source] = join_model.left_reflection.name
+        if options.key? :foreign_key
+          middle_options[:foreign_key] = options[:foreign_key]
+        end
+        middle_options
       end
-      middle_options
-    end
 
-    def belongs_to_options(options)
-      rhs_options = {}
+      def belongs_to_options(options)
+        rhs_options = {}
 
-      if options.key? :class_name
-        rhs_options[:foreign_key] = options[:class_name].to_s.foreign_key
-        rhs_options[:class_name] = options[:class_name]
-      end
+        if options.key? :class_name
+          rhs_options[:foreign_key] = options[:class_name].to_s.foreign_key
+          rhs_options[:class_name] = options[:class_name]
+        end
 
-      if options.key? :association_foreign_key
-        rhs_options[:foreign_key] = options[:association_foreign_key]
-      end
+        if options.key? :association_foreign_key
+          rhs_options[:foreign_key] = options[:association_foreign_key]
+        end
 
-      rhs_options
-    end
+        rhs_options
+      end
   end
 end