activerecord 4.1.15 → 4.2.11.3

data/lib/active_record/associations/alias_tracker.rb

@@ -57,20 +57,10 @@ module ActiveRecord
       end
 
       def aliased_table_for(table_name, aliased_name)
-        table_alias = aliased_name_for(table_name, aliased_name)
-
-        if table_alias == table_name
-          Arel::Table.new(table_name)
-        else
-          Arel::Table.new(table_name).alias(table_alias)
-        end
-      end
-
-      def aliased_name_for(table_name, aliased_name)
         if aliases[table_name].zero?
           # If it's zero, we can have our table_name
           aliases[table_name] = 1
-          table_name
+          Arel::Table.new(table_name)
         else
           # Otherwise, we need to use an alias
           aliased_name = connection.table_alias_for(aliased_name)
@@ -78,11 +68,12 @@ module ActiveRecord
           # Update the count
           aliases[aliased_name] += 1
 
-          if aliases[aliased_name] > 1
+          table_alias = if aliases[aliased_name] > 1
             "#{truncate(aliased_name)}_#{aliases[aliased_name]}"
           else
             aliased_name
           end
+          Arel::Table.new(table_name).alias(table_alias)
         end
       end
 

data/lib/active_record/associations/association.rb

@@ -179,7 +179,7 @@ module ActiveRecord
         def creation_attributes
           attributes = {}
 
-          if (reflection.macro == :has_one || reflection.macro == :has_many) && !options[:through]
+          if (reflection.has_one? || reflection.collection?) && !options[:through]
             attributes[reflection.foreign_key] = owner[reflection.active_record_primary_key]
 
             if reflection.options[:as]
@@ -211,9 +211,12 @@ module ActiveRecord
         # the kind of the class of the associated objects. Meant to be used as
         # a sanity check when you are about to assign an associated record.
         def raise_on_type_mismatch!(record)
-          unless record.is_a?(reflection.klass) || record.is_a?(reflection.class_name.constantize)
-            message = "#{reflection.class_name}(##{reflection.klass.object_id}) expected, got #{record.class}(##{record.class.object_id})"
-            raise ActiveRecord::AssociationTypeMismatch, message
+          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})"
+              raise ActiveRecord::AssociationTypeMismatch, message
+            end
           end
         end
 
@@ -248,6 +251,15 @@ module ActiveRecord
             initialize_attributes(record)
           end
         end
+
+        # Returns true if statement cache should be skipped on the association reader.
+        def skip_statement_cache?
+          reflection.scope_chain.any?(&:any?) ||
+            scope.eager_loading? ||
+            klass.current_scope ||
+            klass.default_scopes.any? ||
+            reflection.source_reflection.active_record.default_scopes.any?
+        end
     end
   end
 end

data/lib/active_record/associations/association_scope.rb

@@ -1,12 +1,33 @@
 module ActiveRecord
   module Associations
     class AssociationScope #:nodoc:
-      INSTANCE = new
-
       def self.scope(association, connection)
         INSTANCE.scope association, connection
       end
 
+      class BindSubstitution
+        def initialize(block)
+          @block = block
+        end
+
+        def bind_value(scope, column, value, alias_tracker)
+          substitute = alias_tracker.connection.substitute_at(column)
+          scope.bind_values += [[column, @block.call(value)]]
+          substitute
+        end
+      end
+
+      def self.create(&block)
+        block = block ? block : lambda { |val| val }
+        new BindSubstitution.new(block)
+      end
+
+      def initialize(bind_substitution)
+        @bind_substitution = bind_substitution
+      end
+
+      INSTANCE = create
+
       def scope(association, connection)
         klass         = association.klass
         reflection    = association.reflection
@@ -22,6 +43,23 @@ module ActiveRecord
         Arel::Nodes::InnerJoin
       end
 
+      def self.get_bind_values(owner, chain)
+        binds = []
+        last_reflection = chain.last
+
+        binds << last_reflection.join_id_for(owner)
+        if last_reflection.type
+          binds << owner.class.base_class.name
+        end
+
+        chain.each_cons(2).each do |reflection, next_reflection|
+          if reflection.type
+            binds << next_reflection.klass.base_class.name
+          end
+        end
+        binds
+      end
+
       private
 
       def construct_tables(chain, klass, refl, alias_tracker)
@@ -49,10 +87,7 @@ module ActiveRecord
       end
 
       def bind_value(scope, column, value, alias_tracker)
-        substitute = alias_tracker.connection.substitute_at(
-          column, scope.bind_values.length)
-        scope.bind_values += [[column, value]]
-        substitute
+        @bind_substitution.bind_value scope, column, value, alias_tracker
       end
 
       def bind(scope, table_name, column_name, value, tracker)
@@ -60,47 +95,55 @@ module ActiveRecord
         bind_value scope, column, value, tracker
       end
 
+      def last_chain_scope(scope, table, reflection, owner, tracker, assoc_klass)
+        join_keys = reflection.join_keys(assoc_klass)
+        key = join_keys.key
+        foreign_key = join_keys.foreign_key
+
+        bind_val = bind scope, table.table_name, key.to_s, owner[foreign_key], tracker
+        scope    = scope.where(table[key].eq(bind_val))
+
+        if reflection.type
+          value    = owner.class.base_class.name
+          bind_val = bind scope, table.table_name, reflection.type, value, tracker
+          scope    = scope.where(table[reflection.type].eq(bind_val))
+        else
+          scope
+        end
+      end
+
+      def next_chain_scope(scope, table, reflection, tracker, assoc_klass, foreign_table, next_reflection)
+        join_keys = reflection.join_keys(assoc_klass)
+        key = join_keys.key
+        foreign_key = join_keys.foreign_key
+
+        constraint = table[key].eq(foreign_table[foreign_key])
+
+        if reflection.type
+          value    = next_reflection.klass.base_class.name
+          bind_val = bind scope, table.table_name, reflection.type, value, tracker
+          scope    = scope.where(table[reflection.type].eq(bind_val))
+        end
+
+        scope = scope.joins(join(foreign_table, constraint))
+      end
+
       def add_constraints(scope, owner, assoc_klass, refl, tracker)
         chain = refl.chain
         scope_chain = refl.scope_chain
 
         tables = construct_tables(chain, assoc_klass, refl, tracker)
 
+        owner_reflection = chain.last
+        table = tables.last
+        scope = last_chain_scope(scope, table, owner_reflection, owner, tracker, assoc_klass)
+
         chain.each_with_index do |reflection, i|
           table, foreign_table = tables.shift, tables.first
 
-          if reflection.source_macro == :belongs_to
-            if reflection.options[:polymorphic]
-              key = reflection.association_primary_key(assoc_klass)
-            else
-              key = reflection.association_primary_key
-            end
-
-            foreign_key = reflection.foreign_key
-          else
-            key         = reflection.foreign_key
-            foreign_key = reflection.active_record_primary_key
-          end
-
-          if reflection == chain.last
-            bind_val = bind scope, table.table_name, key.to_s, owner[foreign_key], tracker
-            scope    = scope.where(table[key].eq(bind_val))
-
-            if reflection.type
-              value    = owner.class.base_class.name
-              bind_val = bind scope, table.table_name, reflection.type.to_s, value, tracker
-              scope    = scope.where(table[reflection.type].eq(bind_val))
-            end
-          else
-            constraint = table[key].eq(foreign_table[foreign_key])
-
-            if reflection.type
-              value    = chain[i + 1].klass.base_class.name
-              bind_val = bind scope, table.table_name, reflection.type.to_s, value, tracker
-              scope    = scope.where(table[reflection.type].eq(bind_val))
-            end
-
-            scope = scope.joins(join(foreign_table, constraint))
+          unless reflection == chain.last
+            next_reflection = chain[i + 1]
+            scope = next_chain_scope(scope, table, reflection, tracker, assoc_klass, foreign_table, next_reflection)
           end
 
           is_first_chain = i == 0
@@ -119,7 +162,9 @@ module ActiveRecord
               scope.includes! item.includes_values
             end
 
+            scope.unscope!(*item.unscope_values)
             scope.where_values += item.where_values
+            scope.bind_values  += item.bind_values
             scope.order_values |= item.order_values
           end
         end

data/lib/active_record/associations/belongs_to_association.rb

@@ -31,6 +31,14 @@ module ActiveRecord
         @updated
       end
 
+      def decrement_counters # :nodoc:
+        with_cache_name { |name| decrement_counter name }
+      end
+
+      def increment_counters # :nodoc:
+        with_cache_name { |name| increment_counter name }
+      end
+
       private
 
         def find_target?
@@ -51,23 +59,28 @@ module ActiveRecord
           end
         end
 
-        def decrement_counters
-          with_cache_name { |name| decrement_counter name }
+        def decrement_counter(counter_cache_name)
+          if foreign_key_present?
+            klass.decrement_counter(counter_cache_name, target_id)
+          end
         end
 
-        def decrement_counter counter_cache_name
+        def increment_counter(counter_cache_name)
           if foreign_key_present?
-            klass.decrement_counter(counter_cache_name, target_id)
+            klass.increment_counter(counter_cache_name, target_id)
+            if target && !stale_target? && counter_cache_available_in_memory?(counter_cache_name)
+              target.increment(counter_cache_name)
+            end
           end
         end
 
         # Checks whether record is different to the current target, without loading it
         def different_target?(record)
-          record.id != owner[reflection.foreign_key]
+          record.id != owner._read_attribute(reflection.foreign_key)
         end
 
         def replace_keys(record)
-          owner[reflection.foreign_key] = record[reflection.association_primary_key(record.class)]
+          owner[reflection.foreign_key] = record._read_attribute(reflection.association_primary_key(record.class))
         end
 
         def remove_keys
@@ -75,26 +88,31 @@ module ActiveRecord
         end
 
         def foreign_key_present?
-          owner[reflection.foreign_key]
+          owner._read_attribute(reflection.foreign_key)
         end
 
         # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
         # has_one associations.
         def invertible_for?(record)
           inverse = inverse_reflection_for(record)
-          inverse && inverse.macro == :has_one
+          inverse && inverse.has_one?
         end
 
         def target_id
           if options[:primary_key]
             owner.send(reflection.name).try(:id)
           else
-            owner[reflection.foreign_key]
+            owner._read_attribute(reflection.foreign_key)
           end
         end
 
         def stale_state
-          owner[reflection.foreign_key] && owner[reflection.foreign_key].to_s
+          result = owner._read_attribute(reflection.foreign_key)
+          result && result.to_s
+        end
+
+        def counter_cache_available_in_memory?(counter_cache_name)
+          target.respond_to?(counter_cache_name)
         end
     end
   end

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

@@ -36,6 +36,7 @@ module ActiveRecord::Associations::Builder
       reflection = builder.build(model)
       define_accessors model, reflection
       define_callbacks model, reflection
+      define_validations model, reflection
       builder.define_extensions model
       reflection
     end
@@ -85,7 +86,11 @@ module ActiveRecord::Associations::Builder
     end
 
     def self.define_callbacks(model, reflection)
-      add_before_destroy_callbacks(model, reflection) if reflection.options[:dependent]
+      if dependent = reflection.options[:dependent]
+        check_dependent_options(dependent)
+        add_destroy_callbacks(model, reflection)
+      end
+
       Association.extensions.each do |extension|
         extension.build model, reflection
       end
@@ -120,17 +125,23 @@ module ActiveRecord::Associations::Builder
       CODE
     end
 
+    def self.define_validations(model, reflection)
+      # noop
+    end
+
     def self.valid_dependent_options
       raise NotImplementedError
     end
 
     private
 
-    def self.add_before_destroy_callbacks(model, reflection)
-      unless valid_dependent_options.include? reflection.options[:dependent]
-        raise ArgumentError, "The :dependent option must be one of #{valid_dependent_options}, but is :#{reflection.options[:dependent]}"
+    def self.check_dependent_options(dependent)
+      unless valid_dependent_options.include? dependent
+        raise ArgumentError, "The :dependent option must be one of #{valid_dependent_options}, but is :#{dependent}"
       end
+    end
 
+    def self.add_destroy_callbacks(model, reflection)
       name = reflection.name
       model.before_destroy lambda { |o| o.association(name).handle_dependency }
     end

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

@@ -26,28 +26,9 @@ module ActiveRecord::Associations::Builder
     private
 
     def self.add_counter_cache_methods(mixin)
-      return if mixin.method_defined? :belongs_to_counter_cache_after_create
+      return if mixin.method_defined? :belongs_to_counter_cache_after_update
 
       mixin.class_eval do
-        def belongs_to_counter_cache_after_create(reflection)
-          if record = send(reflection.name)
-            cache_column = reflection.counter_cache_column
-            record.class.increment_counter(cache_column, record.id)
-            @_after_create_counter_called = true
-          end
-        end
-
-        def belongs_to_counter_cache_before_destroy(reflection)
-          foreign_key = reflection.foreign_key.to_sym
-          unless destroyed_by_association && destroyed_by_association.foreign_key.to_sym == foreign_key
-            record = send reflection.name
-            if record && !self.destroyed?
-              cache_column = reflection.counter_cache_column
-              record.class.decrement_counter(cache_column, record.id)
-            end
-          end
-        end
-
         def belongs_to_counter_cache_after_update(reflection)
           foreign_key  = reflection.foreign_key
           cache_column = reflection.counter_cache_column
@@ -73,14 +54,6 @@ module ActiveRecord::Associations::Builder
     def self.add_counter_cache_callbacks(model, reflection)
       cache_column = reflection.counter_cache_column
 
-      model.after_create lambda { |record|
-        record.belongs_to_counter_cache_after_create(reflection)
-      }
-
-      model.before_destroy lambda { |record|
-        record.belongs_to_counter_cache_before_destroy(reflection)
-      }
-
       model.after_update lambda { |record|
         record.belongs_to_counter_cache_after_update(reflection)
       }
@@ -130,9 +103,14 @@ module ActiveRecord::Associations::Builder
         BelongsTo.touch_record(record, foreign_key, n, touch)
       }
 
-      model.after_save    callback
+      model.after_save    callback, if: :changed?
       model.after_touch   callback
       model.after_destroy callback
     end
+
+    def self.add_destroy_callbacks(model, reflection)
+      name = reflection.name
+      model.after_destroy lambda { |o| o.association(name).handle_dependency }
+    end
   end
 end

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

@@ -82,7 +82,11 @@ module ActiveRecord::Associations::Builder
 
     def wrap_scope(scope, mod)
       if scope
-        proc { |owner| instance_exec(owner, &scope).extending(mod) }
+        if scope.arity > 0
+          proc { |owner| instance_exec(owner, &scope).extending(mod) }
+        else
+          proc { instance_exec(&scope).extending(mod) }
+        end
       else
         proc { extending(mod) }
       end