13 files changed, 294 insertions, 114 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
diff --git a/activerecord/test/models/bulb.rb b/activerecord/test/models/bulb.rb
index 7178bb0d00..89ee5416bf 100644
--- a/activerecord/test/models/bulb.rb
+++ b/activerecord/test/models/bulb.rb
@@ -1,14 +1,15 @@
 class Bulb < ActiveRecord::Base
-
-  default_scope :conditions => {:name => 'defaulty' }
+  def self.default_scope
+    where :name => 'defaulty'
+  end
 
   belongs_to :car
 
-  attr_reader :scoped_methods_after_initialize
+  attr_reader :scope_after_initialize
 
-  after_initialize :record_scoped_methods_after_initialize
-  def record_scoped_methods_after_initialize
-    @scoped_methods_after_initialize = self.class.scoped_methods.dup
+  after_initialize :record_scope_after_initialize
+  def record_scope_after_initialize
+    @scope_after_initialize = self.class.scoped
   end
 
 end
diff --git a/activerecord/test/models/car.rb b/activerecord/test/models/car.rb
index e7db3d3423..a978debb58 100644
--- a/activerecord/test/models/car.rb
+++ b/activerecord/test/models/car.rb
@@ -1,6 +1,7 @@
 class Car < ActiveRecord::Base
 
   has_many :bulbs
+  has_many :foo_bulbs, :class_name => "Bulb", :conditions => { :name => 'foo' }
   has_many :tyres
   has_many :engines
   has_many :wheels, :as => :wheelable
@@ -14,9 +15,13 @@ class Car < ActiveRecord::Base
 end
 
 class CoolCar < Car
-  default_scope :order => 'name desc'
+  def self.default_scope
+    order 'name desc'
+  end
 end
 
 class FastCar < Car
-  default_scope order('name desc')
+  def self.default_scope
+    order 'name desc'
+  end
 end
diff --git a/activerecord/test/models/categorization.rb b/activerecord/test/models/categorization.rb
index 09489b8ea4..39441e8610 100644
--- a/activerecord/test/models/categorization.rb
+++ b/activerecord/test/models/categorization.rb
@@ -13,7 +13,9 @@ end
 class SpecialCategorization < ActiveRecord::Base
   self.table_name = 'categorizations'
 
-  default_scope where(:special => true)
+  def self.default_scope
+    where(:special => true)
+  end
 
   belongs_to :author
   belongs_to :category
diff --git a/activerecord/test/models/developer.rb b/activerecord/test/models/developer.rb
index 32d060cf09..28b31caf7b 100644
--- a/activerecord/test/models/developer.rb
+++ b/activerecord/test/models/developer.rb
@@ -86,7 +86,11 @@ end
 
 class DeveloperOrderedBySalary < ActiveRecord::Base
   self.table_name = 'developers'
-  default_scope :order => 'salary DESC'
+
+  def self.default_scope
+    order('salary DESC')
+  end
+
   scope :by_name, order('name DESC')
 
   def self.all_ordered_by_name
@@ -98,15 +102,72 @@ end
 
 class DeveloperCalledDavid < ActiveRecord::Base
   self.table_name = 'developers'
-  default_scope :conditions => "name = 'David'"
+
+  def self.default_scope
+    where "name = 'David'"
+  end
 end
 
 class DeveloperCalledJamis < ActiveRecord::Base
   self.table_name = 'developers'
-  default_scope :conditions => { :name => 'Jamis' }
+
+  def self.default_scope
+    where :name => 'Jamis'
+  end
+end
+
+class AbstractDeveloperCalledJamis < ActiveRecord::Base
+  self.abstract_class = true
+
+  def self.default_scope
+    where :name => 'Jamis'
+  end
 end
 
 class PoorDeveloperCalledJamis < ActiveRecord::Base
   self.table_name = 'developers'
-  default_scope :conditions => { :name => 'Jamis', :salary => 50000 }
+
+  def self.default_scope
+    where :name => 'Jamis', :salary => 50000
+  end
+end
+
+class InheritedPoorDeveloperCalledJamis < DeveloperCalledJamis
+  self.table_name = 'developers'
+
+  def self.default_scope
+    super.where :salary => 50000
+  end
+end
+
+ActiveSupport::Deprecation.silence do
+  class DeprecatedDeveloperOrderedBySalary < ActiveRecord::Base
+    self.table_name = 'developers'
+    default_scope :order => 'salary DESC'
+
+    def self.by_name
+      order('name DESC')
+    end
+
+    def self.all_ordered_by_name
+      with_scope(:find => { :order => 'name DESC' }) do
+        find(:all)
+      end
+    end
+  end
+
+  class DeprecatedDeveloperCalledDavid < ActiveRecord::Base
+    self.table_name = 'developers'
+    default_scope :conditions => "name = 'David'"
+  end
+
+  class DeprecatedDeveloperCalledJamis < ActiveRecord::Base
+    self.table_name = 'developers'
+    default_scope :conditions => { :name => 'Jamis' }
+  end
+
+  class DeprecatedPoorDeveloperCalledJamis < ActiveRecord::Base
+    self.table_name = 'developers'
+    default_scope :conditions => { :name => 'Jamis', :salary => 50000 }
+  end
 end
diff --git a/activerecord/test/models/pirate.rb b/activerecord/test/models/pirate.rb
index 0d3f62bb33..5e0f5323e6 100644
--- a/activerecord/test/models/pirate.rb
+++ b/activerecord/test/models/pirate.rb
@@ -34,7 +34,7 @@ class Pirate < ActiveRecord::Base
     :after_remove   => proc {|p,b| p.ship_log << "after_removing_proc_bird_#{b.id}"}
   has_many :birds_with_reject_all_blank, :class_name => "Bird"
 
-  has_one :bulb, :foreign_key => :car_id
+  has_one :foo_bulb, :foreign_key => :car_id, :class_name => "Bulb", :conditions => { :name => 'foo' }
 
   accepts_nested_attributes_for :parrots, :birds, :allow_destroy => true, :reject_if => proc { |attributes| attributes.empty? }
   accepts_nested_attributes_for :ship, :allow_destroy => true, :reject_if => proc { |attributes| attributes.empty? }
diff --git a/activerecord/test/models/post.rb b/activerecord/test/models/post.rb
index 82894a3d57..632f83e5d4 100644
--- a/activerecord/test/models/post.rb
+++ b/activerecord/test/models/post.rb
@@ -142,20 +142,25 @@ class SubStiPost < StiPost
   self.table_name = Post.table_name
 end
 
-class PostWithComment < ActiveRecord::Base
-  self.table_name = 'posts'
-  default_scope where("posts.comments_count > 0").order("posts.comments_count ASC")
+ActiveSupport::Deprecation.silence do
+  class DeprecatedPostWithComment < ActiveRecord::Base
+    self.table_name = 'posts'
+    default_scope where("posts.comments_count > 0").order("posts.comments_count ASC")
+  end
 end
 
 class PostForAuthor < ActiveRecord::Base
   self.table_name = 'posts'
   cattr_accessor :selected_author
-  default_scope lambda { where(:author_id => PostForAuthor.selected_author) }
 end
 
 class FirstPost < ActiveRecord::Base
   self.table_name = 'posts'
-  default_scope where(:id => 1)
+
+  def self.default_scope
+    where(:id => 1)
+  end
+
   has_many :comments, :foreign_key => :post_id
   has_one  :comment,  :foreign_key => :post_id
 end
diff --git a/activerecord/test/models/reference.rb b/activerecord/test/models/reference.rb
index e33a0f2acc..76c0a1a32e 100644
--- a/activerecord/test/models/reference.rb
+++ b/activerecord/test/models/reference.rb
@@ -18,6 +18,9 @@ class Reference < ActiveRecord::Base
 end
 
 class BadReference < ActiveRecord::Base
-  self.table_name ='references'
-  default_scope :conditions => {:favourite => false }
+  self.table_name = 'references'
+
+  def self.default_scope
+    where :favourite => false
+  end
 end
diff --git a/activerecord/test/models/without_table.rb b/activerecord/test/models/without_table.rb
index 87f80911e1..1a63d6ceb6 100644
--- a/activerecord/test/models/without_table.rb
+++ b/activerecord/test/models/without_table.rb
@@ -1,3 +1,5 @@
 class WithoutTable < ActiveRecord::Base
-  default_scope where(:published => true)
-end
\ No newline at end of file
+  def self.default_scope
+    where(:published => true)
+  end
+end