activerecord 3.0.0.beta4 → 3.0.0.rc

data/lib/active_record/reflection.rb

@@ -1,12 +1,16 @@
 module ActiveRecord
+  # = Active Record Reflection
   module Reflection # :nodoc:
     extend ActiveSupport::Concern
 
-    # Reflection allows you to interrogate Active Record classes and objects about their associations and aggregations.
-    # This information can, for example, be used in a form builder that took an Active Record object and created input
-    # fields for all of the attributes depending on their type and displayed the associations to other objects.
+    # Reflection allows you to interrogate Active Record classes and objects
+    # about their associations and aggregations. This information can, 
+    # for example, be used in a form builder that took an Active Record object
+    # and created input fields for all of the attributes depending on their type
+    # and displayed the associations to other objects.
     #
-    # You can find the interface for the AggregateReflection and AssociationReflection classes in the abstract MacroReflection class.
+    # You can find the interface for the AggregateReflection and AssociationReflection
+    # classes in the abstract MacroReflection class.
     module ClassMethods
       def create_reflection(macro, name, options, active_record)
         case macro
@@ -43,8 +47,11 @@ module ActiveRecord
         reflections[aggregation].is_a?(AggregateReflection) ? reflections[aggregation] : nil
       end
 
-      # Returns an array of AssociationReflection objects for all the associations in the class. If you only want to reflect on a
-      # certain association type, pass in the symbol (<tt>:has_many</tt>, <tt>:has_one</tt>, <tt>:belongs_to</tt>) for that as the first parameter.
+      # Returns an array of AssociationReflection objects for all the 
+      # associations in the class. If you only want to reflect on a certain 
+      # association type, pass in the symbol (<tt>:has_many</tt>, <tt>:has_one</tt>, 
+      # <tt>:belongs_to</tt>) as the first parameter.
+      #
       # Example:
       #
       #   Account.reflect_on_all_associations             # returns an array of all associations
@@ -55,9 +62,9 @@ module ActiveRecord
         macro ? association_reflections.select { |reflection| reflection.macro == macro } : association_reflections
       end
 
-      # Returns the AssociationReflection object for the named +association+ (use the symbol). Example:
+      # Returns the AssociationReflection object for the +association+ (use the symbol).
       #
-      #   Account.reflect_on_association(:owner) # returns the owner AssociationReflection
+      #   Account.reflect_on_association(:owner)             # returns the owner AssociationReflection
       #   Invoice.reflect_on_association(:line_items).macro  # returns :has_many
       #
       def reflect_on_association(association)
@@ -71,8 +78,9 @@ module ActiveRecord
     end
 
 
-    # Abstract base class for AggregateReflection and AssociationReflection that describes the interface available for both of
-    # those classes. Objects of AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
+    # Abstract base class for AggregateReflection and AssociationReflection that
+    # describes the interface available for both of those classes. Objects of
+    # AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
     class MacroReflection
       attr_reader :active_record
 
@@ -80,32 +88,37 @@ module ActiveRecord
         @macro, @name, @options, @active_record = macro, name, options, active_record
       end
 
-      # Returns the name of the macro.  For example, <tt>composed_of :balance, :class_name => 'Money'</tt> will return
-      # <tt>:balance</tt> or for <tt>has_many :clients</tt> it will return <tt>:clients</tt>.
+      # Returns the name of the macro.
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> will return <tt>:balance</tt> 
+      # <tt>has_many :clients</tt> will return <tt>:clients</tt>
       def name
         @name
       end
 
-      # Returns the macro type. For example, <tt>composed_of :balance, :class_name => 'Money'</tt> will return <tt>:composed_of</tt>
-      # or for <tt>has_many :clients</tt> will return <tt>:has_many</tt>.
+      # Returns the macro type. 
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> will return <tt>:composed_of</tt>
+      # <tt>has_many :clients</tt> will return <tt>:has_many</tt>
       def macro
         @macro
       end
 
-      # Returns the hash of options used for the macro.  For example, it would return <tt>{ :class_name => "Money" }</tt> for
-      # <tt>composed_of :balance, :class_name => 'Money'</tt> or +{}+ for <tt>has_many :clients</tt>.
+      # Returns the hash of options used for the macro.  
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> will return <tt>{ :class_name => "Money" }</tt>
+      # <tt>has_many :clients</tt> will return +{}+
       def options
         @options
       end
 
-      # Returns the class for the macro.  For example, <tt>composed_of :balance, :class_name => 'Money'</tt> returns the Money
-      # class and <tt>has_many :clients</tt> returns the Client class.
+      # Returns the class for the macro.  
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> will return the Money class
+      # <tt>has_many :clients</tt> will return the Client class
       def klass
         @klass ||= class_name.constantize
       end
 
-      # Returns the class name for the macro.  For example, <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>'Money'</tt>
-      # and <tt>has_many :clients</tt> returns <tt>'Client'</tt>.
+      # Returns the class name for the macro.  
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> will return <tt>'Money'</tt>
+      # <tt>has_many :clients</tt> will return <tt>'Client'</tt>
       def class_name
         @class_name ||= options[:class_name] || derive_class_name
       end
@@ -132,11 +145,13 @@ module ActiveRecord
     end
 
 
-    # Holds all the meta-data about an aggregation as it was specified in the Active Record class.
+    # Holds all the meta-data about an aggregation as it was specified in the 
+    # Active Record class.
     class AggregateReflection < MacroReflection #:nodoc:
     end
 
-    # Holds all the meta-data about an association as it was specified in the Active Record class.
+    # Holds all the meta-data about an association as it was specified in the 
+    # Active Record class.
     class AssociationReflection < MacroReflection #:nodoc:
       # Returns the target association's class:
       #
@@ -165,14 +180,14 @@ module ActiveRecord
         klass.new(*options)
       end
 
-      # Creates a new instance of the associated class, and immediates saves it
+      # Creates a new instance of the associated class, and immediately saves it
       # with ActiveRecord::Base#save. +options+ will be passed to the class's
       # creation method. Returns the newly created object.
       def create_association(*options)
         klass.create(*options)
       end
 
-      # Creates a new instance of the associated class, and immediates saves it
+      # Creates a new instance of the associated class, and immediately saves it
       # with ActiveRecord::Base#save!. +options+ will be passed to the class's
       # creation method. If the created record doesn't pass validations, then an
       # exception will be raised.
@@ -267,10 +282,10 @@ module ActiveRecord
       # Returns whether or not the association should be validated as part of
       # the parent's validation.
       #
-      # Unless you explicitely disable validation with
+      # Unless you explicitly disable validation with
       # <tt>:validate => false</tt>, it will take place when:
       #
-      # * you explicitely enable validation; <tt>:validate => true</tt>
+      # * you explicitly enable validation; <tt>:validate => true</tt>
       # * you use autosave; <tt>:autosave => true</tt>
       # * the association is a +has_many+ association
       def validate?
@@ -306,9 +321,12 @@ module ActiveRecord
         end
     end
 
-    # Holds all the meta-data about a :through association as it was specified in the Active Record class.
+    # Holds all the meta-data about a :through association as it was specified
+    # in the Active Record class.
     class ThroughReflection < AssociationReflection #:nodoc:
-      # Gets the source of the through reflection.  It checks both a singularized and pluralized form for <tt>:belongs_to</tt> or <tt>:has_many</tt>.
+      # Gets the source of the through reflection.  It checks both a singularized
+      # and pluralized form for <tt>:belongs_to</tt> or <tt>:has_many</tt>.
+      #
       # (The <tt>:tags</tt> association on Tagging below.)
       #
       #   class Post < ActiveRecord::Base

data/lib/active_record/relation.rb

@@ -1,6 +1,7 @@
 require 'active_support/core_ext/object/blank'
 
 module ActiveRecord
+  # = Active Record Relation
   class Relation
     JoinOperation = Struct.new(:relation, :join_class, :on)
     ASSOCIATION_METHODS = [:includes, :eager_load, :preload]
@@ -9,27 +10,26 @@ module ActiveRecord
 
     include FinderMethods, Calculations, SpawnMethods, QueryMethods, Batches
 
-    delegate :length, :collect, :map, :each, :all?, :include?, :to => :to_a
+    delegate :to_xml, :to_yaml, :length, :collect, :map, :each, :all?, :include?, :to => :to_a
     delegate :insert, :to => :arel
 
-    attr_reader :table, :klass
+    attr_reader :table, :klass, :loaded
     attr_accessor :extensions
+    alias :loaded? :loaded
 
-    def initialize(klass, table, &block)
+    def initialize(klass, table)
       @klass, @table = klass, table
 
       @implicit_readonly = nil
-      @loaded            = nil
+      @loaded            = false
 
       SINGLE_VALUE_METHODS.each {|v| instance_variable_set(:"@#{v}_value", nil)}
       (ASSOCIATION_METHODS + MULTI_VALUE_METHODS).each {|v| instance_variable_set(:"@#{v}_values", [])}
       @extensions = []
-
-      apply_modules(Module.new(&block)) if block_given?
     end
 
     def new(*args, &block)
-      with_create_scope { @klass.new(*args, &block) }
+      scoping { @klass.new(*args, &block) }
     end
 
     def initialize_copy(other)
@@ -39,11 +39,11 @@ module ActiveRecord
     alias build new
 
     def create(*args, &block)
-      with_create_scope { @klass.create(*args, &block) }
+      scoping { @klass.create(*args, &block) }
     end
 
     def create!(*args, &block)
-      with_create_scope { @klass.create!(*args, &block) }
+      scoping { @klass.create!(*args, &block) }
     end
 
     def respond_to?(method, include_private = false)
@@ -67,7 +67,7 @@ module ActiveRecord
       preload +=  @includes_values unless eager_loading?
       preload.each {|associations| @klass.send(:preload_associations, @records, associations) }
 
-      # @readonly_value is true only if set explicity. @implicit_readonly is true if there are JOINS and no explicit SELECT.
+      # @readonly_value is true only if set explicitly. @implicit_readonly is true if there are JOINS and no explicit SELECT.
       readonly = @readonly_value.nil? ? @implicit_readonly : @readonly_value
       @records.each { |record| record.readonly! } if readonly
 
@@ -75,10 +75,14 @@ module ActiveRecord
       @records
     end
 
+    def as_json(options = nil) to_a end #:nodoc:
+
+    # Returns size of the records.
     def size
       loaded? ? @records.length : count
     end
 
+    # Returns true if there are no records.
     def empty?
       loaded? ? @records.empty? : count.zero?
     end
@@ -99,6 +103,25 @@ module ActiveRecord
       end
     end
 
+    # Scope all queries to the current scope.
+    #
+    # ==== Example
+    #
+    #   Comment.where(:post_id => 1).scoping do
+    #     Comment.first #=> SELECT * FROM comments WHERE post_id = 1
+    #   end
+    #
+    # Please check unscoped if you want to remove all previous scopes (including
+    # the default_scope) during the execution of a block.
+    def scoping
+      @klass.scoped_methods << self
+      begin
+        yield
+      ensure
+        @klass.scoped_methods.pop
+      end
+    end
+
     # Updates all records with details given if they match a set of conditions supplied, limits and order can
     # also be supplied. This method constructs a single SQL UPDATE statement and sends it straight to the
     # database. It does not instantiate the involved models and it does not trigger Active Record callbacks
@@ -193,8 +216,7 @@ module ActiveRecord
       if conditions
         where(conditions).destroy_all
       else
-        to_a.each {|object| object.destroy}
-        reset
+        to_a.each {|object| object.destroy }.tap { reset }
       end
     end
 
@@ -240,8 +262,9 @@ module ActiveRecord
     #   Post.delete_all("person_id = 5 AND (category = 'Something' OR category = 'Else')")
     #   Post.delete_all(["person_id = ? AND (category = ? OR category = ?)", 5, 'Something', 'Else'])
     #
-    # Both calls delete the affected posts all at once with a single DELETE statement. If you need to destroy dependent
-    # associations or call your <tt>before_*</tt> or +after_destroy+ callbacks, use the +destroy_all+ method instead.
+    # Both calls delete the affected posts all at once with a single DELETE statement. 
+    # If you need to destroy dependent associations or call your <tt>before_*</tt> or 
+    # +after_destroy+ callbacks, use the +destroy_all+ method instead.
     def delete_all(conditions = nil)
       conditions ? where(conditions).delete_all : arel.delete.tap { reset }
     end
@@ -270,10 +293,6 @@ module ActiveRecord
       where(@klass.primary_key => id_or_array).delete_all
     end
 
-    def loaded?
-      @loaded
-    end
-
     def reload
       reset
       to_a # force reload
@@ -301,7 +320,6 @@ module ActiveRecord
           if where.is_a?(Arel::Predicates::Equality)
             hash[where.operand1.name] = where.operand2.respond_to?(:value) ? where.operand2.value : where.operand2
           end
-
           hash
         end
       end
@@ -332,7 +350,7 @@ module ActiveRecord
       elsif @klass.scopes[method]
         merge(@klass.send(method, *args, &block))
       elsif @klass.respond_to?(method)
-        @klass.send(:with_scope, self) { @klass.send(method, *args, &block) }
+        scoping { @klass.send(method, *args, &block) }
       elsif arel.respond_to?(method)
         arel.send(method, *args, &block)
       elsif match = DynamicFinderMatch.match(method)
@@ -351,10 +369,6 @@ module ActiveRecord
 
     private
 
-    def with_create_scope
-      @klass.send(:with_scope, :create => scope_for_create, :find => {}) { yield }
-    end
-
     def references_eager_loaded_tables?
       # always convert table names to downcase as in Oracle quoted table names are in uppercase
       joined_tables = (tables_in_string(arel.joins(arel)) + [table.name, table.table_alias]).compact.map(&:downcase).uniq

data/lib/active_record/relation/finder_methods.rb

@@ -87,8 +87,8 @@ module ActiveRecord
     #     person.visits += 1
     #     person.save!
     #   end
-    def find(*args, &block)
-      return to_a.find(&block) if block_given?
+    def find(*args)
+      return to_a.find { |*block_args| yield(*block_args) } if block_given?
 
       options = args.extract_options!
 
@@ -259,8 +259,8 @@ module ActiveRecord
       record
     end
 
-    def find_with_ids(*ids, &block)
-      return to_a.find(&block) if block_given?
+    def find_with_ids(*ids)
+      return to_a.find { |*block_args| yield(*block_args) } if block_given?
 
       expects_array = ids.first.kind_of?(Array)
       return ids.first if expects_array && ids.first.empty?
@@ -339,7 +339,7 @@ module ActiveRecord
     end
 
     def using_limitable_reflections?(reflections)
-      reflections.collect(&:collection?).length.zero?
+      reflections.none?(&:collection?)
     end
 
   end

data/lib/active_record/relation/predicate_builder.rb

@@ -20,15 +20,13 @@ module ActiveRecord
             table = Arel::Table.new(table_name, :engine => @engine)
           end
 
-          unless attribute = table[column]
-            raise StatementInvalid, "No attribute named `#{column}` exists for table `#{table.name}`"
-          end
+          attribute = table[column] || Arel::Attribute.new(table, column)
 
           case value
           when Array, ActiveRecord::Associations::AssociationCollection, ActiveRecord::Relation
             values = value.to_a
             attribute.in(values)
-          when Range
+          when Range, Arel::Relation
             attribute.in(value)
           else
             attribute.eq(value)

data/lib/active_record/relation/query_methods.rb

@@ -5,79 +5,92 @@ module ActiveRecord
   module QueryMethods
     extend ActiveSupport::Concern
 
-    included do
-      (ActiveRecord::Relation::ASSOCIATION_METHODS + ActiveRecord::Relation::MULTI_VALUE_METHODS).each do |query_method|
-        attr_accessor :"#{query_method}_values"
-
-        next if [:where, :having, :select].include?(query_method)
-        class_eval <<-CEVAL, __FILE__, __LINE__ + 1
-          def #{query_method}(*args, &block)
-            new_relation = clone
-            new_relation.send(:apply_modules, Module.new(&block)) if block_given?
-            value = Array.wrap(args.flatten).reject {|x| x.blank? }
-            new_relation.#{query_method}_values += value if value.present?
-            new_relation
-          end
-        CEVAL
-      end
+    attr_accessor :includes_values, :eager_load_values, :preload_values,
+                  :select_values, :group_values, :order_values, :joins_values, :where_values, :having_values,
+                  :limit_value, :offset_value, :lock_value, :readonly_value, :create_with_value, :from_value
 
-      class_eval <<-CEVAL, __FILE__, __LINE__ + 1
-        def select(*args, &block)
-          if block_given?
-            to_a.select(&block)
-          else
-            new_relation = clone
-            value = Array.wrap(args.flatten).reject {|x| x.blank? }
-            new_relation.select_values += value if value.present?
-            new_relation
-          end
-        end
-      CEVAL
-
-      [:where, :having].each do |query_method|
-        class_eval <<-CEVAL, __FILE__, __LINE__ + 1
-          def #{query_method}(*args, &block)
-            new_relation = clone
-            new_relation.send(:apply_modules, Module.new(&block)) if block_given?
-            value = build_where(*args)
-            new_relation.#{query_method}_values += Array.wrap(value) if value.present?
-            new_relation
-          end
-        CEVAL
-      end
+    def includes(*args)
+      args.reject! { |a| a.blank? }
+      clone.tap {|r| r.includes_values += args if args.present? }
+    end
+
+    def eager_load(*args)
+      clone.tap {|r| r.eager_load_values += args if args.present? }
+    end
 
-      ActiveRecord::Relation::SINGLE_VALUE_METHODS.each do |query_method|
-        attr_accessor :"#{query_method}_value"
+    def preload(*args)
+      clone.tap {|r| r.preload_values += args if args.present? }
+    end
 
-        class_eval <<-CEVAL, __FILE__, __LINE__ + 1
-          def #{query_method}(value = true, &block)
-            new_relation = clone
-            new_relation.send(:apply_modules, Module.new(&block)) if block_given?
-            new_relation.#{query_method}_value = value
-            new_relation
-          end
-        CEVAL
+    def select(*args)
+      if block_given?
+        to_a.select {|*block_args| yield(*block_args) }
+      else
+        clone.tap {|r| r.select_values += args if args.present? }
       end
     end
 
-    def extending(*modules)
-      new_relation = clone
-      new_relation.send :apply_modules, *modules
-      new_relation
+    def group(*args)
+      clone.tap {|r| r.group_values += args if args.present? }
     end
 
-    def lock(locks = true, &block)
-      relation = clone
-      relation.send(:apply_modules, Module.new(&block)) if block_given?
+    def order(*args)
+      clone.tap {|r| r.order_values += args if args.present? }
+    end
+
+    def reorder(*args)
+      clone.tap {|r| r.order_values = args if args.present? }
+    end
 
+    def joins(*args)
+      args.flatten!
+      clone.tap {|r| r.joins_values += args if args.present? }
+    end
+
+    def where(*args)
+      value = build_where(*args)
+      clone.tap {|r| r.where_values += Array.wrap(value) if value.present? }
+    end
+
+    def having(*args)
+      value = build_where(*args)
+      clone.tap {|r| r.having_values += Array.wrap(value) if value.present? }
+    end
+
+    def limit(value = true)
+      clone.tap {|r| r.limit_value = value }
+    end
+
+    def offset(value = true)
+      clone.tap {|r| r.offset_value = value }
+    end
+
+    def lock(locks = true)
       case locks
       when String, TrueClass, NilClass
-        clone.tap {|new_relation| new_relation.lock_value = locks || true }
+        clone.tap {|r| r.lock_value = locks || true }
       else
-        clone.tap {|new_relation| new_relation.lock_value = false }
+        clone.tap {|r| r.lock_value = false }
       end
     end
 
+    def readonly(value = true)
+      clone.tap {|r| r.readonly_value = value }
+    end
+
+    def create_with(value = true)
+      clone.tap {|r| r.create_with_value = value }
+    end
+
+    def from(value = true)
+      clone.tap {|r| r.from_value = value }
+    end
+
+    def extending(*modules, &block)
+      modules << Module.new(&block) if block_given?
+      clone.tap {|r| r.send(:apply_modules, *modules) }
+    end
+
     def reverse_order
       order_clause = arel.send(:order_clauses).join(', ')
       relation = except(:order)
@@ -116,45 +129,7 @@ module ActiveRecord
     def build_arel
       arel = table
 
-      joined_associations = []
-      association_joins = []
-
-      joins = @joins_values.map {|j| j.respond_to?(:strip) ? j.strip : j}.uniq
-
-      joins.each do |join|
-        association_joins << join if [Hash, Array, Symbol].include?(join.class) && !array_of_strings?(join)
-      end
-
-      stashed_association_joins = joins.select {|j| j.is_a?(ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation)}
-
-      non_association_joins = (joins - association_joins - stashed_association_joins).reject {|j| j.blank?}
-      custom_joins = custom_join_sql(*non_association_joins)
-
-      join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, association_joins, custom_joins)
-
-      join_dependency.graft(*stashed_association_joins)
-
-      @implicit_readonly = true unless association_joins.empty? && stashed_association_joins.empty?
-
-      to_join = []
-
-      join_dependency.join_associations.each do |association|
-        if (association_relation = association.relation).is_a?(Array)
-          to_join << [association_relation.first, association.join_class, association.association_join.first]
-          to_join << [association_relation.last, association.join_class, association.association_join.last]
-        else
-          to_join << [association_relation, association.join_class, association.association_join]
-        end
-      end
-
-      to_join.each do |tj|
-        unless joined_associations.detect {|ja| ja[0] == tj[0] && ja[1] == tj[1] && ja[2] == tj[2] }
-          joined_associations << tj
-          arel = arel.join(tj[0], tj[1]).on(*tj[2])
-        end
-      end
-
-      arel = arel.join(custom_joins)
+      arel = build_joins(arel, @joins_values) if @joins_values.present?
 
       @where_values.uniq.each do |where|
         next if where.blank?
@@ -168,31 +143,18 @@ module ActiveRecord
         end
       end
 
-      @having_values.uniq.each do |h|
-        arel = h.is_a?(String) ? arel.having(h) : arel.having(*h)
-      end
+      arel = arel.having(*@having_values.uniq.select{|h| h.present?}) if @having_values.present?
 
       arel = arel.take(@limit_value) if @limit_value.present?
       arel = arel.skip(@offset_value) if @offset_value.present?
 
-      arel = arel.group(*@group_values.uniq.select{|g| g.present?})
-
-      arel = arel.order(*@order_values.uniq.select{|o| o.present?}.map(&:to_s))
+      arel = arel.group(*@group_values.uniq.select{|g| g.present?}) if @group_values.present?
 
-      selects = @select_values.uniq
+      arel = arel.order(*@order_values.uniq.select{|o| o.present?}) if @order_values.present?
 
-      quoted_table_name = @klass.quoted_table_name
-
-      if selects.present?
-        selects.each do |s|
-          @implicit_readonly = false
-          arel = arel.project(s) if s.present?
-        end
-      else
-        arel = arel.project(quoted_table_name + '.*')
-      end
+      arel = build_select(arel, @select_values.uniq)
 
-      arel = @from_value.present? ? arel.from(@from_value) : arel.from(quoted_table_name)
+      arel = arel.from(@from_value) if @from_value.present?
 
       case @lock_value
       when TrueClass
@@ -221,6 +183,63 @@ module ActiveRecord
 
     private
 
+    def build_joins(relation, joins)
+      joined_associations = []
+      association_joins = []
+
+      joins = @joins_values.map {|j| j.respond_to?(:strip) ? j.strip : j}.uniq
+
+      joins.each do |join|
+        association_joins << join if [Hash, Array, Symbol].include?(join.class) && !array_of_strings?(join)
+      end
+
+      stashed_association_joins = joins.select {|j| j.is_a?(ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation)}
+
+      non_association_joins = (joins - association_joins - stashed_association_joins)
+      custom_joins = custom_join_sql(*non_association_joins)
+
+      join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, association_joins, custom_joins)
+
+      join_dependency.graft(*stashed_association_joins)
+
+      @implicit_readonly = true unless association_joins.empty? && stashed_association_joins.empty?
+
+      to_join = []
+
+      join_dependency.join_associations.each do |association|
+        if (association_relation = association.relation).is_a?(Array)
+          to_join << [association_relation.first, association.join_class, association.association_join.first]
+          to_join << [association_relation.last, association.join_class, association.association_join.last]
+        else
+          to_join << [association_relation, association.join_class, association.association_join]
+        end
+      end
+
+      to_join.each do |tj|
+        unless joined_associations.detect {|ja| ja[0] == tj[0] && ja[1] == tj[1] && ja[2] == tj[2] }
+          joined_associations << tj
+          relation = relation.join(tj[0], tj[1]).on(*tj[2])
+        end
+      end
+
+      relation.join(custom_joins)
+    end
+
+    def build_select(arel, selects)
+      if selects.present?
+        @implicit_readonly = false
+        # TODO: fix this ugly hack, we should refactor the callers to get an ARel compatible array.
+        # Before this change we were passing to ARel the last element only, and ARel is capable of handling an array
+        if selects.all? {|s| s.is_a?(String) || !s.is_a?(Arel::Expression) } && !(selects.last =~ /^COUNT\(/)
+          arel.project(*selects)
+        else
+          arel.project(selects.last)
+        end
+      else
+        arel.project(@klass.quoted_table_name + '.*')
+      end
+    end
+
     def apply_modules(modules)
       values = Array.wrap(modules)
       @extensions += values if values.present?