activerecord 5.0.0 → 5.0.7.2

data/lib/active_record/associations/collection_association.rb

@@ -39,13 +39,8 @@ module ActiveRecord
           reload
         end
 
-        if null_scope?
-          # Cache the proxy separately before the owner has an id
-          # or else a post-save proxy will still lack the id
-          @null_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
@@ -69,13 +64,20 @@ module ActiveRecord
 
       # Implements the ids writer method, e.g. foo.item_ids= for Foo.has_many :items
       def ids_writer(ids)
-        pk_type = reflection.primary_key_type
+        pk_type = reflection.association_primary_key_type
         ids = Array(ids).reject(&:blank?)
         ids.map! { |i| pk_type.cast(i) }
-        records = klass.where(reflection.association_primary_key => ids).index_by do |r|
-          r.send(reflection.association_primary_key)
-        end.values_at(*ids)
-        replace(records)
+
+        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 records.size != ids.size
+          klass.all.raise_record_not_found_exception!(ids, records.size, ids.size, primary_key)
+        else
+          replace(records)
+        end
       end
 
       def reset
@@ -312,9 +314,9 @@ 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)
+        elsif !association_scope.distinct_value && target.is_a?(Array)
           unsaved_records = target.select(&:new_record?)
           unsaved_records.size + count_records
         else
@@ -423,29 +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
-
-        was_loaded = loaded?
-        yield(record) if block_given?
-
-        unless !was_loaded && loaded?
-          if index
-            @target[index] = record
-          else
-            @target << record
-          end
-        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
 
@@ -454,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
@@ -466,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
@@ -516,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
@@ -578,19 +564,41 @@ module ActiveRecord
           end
         end
 
-        def concat_records(records, should_raise = false)
+        def concat_records(records, raise = false)
           result = true
 
           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)

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, klass.predicate_builder
-        merge! association.scope(nullify: false)
+
+        extensions = association.extensions
+        extend(*extensions) if extensions.any?
       end
 
       def target
@@ -732,6 +731,14 @@ module ActiveRecord
         @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,
       # it executes a <tt>SELECT COUNT(*)</tt> query. Else it calls <tt>collection.size</tt>.
       #
@@ -787,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>.
       #
@@ -891,27 +898,14 @@ module ActiveRecord
         !!@association.include?(record)
       end
 
-      def arel #:nodoc:
-        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
@@ -1044,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+.
@@ -1066,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

data/lib/active_record/associations/has_many_association.rb

@@ -40,13 +40,7 @@ module ActiveRecord
 
       def insert_record(record, validate = true, raise = false)
         set_owner_attributes(record)
-        set_inverse_instance(record)
-
-        if raise
-          record.save!(:validate => validate)
-        else
-          record.save(:validate => validate)
-        end
+        super
       end
 
       def empty?

data/lib/active_record/associations/has_many_through_association.rb

@@ -38,10 +38,8 @@ module ActiveRecord
       def insert_record(record, validate = true, raise = false)
         ensure_not_nested
 
-        if raise
-          record.save!(:validate => validate)
-        else
-          return unless record.save(:validate => validate)
+        if record.new_record? || record.changed?
+          return unless super
         end
 
         save_through_record(record)

data/lib/active_record/associations/join_dependency/join_association.rb

@@ -54,22 +54,17 @@ module ActiveRecord
             end
             scope_chain_index += 1
 
+            relation = ActiveRecord::Relation.create(klass, table, predicate_builder)
+            current_scope = klass.current_scope
+
             klass_scope =
-              if klass.current_scope
-                klass.current_scope.clone
+              if current_scope && current_scope.empty_scope?
+                relation
               else
-                relation = ActiveRecord::Relation.create(
-                  klass,
-                  table,
-                  predicate_builder,
-                )
                 klass.send(:build_default_scope, relation)
               end
-            scope_chain_items.concat [klass_scope].compact
 
-            rel = scope_chain_items.inject(scope_chain_items.shift) do |left, right|
-              left.merge right
-            end
+            rel = scope_chain_items.inject(klass_scope || scope_chain_items.shift, &:merge!)
 
             if rel && !rel.arel.constraints.empty?
               binds += rel.bound_attributes

data/lib/active_record/associations/join_dependency/join_part.rb

@@ -62,8 +62,8 @@ module ActiveRecord
           hash
         end
 
-        def instantiate(row, aliases)
-          base_klass.instantiate(extract_record(row, aliases))
+        def instantiate(row, aliases, &block)
+          base_klass.instantiate(extract_record(row, aliases), &block)
         end
       end
     end

data/lib/active_record/associations/join_dependency.rb

@@ -272,7 +272,11 @@ module ActiveRecord
             construct(model, node, row, rs, seen, model_cache, aliases)
           else
             model = construct_model(ar_parent, node, row, model_cache, id, aliases)
-            model.readonly!
+
+            if node.reflection.scope_for(node.base_klass).readonly_value
+              model.readonly!
+            end
+
             seen[ar_parent.object_id][node.base_klass][id] = model
             construct(model, node, row, rs, seen, model_cache, aliases)
           end
@@ -280,17 +284,19 @@ module ActiveRecord
       end
 
       def construct_model(record, node, row, model_cache, id, aliases)
-        model = model_cache[node][id] ||= node.instantiate(row,
-                                                           aliases.column_aliases(node))
         other = record.association(node.reflection.name)
 
+        model = model_cache[node][id] ||=
+          node.instantiate(row, aliases.column_aliases(node)) do |m|
+            other.set_inverse_instance(m)
+          end
+
         if node.reflection.collection?
           other.target.push(model)
         else
           other.target = model
         end
 
-        other.set_inverse_instance(model)
         model
       end
     end

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

@@ -62,7 +62,12 @@ module ActiveRecord
         private
 
         def associated_records_by_owner(preloader)
-          records = load_records
+          records = load_records do |record|
+            owner = owners_by_key[convert_key(record[association_key_name])]
+            association = owner.association(reflection.name)
+            association.set_inverse_instance(record)
+          end
+
           owners.each_with_object({}) do |owner, result|
             result[owner] = records[convert_key(owner[owner_key_name])] || []
           end
@@ -79,6 +84,15 @@ module ActiveRecord
           @owner_keys
         end
 
+        def owners_by_key
+          unless defined?(@owners_by_key)
+            @owners_by_key = owners.each_with_object({}) do |owner, h|
+              h[convert_key(owner[owner_key_name])] = owner
+            end
+          end
+          @owners_by_key
+        end
+
         def key_conversion_required?
           @key_conversion_required ||= association_key_type != owner_key_type
         end
@@ -99,13 +113,13 @@ module ActiveRecord
           @model.type_for_attribute(owner_key_name.to_s).type
         end
 
-        def load_records
+        def load_records(&block)
           return {} if owner_keys.empty?
           # Some databases impose a limit on the number of ids in a list (in Oracle it's 1000)
           # Make several smaller queries if necessary or make one query if the adapter supports it
           slices  = owner_keys.each_slice(klass.connection.in_clause_length || owner_keys.size)
           @preloaded_records = slices.flat_map do |slice|
-            records_for(slice)
+            records_for(slice).load(&block)
           end
           @preloaded_records.group_by do |record| 
             convert_key(record[association_key_name])
@@ -113,46 +127,19 @@ module ActiveRecord
         end
 
         def reflection_scope
-          @reflection_scope ||= reflection.scope ? klass.unscoped.instance_exec(nil, &reflection.scope) : klass.unscoped
+          @reflection_scope ||= reflection.scope_for(klass)
         end
 
         def build_scope
-          scope = klass.unscoped
-
-          values = reflection_scope.values
-          preload_values = preload_scope.values
-
-          scope.where_clause = reflection_scope.where_clause + preload_scope.where_clause
-          scope.references_values = Array(values[:references]) + Array(preload_values[:references])
-
-          if preload_values[:select] || values[:select]
-            scope._select!(preload_values[:select] || values[:select])
-          end
-          scope.includes! preload_values[:includes] || values[:includes]
-          if preload_scope.joins_values.any?
-            scope.joins!(preload_scope.joins_values)
-          else
-            scope.joins!(reflection_scope.joins_values)
-          end
-
-          if order_values = preload_values[:order] || values[:order]
-            scope.order!(order_values)
-          end
-
-          if preload_values[:reordering] || values[:reordering]
-            scope.reordering_value = true
-          end
-
-          if preload_values[:readonly] || values[:readonly]
-            scope.readonly!
-          end
+          scope = klass.scope_for_association
 
-          if options[:as]
-            scope.where!(klass.table_name => { reflection.type => model.base_class.sti_name })
+          if reflection.type
+            scope.where!(reflection.type => model.base_class.sti_name)
           end
 
-          scope.unscope_values = Array(values[:unscope]) + Array(preload_values[:unscope])
-          klass.default_scoped.merge(scope)
+          scope.merge!(reflection_scope)
+          scope.merge!(preload_scope) if preload_scope != NULL_RELATION
+          scope
         end
       end
     end

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

@@ -9,7 +9,6 @@ module ActiveRecord
             association = owner.association(reflection.name)
             association.loaded!
             association.target.concat(records)
-            records.each { |record| association.set_inverse_instance(record) }
           end
         end
       end

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

@@ -11,7 +11,6 @@ module ActiveRecord
 
             association = owner.association(reflection.name)
             association.target = record
-            association.set_inverse_instance(record) if record
           end
         end
 

data/lib/active_record/associations/preloader/through_association.rb

@@ -79,20 +79,26 @@ module ActiveRecord
           end
         end
 
-
         def through_scope
           scope = through_reflection.klass.unscoped
+          values = reflection_scope.values
 
           if options[:source_type]
             scope.where! reflection.foreign_type => options[:source_type]
           else
             unless reflection_scope.where_clause.empty?
-              scope.includes_values = Array(reflection_scope.values[:includes] || options[:source])
+              scope.includes_values = Array(values[:includes] || options[:source])
               scope.where_clause = reflection_scope.where_clause
+              if joins = values[:joins]
+                scope.joins!(source_reflection.name => joins)
+              end
+              if left_outer_joins = values[:left_outer_joins]
+                scope.left_outer_joins!(source_reflection.name => left_outer_joins)
+              end
             end
 
-            scope.references! reflection_scope.values[:references]
-            if scope.eager_loading? && order_values = reflection_scope.values[:order]
+            scope.references! values[:references]
+            if scope.eager_loading? && order_values = values[:order]
               scope = scope.order(order_values)
             end
           end

data/lib/active_record/associations/singular_association.rb

@@ -6,8 +6,7 @@ module ActiveRecord
         if force_reload && klass
           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 parent object instead.
+            deprecated and will be removed in Rails 5.1. Please call `reload_#{reflection.name}` instead.
           MSG
 
           klass.uncached { reload }
@@ -38,6 +37,13 @@ module ActiveRecord
         record
       end
 
+      # Implements the reload reader method, e.g. foo.reload_bar for
+      # Foo.has_one :bar
+      def force_reload_reader
+        klass.uncached { reload }
+        target
+      end
+
       private
 
         def create_scope

data/lib/active_record/associations/through_association.rb

@@ -14,7 +14,7 @@ module ActiveRecord
         def target_scope
           scope = super
           reflection.chain.drop(1).each do |reflection|
-            relation = reflection.klass.all
+            relation = reflection.klass.scope_for_association
             scope.merge!(
               relation.except(:select, :create_with, :includes, :preload, :joins, :eager_load)
             )