activerecord 4.2.11.3 → 5.0.7.2

data/lib/active_record/associations/collection_association.rb

@@ -28,18 +28,19 @@ module ActiveRecord
       # Implements the reader method, e.g. foo.items for Foo.has_many :items
       def reader(force_reload = false)
         if force_reload
+          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+            Passing an argument to force an association to reload is now
+            deprecated and will be removed in Rails 5.1. Please call `reload`
+            on the result collection proxy instead.
+          MSG
+
           klass.uncached { reload }
         elsif stale_target?
           reload
         end
 
-        if owner.new_record?
-          # Cache the proxy separately before the owner has an id
-          # or else a post-save proxy will still lack the id
-          @new_record_proxy ||= CollectionProxy.create(klass, self)
-        else
-          @proxy ||= CollectionProxy.create(klass, self)
-        end
+        @proxy ||= CollectionProxy.create(klass, self)
+        @proxy.reset_scope
       end
 
       # Implements the writer method, e.g. foo.items= for Foo.has_many :items
@@ -54,27 +55,28 @@ module ActiveRecord
             record.send(reflection.association_primary_key)
           end
         else
-          column  = "#{reflection.quoted_table_name}.#{reflection.association_primary_key}"
-          scope.pluck(column)
+          @association_ids ||= (
+            column = "#{reflection.quoted_table_name}.#{reflection.association_primary_key}"
+            scope.pluck(column)
+          )
         end
       end
 
       # Implements the ids writer method, e.g. foo.item_ids= for Foo.has_many :items
       def ids_writer(ids)
-        pk_column = reflection.association_primary_key
-        pk_type = klass.type_for_attribute(pk_column)
-        ids = Array(ids).reject(&:blank?).map do |i|
-          pk_type.type_cast_from_user(i)
-        end
+        pk_type = reflection.association_primary_key_type
+        ids = Array(ids).reject(&:blank?)
+        ids.map! { |i| pk_type.cast(i) }
 
-        objs = klass.where(pk_column => ids).index_by do |r|
-          r.send(pk_column)
+        primary_key = reflection.association_primary_key
+        records = klass.where(primary_key => ids).index_by do |r|
+          r.public_send(primary_key)
         end.values_at(*ids).compact
 
-        if objs.size == ids.size
-          replace(objs.index_by { |r| r.send(pk_column) }.values_at(*ids))
+        if records.size != ids.size
+          klass.all.raise_record_not_found_exception!(ids, records.size, ids.size, primary_key)
         else
-          klass.all.raise_record_not_found_exception!(ids, objs.size, ids.size)
+          replace(records)
         end
       end
 
@@ -136,6 +138,14 @@ module ActiveRecord
         first_nth_or_last(:forty_two, *args)
       end
 
+      def third_to_last(*args)
+        first_nth_or_last(:third_to_last, *args)
+      end
+
+      def second_to_last(*args)
+        first_nth_or_last(:second_to_last, *args)
+      end
+
       def last(*args)
         first_nth_or_last(:last, *args)
       end
@@ -172,6 +182,7 @@ module ActiveRecord
       # be chained. Since << flattens its argument list and inserts each record,
       # +push+ and +concat+ behave identically.
       def concat(*records)
+        records = records.flatten
         if owner.new_record?
           load_target
           concat_records(records)
@@ -239,11 +250,7 @@ module ActiveRecord
 
       # Count all records using SQL.  Construct options and pass them with
       # scope to the target class's +count+.
-      def count(column_name = nil, count_options = {})
-        # TODO: Remove count_options argument as soon we remove support to
-        # activerecord-deprecated_finders.
-        column_name, count_options = nil, column_name if column_name.is_a?(Hash)
-
+      def count(column_name = nil)
         relation = scope
         if association_scope.distinct_value
           # This is needed because 'SELECT count(DISTINCT *)..' is not valid SQL.
@@ -307,10 +314,10 @@ module ActiveRecord
           else
             target.size
           end
-        elsif !loaded? && !association_scope.group_values.empty?
+        elsif !association_scope.group_values.empty?
           load_target.size
-        elsif !loaded? && !association_scope.distinct_value && target.is_a?(Array)
-          unsaved_records = target.select { |r| r.new_record? }
+        elsif !association_scope.distinct_value && target.is_a?(Array)
+          unsaved_records = target.select(&:new_record?)
           unsaved_records.size + count_records
         else
           count_records
@@ -343,7 +350,8 @@ module ActiveRecord
       end
 
       # Returns true if the collections is not empty.
-      # Equivalent to +!collection.empty?+.
+      # If block given, loads all records and checks for one or more matches.
+      # Otherwise, equivalent to +!collection.empty?+.
       def any?
         if block_given?
           load_target.any? { |*block_args| yield(*block_args) }
@@ -353,7 +361,8 @@ module ActiveRecord
       end
 
       # Returns true if the collection has more than 1 record.
-      # Equivalent to +collection.size > 1+.
+      # If block given, loads all records and checks for two or more matches.
+      # Otherwise, equivalent to +collection.size > 1+.
       def many?
         if block_given?
           load_target.many? { |*block_args| yield(*block_args) }
@@ -382,6 +391,8 @@ module ActiveRecord
           replace_common_records_in_memory(other_array, original_target)
           if other_array != original_target
             transaction { replace_records(other_array, original_target) }
+          else
+            other_array
           end
         end
       end
@@ -414,25 +425,9 @@ module ActiveRecord
         replace_on_target(record, index, skip_callbacks, &block)
       end
 
-      def replace_on_target(record, index, skip_callbacks)
-        callback(:before_add, record) unless skip_callbacks
-        yield(record) if block_given?
-
-        if index
-          @target[index] = record
-        else
-          @target << record
-        end
-
-        callback(:after_add, record) unless skip_callbacks
-        set_inverse_instance(record)
-
-        record
-      end
-
-      def scope(opts = {})
-        scope = super()
-        scope.none! if opts.fetch(:nullify, true) && null_scope?
+      def scope
+        scope = super
+        scope.none! if null_scope?
         scope
       end
 
@@ -441,7 +436,7 @@ module ActiveRecord
       end
 
       private
-      def get_records
+      def get_records(&block)
         return scope.to_a if skip_statement_cache?
 
         conn = klass.connection
@@ -453,13 +448,13 @@ module ActiveRecord
         end
 
         binds = AssociationScope.get_bind_values(owner, reflection.chain)
-        sc.execute binds, klass, klass.connection
+        sc.execute(binds, klass, klass.connection, &block)
       end
 
         def find_target
-          records = get_records
-          records.each { |record| set_inverse_instance(record) }
-          records
+          get_records do |record|
+            set_inverse_instance(record)
+          end
         end
 
         # We have some records loaded from the database (persisted) and some that are
@@ -503,15 +498,19 @@ module ActiveRecord
             transaction do
               add_to_target(build_record(attributes)) do |record|
                 yield(record) if block_given?
-                insert_record(record, true, raise)
+                insert_record(record, true, raise) { @_was_loaded = loaded? }
               end
             end
           end
         end
 
         # Do the relevant stuff to insert the given record into the association collection.
-        def insert_record(record, validate = true, raise = false)
-          raise NotImplementedError
+        def insert_record(record, validate = true, raise = false, &block)
+          if raise
+            record.save!(validate: validate, &block)
+          else
+            record.save(validate: validate, &block)
+          end
         end
 
         def create_scope
@@ -521,7 +520,7 @@ module ActiveRecord
         def delete_or_destroy(records, method)
           records = records.flatten
           records.each { |record| raise_on_type_mismatch!(record) }
-          existing_records = records.reject { |r| r.new_record? }
+          existing_records = records.reject(&:new_record?)
 
           if existing_records.empty?
             remove_records(existing_records, records, method)
@@ -565,19 +564,41 @@ module ActiveRecord
           end
         end
 
-        def concat_records(records, should_raise = false)
+        def concat_records(records, raise = false)
           result = true
 
-          records.flatten.each do |record|
+          records.each do |record|
             raise_on_type_mismatch!(record)
-            add_to_target(record) do |rec|
-              result &&= insert_record(rec, true, should_raise) unless owner.new_record?
+            add_to_target(record) do
+              result &&= insert_record(record, true, raise) { @_was_loaded = loaded? } unless owner.new_record?
             end
           end
 
           result && records
         end
 
+        def replace_on_target(record, index, skip_callbacks)
+          callback(:before_add, record) unless skip_callbacks
+
+          set_inverse_instance(record)
+
+          @_was_loaded = true
+
+          yield(record) if block_given?
+
+          if index
+            target[index] = record
+          elsif @_was_loaded || !loaded?
+            target << record
+          end
+
+          callback(:after_add, record) unless skip_callbacks
+
+          record
+        ensure
+          @_was_loaded = nil
+        end
+
         def callback(method, record)
           callbacks_for(method).each do |callback|
             callback.call(method, owner, record)
@@ -612,13 +633,8 @@ module ActiveRecord
           if reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
             assoc = owner.association(reflection.through_reflection.name)
             assoc.reader.any? { |source|
-              target_association = source.send(reflection.source_reflection.name)
-
-              if target_association.respond_to?(:include?)
-                target_association.include?(record)
-              else
-                target_association == record
-              end
+              target_reflection = source.send(reflection.source_reflection.name)
+              target_reflection.respond_to?(:include?) ? target_reflection.include?(record) : target_reflection == record
             } || target.include?(record)
           else
             target.include?(record)
@@ -629,7 +645,7 @@ module ActiveRecord
         # specified, then #find scans the entire collection.
         def find_by_scan(*args)
           expects_array = args.first.kind_of?(Array)
-          ids           = args.flatten.compact.map{ |arg| arg.to_s }.uniq
+          ids           = args.flatten.compact.map(&:to_s).uniq
 
           if ids.size == 1
             id = ids.first

data/lib/active_record/associations/collection_proxy.rb

@@ -28,13 +28,12 @@ module ActiveRecord
     # is computed directly through SQL and does not trigger by itself the
     # instantiation of the actual post records.
     class CollectionProxy < Relation
-      delegate(*(ActiveRecord::Calculations.public_instance_methods - [:count]), to: :scope)
-      delegate :find_nth, to: :scope
-
       def initialize(klass, association) #:nodoc:
         @association = association
-        super klass, klass.arel_table
-        merge! association.scope(nullify: false)
+        super klass, klass.arel_table, klass.predicate_builder
+
+        extensions = association.extensions
+        extend(*extensions) if extensions.any?
       end
 
       def target
@@ -112,7 +111,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 +126,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,32 +170,42 @@ 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)
       end
 
+      # Same as #first except returns only the third-to-last record.
+      def third_to_last(*args)
+        @association.third_to_last(*args)
+      end
+
+      # Same as #first except returns only the second-to-last record.
+      def second_to_last(*args)
+        @association.second_to_last(*args)
+      end
+
       # Returns the last record, or the last +n+ records, from the collection.
       # If the collection is empty, the first form returns +nil+, and the second
       # form returns an empty array.
@@ -227,6 +236,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 +324,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 +341,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 +398,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 +433,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 +452,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 +472,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 +509,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 +566,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,7 +594,7 @@ 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
       # responding to the +id+ and executes delete on them.
@@ -624,7 +658,7 @@ 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
       # responding to the +id+ and then deletes them from the database.
@@ -656,7 +690,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 +727,16 @@ 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
+
+      def calculate(operation, column_name)
+        null_scope? ? scope.calculate(operation, column_name) : super
+      end
+
+      def pluck(*column_names)
+        null_scope? ? scope.pluck(*column_names) : super
       end
 
       # Returns the size of the collection. If the collection hasn't been loaded,
@@ -754,7 +794,7 @@ module ActiveRecord
       # Returns +true+ if the collection is empty. If the collection has been
       # loaded it is equivalent
       # to <tt>collection.size.zero?</tt>. If the collection has not been loaded,
-      # it is equivalent to <tt>collection.exists?</tt>. If the collection has
+      # it is equivalent to <tt>!collection.exists?</tt>. If the collection has
       # not already been loaded and you are going to fetch the records anyway it
       # is better to check <tt>collection.length.zero?</tt>.
       #
@@ -783,7 +823,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,27 +898,14 @@ module ActiveRecord
         !!@association.include?(record)
       end
 
-      def arel
-        scope.arel
-      end
-
       def proxy_association
         @association
       end
 
-      # We don't want this object to be put on the scoping stack, because
-      # that could create an infinite loop where we call an @association
-      # method, which gets the current scope, which is this object, which
-      # delegates to @association, and so on.
-      def scoping
-        @association.scope.scoping { yield }
-      end
-
       # Returns a <tt>Relation</tt> object for the records in this association
       def scope
-        @association.scope
+        @scope ||= @association.scope
       end
-      alias spawn scope
 
       # Equivalent to <tt>Array#==</tt>. Returns +true+ if the two arrays
       # contain the same number of elements and if each element is equal
@@ -946,6 +973,10 @@ module ActiveRecord
       end
       alias_method :to_a, :to_ary
 
+      def records # :nodoc:
+        load_target
+      end
+
       # Adds one or more +records+ to the collection by setting their foreign keys
       # to the association's primary key. Returns +self+, so several appends may be
       # chained together.
@@ -973,12 +1004,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
@@ -1004,7 +1038,7 @@ module ActiveRecord
       #   # => [#<Pet id: 1, name: "Snoop", group: "dogs", person_id: 1>]
       def reload
         proxy_association.reload
-        self
+        reset_scope
       end
 
       # Unloads the association. Returns +self+.
@@ -1026,8 +1060,32 @@ module ActiveRecord
       def reset
         proxy_association.reset
         proxy_association.reset_scope
+        reset_scope
+      end
+
+      def reset_scope # :nodoc:
+        @scope = nil
         self
       end
+
+      delegate_methods = [
+        QueryMethods,
+        SpawnMethods,
+      ].flat_map { |klass|
+        klass.public_instance_methods(false)
+      } - self.public_instance_methods(false) + [:scoping]
+
+      delegate(*delegate_methods, to: :scope)
+
+      private
+
+        def null_scope?
+          @association.null_scope?
+        end
+
+        def exec_queries
+          load_target
+        end
     end
   end
 end