activerecord 4.2.11.3 → 5.0.0.beta1

data/lib/active_record/associations/collection_proxy.rb

@@ -33,7 +33,7 @@ module ActiveRecord
 
       def initialize(klass, association) #:nodoc:
         @association = association
-        super klass, klass.arel_table
+        super klass, klass.arel_table, klass.predicate_builder
         merge! association.scope(nullify: false)
       end
 
@@ -112,7 +112,7 @@ module ActiveRecord
       end
 
       # Finds an object in the collection responding to the +id+. Uses the same
-      # rules as <tt>ActiveRecord::Base.find</tt>. Returns <tt>ActiveRecord::RecordNotFound</tt>
+      # rules as ActiveRecord::Base.find. Returns ActiveRecord::RecordNotFound
       # error if the object cannot be found.
       #
       #   class Person < ActiveRecord::Base
@@ -127,7 +127,7 @@ module ActiveRecord
       #   #    ]
       #
       #   person.pets.find(1) # => #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>
-      #   person.pets.find(4) # => ActiveRecord::RecordNotFound: Couldn't find Pet with id=4
+      #   person.pets.find(4) # => ActiveRecord::RecordNotFound: Couldn't find Pet with 'id'=4
       #
       #   person.pets.find(2) { |pet| pet.name.downcase! }
       #   # => #<Pet id: 2, name: "fancy-fancy", person_id: 1>
@@ -171,27 +171,27 @@ module ActiveRecord
         @association.first(*args)
       end
 
-      # Same as +first+ except returns only the second record.
+      # Same as #first except returns only the second record.
       def second(*args)
         @association.second(*args)
       end
 
-      # Same as +first+ except returns only the third record.
+      # Same as #first except returns only the third record.
       def third(*args)
         @association.third(*args)
       end
 
-      # Same as +first+ except returns only the fourth record.
+      # Same as #first except returns only the fourth record.
       def fourth(*args)
         @association.fourth(*args)
       end
 
-      # Same as +first+ except returns only the fifth record.
+      # Same as #first except returns only the fifth record.
       def fifth(*args)
         @association.fifth(*args)
       end
 
-      # Same as +first+ except returns only the forty second record.
+      # Same as #first except returns only the forty second record.
       # Also known as accessing "the reddit".
       def forty_two(*args)
         @association.forty_two(*args)
@@ -227,6 +227,31 @@ module ActiveRecord
         @association.last(*args)
       end
 
+      # Gives a record (or N records if a parameter is supplied) from the collection
+      # using the same rules as <tt>ActiveRecord::Base.take</tt>.
+      #
+      #   class Person < ActiveRecord::Base
+      #     has_many :pets
+      #   end
+      #
+      #   person.pets
+      #   # => [
+      #   #       #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
+      #   #       #<Pet id: 2, name: "Spook", person_id: 1>,
+      #   #       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
+      #   #    ]
+      #
+      #   person.pets.take # => #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>
+      #
+      #   person.pets.take(2)
+      #   # => [
+      #   #      #<Pet id: 1, name: "Fancy-Fancy", person_id: 1>,
+      #   #      #<Pet id: 2, name: "Spook", person_id: 1>
+      #   #    ]
+      #
+      #   another_person_without.pets         # => []
+      #   another_person_without.pets.take    # => nil
+      #   another_person_without.pets.take(2) # => []
       def take(n = nil)
         @association.take(n)
       end
@@ -290,7 +315,7 @@ module ActiveRecord
         @association.create(attributes, &block)
       end
 
-      # Like +create+, except that if the record is invalid, raises an exception.
+      # Like #create, except that if the record is invalid, raises an exception.
       #
       #   class Person
       #     has_many :pets
@@ -307,8 +332,8 @@ module ActiveRecord
       end
 
       # Add one or more records to the collection by setting their foreign keys
-      # to the association's primary key. Since << flattens its argument list and
-      # inserts each record, +push+ and +concat+ behave identically. Returns +self+
+      # to the association's primary key. Since #<< flattens its argument list and
+      # inserts each record, +push+ and #concat behave identically. Returns +self+
       # so method calls may be chained.
       #
       #   class Person < ActiveRecord::Base
@@ -364,7 +389,7 @@ module ActiveRecord
       # specified by the +:dependent+ option. If no +:dependent+ option is given,
       # then it will follow the default strategy.
       #
-      # For +has_many :through+ associations, the default deletion strategy is
+      # For <tt>has_many :through</tt> associations, the default deletion strategy is
       # +:delete_all+.
       #
       # For +has_many+ associations, the default deletion strategy is +:nullify+.
@@ -399,7 +424,7 @@ module ActiveRecord
       #   #       #<Pet id: 3, name: "Choo-Choo", person_id: nil>
       #   #    ]
       #
-      # Both +has_many+ and +has_many :through+ dependencies default to the
+      # Both +has_many+ and <tt>has_many :through</tt> dependencies default to the
       # +:delete_all+ strategy if the +:dependent+ option is set to +:destroy+.
       # Records are not instantiated and callbacks will not be fired.
       #
@@ -418,7 +443,7 @@ module ActiveRecord
       #   person.pets.delete_all
       #
       #   Pet.find(1, 2, 3)
-      #   # => ActiveRecord::RecordNotFound
+      #   # => ActiveRecord::RecordNotFound: Couldn't find all Pets with 'id': (1, 2, 3)
       #
       # If it is set to <tt>:delete_all</tt>, all the objects are deleted
       # *without* calling their +destroy+ method.
@@ -438,7 +463,7 @@ module ActiveRecord
       #   person.pets.delete_all
       #
       #   Pet.find(1, 2, 3)
-      #   # => ActiveRecord::RecordNotFound
+      #   # => ActiveRecord::RecordNotFound: Couldn't find all Pets with 'id': (1, 2, 3)
       def delete_all(dependent = nil)
         @association.delete_all(dependent)
       end
@@ -475,7 +500,7 @@ module ActiveRecord
       # then it will follow the default strategy. Returns an array with the
       # deleted records.
       #
-      # For +has_many :through+ associations, the default deletion strategy is
+      # For <tt>has_many :through</tt> associations, the default deletion strategy is
       # +:delete_all+.
       #
       # For +has_many+ associations, the default deletion strategy is +:nullify+.
@@ -532,7 +557,7 @@ module ActiveRecord
       #   # => [#<Pet id: 2, name: "Spook", person_id: 1>]
       #
       #   Pet.find(1, 3)
-      #   # => ActiveRecord::RecordNotFound: Couldn't find all Pets with IDs (1, 3)
+      #   # => ActiveRecord::RecordNotFound: Couldn't find all Pets with 'id': (1, 3)
       #
       # If it is set to <tt>:delete_all</tt>, all the +records+ are deleted
       # *without* calling their +destroy+ method.
@@ -560,9 +585,9 @@ module ActiveRecord
       #   #    ]
       #
       #   Pet.find(1)
-      #   # => ActiveRecord::RecordNotFound: Couldn't find Pet with id=1
+      #   # => ActiveRecord::RecordNotFound: Couldn't find Pet with 'id'=1
       #
-      # You can pass +Integer+ or +String+ values, it finds the records
+      # You can pass +Fixnum+ or +String+ values, it finds the records
       # responding to the +id+ and executes delete on them.
       #
       #   class Person < ActiveRecord::Base
@@ -624,9 +649,9 @@ module ActiveRecord
       #   person.pets.size  # => 0
       #   person.pets       # => []
       #
-      #   Pet.find(1, 2, 3) # => ActiveRecord::RecordNotFound: Couldn't find all Pets with IDs (1, 2, 3)
+      #   Pet.find(1, 2, 3) # => ActiveRecord::RecordNotFound: Couldn't find all Pets with 'id': (1, 2, 3)
       #
-      # You can pass +Integer+ or +String+ values, it finds the records
+      # You can pass +Fixnum+ or +String+ values, it finds the records
       # responding to the +id+ and then deletes them from the database.
       #
       #   person.pets.size # => 3
@@ -656,7 +681,7 @@ module ActiveRecord
       #   person.pets.size  # => 0
       #   person.pets       # => []
       #
-      #   Pet.find(4, 5, 6) # => ActiveRecord::RecordNotFound: Couldn't find all Pets with IDs (4, 5, 6)
+      #   Pet.find(4, 5, 6) # => ActiveRecord::RecordNotFound: Couldn't find all Pets with 'id': (4, 5, 6)
       def destroy(*records)
         @association.destroy(*records)
       end
@@ -693,10 +718,8 @@ module ActiveRecord
       #   #       #<Pet id: 2, name: "Spook", person_id: 1>,
       #   #       #<Pet id: 3, name: "Choo-Choo", person_id: 1>
       #   #    ]
-      def count(column_name = nil, options = {})
-        # TODO: Remove options argument as soon we remove support to
-        # activerecord-deprecated_finders.
-        @association.count(column_name, options)
+      def count(column_name = nil)
+        @association.count(column_name)
       end
 
       # Returns the size of the collection. If the collection hasn't been loaded,
@@ -783,7 +806,7 @@ module ActiveRecord
       #   person.pets.any?  # => false
       #
       #   person.pets << Pet.new(name: 'Snoop')
-      #   person.pets.count # => 0
+      #   person.pets.count # => 1
       #   person.pets.any?  # => true
       #
       # You can also pass a +block+ to define criteria. The behavior
@@ -858,7 +881,7 @@ module ActiveRecord
         !!@association.include?(record)
       end
 
-      def arel
+      def arel #:nodoc:
         scope.arel
       end
 
@@ -973,12 +996,15 @@ module ActiveRecord
       alias_method :append, :<<
 
       def prepend(*args)
-        raise NoMethodError, "prepend on association is not defined. Please use << or append"
+        raise NoMethodError, "prepend on association is not defined. Please use <<, push or append"
       end
 
       # Equivalent to +delete_all+. The difference is that returns +self+, instead
       # of an array with the deleted objects, so methods can be chained. See
       # +delete_all+ for more information.
+      # Note that because +delete_all+ removes records by directly
+      # running an SQL query into the database, the +updated_at+ column of
+      # the object is not changed.
       def clear
         delete_all
         self

data/lib/active_record/associations/foreign_association.rb

@@ -1,5 +1,5 @@
 module ActiveRecord::Associations
-  module ForeignAssociation
+  module ForeignAssociation # :nodoc:
     def foreign_key_present?
       if reflection.klass.primary_key
         owner.attribute_present?(reflection.active_record_primary_key)

data/lib/active_record/associations/has_many_association.rb

@@ -15,9 +15,16 @@ module ActiveRecord
 
         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
+            record = owner.class.human_attribute_name(reflection.name).downcase
+            message = owner.errors.generate_message(:base, :'restrict_dependent_destroy.many', record: record, raise: true) rescue nil
+            if message
+              ActiveSupport::Deprecation.warn(<<-MESSAGE.squish)
+                The error key `:'restrict_dependent_destroy.many'` has been deprecated and will be removed in Rails 5.1.
+                Please use `:'restrict_dependent_destroy.has_many'` instead.
+              MESSAGE
+            end
+            owner.errors.add(:base, message || :'restrict_dependent_destroy.has_many', record: record)
+            throw(:abort)
           end
 
         else
@@ -43,7 +50,7 @@ module ActiveRecord
       end
 
       def empty?
-        if has_cached_counter?
+        if reflection.has_cached_counter?
           size.zero?
         else
           super
@@ -66,8 +73,8 @@ module ActiveRecord
         # If the collection is empty the target is set to an empty array and
         # the loaded flag is set to true as well.
         def count_records
-          count = if has_cached_counter?
-            owner._read_attribute cached_counter_attribute_name
+          count = if reflection.has_cached_counter?
+            owner._read_attribute reflection.counter_cache_column
           else
             scope.count
           end
@@ -80,78 +87,20 @@ module ActiveRecord
           [association_scope.limit_value, count].compact.min
         end
 
-
-        # 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())
-          if reflection.options[:counter_cache]
-            reflection.options[:counter_cache].to_s
-          else
-            "#{reflection.name}_count"
-          end
-        end
-
         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)
+          if reflection.has_cached_counter?
+            owner.increment!(reflection.counter_cache_column, 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.send(:clear_attribute_changes, counter) # eww
+          if reflection.counter_must_be_updated_by_has_many?
+            counter = reflection.counter_cache_column
+            owner.increment(counter, difference)
+            owner.send(:clear_attribute_change, counter) # eww
           end
         end
 
-        # This shit is nasty. We need to avoid the following situation:
-        #
-        #   * An associated record is deleted via record.destroy
-        #   * Hence the callbacks run, and they find a belongs_to on the record with a
-        #     :counter_cache options which points back at our owner. So they update the
-        #     counter cache.
-        #   * In which case, we must make sure to *not* update the counter cache, or else
-        #     it will be decremented twice.
-        #
-        # Hence this method.
-        def inverse_which_updates_counter_cache(reflection = reflection())
-          counter_name = cached_counter_attribute_name(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
@@ -169,7 +118,7 @@ module ActiveRecord
         def delete_records(records, method)
           if method == :destroy
             records.each(&:destroy!)
-            update_counter(-records.length) unless inverse_updates_counter_cache?
+            update_counter(-records.length) unless reflection.inverse_updates_counter_cache?
           else
             scope = self.scope.where(reflection.klass.primary_key => records)
             update_counter(-delete_count(method, scope))

data/lib/active_record/associations/has_many_through_association.rb

@@ -1,5 +1,3 @@
-require 'active_support/core_ext/string/filters'
-
 module ActiveRecord
   # = Active Record Has Many Through Association
   module Associations
@@ -13,21 +11,6 @@ module ActiveRecord
         @through_association = nil
       end
 
-      # 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._read_attribute cached_counter_attribute_name(reflection)
-        elsif loaded?
-          target.size
-        else
-          super
-        end
-      end
-
       def concat(*records)
         unless owner.new_record?
           records.flatten.each do |record|
@@ -55,25 +38,14 @@ module ActiveRecord
       def insert_record(record, validate = true, raise = false)
         ensure_not_nested
 
-        if record.new_record?
-          if raise
-            record.save!(:validate => validate)
-          else
-            return unless record.save(:validate => validate)
-          end
+        if raise
+          record.save!(:validate => validate)
+        else
+          return unless record.save(:validate => validate)
         end
 
         save_through_record(record)
-        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
 
@@ -94,11 +66,6 @@ module ActiveRecord
 
             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
@@ -143,7 +110,7 @@ module ActiveRecord
         def update_through_counter?(method)
           case method
           when :destroy
-            !inverse_updates_counter_cache?(through_reflection)
+            !through_reflection.inverse_updates_counter_cache?
           when :nullify
             false
           else
@@ -166,17 +133,15 @@ module ActiveRecord
             if scope.klass.primary_key
               count = scope.destroy_all.length
             else
-              scope.each do |record|
-                record._run_destroy_callbacks
-              end
+              scope.each(&:_run_destroy_callbacks)
 
               arel = scope.arel
 
-              stmt = Arel::DeleteManager.new arel.engine
+              stmt = Arel::DeleteManager.new
               stmt.from scope.klass.arel_table
               stmt.wheres = arel.constraints
 
-              count = scope.klass.connection.delete(stmt, 'SQL', scope.bind_values)
+              count = scope.klass.connection.delete(stmt, 'SQL', scope.bound_attributes)
             end
           when :nullify
             count = scope.update_all(source_reflection.foreign_key => nil)
@@ -233,15 +198,6 @@ module ActiveRecord
         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