Merge remote branch 'mainstream/master'

Conflicts:
	railties/README
	railties/guides/source/active_support_core_extensions.textile
	railties/guides/source/getting_started.textile
	railties/lib/generators/rails/app/templates/README

13 files changed, 115 insertions, 115 deletions

diff --git a/activerecord/CHANGELOG b/activerecord/CHANGELOG
index a4fa000964..214ec8c1d8 100644
--- a/activerecord/CHANGELOG
+++ b/activerecord/CHANGELOG
@@ -1,5 +1,10 @@
 *Edge*
 
+* Silenced "SHOW FIELDS" and "SET SQL_AUTO_IS_NULL=0" statements from the MySQL driver to improve log signal to noise ration in development [DHH]
+
+
+*Rails 3.0 [Beta] (February 4th, 2010)*
+
 * PostgreSQLAdapter: set time_zone to UTC when Base.default_timezone == :utc so that Postgres doesn't incorrectly offset-adjust values inserted into TIMESTAMP WITH TIME ZONE columns. #3777 [Jack Christensen]
 
 * Allow relations to be used as scope.
diff --git a/activerecord/Rakefile b/activerecord/Rakefile
index 2511f13fed..8a414a751b 100644
--- a/activerecord/Rakefile
+++ b/activerecord/Rakefile
@@ -226,11 +226,11 @@ end
 
 # Publishing ------------------------------------------------------
 
-desc "Publish the beta gem"
-task :pgem => [:package] do
-  require 'rake/contrib/sshpublisher'
-  Rake::SshFilePublisher.new("gems.rubyonrails.org", "/u/sites/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
-  `ssh gems.rubyonrails.org '/u/sites/gems/gemupdate.sh'`
+desc "Release to gemcutter"
+task :release => :package do
+  require 'rake/gemcutter'
+  Rake::Gemcutter::Tasks.new(spec).define
+  Rake::Task['gem:push'].invoke
 end
 
 desc "Publish the API documentation"
@@ -238,15 +238,3 @@ task :pdoc => [:rdoc] do
   require 'rake/contrib/sshpublisher'
   Rake::SshDirPublisher.new("wrath.rubyonrails.org", "public_html/ar", "doc").upload
 end
-
-desc "Publish the release files to RubyForge."
-task :release => [ :package ] do
-  require 'rubyforge'
-  require 'rake/contrib/rubyforgepublisher'
-
-  packages = %w( gem tgz zip ).collect{ |ext| "pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}" }
-
-  rubyforge = RubyForge.new
-  rubyforge.login
-  rubyforge.add_release(PKG_NAME, PKG_NAME, "REL #{PKG_VERSION}", *packages)
-end
diff --git a/activerecord/activerecord.gemspec b/activerecord/activerecord.gemspec
index f7ed77ca4b..aeaafbb694 100644
--- a/activerecord/activerecord.gemspec
+++ b/activerecord/activerecord.gemspec
@@ -1,9 +1,10 @@
 Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.name        = 'activerecord'
-  s.version     = '3.0.0.beta'
+  s.version     = '3.0.0.beta1'
   s.summary     = 'Object-relational mapper framework (part of Rails).'
   s.description = 'Object-relational mapper framework (part of Rails).'
+  s.required_ruby_version = '>= 1.8.7'
 
   s.author            = 'David Heinemeier Hansson'
   s.email             = 'david@loudthinking.com'
@@ -17,7 +18,7 @@ Gem::Specification.new do |s|
   s.extra_rdoc_files = %w( README )
   s.rdoc_options.concat ['--main',  'README']
 
-  s.add_dependency('activesupport', '= 3.0.0.beta')
-  s.add_dependency('activemodel',   '= 3.0.0.beta')
-  s.add_dependency('arel',          '~> 0.2.0')
+  s.add_dependency('activesupport', '= 3.0.0.beta1')
+  s.add_dependency('activemodel',   '= 3.0.0.beta1')
+  s.add_dependency('arel',          '~> 0.2.1')
 end
diff --git a/activerecord/lib/active_record.rb b/activerecord/lib/active_record.rb
index 9535c576be..b79da4565d 100644
--- a/activerecord/lib/active_record.rb
+++ b/activerecord/lib/active_record.rb
@@ -55,10 +55,10 @@ module ActiveRecord
       autoload :Calculations
       autoload :PredicateBuilder
       autoload :SpawnMethods
+      autoload :Batches
     end
 
     autoload :Base
-    autoload :Batches
     autoload :Callbacks
     autoload :DynamicFinderMatch
     autoload :DynamicScopeMatch
diff --git a/activerecord/lib/active_record/base.rb b/activerecord/lib/active_record/base.rb
index c4e07e8786..f30eba4f06 100755
--- a/activerecord/lib/active_record/base.rb
+++ b/activerecord/lib/active_record/base.rb
@@ -557,6 +557,7 @@ module ActiveRecord #:nodoc:
       alias :colorize_logging= :colorize_logging
 
       delegate :find, :first, :last, :all, :destroy, :destroy_all, :exists?, :delete, :delete_all, :update, :update_all, :to => :scoped
+      delegate :find_each, :find_in_batches, :to => :scoped
       delegate :select, :group, :order, :limit, :joins, :where, :preload, :eager_load, :includes, :from, :lock, :readonly, :having, :to => :scoped
       delegate :count, :average, :minimum, :maximum, :sum, :calculate, :to => :scoped
 
@@ -2394,7 +2395,7 @@ module ActiveRecord #:nodoc:
     # #save_with_autosave_associations to be wrapped inside a transaction.
     include AutosaveAssociation, NestedAttributes
 
-    include Aggregations, Transactions, Reflection, Batches, Serialization
+    include Aggregations, Transactions, Reflection, Serialization
 
   end
 end
diff --git a/activerecord/lib/active_record/batches.rb b/activerecord/lib/active_record/batches.rb
deleted file mode 100644
index e41d38fb8f..0000000000
--- a/activerecord/lib/active_record/batches.rb
+++ /dev/null
@@ -1,79 +0,0 @@
-module ActiveRecord
-  module Batches # :nodoc:
-    extend ActiveSupport::Concern
-
-    # When processing large numbers of records, it's often a good idea to do
-    # so in batches to prevent memory ballooning.
-    module ClassMethods
-      # Yields each record that was found by the find +options+. The find is
-      # performed by find_in_batches with a batch size of 1000 (or as
-      # specified by the <tt>:batch_size</tt> option).
-      #
-      # Example:
-      #
-      #   Person.find_each(:conditions => "age > 21") do |person|
-      #     person.party_all_night!
-      #   end
-      #
-      # Note: This method is only intended to use for batch processing of
-      # large amounts of records that wouldn't fit in memory all at once. If
-      # you just need to loop over less than 1000 records, it's probably
-      # better just to use the regular find methods.
-      def find_each(options = {})
-        find_in_batches(options) do |records|
-          records.each { |record| yield record }
-        end
-
-        self
-      end
-
-      # Yields each batch of records that was found by the find +options+ as
-      # an array. The size of each batch is set by the <tt>:batch_size</tt>
-      # option; the default is 1000.
-      #
-      # You can control the starting point for the batch processing by
-      # supplying the <tt>:start</tt> option. This is especially useful if you
-      # want multiple workers dealing with the same processing queue. You can
-      # make worker 1 handle all the records between id 0 and 10,000 and
-      # worker 2 handle from 10,000 and beyond (by setting the <tt>:start</tt>
-      # option on that worker).
-      #
-      # It's not possible to set the order. That is automatically set to
-      # ascending on the primary key ("id ASC") to make the batch ordering
-      # work. This also mean that this method only works with integer-based
-      # primary keys. You can't set the limit either, that's used to control
-      # the the batch sizes.
-      #
-      # Example:
-      #
-      #   Person.find_in_batches(:conditions => "age > 21") do |group|
-      #     sleep(50) # Make sure it doesn't get too crowded in there!
-      #     group.each { |person| person.party_all_night! }
-      #   end
-      def find_in_batches(options = {})
-        raise "You can't specify an order, it's forced to be #{batch_order}" if options[:order]
-        raise "You can't specify a limit, it's forced to be the batch_size"  if options[:limit]
-
-        start = options.delete(:start).to_i
-        batch_size = options.delete(:batch_size) || 1000
-
-        with_scope(:find => options.merge(:order => batch_order, :limit => batch_size)) do
-          records = find(:all, :conditions => [ "#{table_name}.#{primary_key} >= ?", start ])
-
-          while records.any?
-            yield records
-
-            break if records.size < batch_size
-            records = find(:all, :conditions => [ "#{table_name}.#{primary_key} > ?", records.last.id ])
-          end
-        end
-      end
-      
-      
-      private
-        def batch_order
-          "#{table_name}.#{primary_key} ASC"
-        end
-    end
-  end
-end
\ No newline at end of file
diff --git a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
index 8c0bf6396a..1f1df7e8c3 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
@@ -321,7 +321,11 @@ module ActiveRecord
 
       # Executes a SQL query and returns a MySQL::Result object. Note that you have to free the Result object after you're done using it.
       def execute(sql, name = nil) #:nodoc:
-        log(sql, name) { @connection.query(sql) }
+        if name == :skip_logging
+          @connection.query(sql)
+        else
+          log(sql, name) { @connection.query(sql) }
+        end
       rescue ActiveRecord::StatementInvalid => exception
         if exception.message.split(":").first =~ /Packets out of order/
           raise ActiveRecord::StatementInvalid, "'Packets out of order' error was received from the database. Please update your mysql bindings (gem install mysql) and read http://dev.mysql.com/doc/mysql/en/password-hashing.html for more information.  If you're on Windows, use the Instant Rails installer to get the updated mysql bindings."
@@ -456,7 +460,7 @@ module ActiveRecord
       def columns(table_name, name = nil)#:nodoc:
         sql = "SHOW FIELDS FROM #{quote_table_name(table_name)}"
         columns = []
-        result = execute(sql, name)
+        result = execute(sql, :skip_logging)
         result.each { |field| columns << MysqlColumn.new(field[0], field[4], field[1], field[2] == "YES") }
         result.free
         columns
@@ -616,11 +620,11 @@ module ActiveRecord
 
         def configure_connection
           encoding = @config[:encoding]
-          execute("SET NAMES '#{encoding}'") if encoding
+          execute("SET NAMES '#{encoding}'", :skip_logging) if encoding
 
           # By default, MySQL 'where id is null' selects the last inserted id.
           # Turn this off. http://dev.rubyonrails.org/ticket/6778
-          execute("SET SQL_AUTO_IS_NULL=0")
+          execute("SET SQL_AUTO_IS_NULL=0", :skip_logging)
         end
 
         def select(sql, name = nil)
diff --git a/activerecord/lib/active_record/migration.rb b/activerecord/lib/active_record/migration.rb
index c5630ba2fd..068d2a25b2 100644
--- a/activerecord/lib/active_record/migration.rb
+++ b/activerecord/lib/active_record/migration.rb
@@ -107,7 +107,7 @@ module ActiveRecord
   # The Rails package has several tools to help create and apply migrations.
   #
   # To generate a new migration, you can use
-  #   script/generate migration MyNewMigration
+  #   rails generate migration MyNewMigration
   #
   # where MyNewMigration is the name of your migration. The generator will
   # create an empty migration file <tt>timestamp_my_new_migration.rb</tt> in the <tt>db/migrate/</tt>
@@ -117,7 +117,7 @@ module ActiveRecord
   # MyNewMigration.
   #
   # There is a special syntactic shortcut to generate migrations that add fields to a table.
-  #   script/generate migration add_fieldname_to_tablename fieldname:string
+  #   rails generate migration add_fieldname_to_tablename fieldname:string
   #
   # This will generate the file <tt>timestamp_add_fieldname_to_tablename</tt>, which will look like this:
   #   class AddFieldnameToTablename < ActiveRecord::Migration
diff --git a/activerecord/lib/active_record/railtie.rb b/activerecord/lib/active_record/railtie.rb
index 2b204043b4..e70b0d1bfb 100644
--- a/activerecord/lib/active_record/railtie.rb
+++ b/activerecord/lib/active_record/railtie.rb
@@ -1,10 +1,12 @@
+require "active_record"
+require "rails"
+require "active_model/railtie"
+
 # For now, action_controller must always be present with
 # rails, so let's make sure that it gets required before
 # here. This is needed for correctly setting up the middleware.
 # In the future, this might become an optional require.
-require "active_record"
 require "action_controller/railtie"
-require "rails"
 
 module ActiveRecord
   class Railtie < Rails::Railtie
diff --git a/activerecord/lib/active_record/relation.rb b/activerecord/lib/active_record/relation.rb
index 1a96cdad17..7bc3d3bf33 100644
--- a/activerecord/lib/active_record/relation.rb
+++ b/activerecord/lib/active_record/relation.rb
@@ -5,7 +5,7 @@ module ActiveRecord
     MULTI_VALUE_METHODS = [:select, :group, :order, :joins, :where, :having]
     SINGLE_VALUE_METHODS = [:limit, :offset, :lock, :readonly, :create_with, :from]
 
-    include FinderMethods, Calculations, SpawnMethods, QueryMethods
+    include FinderMethods, Calculations, SpawnMethods, QueryMethods, Batches
 
     delegate :length, :collect, :map, :each, :all?, :include?, :to => :to_a
     delegate :insert, :to => :arel
diff --git a/activerecord/lib/active_record/relation/batches.rb b/activerecord/lib/active_record/relation/batches.rb
new file mode 100644
index 0000000000..4a260d4caa
--- /dev/null
+++ b/activerecord/lib/active_record/relation/batches.rb
@@ -0,0 +1,78 @@
+module ActiveRecord
+  module Batches # :nodoc:
+    # Yields each record that was found by the find +options+. The find is
+    # performed by find_in_batches with a batch size of 1000 (or as
+    # specified by the <tt>:batch_size</tt> option).
+    #
+    # Example:
+    #
+    #   Person.where("age > 21").find_each do |person|
+    #     person.party_all_night!
+    #   end
+    #
+    # Note: This method is only intended to use for batch processing of
+    # large amounts of records that wouldn't fit in memory all at once. If
+    # you just need to loop over less than 1000 records, it's probably
+    # better just to use the regular find methods.
+    def find_each(options = {})
+      find_in_batches(options) do |records|
+        records.each { |record| yield record }
+      end
+
+      self
+    end
+
+    # Yields each batch of records that was found by the find +options+ as
+    # an array. The size of each batch is set by the <tt>:batch_size</tt>
+    # option; the default is 1000.
+    #
+    # You can control the starting point for the batch processing by
+    # supplying the <tt>:start</tt> option. This is especially useful if you
+    # want multiple workers dealing with the same processing queue. You can
+    # make worker 1 handle all the records between id 0 and 10,000 and
+    # worker 2 handle from 10,000 and beyond (by setting the <tt>:start</tt>
+    # option on that worker).
+    #
+    # It's not possible to set the order. That is automatically set to
+    # ascending on the primary key ("id ASC") to make the batch ordering
+    # work. This also mean that this method only works with integer-based
+    # primary keys. You can't set the limit either, that's used to control
+    # the the batch sizes.
+    #
+    # Example:
+    #
+    #   Person.where("age > 21").find_in_batches do |group|
+    #     sleep(50) # Make sure it doesn't get too crowded in there!
+    #     group.each { |person| person.party_all_night! }
+    #   end
+    def find_in_batches(options = {})
+      relation = self
+
+      if (finder_options = options.except(:start, :batch_size)).present?
+        raise "You can't specify an order, it's forced to be #{batch_order}" if options[:order].present?
+        raise "You can't specify a limit, it's forced to be the batch_size"  if options[:limit].present?
+
+        relation = apply_finder_options(finder_options)
+      end
+
+      start = options.delete(:start).to_i
+      batch_size = options.delete(:batch_size) || 1000
+
+      relation = relation.except(:order).order(batch_order).limit(batch_size)
+      records = relation.where(primary_key.gteq(start)).all
+
+      while records.any?
+        yield records
+
+        break if records.size < batch_size
+        records = relation.where(primary_key.gt(records.last.id)).all
+      end
+    end
+
+    private
+
+    def batch_order
+      "#{@klass.table_name}.#{@klass.primary_key} ASC"
+    end
+  end
+end
\ No newline at end of file
diff --git a/activerecord/lib/active_record/version.rb b/activerecord/lib/active_record/version.rb
index d55b14f082..286ecd0289 100644
--- a/activerecord/lib/active_record/version.rb
+++ b/activerecord/lib/active_record/version.rb
@@ -2,7 +2,7 @@ module ActiveRecord
   module VERSION #:nodoc:
     MAJOR = 3
     MINOR = 0
-    TINY  = "0.beta"
+    TINY  = "0.beta1"
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end
diff --git a/activerecord/test/cases/validations_test.rb b/activerecord/test/cases/validations_test.rb
index 5aac0229cd..937e08ac68 100644
--- a/activerecord/test/cases/validations_test.rb
+++ b/activerecord/test/cases/validations_test.rb
@@ -157,9 +157,9 @@ class ValidationsTest < ActiveRecord::TestCase
   end
 
   def test_validates_acceptance_of_as_database_column
-    Topic.validates_acceptance_of(:author_name)
-    topic = Topic.create("author_name" => "Dan Brown")
-    assert_equal "Dan Brown", topic["author_name"]
+    Topic.validates_acceptance_of(:approved)
+    topic = Topic.create("approved" => true)
+    assert topic["approved"]
   end
 
   def test_validate_is_deprecated_on_create