activerecord 3.1.10 → 4.2.11

data/lib/active_record/associations/foreign_association.rb

@@ -0,0 +1,11 @@
+module ActiveRecord::Associations
+  module ForeignAssociation
+    def foreign_key_present?
+      if reflection.klass.primary_key
+        owner.attribute_present?(reflection.active_record_primary_key)
+      else
+        false
+      end
+    end
+  end
+end

data/lib/active_record/associations/has_many_association.rb

@@ -6,9 +6,34 @@ module ActiveRecord
     # If the association has a <tt>:through</tt> option further specialization
     # is provided by its child HasManyThroughAssociation.
     class HasManyAssociation < CollectionAssociation #:nodoc:
+      include ForeignAssociation
+
+      def handle_dependency
+        case options[:dependent]
+        when :restrict_with_exception
+          raise ActiveRecord::DeleteRestrictionError.new(reflection.name) unless empty?
+
+        when :restrict_with_error
+          unless empty?
+            record = klass.human_attribute_name(reflection.name).downcase
+            owner.errors.add(:base, :"restrict_dependent_destroy.many", record: record)
+            false
+          end
+
+        else
+          if options[:dependent] == :destroy
+            # No point in executing the counter update since we're going to destroy the parent anyway
+            load_target.each { |t| t.destroyed_by_association = reflection }
+            destroy_all
+          else
+            delete_all
+          end
+        end
+      end
 
       def insert_record(record, validate = true, raise = false)
         set_owner_attributes(record)
+        set_inverse_instance(record)
 
         if raise
           record.save!(:validate => validate)
@@ -17,13 +42,21 @@ module ActiveRecord
         end
       end
 
+      def empty?
+        if has_cached_counter?
+          size.zero?
+        else
+          super
+        end
+      end
+
       private
 
         # Returns the number of records in this collection.
         #
         # If the association has a counter cache it gets that value. Otherwise
         # it will attempt to do a count via SQL, bounded to <tt>:limit</tt> if
-        # there's one.  Some configuration options like :group make it impossible
+        # there's one. Some configuration options like :group make it impossible
         # to do an SQL count, in those cases the array count will be used.
         #
         # That does not depend on whether the collection has already been loaded
@@ -34,11 +67,9 @@ module ActiveRecord
         # the loaded flag is set to true as well.
         def count_records
           count = if has_cached_counter?
-            owner.send(:read_attribute, cached_counter_attribute_name)
-          elsif options[:counter_sql] || options[:finder_sql]
-            reflection.klass.count_by_sql(custom_counter_sql)
+            owner._read_attribute cached_counter_attribute_name
           else
-            scoped.count
+            scope.count
           end
 
           # If there's nothing in the database and @target has no new records
@@ -46,23 +77,45 @@ module ActiveRecord
           # documented side-effect of the method that may avoid an extra SELECT.
           @target ||= [] and loaded! if count == 0
 
-          [options[:limit], count].compact.min
+          [association_scope.limit_value, count].compact.min
         end
 
-        def has_cached_counter?(reflection = reflection)
-          owner.attribute_present?(cached_counter_attribute_name(reflection))
+
+        # Returns whether a counter cache should be used for this association.
+        #
+        # The counter_cache option must be given on either the owner or inverse
+        # association, and the column must be present on the owner.
+        def has_cached_counter?(reflection = reflection())
+          if reflection.options[:counter_cache] || (inverse = inverse_which_updates_counter_cache(reflection)) && inverse.options[:counter_cache]
+            owner.attribute_present?(cached_counter_attribute_name(reflection))
+          end
         end
 
-        def cached_counter_attribute_name(reflection = reflection)
-          "#{reflection.name}_count"
+        def cached_counter_attribute_name(reflection = reflection())
+          if reflection.options[:counter_cache]
+            reflection.options[:counter_cache].to_s
+          else
+            "#{reflection.name}_count"
+          end
         end
 
-        def update_counter(difference, reflection = reflection)
+        def update_counter(difference, reflection = reflection())
+          update_counter_in_database(difference, reflection)
+          update_counter_in_memory(difference, reflection)
+        end
+
+        def update_counter_in_database(difference, reflection = reflection())
           if has_cached_counter?(reflection)
             counter = cached_counter_attribute_name(reflection)
             owner.class.update_counters(owner.id, counter => difference)
+          end
+        end
+
+        def update_counter_in_memory(difference, reflection = reflection())
+          if counter_must_be_updated_by_has_many?(reflection)
+            counter = cached_counter_attribute_name(reflection)
             owner[counter] += difference
-            owner.changed_attributes.delete(counter) # eww
+            owner.send(:clear_attribute_changes, counter) # eww
           end
         end
 
@@ -76,28 +129,70 @@ module ActiveRecord
         #     it will be decremented twice.
         #
         # Hence this method.
-        def inverse_updates_counter_cache?(reflection = reflection)
+        def inverse_which_updates_counter_cache(reflection = reflection())
           counter_name = cached_counter_attribute_name(reflection)
-          reflection.klass.reflect_on_all_associations(:belongs_to).any? { |inverse_reflection|
+          inverse_which_updates_counter_named(counter_name, reflection)
+        end
+        alias inverse_updates_counter_cache? inverse_which_updates_counter_cache
+
+        def inverse_which_updates_counter_named(counter_name, reflection)
+          reflection.klass._reflections.values.find { |inverse_reflection|
+            inverse_reflection.belongs_to? &&
             inverse_reflection.counter_cache_column == counter_name
           }
         end
+        alias inverse_updates_counter_named? inverse_which_updates_counter_named
+
+        def inverse_updates_counter_in_memory?(reflection)
+          inverse = inverse_which_updates_counter_cache(reflection)
+          inverse && inverse == reflection.inverse_of
+        end
+
+        def counter_must_be_updated_by_has_many?(reflection)
+          !inverse_updates_counter_in_memory?(reflection) && has_cached_counter?(reflection)
+        end
+
+        def delete_count(method, scope)
+          if method == :delete_all
+            scope.delete_all
+          else
+            scope.update_all(reflection.foreign_key => nil)
+          end
+        end
+
+        def delete_or_nullify_all_records(method)
+          count = delete_count(method, self.scope)
+          update_counter(-count)
+        end
 
         # Deletes the records according to the <tt>:dependent</tt> option.
         def delete_records(records, method)
           if method == :destroy
-            records.each { |r| r.destroy }
+            records.each(&:destroy!)
             update_counter(-records.length) unless inverse_updates_counter_cache?
           else
-            keys  = records.map { |r| r[reflection.association_primary_key] }
-            scope = scoped.where(reflection.association_primary_key => keys)
-
-            if method == :delete_all
-              update_counter(-scope.delete_all)
-            else
-              update_counter(-scope.update_all(reflection.foreign_key => nil))
-            end
+            scope = self.scope.where(reflection.klass.primary_key => records)
+            update_counter(-delete_count(method, scope))
+          end
+        end
+
+        def concat_records(records, *)
+          update_counter_if_success(super, records.length)
+        end
+
+        def _create_record(attributes, *)
+          if attributes.is_a?(Array)
+            super
+          else
+            update_counter_if_success(super, 1)
+          end
+        end
+
+        def update_counter_if_success(saved_successfully, difference)
+          if saved_successfully
+            update_counter_in_memory(difference)
           end
+          saved_successfully
         end
     end
   end

data/lib/active_record/associations/has_many_through_association.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/string/filters'
 
 module ActiveRecord
   # = Active Record Has Many Through Association
@@ -8,34 +8,50 @@ module ActiveRecord
 
       def initialize(owner, reflection)
         super
-        @through_records = {}
+
+        @through_records     = {}
+        @through_association = nil
       end
 
-      # Returns the size of the collection by executing a SELECT COUNT(*) query if the collection hasn't been
-      # loaded and calling collection.size if it has. If it's more likely than not that the collection does
-      # have a size larger than zero, and you need to fetch that collection afterwards, it'll take one fewer
-      # SELECT query if you use #length.
+      # Returns the size of the collection by executing a SELECT COUNT(*) query
+      # if the collection hasn't been loaded, and by calling collection.size if
+      # it has. If the collection will likely have a size greater than zero,
+      # and if fetching the collection will be needed afterwards, one less
+      # SELECT query will be generated by using #length instead.
       def size
         if has_cached_counter?
-          owner.send(:read_attribute, cached_counter_attribute_name)
+          owner._read_attribute cached_counter_attribute_name(reflection)
         elsif loaded?
           target.size
         else
-          count
+          super
         end
       end
 
       def concat(*records)
         unless owner.new_record?
           records.flatten.each do |record|
-            raise_on_type_mismatch(record)
-            record.save! if record.new_record?
+            raise_on_type_mismatch!(record)
           end
         end
 
         super
       end
 
+      def concat_records(records)
+        ensure_not_nested
+
+        records = super(records, true)
+
+        if owner.new_record? && records
+          records.flatten.each do |record|
+            build_through_record(record)
+          end
+        end
+
+        records
+      end
+
       def insert_record(record, validate = true, raise = false)
         ensure_not_nested
 
@@ -48,51 +64,71 @@ module ActiveRecord
         end
 
         save_through_record(record)
-        update_counter(1)
+        if has_cached_counter? && !through_reflection_updates_counter_cache?
+          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+            Automatic updating of counter caches on through associations has been
+            deprecated, and will be removed in Rails 5. Instead, please set the
+            appropriate `counter_cache` options on the `has_many` and `belongs_to`
+            for your associations to #{through_reflection.name}.
+          MSG
+
+          update_counter_in_database(1)
+        end
         record
       end
 
-      # ActiveRecord::Relation#delete_all needs to support joins before we can use a
-      # SQL-only implementation.
-      alias delete_all_on_destroy delete_all
-
       private
 
         def through_association
-          owner.association(through_reflection.name)
+          @through_association ||= owner.association(through_reflection.name)
         end
 
-        # We temporarily cache through record that has been build, because if we build a
-        # through record in build_record and then subsequently call insert_record, then we
-        # want to use the exact same object.
+        # The through record (built with build_record) is temporarily cached
+        # so that it may be reused if insert_record is subsequently called.
         #
-        # However, after insert_record has been called, we clear the cache entry because
-        # we want it to be possible to have multiple instances of the same record in an
-        # association
+        # However, after insert_record has been called, the cache is cleared in
+        # order to allow multiple instances of the same record in an association.
         def build_through_record(record)
           @through_records[record.object_id] ||= begin
-            through_record = through_association.build(construct_join_attributes(record))
+            ensure_mutable
+
+            through_record = through_association.build(*options_for_through_record)
             through_record.send("#{source_reflection.name}=", record)
+
+            if options[:source_type]
+              through_record.send("#{source_reflection.foreign_type}=", options[:source_type])
+            end
+
             through_record
           end
         end
 
+        def options_for_through_record
+          [through_scope_attributes]
+        end
+
+        def through_scope_attributes
+          scope.where_values_hash(through_association.reflection.name.to_s).
+            except!(through_association.reflection.foreign_key,
+                    through_association.reflection.klass.inheritance_column)
+        end
+
         def save_through_record(record)
           build_through_record(record).save!
         ensure
           @through_records.delete(record.object_id)
         end
 
-        def build_record(attributes, options = {})
+        def build_record(attributes)
           ensure_not_nested
 
-          record = super(attributes, options)
+          record = super(attributes)
 
           inverse = source_reflection.inverse_of
           if inverse
-            if inverse.macro == :has_many
+            if inverse.collection?
               record.send(inverse.name) << build_through_record(record)
-            elsif inverse.macro == :has_one
+            elsif inverse.has_one?
               record.send("#{inverse.name}=", build_through_record(record))
             end
           end
@@ -101,11 +137,7 @@ module ActiveRecord
         end
 
         def target_reflection_has_associated_record?
-          if through_reflection.macro == :belongs_to && owner[through_reflection.foreign_key].blank?
-            false
-          else
-            true
-          end
+          !(through_reflection.belongs_to? && owner[through_reflection.foreign_key].blank?)
         end
 
         def update_through_counter?(method)
@@ -119,44 +151,73 @@ module ActiveRecord
           end
         end
 
+        def delete_or_nullify_all_records(method)
+          delete_records(load_target, method)
+        end
+
         def delete_records(records, method)
           ensure_not_nested
 
-          through = through_association
-          scope   = through.scoped.where(construct_join_attributes(*records))
+          scope = through_association.scope
+          scope.where! construct_join_attributes(*records)
 
           case method
           when :destroy
-            count = scope.destroy_all.length
+            if scope.klass.primary_key
+              count = scope.destroy_all.length
+            else
+              scope.each do |record|
+                record._run_destroy_callbacks
+              end
+
+              arel = scope.arel
+
+              stmt = Arel::DeleteManager.new arel.engine
+              stmt.from scope.klass.arel_table
+              stmt.wheres = arel.constraints
+
+              count = scope.klass.connection.delete(stmt, 'SQL', scope.bind_values)
+            end
           when :nullify
             count = scope.update_all(source_reflection.foreign_key => nil)
           else
             count = scope.delete_all
           end
 
-          delete_through_records(through, records)
+          delete_through_records(records)
 
-          if through_reflection.macro == :has_many && update_through_counter?(method)
-            update_counter(-count, through_reflection)
+          if source_reflection.options[:counter_cache] && method != :destroy
+            counter = source_reflection.counter_cache_column
+            klass.decrement_counter counter, records.map(&:id)
           end
 
-          update_counter(-count)
+          if through_reflection.collection? && update_through_counter?(method)
+            update_counter(-count, through_reflection)
+          else
+            update_counter(-count)
+          end
         end
 
         def through_records_for(record)
           attributes = construct_join_attributes(record)
           candidates = Array.wrap(through_association.target)
-          candidates.find_all { |c| c.attributes.slice(*attributes.keys) == attributes }
+          candidates.find_all do |c|
+            attributes.all? do |key, value|
+              c.public_send(key) == value
+            end
+          end
         end
 
-        def delete_through_records(through, records)
+        def delete_through_records(records)
           records.each do |record|
             through_records = through_records_for(record)
 
-            if through_reflection.macro == :has_many
-              through_records.each { |r| through.target.delete(r) }
+            if through_reflection.collection?
+              through_records.each { |r| through_association.target.delete(r) }
             else
-              through.target = nil if through_records.include?(through.target)
+              if through_records.include?(through_association.target)
+                through_association.target = nil
+              end
             end
 
             @through_records.delete(record.object_id)
@@ -165,13 +226,22 @@ module ActiveRecord
 
         def find_target
           return [] unless target_reflection_has_associated_record?
-          scoped.all
+          get_records
         end
 
         # NOTE - not sure that we can actually cope with inverses here
         def invertible_for?(record)
           false
         end
+
+        def has_cached_counter?(reflection = reflection())
+          owner.attribute_present?(cached_counter_attribute_name(reflection))
+        end
+
+        def through_reflection_updates_counter_cache?
+          counter_name = cached_counter_attribute_name
+          inverse_updates_counter_named?(counter_name, through_reflection)
+        end
     end
   end
 end

data/lib/active_record/associations/has_one_association.rb

@@ -1,26 +1,48 @@
-require 'active_support/core_ext/object/inclusion'
-
 module ActiveRecord
   # = Active Record Belongs To Has One Association
   module Associations
     class HasOneAssociation < SingularAssociation #:nodoc:
+      include ForeignAssociation
+
+      def handle_dependency
+        case options[:dependent]
+        when :restrict_with_exception
+          raise ActiveRecord::DeleteRestrictionError.new(reflection.name) if load_target
+
+        when :restrict_with_error
+          if load_target
+            record = klass.human_attribute_name(reflection.name).downcase
+            owner.errors.add(:base, :"restrict_dependent_destroy.one", record: record)
+            false
+          end
+
+        else
+          delete
+        end
+      end
+
       def replace(record, save = true)
-        raise_on_type_mismatch(record) if record
+        raise_on_type_mismatch!(record) if record
         load_target
 
-        reflection.klass.transaction do
-          if target && target != record
-            remove_target!(options[:dependent]) unless target.destroyed?
-          end
+        return self.target if !(target || record)
+
+        assigning_another_record = target != record
+        if assigning_another_record || record.changed?
+          save &&= owner.persisted?
+
+          transaction_if(save) do
+            remove_target!(options[:dependent]) if target && !target.destroyed? && assigning_another_record
 
-          if record
-            set_owner_attributes(record)
-            set_inverse_instance(record)
+            if record
+              set_owner_attributes(record)
+              set_inverse_instance(record)
 
-            if owner.persisted? && save && !record.save
-              nullify_owner_attributes(record)
-              set_owner_attributes(target) if target
-              raise RecordNotSaved, "Failed to save the new associated #{reflection.name}."
+              if save && !record.save
+                nullify_owner_attributes(record)
+                set_owner_attributes(target) if target
+                raise RecordNotSaved, "Failed to save the new associated #{reflection.name}."
+              end
             end
           end
         end
@@ -36,7 +58,7 @@ module ActiveRecord
             when :destroy
               target.destroy
             when :nullify
-              target.update_attribute(reflection.foreign_key, nil)
+              target.update_columns(reflection.foreign_key => nil)
           end
         end
       end
@@ -52,22 +74,33 @@ module ActiveRecord
         end
 
         def remove_target!(method)
-          if method.in?([:delete, :destroy])
-            target.send(method)
-          else
-            nullify_owner_attributes(target)
+          case method
+            when :delete
+              target.delete
+            when :destroy
+              target.destroy
+            else
+              nullify_owner_attributes(target)
 
-            if target.persisted? && owner.persisted? && !target.save
-              set_owner_attributes(target)
-              raise RecordNotSaved, "Failed to remove the existing associated #{reflection.name}. " +
-                                    "The record failed to save when after its foreign key was set to nil."
-            end
+              if target.persisted? && owner.persisted? && !target.save
+                set_owner_attributes(target)
+                raise RecordNotSaved, "Failed to remove the existing associated #{reflection.name}. " +
+                                      "The record failed to save after its foreign key was set to nil."
+              end
           end
         end
 
         def nullify_owner_attributes(record)
           record[reflection.foreign_key] = nil
         end
+
+        def transaction_if(value)
+          if value
+            reflection.klass.transaction { yield }
+          else
+            yield
+          end
+        end
     end
   end
 end

data/lib/active_record/associations/has_one_through_association.rb

@@ -23,7 +23,7 @@ module ActiveRecord
             attributes = construct_join_attributes(record)
 
             if through_record
-              through_record.update_attributes(attributes)
+              through_record.update(attributes)
             elsif owner.new_record?
               through_proxy.build(attributes)
             else