Deprecated support for passing hashes and relations to default_scope, in favour of defining a 'default_scope' class method in the model. See the CHANGELOG for more details.

5 files changed, 192 insertions, 91 deletions

diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index 16d4877fe8..007f11b535 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -70,16 +70,16 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   # would be convenient), because this would cause that scope to be applied to any callbacks etc.
   def test_build_and_create_should_not_happen_within_scope
     car = cars(:honda)
-    original_scoped_methods = Bulb.scoped_methods
+    scoped_count = car.foo_bulbs.scoped.where_values.count
 
-    bulb = car.bulbs.build
-    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
+    bulb = car.foo_bulbs.build
+    assert_not_equal scoped_count, bulb.scope_after_initialize.where_values.count
 
-    bulb = car.bulbs.create
-    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
+    bulb = car.foo_bulbs.create
+    assert_not_equal scoped_count, bulb.scope_after_initialize.where_values.count
 
-    bulb = car.bulbs.create!
-    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
+    bulb = car.foo_bulbs.create!
+    assert_not_equal scoped_count, bulb.scope_after_initialize.where_values.count
   end
 
   def test_no_sql_should_be_fired_if_association_already_loaded
diff --git a/activerecord/test/cases/associations/has_one_associations_test.rb b/activerecord/test/cases/associations/has_one_associations_test.rb
index c1dad5e246..f3c96ccbe6 100644
--- a/activerecord/test/cases/associations/has_one_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_associations_test.rb
@@ -165,16 +165,16 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
 
   def test_build_and_create_should_not_happen_within_scope
     pirate = pirates(:blackbeard)
-    original_scoped_methods = Bulb.scoped_methods.dup
+    scoped_count = pirate.association(:foo_bulb).scoped.where_values.count
 
-    bulb = pirate.build_bulb
-    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
+    bulb = pirate.build_foo_bulb
+    assert_not_equal scoped_count, bulb.scope_after_initialize.where_values.count
 
-    bulb = pirate.create_bulb
-    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
+    bulb = pirate.create_foo_bulb
+    assert_not_equal scoped_count, bulb.scope_after_initialize.where_values.count
 
-    bulb = pirate.create_bulb!
-    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
+    bulb = pirate.create_foo_bulb!
+    assert_not_equal scoped_count, bulb.scope_after_initialize.where_values.count
   end
 
   def test_create_association
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index b3facf50b8..73887f9b49 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -1630,14 +1630,18 @@ class BasicsTest < ActiveRecord::TestCase
     Object.const_set :UnloadablePost, Class.new(ActiveRecord::Base)
     UnloadablePost.table_name = 'posts'
     UnloadablePost.class_eval do
-      default_scope order('posts.comments_count ASC')
+      class << self
+        def default_scope
+          order('posts.comments_count ASC')
+        end
+      end
     end
-    UnloadablePost.scoped_methods # make Thread.current[:UnloadablePost_scoped_methods] not nil
+    UnloadablePost.scoped # make Thread.current[:UnloadablePost_scoped_methods] not nil
 
     UnloadablePost.unloadable
-    assert_not_nil Thread.current[:UnloadablePost_scoped_methods]
+    assert_not_nil Thread.current[:UnloadablePost_current_scope]
     ActiveSupport::Dependencies.remove_unloadable_constants!
-    assert_nil Thread.current[:UnloadablePost_scoped_methods]
+    assert_nil Thread.current[:UnloadablePost_current_scope]
   ensure
     Object.class_eval{ remove_const :UnloadablePost } if defined?(UnloadablePost)
   end
diff --git a/activerecord/test/cases/method_scoping_test.rb b/activerecord/test/cases/method_scoping_test.rb
index 7e8383da9e..7f0f007a70 100644
--- a/activerecord/test/cases/method_scoping_test.rb
+++ b/activerecord/test/cases/method_scoping_test.rb
@@ -249,22 +249,21 @@ class MethodScopingTest < ActiveRecord::TestCase
   end
 
   def test_scoped_with_duck_typing
-    scoping = Struct.new(:method_scoping).new(:find => { :conditions => ["name = ?", 'David'] })
+    scoping = Struct.new(:current_scope).new(:find => { :conditions => ["name = ?", 'David'] })
     Developer.send(:with_scope, scoping) do
        assert_equal %w(David), Developer.find(:all).map { |d| d.name }
     end
   end
 
   def test_ensure_that_method_scoping_is_correctly_restored
-    scoped_methods = Developer.instance_eval('current_scoped_methods')
-
     begin
       Developer.send(:with_scope, :find => { :conditions => "name = 'Jamis'" }) do
         raise "an exception"
       end
     rescue
     end
-    assert_equal scoped_methods, Developer.instance_eval('current_scoped_methods')
+
+    assert !Developer.scoped.where_values.include?("name = 'Jamis'")
   end
 end
 
@@ -509,14 +508,15 @@ class NestedScopingTest < ActiveRecord::TestCase
 
   def test_ensure_that_method_scoping_is_correctly_restored
     Developer.send(:with_scope, :find => { :conditions => "name = 'David'" }) do
-      scoped_methods = Developer.instance_eval('current_scoped_methods')
       begin
         Developer.send(:with_scope, :find => { :conditions => "name = 'Maiha'" }) do
           raise "an exception"
         end
       rescue
       end
-      assert_equal scoped_methods, Developer.instance_eval('current_scoped_methods')
+
+      assert Developer.scoped.where_values.include?("name = 'David'")
+      assert !Developer.scoped.where_values.include?("name = 'Maiha'")
     end
   end
 
diff --git a/activerecord/test/cases/relation_scoping_test.rb b/activerecord/test/cases/relation_scoping_test.rb
index 30a783d5a2..a91072b94b 100644
--- a/activerecord/test/cases/relation_scoping_test.rb
+++ b/activerecord/test/cases/relation_scoping_test.rb
@@ -132,8 +132,6 @@ class RelationScopingTest < ActiveRecord::TestCase
   end
 
   def test_ensure_that_method_scoping_is_correctly_restored
-    scoped_methods = Developer.send(:current_scoped_methods)
-
     begin
       Developer.where("name = 'Jamis'").scoping do
         raise "an exception"
@@ -141,7 +139,7 @@ class RelationScopingTest < ActiveRecord::TestCase
     rescue
     end
 
-    assert_equal scoped_methods, Developer.send(:current_scoped_methods)
+    assert !Developer.scoped.where_values.include?("name = 'Jamis'")
   end
 end
 
@@ -310,72 +308,173 @@ class DefaultScopingTest < ActiveRecord::TestCase
     assert_equal expected, received
   end
 
-  def test_default_scope_with_lambda
-    expected = Post.find_all_by_author_id(2)
-    PostForAuthor.selected_author = 2
-    received = PostForAuthor.all
-    assert_equal expected, received
-    expected = Post.find_all_by_author_id(1)
-    PostForAuthor.selected_author = 1
-    received = PostForAuthor.all
+  def test_default_scope_is_unscoped_on_find
+    assert_equal 1, DeveloperCalledDavid.count
+    assert_equal 11, DeveloperCalledDavid.unscoped.count
+  end
+
+  def test_default_scope_is_unscoped_on_create
+    assert_nil DeveloperCalledJamis.unscoped.create!.name
+  end
+
+  def test_default_scope_with_conditions_string
+    assert_equal Developer.find_all_by_name('David').map(&:id).sort, DeveloperCalledDavid.find(:all).map(&:id).sort
+    assert_equal nil, DeveloperCalledDavid.create!.name
+  end
+
+  def test_default_scope_with_conditions_hash
+    assert_equal Developer.find_all_by_name('Jamis').map(&:id).sort, DeveloperCalledJamis.find(:all).map(&:id).sort
+    assert_equal 'Jamis', DeveloperCalledJamis.create!.name
+  end
+
+  def test_default_scoping_with_threads
+    2.times do
+      Thread.new { assert_equal ['salary DESC'], DeveloperOrderedBySalary.scoped.order_values }.join
+    end
+  end
+
+  def test_default_scope_with_inheritance
+    wheres = InheritedPoorDeveloperCalledJamis.scoped.where_values_hash
+    assert_equal "Jamis", wheres[:name]
+    assert_equal 50000,   wheres[:salary]
+  end
+
+  def test_method_scope
+    expected = Developer.find(:all, :order => 'salary DESC, name DESC').collect { |dev| dev.salary }
+    received = DeveloperOrderedBySalary.all_ordered_by_name.collect { |dev| dev.salary }
     assert_equal expected, received
   end
 
-  def test_default_scope_with_thing_that_responds_to_call
-    klass = Class.new(ActiveRecord::Base) do
-      self.table_name = 'posts'
+  def test_nested_scope
+    expected = Developer.find(:all, :order => 'salary DESC, name DESC').collect { |dev| dev.salary }
+    received = DeveloperOrderedBySalary.send(:with_scope, :find => { :order => 'name DESC'}) do
+      DeveloperOrderedBySalary.find(:all).collect { |dev| dev.salary }
     end
+    assert_equal expected, received
+  end
 
-    klass.class_eval do
-      default_scope Class.new(Struct.new(:klass)) {
-        def call
-          klass.where(:author_id => 2)
-        end
-      }.new(self)
+  def test_scope_overwrites_default
+    expected = Developer.find(:all, :order => 'salary DESC, name DESC').collect { |dev| dev.name }
+    received = DeveloperOrderedBySalary.by_name.find(:all).collect { |dev| dev.name }
+    assert_equal expected, received
+  end
+
+  def test_reorder_overrides_default_scope_order
+    expected = Developer.order('name DESC').collect { |dev| dev.name }
+    received = DeveloperOrderedBySalary.reorder('name DESC').collect { |dev| dev.name }
+    assert_equal expected, received
+  end
+
+  def test_nested_exclusive_scope
+    expected = Developer.find(:all, :limit => 100).collect { |dev| dev.salary }
+    received = DeveloperOrderedBySalary.send(:with_exclusive_scope, :find => { :limit => 100 }) do
+      DeveloperOrderedBySalary.find(:all).collect { |dev| dev.salary }
     end
+    assert_equal expected, received
+  end
+
+  def test_order_in_default_scope_should_prevail
+    expected = Developer.find(:all, :order => 'salary desc').collect { |dev| dev.salary }
+    received = DeveloperOrderedBySalary.find(:all, :order => 'salary').collect { |dev| dev.salary }
+    assert_equal expected, received
+  end
 
-    records = klass.all
-    assert_equal 3, records.length
-    assert_equal 2, records.first.author_id
+  def test_create_attribute_overwrites_default_scoping
+    assert_equal 'David', PoorDeveloperCalledJamis.create!(:name => 'David').name
+    assert_equal 200000, PoorDeveloperCalledJamis.create!(:name => 'David', :salary => 200000).salary
+  end
+
+  def test_create_attribute_overwrites_default_values
+    assert_equal nil, PoorDeveloperCalledJamis.create!(:salary => nil).salary
+    assert_equal 50000, PoorDeveloperCalledJamis.create!(:name => 'David').salary
+  end
+
+  def test_default_scope_attribute
+    jamis = PoorDeveloperCalledJamis.new(:name => 'David')
+    assert_equal 50000, jamis.salary
+  end
+
+  def test_where_attribute
+    aaron = PoorDeveloperCalledJamis.where(:salary => 20).new(:name => 'Aaron')
+    assert_equal 20, aaron.salary
+    assert_equal 'Aaron', aaron.name
+  end
+
+  def test_where_attribute_merge
+    aaron = PoorDeveloperCalledJamis.where(:name => 'foo').new(:name => 'Aaron')
+    assert_equal 'Aaron', aaron.name
+  end
+
+  def test_scope_composed_by_limit_and_then_offset_is_equal_to_scope_composed_by_offset_and_then_limit
+    posts_limit_offset = Post.limit(3).offset(2)
+    posts_offset_limit = Post.offset(2).limit(3)
+    assert_equal posts_limit_offset, posts_offset_limit
+  end
+
+  def test_create_with_merge
+    aaron = PoorDeveloperCalledJamis.create_with(:name => 'foo', :salary => 20).merge(
+              PoorDeveloperCalledJamis.create_with(:name => 'Aaron')).new
+    assert_equal 20, aaron.salary
+    assert_equal 'Aaron', aaron.name
+
+    aaron = PoorDeveloperCalledJamis.create_with(:name => 'foo', :salary => 20).
+                                     create_with(:name => 'Aaron').new
+    assert_equal 20, aaron.salary
+    assert_equal 'Aaron', aaron.name
+  end
+
+  def test_create_with_reset
+    jamis = PoorDeveloperCalledJamis.create_with(:name => 'Aaron').create_with(nil).new
+    assert_equal 'Jamis', jamis.name
+  end
+end
+
+class DeprecatedDefaultScopingTest < ActiveRecord::TestCase
+  fixtures :developers, :posts
+
+  def test_default_scope
+    expected = Developer.find(:all, :order => 'salary DESC').collect { |dev| dev.salary }
+    received = DeprecatedDeveloperOrderedBySalary.find(:all).collect { |dev| dev.salary }
+    assert_equal expected, received
   end
 
   def test_default_scope_is_unscoped_on_find
-    assert_equal 1, DeveloperCalledDavid.count
-    assert_equal 11, DeveloperCalledDavid.unscoped.count
+    assert_equal 1, DeprecatedDeveloperCalledDavid.count
+    assert_equal 11, DeprecatedDeveloperCalledDavid.unscoped.count
   end
 
   def test_default_scope_is_unscoped_on_create
-    assert_nil DeveloperCalledJamis.unscoped.create!.name
+    assert_nil DeprecatedDeveloperCalledJamis.unscoped.create!.name
   end
 
   def test_default_scope_with_conditions_string
-    assert_equal Developer.find_all_by_name('David').map(&:id).sort, DeveloperCalledDavid.find(:all).map(&:id).sort
-    assert_equal nil, DeveloperCalledDavid.create!.name
+    assert_equal Developer.find_all_by_name('David').map(&:id).sort, DeprecatedDeveloperCalledDavid.find(:all).map(&:id).sort
+    assert_equal nil, DeprecatedDeveloperCalledDavid.create!.name
   end
 
   def test_default_scope_with_conditions_hash
-    assert_equal Developer.find_all_by_name('Jamis').map(&:id).sort, DeveloperCalledJamis.find(:all).map(&:id).sort
-    assert_equal 'Jamis', DeveloperCalledJamis.create!.name
+    assert_equal Developer.find_all_by_name('Jamis').map(&:id).sort, DeprecatedDeveloperCalledJamis.find(:all).map(&:id).sort
+    assert_equal 'Jamis', DeprecatedDeveloperCalledJamis.create!.name
   end
 
   def test_default_scoping_with_threads
     2.times do
-      Thread.new { assert_equal ['salary DESC'], DeveloperOrderedBySalary.scoped.order_values }.join
+      Thread.new { assert_equal ['salary DESC'], DeprecatedDeveloperOrderedBySalary.scoped.order_values }.join
     end
   end
 
   def test_default_scoping_with_inheritance
     # Inherit a class having a default scope and define a new default scope
-    klass = Class.new(DeveloperOrderedBySalary)
-    klass.send :default_scope, :limit => 1
+    klass = Class.new(DeprecatedDeveloperOrderedBySalary)
+    ActiveSupport::Deprecation.silence { klass.send :default_scope, :limit => 1 }
 
     # Scopes added on children should append to parent scope
     assert_equal 1,               klass.scoped.limit_value
     assert_equal ['salary DESC'], klass.scoped.order_values
 
     # Parent should still have the original scope
-    assert_nil DeveloperOrderedBySalary.scoped.limit_value
-    assert_equal ['salary DESC'], DeveloperOrderedBySalary.scoped.order_values
+    assert_nil DeprecatedDeveloperOrderedBySalary.scoped.limit_value
+    assert_equal ['salary DESC'], DeprecatedDeveloperOrderedBySalary.scoped.order_values
   end
 
   def test_default_scope_called_twice_merges_conditions
@@ -385,8 +484,10 @@ class DefaultScopingTest < ActiveRecord::TestCase
     Developer.create!(:name => "Brian", :salary => 100000)
 
     klass = Class.new(Developer)
-    klass.__send__ :default_scope, :conditions => { :name => "David" }
-    klass.__send__ :default_scope, :conditions => { :salary => 100000 }
+    ActiveSupport::Deprecation.silence do
+      klass.__send__ :default_scope, :conditions => { :name => "David" }
+      klass.__send__ :default_scope, :conditions => { :salary => 100000 }
+    end
     assert_equal 1,       klass.count
     assert_equal "David", klass.first.name
     assert_equal 100000,  klass.first.salary
@@ -399,9 +500,11 @@ class DefaultScopingTest < ActiveRecord::TestCase
     Developer.create!(:name => "Brian", :salary => 100000)
 
     klass = Class.new(Developer)
-    klass.class_eval do
-      default_scope where("name = 'David'")
-      default_scope where("salary = 100000")
+    ActiveSupport::Deprecation.silence do
+      klass.class_eval do
+        default_scope where("name = 'David'")
+        default_scope where("salary = 100000")
+      end
     end
 
     assert_equal 1,       klass.count
@@ -411,96 +514,90 @@ class DefaultScopingTest < ActiveRecord::TestCase
 
   def test_method_scope
     expected = Developer.find(:all, :order => 'salary DESC, name DESC').collect { |dev| dev.salary }
-    received = DeveloperOrderedBySalary.all_ordered_by_name.collect { |dev| dev.salary }
+    received = DeprecatedDeveloperOrderedBySalary.all_ordered_by_name.collect { |dev| dev.salary }
     assert_equal expected, received
   end
 
   def test_nested_scope
     expected = Developer.find(:all, :order => 'salary DESC, name DESC').collect { |dev| dev.salary }
-    received = DeveloperOrderedBySalary.send(:with_scope, :find => { :order => 'name DESC'}) do
-      DeveloperOrderedBySalary.find(:all).collect { |dev| dev.salary }
+    received = DeprecatedDeveloperOrderedBySalary.send(:with_scope, :find => { :order => 'name DESC'}) do
+      DeprecatedDeveloperOrderedBySalary.find(:all).collect { |dev| dev.salary }
     end
     assert_equal expected, received
   end
 
   def test_scope_overwrites_default
     expected = Developer.find(:all, :order => 'salary DESC, name DESC').collect { |dev| dev.name }
-    received = DeveloperOrderedBySalary.by_name.find(:all).collect { |dev| dev.name }
+    received = DeprecatedDeveloperOrderedBySalary.by_name.find(:all).collect { |dev| dev.name }
     assert_equal expected, received
   end
 
   def test_reorder_overrides_default_scope_order
     expected = Developer.order('name DESC').collect { |dev| dev.name }
-    received = DeveloperOrderedBySalary.reorder('name DESC').collect { |dev| dev.name }
+    received = DeprecatedDeveloperOrderedBySalary.reorder('name DESC').collect { |dev| dev.name }
     assert_equal expected, received
   end
 
   def test_nested_exclusive_scope
     expected = Developer.find(:all, :limit => 100).collect { |dev| dev.salary }
-    received = DeveloperOrderedBySalary.send(:with_exclusive_scope, :find => { :limit => 100 }) do
-      DeveloperOrderedBySalary.find(:all).collect { |dev| dev.salary }
+    received = DeprecatedDeveloperOrderedBySalary.send(:with_exclusive_scope, :find => { :limit => 100 }) do
+      DeprecatedDeveloperOrderedBySalary.find(:all).collect { |dev| dev.salary }
     end
     assert_equal expected, received
   end
 
   def test_order_in_default_scope_should_prevail
     expected = Developer.find(:all, :order => 'salary desc').collect { |dev| dev.salary }
-    received = DeveloperOrderedBySalary.find(:all, :order => 'salary').collect { |dev| dev.salary }
+    received = DeprecatedDeveloperOrderedBySalary.find(:all, :order => 'salary').collect { |dev| dev.salary }
     assert_equal expected, received
   end
 
   def test_default_scope_using_relation
-    posts = PostWithComment.scoped
-    assert_equal 2, posts.count
+    posts = DeprecatedPostWithComment.scoped
+    assert_equal 2, posts.to_a.length
     assert_equal posts(:thinking), posts.first
   end
 
   def test_create_attribute_overwrites_default_scoping
-    assert_equal 'David', PoorDeveloperCalledJamis.create!(:name => 'David').name
-    assert_equal 200000, PoorDeveloperCalledJamis.create!(:name => 'David', :salary => 200000).salary
+    assert_equal 'David', DeprecatedPoorDeveloperCalledJamis.create!(:name => 'David').name
+    assert_equal 200000, DeprecatedPoorDeveloperCalledJamis.create!(:name => 'David', :salary => 200000).salary
   end
 
   def test_create_attribute_overwrites_default_values
-    assert_equal nil, PoorDeveloperCalledJamis.create!(:salary => nil).salary
-    assert_equal 50000, PoorDeveloperCalledJamis.create!(:name => 'David').salary
+    assert_equal nil, DeprecatedPoorDeveloperCalledJamis.create!(:salary => nil).salary
+    assert_equal 50000, DeprecatedPoorDeveloperCalledJamis.create!(:name => 'David').salary
   end
 
   def test_default_scope_attribute
-    jamis = PoorDeveloperCalledJamis.new(:name => 'David')
+    jamis = DeprecatedPoorDeveloperCalledJamis.new(:name => 'David')
     assert_equal 50000, jamis.salary
   end
 
   def test_where_attribute
-    aaron = PoorDeveloperCalledJamis.where(:salary => 20).new(:name => 'Aaron')
+    aaron = DeprecatedPoorDeveloperCalledJamis.where(:salary => 20).new(:name => 'Aaron')
     assert_equal 20, aaron.salary
     assert_equal 'Aaron', aaron.name
   end
 
   def test_where_attribute_merge
-    aaron = PoorDeveloperCalledJamis.where(:name => 'foo').new(:name => 'Aaron')
+    aaron = DeprecatedPoorDeveloperCalledJamis.where(:name => 'foo').new(:name => 'Aaron')
     assert_equal 'Aaron', aaron.name
   end
 
-  def test_scope_composed_by_limit_and_then_offset_is_equal_to_scope_composed_by_offset_and_then_limit
-    posts_limit_offset = Post.limit(3).offset(2)
-    posts_offset_limit = Post.offset(2).limit(3)
-    assert_equal posts_limit_offset, posts_offset_limit
-  end
-
   def test_create_with_merge
-    aaron = PoorDeveloperCalledJamis.create_with(:name => 'foo', :salary => 20).merge(
-              PoorDeveloperCalledJamis.create_with(:name => 'Aaron')).new
+    aaron = DeprecatedPoorDeveloperCalledJamis.create_with(:name => 'foo', :salary => 20).merge(
+              DeprecatedPoorDeveloperCalledJamis.create_with(:name => 'Aaron')).new
     assert_equal 20, aaron.salary
     assert_equal 'Aaron', aaron.name
 
-    aaron = PoorDeveloperCalledJamis.create_with(:name => 'foo', :salary => 20).
+    aaron = DeprecatedPoorDeveloperCalledJamis.create_with(:name => 'foo', :salary => 20).
                                      create_with(:name => 'Aaron').new
     assert_equal 20, aaron.salary
     assert_equal 'Aaron', aaron.name
   end
 
   def test_create_with_reset
-    jamis = PoorDeveloperCalledJamis.create_with(:name => 'Aaron').create_with(nil).new
+    jamis = DeprecatedPoorDeveloperCalledJamis.create_with(:name => 'Aaron').create_with(nil).new
     assert_equal 'Jamis', jamis.name
   end
 end