activerecord 4.2.6 → 5.0.0

data/lib/active_record/associations/preloader.rb

@@ -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
@@ -179,8 +184,13 @@ module ActiveRecord
         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

@@ -4,6 +4,12 @@ module ActiveRecord
       # Implements the reader method, e.g. foo.bar for Foo.has_one :bar
       def reader(force_reload = false)
         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,7 +45,7 @@ module ActiveRecord
         end
 
         def get_records
-          return scope.limit(1).to_a if skip_statement_cache?
+          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

@@ -27,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.
@@ -76,13 +76,21 @@ 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