activerecord 4.2.0 → 5.0.0

data/lib/active_record/associations/preloader.rb

@@ -10,13 +10,13 @@ module ActiveRecord
     #   end
     #
     #   class Book < ActiveRecord::Base
-    #     # columns: title, sales
+    #     # columns: title, sales, author_id
     #   end
     #
     # When you load an author with all associated books Active Record will make
     # multiple queries like this:
     #
-    #   Author.includes(:books).where(:name => ['bell hooks', 'Homer').to_a
+    #   Author.includes(:books).where(name: ['bell hooks', 'Homer']).to_a
     #
     #   => SELECT `authors`.* FROM `authors` WHERE `name` IN ('bell hooks', 'Homer')
     #   => SELECT `books`.* FROM `books` WHERE `author_id` IN (2, 5)
@@ -54,6 +54,8 @@ module ActiveRecord
         autoload :BelongsTo,           'active_record/associations/preloader/belongs_to'
       end
 
+      NULL_RELATION = Struct.new(:values, :where_clause, :joins_values).new({}, Relation::WhereClause.empty, [])
+
       # Eager loads the named associations for the given Active Record record(s).
       #
       # In this description, 'association name' shall refer to the name passed
@@ -88,9 +90,6 @@ module ActiveRecord
       #   [ :books, :author ]
       #   { author: :avatar }
       #   [ :books, { author: :avatar } ]
-
-      NULL_RELATION = Struct.new(:values, :bind_values).new({}, [])
-
       def preload(records, associations, preload_scope = nil)
         records       = Array.wrap(records).compact.uniq
         associations  = Array.wrap(associations)
@@ -107,6 +106,7 @@ module ActiveRecord
 
       private
 
+      # Loads all the given data into +records+ for the +association+.
       def preloaders_on(association, records, scope)
         case association
         when Hash
@@ -116,7 +116,7 @@ module ActiveRecord
         when String
           preloaders_for_one(association.to_sym, records, scope)
         else
-          raise ArgumentError, "#{association.inspect} was not recognised for preload"
+          raise ArgumentError, "#{association.inspect} was not recognized for preload"
         end
       end
 
@@ -132,6 +132,11 @@ module ActiveRecord
         }
       end
 
+      # Loads all the given data into +records+ for a singular +association+.
+      #
+      # Functions by instantiating a preloader class such as Preloader::HasManyThrough and
+      # call the +run+ method for each passed in class in the +records+ argument.
+      #
       # Not all records have the same class, so group then preload group on the reflection
       # itself so that if various subclass share the same association then we do not split
       # them unnecessarily
@@ -160,7 +165,7 @@ module ActiveRecord
         h
       end
 
-      class AlreadyLoaded
+      class AlreadyLoaded # :nodoc:
         attr_reader :owners, :reflection
 
         def initialize(klass, owners, reflection, preload_scope)
@@ -175,12 +180,17 @@ module ActiveRecord
         end
       end
 
-      class NullPreloader
+      class NullPreloader # :nodoc:
         def self.new(klass, owners, reflection, preload_scope); self; end
         def self.run(preloader); end
         def self.preloaded_records; []; end
+        def self.owners; []; end
       end
 
+      # Returns a class containing the logic needed to load preload the data
+      # and attach it to a relation. For example +Preloader::Association+ or
+      # +Preloader::HasManyThrough+. The class returned implements a `run` method
+      # that accepts a preloader.
       def preloader_for(reflection, owners, rhs_klass)
         return NullPreloader unless rhs_klass
 

data/lib/active_record/associations/singular_association.rb

@@ -3,7 +3,13 @@ module ActiveRecord
     class SingularAssociation < Association #:nodoc:
       # Implements the reader method, e.g. foo.bar for Foo.has_one :bar
       def reader(force_reload = false)
-        if force_reload
+        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.
+          MSG
+
           klass.uncached { reload }
         elsif !loaded? || stale_target?
           reload
@@ -39,13 +45,7 @@ module ActiveRecord
         end
 
         def get_records
-          if reflection.scope_chain.any?(&:any?) ||
-              scope.eager_loading? ||
-              klass.current_scope ||
-              klass.default_scopes.any?
-
-            return scope.limit(1).to_a
-          end
+          return scope.limit(1).records if skip_statement_cache?
 
           conn = klass.connection
           sc = reflection.association_scope_cache(conn, owner) do

data/lib/active_record/associations/through_association.rb

@@ -15,12 +15,6 @@ module ActiveRecord
           scope = super
           reflection.chain.drop(1).each do |reflection|
             relation = reflection.klass.all
-
-            reflection_scope = reflection.scope
-            if reflection_scope && reflection_scope.arity.zero?
-              relation.merge!(reflection_scope)
-            end
-
             scope.merge!(
               relation.except(:select, :create_with, :includes, :preload, :joins, :eager_load)
             )
@@ -33,7 +27,7 @@ module ActiveRecord
         # Construct attributes for :through pointing to owner and associate. This is used by the
         # methods which create and delete records on the association.
         #
-        # We only support indirectly modifying through associations which has a belongs_to source.
+        # We only support indirectly modifying through associations which have a belongs_to source.
         # This is the "has_many :tags, through: :taggings" situation, where the join model
         # typically has a belongs_to on both side. In other words, associations which could also
         # be represented as has_and_belongs_to_many associations.
@@ -82,15 +76,34 @@ module ActiveRecord
 
         def ensure_mutable
           unless source_reflection.belongs_to?
-            raise HasManyThroughCantAssociateThroughHasOneOrManyReflection.new(owner, reflection)
+            if reflection.has_one?
+              raise HasOneThroughCantAssociateThroughHasOneOrManyReflection.new(owner, reflection)
+            else
+              raise HasManyThroughCantAssociateThroughHasOneOrManyReflection.new(owner, reflection)
+            end
           end
         end
 
         def ensure_not_nested
           if reflection.nested?
-            raise HasManyThroughNestedAssociationsAreReadonly.new(owner, reflection)
+            if reflection.has_one?
+              raise HasOneThroughNestedAssociationsAreReadonly.new(owner, reflection)
+            else
+              raise HasManyThroughNestedAssociationsAreReadonly.new(owner, reflection)
+            end
           end
         end
+
+        def build_record(attributes)
+          inverse = source_reflection.inverse_of
+          target = through_association.target
+
+          if inverse && target && !target.is_a?(Array)
+            attributes[inverse.foreign_key] = target.id
+          end
+
+          super(attributes)
+        end
     end
   end
 end