Add Model.select/group/order/limit/joins/conditions/preload/eager_load class methods returning a lazy relation.

  Examples :

    posts = Post.select('id).order('name') # Returns a lazy relation
    posts.each {|p| puts p.id } # Fires "select id from posts order by name"

4 files changed, 88 insertions, 59 deletions

diff --git a/activerecord/lib/active_record/base.rb b/activerecord/lib/active_record/base.rb
index 321bba466e..03324b7f24 100755
--- a/activerecord/lib/active_record/base.rb
+++ b/activerecord/lib/active_record/base.rb
@@ -13,6 +13,7 @@ require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/hash/slice'
 require 'active_support/core_ext/string/behavior'
 require 'active_support/core_ext/object/metaclass'
+require 'active_support/core_ext/module/delegation'
 
 module ActiveRecord #:nodoc:
   # Generic Active Record exception class.
@@ -650,6 +651,8 @@ module ActiveRecord #:nodoc:
         end
       end
 
+      delegate :select, :group, :order, :limit, :joins, :conditions, :preload, :eager_load, :to => :arel_table
+
       # A convenience wrapper for <tt>find(:first, *args)</tt>. You can pass in all the
       # same arguments to this method as you can to <tt>find(:first)</tt>.
       def first(*args)
@@ -1514,13 +1517,8 @@ module ActiveRecord #:nodoc:
         "(#{segments.join(') AND (')})" unless segments.empty?
       end
 
-
       def arel_table(table = nil)
-        table = table_name if table.blank?
-        if @arel_table.nil? || @arel_table.name != table
-          @arel_table = Relation.new(self, Arel::Table.new(table))
-        end
-        @arel_table
+        Relation.new(self, Arel::Table.new(table || table_name))
       end
 
       private
diff --git a/activerecord/lib/active_record/named_scope.rb b/activerecord/lib/active_record/named_scope.rb
index 321871104c..38d54fa8ec 100644
--- a/activerecord/lib/active_record/named_scope.rb
+++ b/activerecord/lib/active_record/named_scope.rb
@@ -23,7 +23,26 @@ module ActiveRecord
       #
       # You can define a scope that applies to all finders using ActiveRecord::Base.default_scope.
       def scoped(options = {}, &block)
-        options.present? ? Scope.new(self, options, &block) : arel_table
+        if options.present?
+          Scope.new(self, options, &block)
+        else
+          if !scoped?(:find)
+            relation = arel_table
+          else
+            relation = construct_finder_arel
+            include_associations = scope(:find, :include)
+
+            if include_associations.present?
+              if references_eager_loaded_tables?(options)
+                relation.eager_load(include_associations)
+              else
+                relation.preload(include_associations)
+              end
+            end
+          end
+
+          relation
+        end
       end
 
       def scopes
diff --git a/activerecord/lib/active_record/relation.rb b/activerecord/lib/active_record/relation.rb
index 5f0eec754f..28f04e5d85 100644
--- a/activerecord/lib/active_record/relation.rb
+++ b/activerecord/lib/active_record/relation.rb
@@ -4,20 +4,20 @@ module ActiveRecord
     delegate :length, :collect, :find, :map, :each, :to => :to_a
     attr_reader :relation, :klass
 
-    def initialize(klass, relation)
+    def initialize(klass, relation, readonly = false, preload = [], eager_load = [])
       @klass, @relation = klass, relation
-      @readonly = false
-      @associations_to_preload = []
-      @eager_load_associations = []
+      @readonly = readonly
+      @associations_to_preload = preload
+      @eager_load_associations = eager_load
     end
 
-    def preload(association)
-      @associations_to_preload += association
+    def preload(associations)
+      @associations_to_preload << associations
       self
     end
 
-    def eager_load(association)
-      @eager_load_associations += association
+    def eager_load(associations)
+      @eager_load_associations += Array.wrap(associations)
       self
     end
 
@@ -45,7 +45,7 @@ module ActiveRecord
         @klass.find_by_sql(@relation.to_sql)
       end
 
-      @klass.send(:preload_associations, records, @associations_to_preload) unless @associations_to_preload.empty?
+      @associations_to_preload.each {|associations| @klass.send(:preload_associations, records, associations) }
       records.each { |record| record.readonly! } if @readonly
 
       records
@@ -57,27 +57,27 @@ module ActiveRecord
     end
 
     def select(selects)
-      selects.blank? ? self : Relation.new(@klass, @relation.project(selects))
+      selects.blank? ? self : create_new_relation(@relation.project(selects))
     end
 
     def group(groups)
-      groups.blank? ? self : Relation.new(@klass, @relation.group(groups))
+      groups.blank? ? self : create_new_relation(@relation.group(groups))
     end
 
     def order(orders)
-      orders.blank? ? self : Relation.new(@klass, @relation.order(orders))
+      orders.blank? ? self : create_new_relation(@relation.order(orders))
     end
 
     def limit(limits)
-      limits.blank? ? self : Relation.new(@klass, @relation.take(limits))
+      limits.blank? ? self : create_new_relation(@relation.take(limits))
     end
 
     def offset(offsets)
-      offsets.blank? ? self : Relation.new(@klass, @relation.skip(offsets))
+      offsets.blank? ? self : create_new_relation(@relation.skip(offsets))
     end
 
     def on(join)
-      join.blank? ? self : Relation.new(@klass, @relation.on(join))
+      join.blank? ? self : create_new_relation(@relation.on(join))
     end
 
     def joins(join, join_type = nil)
@@ -96,7 +96,7 @@ module ActiveRecord
           else
             @relation.join(join, join_type)
         end
-        Relation.new(@klass, join)
+        create_new_relation(join)
       end
     end
 
@@ -105,7 +105,7 @@ module ActiveRecord
         self
       else
         conditions = @klass.send(:merge_conditions, conditions) if [String, Hash, Array].include?(conditions.class)
-        Relation.new(@klass, @relation.where(conditions))
+        create_new_relation(@relation.where(conditions))
       end
     end
 
@@ -114,14 +114,20 @@ module ActiveRecord
     end
 
     private
-      def method_missing(method, *args, &block)
-        if @relation.respond_to?(method)
-          @relation.send(method, *args, &block)
-        elsif Array.method_defined?(method)
-          to_a.send(method, *args, &block)
-        else
-          super
-        end
+
+    def method_missing(method, *args, &block)
+      if @relation.respond_to?(method)
+        @relation.send(method, *args, &block)
+      elsif Array.method_defined?(method)
+        to_a.send(method, *args, &block)
+      else
+        super
       end
+    end
+
+    def create_new_relation(relation)
+      Relation.new(@klass, relation, @readonly, @associations_to_preload, @eager_load_associations)
+    end
+
   end
 end
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 5fa151df45..910b954c8c 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -19,47 +19,49 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_finding_with_conditions
-    assert_equal Author.find(:all, :conditions => "name = 'David'"), Author.all.conditions("name = 'David'").to_a
+    assert_equal ["David"], Author.conditions(:name => 'David').map(&:name)
+    assert_equal ['Mary'],  Author.conditions(["name = ?", 'Mary']).map(&:name)
   end
 
   def test_finding_with_order
-    topics = Topic.all.order('id')
+    topics = Topic.order('id')
     assert_equal 4, topics.size
     assert_equal topics(:first).title, topics.first.title
   end
 
   def test_finding_with_order_and_take
-    entrants = Entrant.all.order("id ASC").limit(2).to_a
+    entrants = Entrant.order("id ASC").limit(2).to_a
 
     assert_equal(2, entrants.size)
     assert_equal(entrants(:first).name, entrants.first.name)
   end
 
   def test_finding_with_order_limit_and_offset
-    entrants = Entrant.all.order("id ASC").limit(2).offset(1)
+    entrants = Entrant.order("id ASC").limit(2).offset(1)
 
     assert_equal(2, entrants.size)
     assert_equal(entrants(:second).name, entrants.first.name)
 
-    entrants = Entrant.all.order("id ASC").limit(2).offset(2)
+    entrants = Entrant.order("id ASC").limit(2).offset(2)
     assert_equal(1, entrants.size)
     assert_equal(entrants(:third).name, entrants.first.name)
   end
 
   def test_finding_with_group
-    developers = Developer.all.group("salary").select("salary").to_a
+    developers = Developer.group("salary").select("salary").to_a
     assert_equal 4, developers.size
     assert_equal 4, developers.map(&:salary).uniq.size
   end
 
   def test_finding_with_hash_conditions_on_joined_table
-    firms = DependentFirm.all.joins(:account).conditions({:name => 'RailsCore', :accounts => { :credit_limit => 55..60 }}).to_a
+    firms = DependentFirm.joins(:account).conditions({:name => 'RailsCore', :accounts => { :credit_limit => 55..60 }}).to_a
     assert_equal 1, firms.size
     assert_equal companies(:rails_core), firms.first
   end
 
   def test_find_all_with_join
-    developers_on_project_one = Developer.all.joins('LEFT JOIN developers_projects ON developers.id = developers_projects.developer_id').conditions('project_id=1').to_a
+    developers_on_project_one = Developer.joins('LEFT JOIN developers_projects ON developers.id = developers_projects.developer_id').
+      conditions('project_id=1').to_a
 
     assert_equal 3, developers_on_project_one.length
     developer_names = developers_on_project_one.map { |d| d.name }
@@ -68,11 +70,11 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_find_on_hash_conditions
-    assert_equal Topic.find(:all, :conditions => {:approved => false}), Topic.all.conditions({ :approved => false }).to_a
+    assert_equal Topic.find(:all, :conditions => {:approved => false}), Topic.conditions({ :approved => false }).to_a
   end
 
   def test_joins_with_string_array
-    person_with_reader_and_post = Post.all.joins([
+    person_with_reader_and_post = Post.joins([
         "INNER JOIN categorizations ON categorizations.post_id = posts.id",
         "INNER JOIN categories ON categories.id = categorizations.category_id AND categories.type = 'SpecialCategory'"
       ]
@@ -80,8 +82,8 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal 1, person_with_reader_and_post.size
   end
 
-  def test_relation_responds_to_delegated_methods
-    relation = Topic.all
+  def test_scoped_responds_to_delegated_methods
+    relation = Topic.scoped
 
     ["map", "uniq", "sort", "insert", "delete", "update"].each do |method|
       assert relation.respond_to?(method), "Topic.all should respond to #{method.inspect}"
@@ -89,13 +91,14 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_find_with_readonly_option
-    Developer.all.each { |d| assert !d.readonly? }
-    Developer.all.readonly.each { |d| assert d.readonly? }
-    Developer.all(:readonly => true).each { |d| assert d.readonly? }
+    Developer.scoped.each { |d| assert !d.readonly? }
+    Developer.scoped.readonly.each { |d| assert d.readonly? }
   end
 
   def test_eager_association_loading_of_stis_with_multiple_references
-    authors = Author.all(:include => { :posts => { :special_comments => { :post => [ :special_comments, :very_special_comment ] } } }, :order => 'comments.body, very_special_comments_posts.body', :conditions => 'posts.id = 4').to_a
+    authors = Author.eager_load(:posts => { :special_comments => { :post => [ :special_comments, :very_special_comment ] } }).
+      order('comments.body, very_special_comments_posts.body').conditions('posts.id = 4').to_a
+
     assert_equal [authors(:david)], authors
     assert_no_queries do
       authors.first.posts.first.special_comments.first.post.special_comments
@@ -105,50 +108,53 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_find_with_included_associations
     assert_queries(2) do
-      posts = Post.find(:all, :include => :comments)
+      posts = Post.preload(:comments)
       posts.first.comments.first
     end
+
     assert_queries(2) do
-      posts = Post.all(:include => :comments).to_a
+      posts = Post.preload(:comments).to_a
       posts.first.comments.first
     end
+
     assert_queries(2) do
-      posts = Post.find(:all, :include => :author)
+      posts = Post.preload(:author)
       posts.first.author
     end
+
     assert_queries(2) do
-      posts = Post.all(:include => :author).to_a
+      posts = Post.preload(:author).to_a
       posts.first.author
     end
   end
 
     def test_default_scope_with_conditions_string
-    assert_equal Developer.find_all_by_name('David').map(&:id).sort, DeveloperCalledDavid.all.to_a.map(&:id).sort
+    assert_equal Developer.find_all_by_name('David').map(&:id).sort, DeveloperCalledDavid.scoped.to_a.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.all.map(&:id).sort
+    assert_equal Developer.find_all_by_name('Jamis').map(&:id).sort, DeveloperCalledJamis.scoped.map(&:id).sort
     assert_equal 'Jamis', DeveloperCalledJamis.create!.name
   end
 
-    def test_loading_with_one_association
-    posts = Post.all(:include => :comments)
+  def test_loading_with_one_association
+    posts = Post.preload(:comments)
     post = posts.find { |p| p.id == 1 }
     assert_equal 2, post.comments.size
     assert post.comments.include?(comments(:greetings))
 
-    post = Post.find(:first, :include => :comments, :conditions => "posts.title = 'Welcome to the weblog'")
+    post = Post.conditions("posts.title = 'Welcome to the weblog'").preload(:comments).first
     assert_equal 2, post.comments.size
     assert post.comments.include?(comments(:greetings))
 
-    posts = Post.all(:include => :last_comment)
+    posts = Post.preload(:last_comment)
     post = posts.find { |p| p.id == 1 }
     assert_equal Post.find(1).last_comment, post.last_comment
   end
 
   def test_loading_with_one_association_with_non_preload
-    posts = Post.all(:include => :last_comment, :order => 'comments.id DESC')
+    posts = Post.eager_load(:last_comment).order('comments.id DESC')
     post = posts.find { |p| p.id == 1 }
     assert_equal Post.find(1).last_comment, post.last_comment
   end