activerecord 3.2.22.4 → 4.0.13

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

@@ -2,16 +2,16 @@ module ActiveRecord
   module Associations
     class Preloader
       class Association #:nodoc:
-        attr_reader :owners, :reflection, :preload_options, :model, :klass
-
-        def initialize(klass, owners, reflection, preload_options)
-          @klass           = klass
-          @owners          = owners
-          @reflection      = reflection
-          @preload_options = preload_options || {}
-          @model           = owners.first && owners.first.class
-          @scoped          = nil
-          @owners_by_key   = nil
+        attr_reader :owners, :reflection, :preload_scope, :model, :klass
+
+        def initialize(klass, owners, reflection, preload_scope)
+          @klass         = klass
+          @owners        = owners
+          @reflection    = reflection
+          @preload_scope = preload_scope
+          @model         = owners.first && owners.first.class
+          @scope         = nil
+          @owners_by_key = nil
         end
 
         def run
@@ -24,12 +24,12 @@ module ActiveRecord
           raise NotImplementedError
         end
 
-        def scoped
-          @scoped ||= build_scope
+        def scope
+          @scope ||= build_scope
         end
 
         def records_for(ids)
-          scoped.where(association_key.in(ids))
+          scope.where(association_key.in(ids))
         end
 
         def table
@@ -76,8 +76,8 @@ module ActiveRecord
           else
             # 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
-            sliced  = owner_keys.each_slice(model.connection.in_clause_length || owner_keys.size)
-            records = sliced.map { |slice| records_for(slice) }.flatten
+            sliced  = owner_keys.each_slice(klass.connection.in_clause_length || owner_keys.size)
+            records = sliced.map { |slice| records_for(slice).to_a }.flatten
           end
 
           # Each record may have multiple owners, and vice-versa
@@ -92,33 +92,29 @@ module ActiveRecord
           records_by_owner
         end
 
+        def reflection_scope
+          @reflection_scope ||= reflection.scope ? klass.unscoped.instance_exec(nil, &reflection.scope) : klass.unscoped
+        end
+
         def build_scope
-          scope = klass.scoped
+          scope = klass.unscoped
+          scope.default_scoped = true
 
-          scope = scope.where(process_conditions(options[:conditions]))
-          scope = scope.where(process_conditions(preload_options[:conditions]))
+          values         = reflection_scope.values
+          preload_values = preload_scope.values
 
-          scope = scope.select(preload_options[:select] || options[:select] || table[Arel.star])
-          scope = scope.includes(preload_options[:include] || options[:include])
+          scope.where_values      = Array(values[:where])      + Array(preload_values[:where])
+          scope.references_values = Array(values[:references]) + Array(preload_values[:references])
+
+          scope._select!   preload_values[:select] || values[:select] || table[Arel.star]
+          scope.includes! preload_values[:includes] || values[:includes]
 
           if options[:as]
-            scope = scope.where(
-              klass.table_name => {
-                reflection.type => model.base_class.sti_name
-              }
-            )
+            scope.where!(klass.table_name => { reflection.type => model.base_class.sti_name })
           end
 
           scope
         end
-
-        def process_conditions(conditions)
-          if conditions.respond_to?(:to_proc)
-            conditions = klass.send(:instance_eval, &conditions)
-          end
-
-          conditions
-        end
       end
     end
   end

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

@@ -6,7 +6,7 @@ module ActiveRecord
         private
 
         def build_scope
-          super.order(preload_options[:order] || options[:order])
+          super.order(preload_scope.values[:order] || reflection_scope.values[:order])
         end
 
         def preload

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

@@ -6,7 +6,7 @@ module ActiveRecord
 
         def initialize(klass, records, reflection, preload_options)
           super
-          @join_table = Arel::Table.new(options[:join_table]).alias('t0')
+          @join_table = Arel::Table.new(reflection.join_table).alias('t0')
         end
 
         # Unlike the other associations, we want to get a raw array of rows so that we can
@@ -35,7 +35,7 @@ module ActiveRecord
         # record
         def associated_records_by_owner
           records = {}
-          super.each do |owner_key, rows|
+          super.each_value do |rows|
             rows.map! { |row| records[row[klass.primary_key]] ||= klass.instantiate(row) }
           end
         end

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

@@ -5,9 +5,13 @@ module ActiveRecord
         include ThroughAssociation
 
         def associated_records_by_owner
-          super.each do |owner, records|
-            records.uniq! if options[:uniq]
+          records_by_owner = super
+
+          if reflection_scope.distinct_value
+            records_by_owner.each_value { |records| records.uniq! }
           end
+
+          records_by_owner
         end
       end
     end

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

@@ -14,7 +14,7 @@ module ActiveRecord
         private
 
         def build_scope
-          super.order(preload_options[:order] || options[:order])
+          super.order(preload_scope.values[:order] || reflection_scope.values[:order])
         end
 
       end

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

@@ -14,10 +14,7 @@ module ActiveRecord
         def associated_records_by_owner
           through_records = through_records_by_owner
 
-          ActiveRecord::Associations::Preloader.new(
-            through_records.values.flatten,
-            source_reflection.name, options
-          ).run
+          Preloader.new(through_records.values.flatten, source_reflection.name, reflection_scope).run
 
           through_records.each do |owner, records|
             records.map! { |r| r.send(source_reflection.name) }.flatten!
@@ -28,16 +25,13 @@ module ActiveRecord
         private
 
         def through_records_by_owner
-          ActiveRecord::Associations::Preloader.new(
-            owners, through_reflection.name,
-            through_options
-          ).run
+          Preloader.new(owners, through_reflection.name, through_scope).run
 
           Hash[owners.map do |owner|
             through_records = Array.wrap(owner.send(through_reflection.name))
 
             # Dont cache the association - we would only be caching a subset
-            if (preload_options != through_options) ||
+            if (through_scope != through_reflection.klass.unscoped) ||
                (reflection.options[:source_type] && through_reflection.collection?)
               owner.association(through_reflection.name).reset
             end
@@ -46,20 +40,22 @@ module ActiveRecord
           end]
         end
 
-        def through_options
-          through_options = {}
+        def through_scope
+          through_scope = through_reflection.klass.unscoped
 
           if options[:source_type]
-            through_options[:conditions] = { reflection.foreign_type => options[:source_type] }
+            through_scope.where! reflection.foreign_type => options[:source_type]
           else
-            if options[:conditions]
-              through_options[:include]    = options[:include] || options[:source]
-              through_options[:conditions] = options[:conditions]
+            unless reflection_scope.where_values.empty?
+              through_scope.includes_values = Array(reflection_scope.values[:includes] || options[:source])
+              through_scope.where_values    = reflection_scope.values[:where]
             end
-            through_options[:order] = options[:order] if options.has_key?(:order)
+
+            through_scope.references! reflection_scope.values[:references]
+            through_scope.order! reflection_scope.values[:order] if through_scope.eager_loading?
           end
 
-          through_options
+          through_scope
         end
       end
     end

data/lib/active_record/associations/preloader.rb

@@ -12,7 +12,7 @@ module ActiveRecord
     # and all of its books via a single query:
     #
     #   SELECT * FROM authors
-    #   LEFT OUTER JOIN books ON authors.id = books.id
+    #   LEFT OUTER JOIN books ON authors.id = books.author_id
     #   WHERE authors.name = 'Ken Akamatsu'
     #
     # However, this could result in many rows that contain redundant data. After
@@ -46,7 +46,7 @@ module ActiveRecord
         autoload :BelongsTo,           'active_record/associations/preloader/belongs_to'
       end
 
-      attr_reader :records, :associations, :options, :model
+      attr_reader :records, :associations, :preload_scope, :model
 
       # Eager loads the named associations for the given Active Record record(s).
       #
@@ -72,7 +72,7 @@ module ActiveRecord
       #   books.
       # - a Hash which specifies multiple association names, as well as
       #   association names for the to-be-preloaded association objects. For
-      #   example, specifying <tt>{ :author => :avatar }</tt> will preload a
+      #   example, specifying <tt>{ author: :avatar }</tt> will preload a
       #   book's author, as well as that author's avatar.
       #
       # +:associations+ has the same format as the +:include+ option for
@@ -80,17 +80,12 @@ module ActiveRecord
       #
       #   :books
       #   [ :books, :author ]
-      #   { :author => :avatar }
-      #   [ :books, { :author => :avatar } ]
-      #
-      # +options+ contains options that will be passed to ActiveRecord::Base#find
-      # (which is called under the hood for preloading records). But it is passed
-      # only one level deep in the +associations+ argument, i.e. it's not passed
-      # to the child associations when +associations+ is a Hash.
-      def initialize(records, associations, options = {})
-        @records      = Array.wrap(records).compact.uniq
-        @associations = Array.wrap(associations)
-        @options      = options
+      #   { author: :avatar }
+      #   [ :books, { author: :avatar } ]
+      def initialize(records, associations, preload_scope = nil)
+        @records       = Array.wrap(records).compact.uniq
+        @associations  = Array.wrap(associations)
+        @preload_scope = preload_scope || Relation.new(nil, nil)
       end
 
       def run
@@ -105,7 +100,9 @@ module ActiveRecord
         case association
         when Hash
           preload_hash(association)
-        when String, Symbol
+        when Symbol
+          preload_one(association)
+        when String
           preload_one(association.to_sym)
         else
           raise ArgumentError, "#{association.inspect} was not recognised for preload"
@@ -114,7 +111,7 @@ module ActiveRecord
 
       def preload_hash(association)
         association.each do |parent, child|
-          Preloader.new(records, parent, options).run
+          Preloader.new(records, parent, preload_scope).run
           Preloader.new(records.map { |record| record.send(parent) }.flatten, child).run
         end
       end
@@ -129,39 +126,19 @@ module ActiveRecord
       def preload_one(association)
         grouped_records(association).each do |reflection, klasses|
           klasses.each do |klass, records|
-            preloader_for(reflection).new(klass, records, reflection, options).run
+            preloader_for(reflection).new(klass, records, reflection, preload_scope).run
           end
         end
       end
 
       def grouped_records(association)
-        Hash[
-          records_by_reflection(association).map do |reflection, records|
-            [reflection, records.group_by { |record| association_klass(reflection, record) }]
-          end
-        ]
-      end
-
-      def records_by_reflection(association)
-        records.group_by do |record|
-          reflection = record.class.reflections[association]
-
-          unless reflection
-            raise ActiveRecord::ConfigurationError, "Association named '#{association}' was not found; " \
-                                                    "perhaps you misspelled it?"
-          end
-
-          reflection
-        end
-      end
-
-      def association_klass(reflection, record)
-        if reflection.macro == :belongs_to && reflection.options[:polymorphic]
-          klass = record.send(reflection.foreign_type)
-          klass && klass.constantize
-        else
-          reflection.klass
+        h = {}
+        records.each do |record|
+          assoc = record.association(association)
+          klasses = h[assoc.reflection] ||= {}
+          (klasses[assoc.klass] ||= []) << record
         end
+        h
       end
 
       def preloader_for(reflection)

data/lib/active_record/associations/singular_association.rb

@@ -12,21 +12,21 @@ module ActiveRecord
         target
       end
 
-      # Implements the writer method, e.g. foo.items= for Foo.has_many :items
+      # Implements the writer method, e.g. foo.bar= for Foo.belongs_to :bar
       def writer(record)
         replace(record)
       end
 
-      def create(attributes = {}, options = {}, &block)
-        create_record(attributes, options, &block)
+      def create(attributes = {}, &block)
+        _create_record(attributes, &block)
       end
 
-      def create!(attributes = {}, options = {}, &block)
-        create_record(attributes, options, true, &block)
+      def create!(attributes = {}, &block)
+        _create_record(attributes, true, &block)
       end
 
-      def build(attributes = {}, options = {})
-        record = build_record(attributes, options)
+      def build(attributes = {})
+        record = build_record(attributes)
         yield(record) if block_given?
         set_new_record(record)
         record
@@ -35,11 +35,11 @@ module ActiveRecord
       private
 
         def create_scope
-          scoped.scope_for_create.stringify_keys.except(klass.primary_key)
+          scope.scope_for_create.stringify_keys.except(klass.primary_key)
         end
 
         def find_target
-          scoped.first.tap { |record| set_inverse_instance(record) }
+          scope.take.tap { |record| set_inverse_instance(record) }
         end
 
         # Implemented by subclasses
@@ -51,8 +51,8 @@ module ActiveRecord
           replace(record)
         end
 
-        def create_record(attributes, options, raise_error = false)
-          record = build_record(attributes, options)
+        def _create_record(attributes, raise_error = false)
+          record = build_record(attributes)
           yield(record) if block_given?
           saved = record.save
           set_new_record(record)

data/lib/active_record/associations/through_association.rb

@@ -14,8 +14,8 @@ module ActiveRecord
         def target_scope
           scope = super
           chain[1..-1].each do |reflection|
-            scope = scope.merge(
-              reflection.klass.scoped.with_default_scope.
+            scope.merge!(
+              reflection.klass.all.with_default_scope.
                 except(:select, :create_with, :includes, :preload, :joins, :eager_load)
             )
           end
@@ -28,7 +28,7 @@ module ActiveRecord
         # methods which create and delete records on the association.
         #
         # We only support indirectly modifying through associations which has a belongs_to source.
-        # This is the "has_many :tags, :through => :taggings" situation, where the join model
+        # 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.
         #