activerecord 4.1.16 → 4.2.11.3

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

@@ -5,7 +5,7 @@ module ActiveRecord::Associations::Builder
     end
 
     def valid_options
-      valid = super + [:order, :as]
+      valid = super + [:as, :foreign_type]
       valid += [:through, :source, :source_type] if options[:through]
       valid
     end
@@ -16,7 +16,7 @@ module ActiveRecord::Associations::Builder
 
     private
 
-    def self.add_before_destroy_callbacks(model, reflection)
+    def self.add_destroy_callbacks(model, reflection)
       super unless reflection.options[:through]
     end
   end

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

@@ -3,7 +3,7 @@
 module ActiveRecord::Associations::Builder
   class SingularAssociation < Association #:nodoc:
     def valid_options
-      super + [:remote, :dependent, :primary_key, :inverse_of]
+      super + [:dependent, :primary_key, :inverse_of, :required]
     end
 
     def self.define_accessors(model, reflection)
@@ -27,5 +27,12 @@ module ActiveRecord::Associations::Builder
         end
       CODE
     end
+
+    def self.define_validations(model, reflection)
+      super
+      if reflection.options[:required]
+        model.validates_presence_of reflection.name
+      end
+    end
   end
 end

data/lib/active_record/associations/collection_association.rb

@@ -61,10 +61,21 @@ module ActiveRecord
 
       # Implements the ids writer method, e.g. foo.item_ids= for Foo.has_many :items
       def ids_writer(ids)
-        pk_column = reflection.primary_key_column
-        ids = Array(ids).reject { |id| id.blank? }
-        ids.map! { |i| pk_column.type_cast(i) }
-        replace(klass.find(ids).index_by { |r| r.id }.values_at(*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
+
+        objs = klass.where(pk_column => ids).index_by do |r|
+          r.send(pk_column)
+        end.values_at(*ids).compact
+
+        if objs.size == ids.size
+          replace(objs.index_by { |r| r.send(pk_column) }.values_at(*ids))
+        else
+          klass.all.raise_record_not_found_exception!(ids, objs.size, ids.size)
+        end
       end
 
       def reset
@@ -161,9 +172,8 @@ module ActiveRecord
       # be chained. Since << flattens its argument list and inserts each record,
       # +push+ and +concat+ behave identically.
       def concat(*records)
-        load_target if owner.new_record?
-
         if owner.new_record?
+          load_target
           concat_records(records)
         else
           transaction { concat_records(records) }
@@ -186,8 +196,8 @@ module ActiveRecord
       end
 
       # Removes all records from the association without calling callbacks
-      # on the associated records. It honors the `:dependent` option. However
-      # if the `:dependent` value is `:destroy` then in that case the `:delete_all`
+      # on the associated records. It honors the +:dependent+ option. However
+      # if the +:dependent+ value is +:destroy+ then in that case the +:delete_all+
       # deletion strategy for the association is applied.
       #
       # You can force a particular deletion strategy by passing a parameter.
@@ -199,11 +209,11 @@ module ActiveRecord
       #
       # See delete for more info.
       def delete_all(dependent = nil)
-        if dependent.present? && ![:nullify, :delete_all].include?(dependent)
+        if dependent && ![:nullify, :delete_all].include?(dependent)
           raise ArgumentError, "Valid values are :nullify or :delete_all"
         end
 
-        dependent = if dependent.present?
+        dependent = if dependent
                       dependent
                     elsif options[:dependent] == :destroy
                       :delete_all
@@ -211,7 +221,7 @@ module ActiveRecord
                       options[:dependent]
                     end
 
-        delete(:all, dependent: dependent).tap do
+        delete_or_nullify_all_records(dependent).tap do
           reset
           loaded!
         end
@@ -261,19 +271,12 @@ module ActiveRecord
       # are actually removed from the database, that depends precisely on
       # +delete_records+. They are in any case removed from the collection.
       def delete(*records)
+        return if records.empty?
         _options = records.extract_options!
         dependent = _options[:dependent] || options[:dependent]
 
-        if records.first == :all
-          if (loaded? || dependent == :destroy) && dependent != :delete_all
-            delete_or_destroy(load_target, dependent)
-          else
-            delete_records(:all, dependent)
-          end
-        else
-          records = find(records) if records.any? { |record| record.kind_of?(Fixnum) || record.kind_of?(String) }
-          delete_or_destroy(records, dependent)
-        end
+        records = find(records) if records.any? { |record| record.kind_of?(Integer) || record.kind_of?(String) }
+        delete_or_destroy(records, dependent)
       end
 
       # Deletes the +records+ and removes them from this association calling
@@ -282,7 +285,8 @@ module ActiveRecord
       # Note that this method removes records from the database ignoring the
       # +:dependent+ option.
       def destroy(*records)
-        records = find(records) if records.any? { |record| record.kind_of?(Fixnum) || record.kind_of?(String) }
+        return if records.empty?
+        records = find(records) if records.any? { |record| record.kind_of?(Integer) || record.kind_of?(String) }
         delete_or_destroy(records, :destroy)
       end
 
@@ -375,7 +379,10 @@ module ActiveRecord
         if owner.new_record?
           replace_records(other_array, original_target)
         else
-          transaction { replace_records(other_array, original_target) }
+          replace_common_records_in_memory(other_array, original_target)
+          if other_array != original_target
+            transaction { replace_records(other_array, original_target) }
+          end
         end
       end
 
@@ -384,7 +391,7 @@ module ActiveRecord
           if record.new_record?
             include_in_memory?(record)
           else
-            loaded? ? target.include?(record) : scope.exists?(record)
+            loaded? ? target.include?(record) : scope.exists?(record.id)
           end
         else
           false
@@ -400,11 +407,18 @@ module ActiveRecord
         target
       end
 
-      def add_to_target(record, skip_callbacks = false)
+      def add_to_target(record, skip_callbacks = false, &block)
+        if association_scope.distinct_value
+          index = @target.index(record)
+        end
+        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 association_scope.distinct_value && index = @target.index(record)
+        if index
           @target[index] = record
         else
           @target << record
@@ -427,9 +441,23 @@ module ActiveRecord
       end
 
       private
+      def get_records
+        return scope.to_a if skip_statement_cache?
+
+        conn = klass.connection
+        sc = reflection.association_scope_cache(conn, owner) do
+          StatementCache.create(conn) { |params|
+            as = AssociationScope.create { params.bind }
+            target_scope.merge as.scope(self, conn)
+          }
+        end
+
+        binds = AssociationScope.get_bind_values(owner, reflection.chain)
+        sc.execute binds, klass, klass.connection
+      end
 
         def find_target
-          records = scope.to_a
+          records = get_records
           records.each { |record| set_inverse_instance(record) }
           records
         end
@@ -529,6 +557,14 @@ module ActiveRecord
           target
         end
 
+        def replace_common_records_in_memory(new_target, original_target)
+          common_records = new_target & original_target
+          common_records.each do |record|
+            skip_callbacks = true
+            replace_on_target(record, @target.index(record), skip_callbacks)
+          end
+        end
+
         def concat_records(records, should_raise = false)
           result = true
 

data/lib/active_record/associations/collection_proxy.rb

@@ -29,6 +29,7 @@ module ActiveRecord
     # 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
@@ -359,14 +360,15 @@ module ActiveRecord
         @association.replace(other_array)
       end
 
-      # Deletes all the records from the collection. For +has_many+ associations,
-      # the deletion is done according to the strategy specified by the <tt>:dependent</tt>
-      # option. Returns an array with the deleted records.
+      # Deletes all the records from the collection according to the strategy
+      # specified by the +:dependent+ option. If no +:dependent+ option is given,
+      # then it will follow the default strategy.
       #
-      # If no <tt>:dependent</tt> option is given, then it will follow the
-      # default strategy. The default strategy is <tt>:nullify</tt>. This
-      # sets the foreign keys to <tt>NULL</tt>. For, +has_many+ <tt>:through</tt>,
-      # the default strategy is +delete_all+.
+      # For +has_many :through+ associations, the default deletion strategy is
+      # +:delete_all+.
+      #
+      # For +has_many+ associations, the default deletion strategy is +:nullify+.
+      # This sets the foreign keys to +NULL+.
       #
       #   class Person < ActiveRecord::Base
       #     has_many :pets # dependent: :nullify option by default
@@ -397,9 +399,9 @@ module ActiveRecord
       #   #       #<Pet id: 3, name: "Choo-Choo", person_id: nil>
       #   #    ]
       #
-      # If it is set to <tt>:destroy</tt> all the objects from the collection
-      # are removed by calling their +destroy+ method. See +destroy+ for more
-      # information.
+      # Both +has_many+ and +has_many :through+ 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.
       #
       #   class Person < ActiveRecord::Base
       #     has_many :pets, dependent: :destroy
@@ -414,11 +416,6 @@ module ActiveRecord
       #   #    ]
       #
       #   person.pets.delete_all
-      #   # => [
-      #   #       #<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>
-      #   #    ]
       #
       #   Pet.find(1, 2, 3)
       #   # => ActiveRecord::RecordNotFound
@@ -439,11 +436,6 @@ module ActiveRecord
       #   #    ]
       #
       #   person.pets.delete_all
-      #   # => [
-      #   #       #<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>
-      #   #    ]
       #
       #   Pet.find(1, 2, 3)
       #   # => ActiveRecord::RecordNotFound
@@ -452,8 +444,9 @@ module ActiveRecord
       end
 
       # Deletes the records of the collection directly from the database
-      # ignoring the +:dependent+ option. It invokes +before_remove+,
-      # +after_remove+ , +before_destroy+ and +after_destroy+ callbacks.
+      # ignoring the +:dependent+ option. Records are instantiated and it
+      # invokes +before_remove+, +after_remove+ , +before_destroy+ and
+      # +after_destroy+ callbacks.
       #
       #   class Person < ActiveRecord::Base
       #     has_many :pets
@@ -477,15 +470,16 @@ module ActiveRecord
         @association.destroy_all
       end
 
-      # Deletes the +records+ supplied and removes them from the collection. For
-      # +has_many+ associations, the deletion is done according to the strategy
-      # specified by the <tt>:dependent</tt> option. Returns an array with the
+      # Deletes the +records+ supplied from the collection according to the strategy
+      # specified by the +:dependent+ option. If no +:dependent+ option is given,
+      # then it will follow the default strategy. Returns an array with the
       # deleted records.
       #
-      # If no <tt>:dependent</tt> option is given, then it will follow the default
-      # strategy. The default strategy is <tt>:nullify</tt>. This sets the foreign
-      # keys to <tt>NULL</tt>. For, +has_many+ <tt>:through</tt>, the default
-      # strategy is +delete_all+.
+      # For +has_many :through+ associations, the default deletion strategy is
+      # +:delete_all+.
+      #
+      # For +has_many+ associations, the default deletion strategy is +:nullify+.
+      # This sets the foreign keys to +NULL+.
       #
       #   class Person < ActiveRecord::Base
       #     has_many :pets # dependent: :nullify option by default
@@ -568,7 +562,7 @@ module ActiveRecord
       #   Pet.find(1)
       #   # => ActiveRecord::RecordNotFound: Couldn't find Pet with id=1
       #
-      # You can pass +Fixnum+ or +String+ values, it finds the records
+      # You can pass +Integer+ or +String+ values, it finds the records
       # responding to the +id+ and executes delete on them.
       #
       #   class Person < ActiveRecord::Base
@@ -632,7 +626,7 @@ module ActiveRecord
       #
       #   Pet.find(1, 2, 3) # => ActiveRecord::RecordNotFound: Couldn't find all Pets with IDs (1, 2, 3)
       #
-      # You can pass +Fixnum+ or +String+ values, it finds the records
+      # You can pass +Integer+ or +String+ values, it finds the records
       # responding to the +id+ and then deletes them from the database.
       #
       #   person.pets.size # => 3
@@ -792,7 +786,7 @@ module ActiveRecord
       #   person.pets.count # => 0
       #   person.pets.any?  # => true
       #
-      # You can also pass a block to define criteria. The behavior
+      # You can also pass a +block+ to define criteria. The behavior
       # is the same, it returns true if the collection based on the
       # criteria is not empty.
       #
@@ -826,7 +820,7 @@ module ActiveRecord
       #   person.pets.count # => 2
       #   person.pets.many? # => true
       #
-      # You can also pass a block to define criteria. The
+      # You can also pass a +block+ to define criteria. The
       # behavior is the same, it returns true if the collection
       # based on the criteria has more than one record.
       #
@@ -850,7 +844,7 @@ module ActiveRecord
         @association.many?(&block)
       end
 
-      # Returns +true+ if the given object is present in the collection.
+      # Returns +true+ if the given +record+ is present in the collection.
       #
       #   class Person < ActiveRecord::Base
       #     has_many :pets
@@ -888,7 +882,7 @@ module ActiveRecord
 
       # Equivalent to <tt>Array#==</tt>. Returns +true+ if the two arrays
       # contain the same number of elements and if each element is equal
-      # to the corresponding element in the other array, otherwise returns
+      # to the corresponding element in the +other+ array, otherwise returns
       # +false+.
       #
       #   class Person < ActiveRecord::Base

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,6 +6,7 @@ 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]
@@ -41,6 +42,14 @@ 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.
@@ -58,7 +67,7 @@ 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)
+            owner._read_attribute cached_counter_attribute_name
           else
             scope.count
           end
@@ -71,20 +80,42 @@ 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())
-          owner.attribute_present?(cached_counter_attribute_name(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())
-          options[:counter_cache] || "#{reflection.name}_count"
+          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)
+          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
 
@@ -98,13 +129,41 @@ 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._reflections.values.any? { |inverse_reflection|
-            :belongs_to == inverse_reflection.macro &&
+          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)
@@ -112,26 +171,28 @@ module ActiveRecord
             records.each(&:destroy!)
             update_counter(-records.length) unless inverse_updates_counter_cache?
           else
-            if records == :all || !reflection.klass.primary_key
-              scope = self.scope
-            else
-              scope = self.scope.where(reflection.klass.primary_key => records)
-            end
-
-            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 foreign_key_present?
-          if reflection.klass.primary_key
-            owner.attribute_present?(reflection.association_primary_key)
+        def concat_records(records, *)
+          update_counter_if_success(super, records.length)
+        end
+
+        def _create_record(attributes, *)
+          if attributes.is_a?(Array)
+            super
           else
-            false
+            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