1 files changed, 35 insertions, 35 deletions

diff --git a/activerecord/lib/active_record/associations/join_dependency/join_association.rb b/activerecord/lib/active_record/associations/join_dependency/join_association.rb
index e0715d9dd1..58fc00d811 100644
--- a/activerecord/lib/active_record/associations/join_dependency/join_association.rb
+++ b/activerecord/lib/active_record/associations/join_dependency/join_association.rb
@@ -25,11 +25,8 @@ module ActiveRecord
         attr_reader :tables
 
         delegate :options, :through_reflection, :source_reflection, :chain, :to => :reflection
-        delegate :table, :table_name, :to => :parent, :prefix => :parent
         delegate :alias_tracker, :to => :join_dependency
 
-        alias :alias_suffix :parent_table_name
-
         def initialize(reflection, join_dependency, parent = nil)
           reflection.check_validity!
 
@@ -47,6 +44,9 @@ module ActiveRecord
           @tables          = construct_tables.reverse
         end
 
+        def parent_table_name; parent.table_name; end
+        alias :alias_suffix :parent_table_name
+
         def ==(other)
           other.class == self.class &&
             other.reflection == reflection &&
@@ -64,15 +64,20 @@ module ActiveRecord
           end
         end
 
-        def join_to(manager)
+        def join_constraints
+          joins         = []
           tables        = @tables.dup
-          foreign_table = parent_table
+
+          foreign_table = parent.table
           foreign_klass = parent.base_klass
 
+          scope_chain_iter = reflection.scope_chain.reverse_each
+
           # The chain starts with the target table, but we want to end with it here (makes
           # more sense in this context), so we reverse
-          chain.reverse.each_with_index do |reflection, i|
+          chain.reverse_each do |reflection|
             table = tables.shift
+            klass = reflection.klass
 
             case reflection.source_macro
             when :belongs_to
@@ -80,11 +85,10 @@ module ActiveRecord
               foreign_key = reflection.foreign_key
             when :has_and_belongs_to_many
               # Join the join table first...
-              manager.from(join(
+              joins << join(
                 table,
                 table[reflection.foreign_key].
-                  eq(foreign_table[reflection.active_record_primary_key])
-              ))
+                  eq(foreign_table[reflection.active_record_primary_key]))
 
               foreign_table, table = table, tables.shift
 
@@ -95,38 +99,39 @@ module ActiveRecord
               foreign_key = reflection.active_record_primary_key
             end
 
-            constraint = build_constraint(reflection, table, key, foreign_table, foreign_key)
+            constraint = build_constraint(klass, table, key, foreign_table, foreign_key)
 
-            scope_chain_items = scope_chain[i]
+            scope_chain_items = scope_chain_iter.next.map do |item|
+              if item.is_a?(Relation)
+                item
+              else
+                ActiveRecord::Relation.create(klass, table).instance_exec(self, &item)
+              end
+            end
 
             if reflection.type
-              scope_chain_items += [
-                ActiveRecord::Relation.new(reflection.klass, table)
+              scope_chain_items <<
+                ActiveRecord::Relation.create(klass, table)
                   .where(reflection.type => foreign_klass.base_class.name)
-              ]
             end
 
-            scope_chain_items += [reflection.klass.send(:build_default_scope)].compact
+            scope_chain_items.concat [klass.send(:build_default_scope)].compact
 
-            constraint = scope_chain_items.inject(constraint) do |chain, item|
-              unless item.is_a?(Relation)
-                item = ActiveRecord::Relation.new(reflection.klass, table).instance_exec(self, &item)
-              end
+            rel = scope_chain_items.inject(scope_chain_items.shift) do |left, right|
+              left.merge right
+            end
 
-              if item.arel.constraints.empty?
-                chain
-              else
-                chain.and(item.arel.constraints)
-              end
+            if rel && !rel.arel.constraints.empty?
+              constraint = constraint.and rel.arel.constraints
             end
 
-            manager.from(join(table, constraint))
+            joins << join(table, constraint)
 
             # The current table in this iteration becomes the foreign table in the next
-            foreign_table, foreign_klass = table, reflection.klass
+            foreign_table, foreign_klass = table, klass
           end
 
-          manager
+          joins
         end
 
         #  Builds equality condition.
@@ -144,13 +149,13 @@ module ActiveRecord
         #    foreign_table #=> #<Arel::Table @name="physicians" ...>
         #    foreign_key   #=> id
         #
-        def build_constraint(reflection, table, key, foreign_table, foreign_key)
+        def build_constraint(klass, table, key, foreign_table, foreign_key)
           constraint = table[key].eq(foreign_table[foreign_key])
 
-          if reflection.klass.finder_needs_type_condition?
+          if klass.finder_needs_type_condition?
             constraint = table.create_and([
               constraint,
-              reflection.klass.send(:type_condition, table)
+              klass.send(:type_condition, table)
             ])
           end
 
@@ -169,11 +174,6 @@ module ActiveRecord
         def aliased_table_name
           table.table_alias || table.name
         end
-
-        def scope_chain
-          @scope_chain ||= reflection.scope_chain.reverse
-        end
-
       end
     end
   end