activerecord 3.0.0.beta → 3.0.0.beta2

data/lib/active_record/fixtures.rb

@@ -4,6 +4,7 @@ require 'csv'
 require 'zlib'
 require 'active_support/dependencies'
 require 'active_support/core_ext/logger'
+require 'active_support/core_ext/object/blank'
 
 if RUBY_VERSION < '1.9'
   module YAML #:nodoc:

data/lib/active_record/migration.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/object/metaclass'
+require 'active_support/core_ext/object/singleton_class'
 
 module ActiveRecord
   # Exception that can be raised to stop migrations from going backwards.
@@ -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
@@ -303,7 +303,7 @@ module ActiveRecord
 
           case sym
             when :up, :down
-              metaclass.send(:alias_method_chain, sym, "benchmarks")
+              singleton_class.send(:alias_method_chain, sym, "benchmarks")
           end
         ensure
           @ignore_new_methods = false
@@ -315,7 +315,9 @@ module ActiveRecord
       end
 
       def announce(message)
-        text = "#{@version} #{name}: #{message}"
+        version = defined?(@version) ? @version : nil
+
+        text = "#{version} #{name}: #{message}"
         length = [0, 75 - text.length].max
         write "== %s %s" % [text, "=" * length]
       end
@@ -372,7 +374,7 @@ module ActiveRecord
       end
 
       def load_migration
-        load(filename)
+        require(File.expand_path(filename))
         name.constantize
       end
 

data/lib/active_record/named_scope.rb

@@ -1,6 +1,7 @@
 require 'active_support/core_ext/array'
 require 'active_support/core_ext/hash/except'
-require 'active_support/core_ext/object/metaclass'
+require 'active_support/core_ext/object/singleton_class'
+require 'active_support/core_ext/object/blank'
 
 module ActiveRecord
   module NamedScope
@@ -26,7 +27,7 @@ module ActiveRecord
         if options.present?
           Scope.init(self, options, &block)
         else
-          current_scoped_methods ? unscoped.merge(current_scoped_methods) : unscoped.spawn
+          current_scoped_methods ? unscoped.merge(current_scoped_methods) : unscoped.clone
         end
       end
 
@@ -101,7 +102,8 @@ module ActiveRecord
         name = name.to_sym
 
         if !scopes[name] && respond_to?(name, true)
-          raise ArgumentError, "Cannot define scope :#{name} because #{self.name}.#{name} method already exists."
+          logger.warn "Creating scope :#{name}. " \
+                      "Overwriting existing method #{self.name}.#{name}."
         end
 
         scopes[name] = lambda do |parent_scope, *args|
@@ -112,7 +114,7 @@ module ActiveRecord
               options.call(*args)
           end, &block)
         end
-        metaclass.instance_eval do
+        singleton_class.instance_eval do
           define_method name do |*args|
             scopes[name].call(self, *args)
           end
@@ -165,7 +167,14 @@ module ActiveRecord
       end
 
       def ==(other)
-        other.respond_to?(:to_ary) ? to_a == other.to_a : false
+        case other
+        when Scope
+          to_sql == other.to_sql
+        when Relation
+          other == self
+        when Array
+          to_a == other.to_a
+        end
       end
 
       private

data/lib/active_record/nested_attributes.rb

@@ -1,5 +1,6 @@
 require 'active_support/core_ext/hash/except'
 require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/object/blank'
 
 module ActiveRecord
   module NestedAttributes #:nodoc:
@@ -243,11 +244,14 @@ module ActiveRecord
             # def pirate_attributes=(attributes)
             #   assign_nested_attributes_for_one_to_one_association(:pirate, attributes)
             # end
-            class_eval %{
+            class_eval <<-eoruby, __FILE__, __LINE__ + 1
+              if method_defined?(:#{association_name}_attributes=)
+                remove_method(:#{association_name}_attributes=)
+              end
               def #{association_name}_attributes=(attributes)
                 assign_nested_attributes_for_#{type}_association(:#{association_name}, attributes)
               end
-            }, __FILE__, __LINE__
+            eoruby
           else
             raise ArgumentError, "No association found for name `#{association_name}'. Has it been defined yet?"
           end

data/lib/active_record/query_cache.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/object/blank'
+
 module ActiveRecord
   class QueryCache
     module ClassMethods

data/lib/active_record/railtie.rb

@@ -10,7 +10,7 @@ require "action_controller/railtie"
 
 module ActiveRecord
   class Railtie < Rails::Railtie
-    railtie_name :active_record
+    config.active_record = ActiveSupport::OrderedOptions.new
 
     config.generators.orm :active_record, :migration => true,
                                           :timestamps => true
@@ -19,36 +19,43 @@ module ActiveRecord
       load "active_record/railties/databases.rake"
     end
 
-    # TODO If we require the wrong file, the error never comes up.
-    require "active_record/railties/subscriber"
-    subscriber ActiveRecord::Railties::Subscriber.new
+    require "active_record/railties/log_subscriber"
+    log_subscriber :active_record, ActiveRecord::Railties::LogSubscriber.new
 
     initializer "active_record.initialize_timezone" do
-      ActiveRecord::Base.time_zone_aware_attributes = true
-      ActiveRecord::Base.default_timezone = :utc
+      ActiveSupport.on_load(:active_record) do
+        self.time_zone_aware_attributes = true
+        self.default_timezone = :utc
+      end
     end
 
     initializer "active_record.logger" do
-      ActiveRecord::Base.logger ||= ::Rails.logger
+      ActiveSupport.on_load(:active_record) { self.logger ||= ::Rails.logger }
     end
 
     initializer "active_record.set_configs" do |app|
-      app.config.active_record.each do |k,v|
-        ActiveRecord::Base.send "#{k}=", v
+      ActiveSupport.on_load(:active_record) do
+        app.config.active_record.each do |k,v|
+          send "#{k}=", v
+        end
       end
     end
 
     # This sets the database configuration from Configuration#database_configuration
     # and then establishes the connection.
     initializer "active_record.initialize_database" do |app|
-      ActiveRecord::Base.configurations = app.config.database_configuration
-      ActiveRecord::Base.establish_connection
+      ActiveSupport.on_load(:active_record) do
+        self.configurations = app.config.database_configuration
+        establish_connection
+      end
     end
 
     # Expose database runtime to controller for logging.
     initializer "active_record.log_runtime" do |app|
       require "active_record/railties/controller_runtime"
-      ActionController::Base.send :include, ActiveRecord::Railties::ControllerRuntime
+      ActiveSupport.on_load(:action_controller) do
+        include ActiveRecord::Railties::ControllerRuntime
+      end
     end
 
     # Setup database middleware after initializers have run
@@ -64,18 +71,22 @@ module ActiveRecord
     end
 
     initializer "active_record.load_observers" do
-      ActiveRecord::Base.instantiate_observers
+      ActiveSupport.on_load(:active_record) { instantiate_observers }
 
-      ActionDispatch::Callbacks.to_prepare(:activerecord_instantiate_observers) do
-        ActiveRecord::Base.instantiate_observers
+      ActiveSupport.on_load(:active_record) do
+        ActionDispatch::Callbacks.to_prepare(:activerecord_instantiate_observers) do
+          ActiveRecord::Base.instantiate_observers
+        end
       end
     end
 
     initializer "active_record.set_dispatch_hooks", :before => :set_clear_dependencies_hook do |app|
-      unless app.config.cache_classes
-        ActionDispatch::Callbacks.after do
-          ActiveRecord::Base.reset_subclasses
-          ActiveRecord::Base.clear_reloadable_connections!
+      ActiveSupport.on_load(:active_record) do
+        unless app.config.cache_classes
+          ActionDispatch::Callbacks.after do
+            ActiveRecord::Base.reset_subclasses
+            ActiveRecord::Base.clear_reloadable_connections!
+          end
         end
       end
     end

data/lib/active_record/railties/databases.rake

@@ -84,9 +84,15 @@ namespace :db do
           end
         end
       when 'postgresql'
-        @encoding = config[:encoding] || ENV['CHARSET'] || 'utf8'
+        @encoding = config['encoding'] || ENV['CHARSET'] || 'utf8'
+        schema_search_path = config['schema_search_path'] || 'public'
+        first_in_schema_search_path = schema_search_path.split(',').first.strip
         begin
           ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
+          unless ActiveRecord::Base.connection.all_schemas.include?(first_in_schema_search_path)
+            ActiveRecord::Base.connection.create_schema(first_in_schema_search_path, config['username'])
+            $stderr.puts "Schema #{first_in_schema_search_path} has been created."
+          end
           ActiveRecord::Base.connection.create_database(config['database'], config.merge('encoding' => @encoding))
           ActiveRecord::Base.establish_connection(config)
         rescue
@@ -109,7 +115,7 @@ namespace :db do
           # Only connect to local databases
           local_database?(config) { drop_database(config) }
         rescue Exception => e
-          puts "Couldn't drop #{config['database']} : #{e.inspect}"
+          $stderr.puts "Couldn't drop #{config['database']} : #{e.inspect}"
         end
       end
     end
@@ -121,7 +127,7 @@ namespace :db do
     begin
       drop_database(config)
     rescue Exception => e
-      puts "Couldn't drop #{config['database']} : #{e.inspect}"
+      $stderr.puts "Couldn't drop #{config['database']} : #{e.inspect}"
     end
   end
 
@@ -129,7 +135,7 @@ namespace :db do
     if %w( 127.0.0.1 localhost ).include?(config['host']) || config['host'].blank?
       yield
     else
-      puts "This task only modifies local databases. #{config['database']} is on a remote host."
+      $stderr.puts "This task only modifies local databases. #{config['database']} is on a remote host."
     end
   end
 
@@ -204,7 +210,7 @@ namespace :db do
       ActiveRecord::Base.establish_connection(config)
       puts ActiveRecord::Base.connection.encoding
     else
-      puts 'sorry, your database adapter is not supported yet, feel free to submit a patch'
+      $stderr.puts 'sorry, your database adapter is not supported yet, feel free to submit a patch'
     end
   end
 
@@ -216,7 +222,7 @@ namespace :db do
       ActiveRecord::Base.establish_connection(config)
       puts ActiveRecord::Base.connection.collation
     else
-      puts 'sorry, your database adapter is not supported yet, feel free to submit a patch'
+      $stderr.puts 'sorry, your database adapter is not supported yet, feel free to submit a patch'
     end
   end
 
@@ -435,7 +441,7 @@ namespace :db do
     task :create => :environment do
       raise "Task unavailable to this database (no migration support)" unless ActiveRecord::Base.connection.supports_migrations?
       require 'rails/generators'
-      require 'generators/rails/session_migration/session_migration_generator'
+      require 'rails/generators/rails/session_migration/session_migration_generator'
       Rails::Generators::SessionMigrationGenerator.start [ ENV["MIGRATION"] || "add_sessions_table" ]
     end
 

data/lib/active_record/railties/{subscriber.rb → log_subscriber.rb}

@@ -1,6 +1,11 @@
 module ActiveRecord
   module Railties
-    class Subscriber < Rails::Subscriber
+    class LogSubscriber < Rails::LogSubscriber
+      def initialize
+        super
+        @odd_or_even = false
+      end
+
       def sql(event)
         name = '%s (%.1fms)' % [event.payload[:name], event.duration]
         sql  = event.payload[:sql].squeeze(' ')
@@ -24,4 +29,4 @@ module ActiveRecord
       end
     end
   end
-end
+end

data/lib/active_record/reflection.rb

@@ -154,6 +154,11 @@ module ActiveRecord
         @klass ||= active_record.send(:compute_type, class_name)
       end
 
+      def initialize(macro, name, options, active_record)
+        super
+        @collection = [:has_many, :has_and_belongs_to_many].include?(macro)
+      end
+
       # Returns a new, unsaved instance of the associated class. +options+ will
       # be passed to the class's constructor.
       def build_association(*options)
@@ -256,9 +261,6 @@ module ActiveRecord
       # association. Returns +true+ if the +macro+ is one of +has_many+ or
       # +has_and_belongs_to_many+, +false+ otherwise.
       def collection?
-        if @collection.nil?
-          @collection = [:has_many, :has_and_belongs_to_many].include?(macro)
-        end
         @collection
       end
 

data/lib/active_record/relation.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/object/blank'
+
 module ActiveRecord
   class Relation
     JoinOperation = Struct.new(:relation, :join_class, :on)
@@ -5,7 +7,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
@@ -14,6 +16,11 @@ module ActiveRecord
 
     def initialize(klass, table)
       @klass, @table = klass, table
+
+      @implicit_readonly = nil
+      @loaded            = nil
+
+      SINGLE_VALUE_METHODS.each {|v| instance_variable_set(:"@#{v}_value", nil)}
       (ASSOCIATION_METHODS + MULTI_VALUE_METHODS).each {|v| instance_variable_set(:"@#{v}_values", [])}
     end
 
@@ -21,6 +28,10 @@ module ActiveRecord
       with_create_scope { @klass.new(*args, &block) }
     end
 
+    def initialize_copy(other)
+      reset
+    end
+
     alias build new
 
     def create(*args, &block)
@@ -50,7 +61,7 @@ module ActiveRecord
 
       preload = @preload_values
       preload +=  @includes_values unless eager_loading?
-      preload.each {|associations| @klass.send(:preload_associations, @records, associations) } 
+      preload.each {|associations| @klass.send(:preload_associations, @records, associations) }
 
       # @readonly_value is true only if set explicity. @implicit_readonly is true if there are JOINS and no explicit SELECT.
       readonly = @readonly_value.nil? ? @implicit_readonly : @readonly_value

data/lib/active_record/relation/batches.rb

@@ -0,0 +1,84 @@
+require 'active_support/core_ext/object/blank'
+
+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 orders.present? || taken.present?
+         ActiveRecord::Base.logger.warn("Scoped order and limit are ignored, it's forced to be batch order and batch size")
+       end
+
+      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