0
@@ -1599,7 +1599,7 @@ module ActiveRecord
0
           sql = "SELECT #{column_aliases(join_dependency)} FROM #{(scope && scope[:from]) || options[:from] || quoted_table_name} "
0
           sql << join_dependency.join_associations.collect{|join| join.association_join }.join
0
 
0
-          add_joins!(sql, options, scope)
0
+          add_joins!(sql, options[:joins], scope)
0
           add_conditions!(sql, options[:conditions], scope)
0
           add_limited_ids_condition!(sql, options, join_dependency) if !using_limitable_reflections?(join_dependency.reflections) && ((scope && scope[:limit]) || options[:limit])
0
 
0
@@ -1655,7 +1655,7 @@ module ActiveRecord
0
 
0
           if is_distinct
0
             sql << distinct_join_associations.collect { |assoc| assoc.association_join }.join
0
-            add_joins!(sql, options, scope)
0
+            add_joins!(sql, options[:joins], scope)
0
           end
0
 
0
           add_conditions!(sql, options[:conditions], scope)

0
@@ -1549,7 +1549,7 @@ module ActiveRecord #:nodoc:
0
           sql  = "SELECT #{options[:select] || (scope && scope[:select]) || ((options[:joins] || (scope && scope[:joins])) && quoted_table_name + '.*') || '*'} "
0
           sql << "FROM #{(scope && scope[:from]) || options[:from] || quoted_table_name} "
0
 
0
-          add_joins!(sql, options, scope)
0
+          add_joins!(sql, options[:joins], scope)
0
           add_conditions!(sql, options[:conditions], scope)
0
 
0
           add_group!(sql, options[:group], scope)
0
@@ -1565,6 +1565,22 @@ module ActiveRecord #:nodoc:
0
          (safe_to_array(first) + safe_to_array(second)).uniq
0
         end
0
 
0
+        def merge_joins(first, second)
0
+          if first.is_a?(String) && second.is_a?(String)
0
+            "#{first} #{second}"
0
+          elsif first.is_a?(String) || second.is_a?(String)
0
+            if first.is_a?(String)
0
+              join_dependency = ActiveRecord::Associations::ClassMethods::InnerJoinDependency.new(self, second, nil)
0
+              "#{first} #{join_dependency.join_associations.collect { |assoc| assoc.association_join }.join}"
0
+            else
0
+              join_dependency = ActiveRecord::Associations::ClassMethods::InnerJoinDependency.new(self, first, nil)
0
+              "#{join_dependency.join_associations.collect { |assoc| assoc.association_join }.join} #{second}"
0
+            end
0
+          else
0
+            (safe_to_array(first) + safe_to_array(second)).uniq
0
+          end
0
+        end
0
+
0
         # Object#to_a is deprecated, though it does have the desired behavior
0
         def safe_to_array(o)
0
           case o
0
@@ -1620,16 +1636,15 @@ module ActiveRecord #:nodoc:
0
         end
0
 
0
         # The optional scope argument is for the current <tt>:find</tt> scope.
0
-        def add_joins!(sql, options, scope = :auto)
0
+        def add_joins!(sql, joins, scope = :auto)
0
           scope = scope(:find) if :auto == scope
0
-          [(scope && scope[:joins]), options[:joins]].each do |join|
0
-            case join
0
-            when Symbol, Hash, Array
0
-              join_dependency = ActiveRecord::Associations::ClassMethods::InnerJoinDependency.new(self, join, nil)
0
-              sql << " #{join_dependency.join_associations.collect { |assoc| assoc.association_join }.join} "
0
-            else
0
-              sql << " #{join} "
0
-            end
0
+          merged_joins = scope && scope[:joins] && joins ? merge_joins(scope[:joins], joins) : (joins || scope && scope[:joins])
0
+          case merged_joins
0
+          when Symbol, Hash, Array
0
+            join_dependency = ActiveRecord::Associations::ClassMethods::InnerJoinDependency.new(self, merged_joins, nil)
0
+            sql << " #{join_dependency.join_associations.collect { |assoc| assoc.association_join }.join} "
0
+          when String
0
+            sql << " #{merged_joins} "
0
           end
0
         end
0
 
0
@@ -1879,6 +1894,8 @@ module ActiveRecord #:nodoc:
0
                         hash[method][key] = merge_conditions(params[key], hash[method][key])
0
                       elsif key == :include && merge
0
                         hash[method][key] = merge_includes(hash[method][key], params[key]).uniq
0
+                      elsif key == :joins && merge
0
+                        hash[method][key] = merge_joins(params[key], hash[method][key])
0
                       else
0
                         hash[method][key] = hash[method][key] || params[key]
0
                       end

0
@@ -188,7 +188,7 @@ module ActiveRecord
0
           end
0
 
0
           joins = ""
0
-          add_joins!(joins, options, scope)
0
+          add_joins!(joins, options[:joins], scope)
0
 
0
           if merged_includes.any?
0
             join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(self, merged_includes, joins)

0
@@ -1,4 +1,5 @@
0
 require "cases/helper"
0
+require 'models/author'
0
 require 'models/developer'
0
 require 'models/project'
0
 require 'models/comment'
0
@@ -6,7 +7,7 @@ require 'models/post'
0
 require 'models/category'
0
 
0
 class MethodScopingTest < ActiveRecord::TestCase
0
-  fixtures :developers, :projects, :comments, :posts, :developers_projects
0
+  fixtures :authors, :developers, :projects, :comments, :posts, :developers_projects
0
 
0
   def test_set_conditions
0
     Developer.with_scope(:find => { :conditions => 'just a test...' }) do
0
@@ -97,6 +98,46 @@ class MethodScopingTest < ActiveRecord::TestCase
0
     assert_equal developers(:david).attributes, scoped_developers.first.attributes
0
   end
0
 
0
+  def test_scoped_find_using_new_style_joins
0
+    scoped_developers = Developer.with_scope(:find => { :joins => :projects }) do
0
+      Developer.find(:all, :conditions => 'projects.id = 2')
0
+    end
0
+    assert scoped_developers.include?(developers(:david))
0
+    assert !scoped_developers.include?(developers(:jamis))
0
+    assert_equal 1, scoped_developers.size
0
+    assert_equal developers(:david).attributes, scoped_developers.first.attributes
0
+  end
0
+
0
+  def test_scoped_find_merges_old_style_joins
0
+    scoped_authors = Author.with_scope(:find => { :joins => 'INNER JOIN posts ON authors.id = posts.author_id ' }) do
0
+      Author.find(:all, :select => 'DISTINCT authors.*', :joins => 'INNER JOIN comments ON posts.id = comments.post_id', :conditions => 'comments.id = 1')
0
+    end
0
+    assert scoped_authors.include?(authors(:david))
0
+    assert !scoped_authors.include?(authors(:mary))
0
+    assert_equal 1, scoped_authors.size
0
+    assert_equal authors(:david).attributes, scoped_authors.first.attributes
0
+  end
0
+
0
+  def test_scoped_find_merges_new_style_joins
0
+    scoped_authors = Author.with_scope(:find => { :joins => :posts }) do
0
+      Author.find(:all, :select => 'DISTINCT authors.*', :joins => :comments, :conditions => 'comments.id = 1')
0
+    end
0
+    assert scoped_authors.include?(authors(:david))
0
+    assert !scoped_authors.include?(authors(:mary))
0
+    assert_equal 1, scoped_authors.size
0
+    assert_equal authors(:david).attributes, scoped_authors.first.attributes
0
+  end
0
+
0
+  def test_scoped_find_merges_new_and_old_style_joins
0
+    scoped_authors = Author.with_scope(:find => { :joins => :posts }) do
0
+      Author.find(:all, :select => 'DISTINCT authors.*', :joins => 'JOIN comments ON posts.id = comments.post_id', :conditions => 'comments.id = 1')
0
+    end
0
+    assert scoped_authors.include?(authors(:david))
0
+    assert !scoped_authors.include?(authors(:mary))
0
+    assert_equal 1, scoped_authors.size
0
+    assert_equal authors(:david).attributes, scoped_authors.first.attributes
0
+  end
0
+
0
   def test_scoped_count_include
0
     # with the include, will retrieve only developers for the given project
0
     Developer.with_scope(:find => { :include => :projects }) do
0
@@ -152,7 +193,7 @@ class MethodScopingTest < ActiveRecord::TestCase
0
 end
0
 
0
 class NestedScopingTest < ActiveRecord::TestCase
0
-  fixtures :developers, :projects, :comments, :posts
0
+  fixtures :authors, :developers, :projects, :comments, :posts
0
 
0
   def test_merge_options
0
     Developer.with_scope(:find => { :conditions => 'salary = 80000' }) do
0
@@ -357,6 +398,42 @@ class NestedScopingTest < ActiveRecord::TestCase
0
       assert_equal scoped_methods, Developer.instance_eval('current_scoped_methods')
0
     end
0
   end
0
+
0
+  def test_nested_scoped_find_merges_old_style_joins
0
+    scoped_authors = Author.with_scope(:find => { :joins => 'INNER JOIN posts ON authors.id = posts.author_id' }) do
0
+      Author.with_scope(:find => { :joins => 'INNER JOIN comments ON posts.id = comments.post_id' }) do
0
+        Author.find(:all, :select => 'DISTINCT authors.*', :conditions => 'comments.id = 1')
0
+      end
0
+    end
0
+    assert scoped_authors.include?(authors(:david))
0
+    assert !scoped_authors.include?(authors(:mary))
0
+    assert_equal 1, scoped_authors.size
0
+    assert_equal authors(:david).attributes, scoped_authors.first.attributes
0
+  end
0
+
0
+  def test_nested_scoped_find_merges_new_style_joins
0
+    scoped_authors = Author.with_scope(:find => { :joins => :posts }) do
0
+      Author.with_scope(:find => { :joins => :comments }) do
0
+        Author.find(:all, :select => 'DISTINCT authors.*', :conditions => 'comments.id = 1')
0
+      end
0
+    end
0
+    assert scoped_authors.include?(authors(:david))
0
+    assert !scoped_authors.include?(authors(:mary))
0
+    assert_equal 1, scoped_authors.size
0
+    assert_equal authors(:david).attributes, scoped_authors.first.attributes
0
+  end
0
+
0
+  def test_nested_scoped_find_merges_new_and_old_style_joins
0
+    scoped_authors = Author.with_scope(:find => { :joins => :posts }) do
0
+      Author.with_scope(:find => { :joins => 'INNER JOIN comments ON posts.id = comments.post_id' }) do
0
+        Author.find(:all, :select => 'DISTINCT authors.*', :joins => '', :conditions => 'comments.id = 1')
0
+      end
0
+    end
0
+    assert scoped_authors.include?(authors(:david))
0
+    assert !scoped_authors.include?(authors(:mary))
0
+    assert_equal 1, scoped_authors.size
0
+    assert_equal authors(:david).attributes, scoped_authors.first.attributes
0
+  end
0
 end
0
 
0
 class HasManyScopingTest< ActiveRecord::TestCase