activerecord 2.3.18 → 3.0.0.beta

data/lib/active_record/batches.rb

@@ -1,8 +1,6 @@
 module ActiveRecord
   module Batches # :nodoc:
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
+    extend ActiveSupport::Concern
 
     # When processing large numbers of records, it's often a good idea to do
     # so in batches to prevent memory ballooning.
@@ -59,23 +57,19 @@ module ActiveRecord
         start = options.delete(:start).to_i
         batch_size = options.delete(:batch_size) || 1000
 
-        proxy = scoped(options.merge(:order => batch_order, :limit => batch_size))
-        records = proxy.find(:all, :conditions => [ "#{table_name}.#{primary_key} >= ?", start ])
+        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
+          while records.any?
+            yield records
 
-          break if records.size < batch_size
-          
-          last_value = records.last.id
-          
-          raise "You must include the primary key if you define a select" unless last_value.present?
-          
-          records = proxy.find(:all, :conditions => [ "#{table_name}.#{primary_key} > ?", last_value ])
+            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"

data/lib/active_record/callbacks.rb

@@ -1,5 +1,3 @@
-require 'observer'
-
 module ActiveRecord
   # Callbacks are hooks into the lifecycle of an Active Record object that allow you to trigger logic
   # before or after an alteration of the object state. This can be used to make sure that associated and
@@ -10,19 +8,16 @@ module ActiveRecord
   # * (-) <tt>save</tt>
   # * (-) <tt>valid</tt>
   # * (1) <tt>before_validation</tt>
-  # * (2) <tt>before_validation_on_create</tt>
   # * (-) <tt>validate</tt>
-  # * (-) <tt>validate_on_create</tt>
-  # * (3) <tt>after_validation</tt>
-  # * (4) <tt>after_validation_on_create</tt>
-  # * (5) <tt>before_save</tt>
-  # * (6) <tt>before_create</tt>
+  # * (2) <tt>after_validation</tt>
+  # * (3) <tt>before_save</tt>
+  # * (4) <tt>before_create</tt>
   # * (-) <tt>create</tt>
-  # * (7) <tt>after_create</tt>
-  # * (8) <tt>after_save</tt>
+  # * (5) <tt>after_create</tt>
+  # * (6) <tt>after_save</tt>
   #
   # That's a total of eight callbacks, which gives you immense power to react and prepare for each state in the
-  # Active Record lifecycle. The sequence for calling <tt>Base#save</tt> an existing record is similar, except that each 
+  # Active Record lifecycle. The sequence for calling <tt>Base#save</tt> for an existing record is similar, except that each
   # <tt>_on_create</tt> callback is replaced by the corresponding <tt>_on_update</tt> callback.
   #
   # Examples:
@@ -211,150 +206,95 @@ module ActiveRecord
   # needs to be aware of it because an ordinary +save+ will raise such exception
   # instead of quietly returning +false+.
   module Callbacks
-    CALLBACKS = %w(
-      after_find after_initialize before_save after_save before_create after_create before_update after_update before_validation
-      after_validation before_validation_on_create after_validation_on_create before_validation_on_update
-      after_validation_on_update before_destroy after_destroy
-    )
+    extend ActiveSupport::Concern
 
-    def self.included(base) #:nodoc:
-      base.extend Observable
+    CALLBACKS = [
+      :after_initialize, :after_find, :before_validation, :after_validation,
+      :before_save, :around_save, :after_save, :before_create, :around_create,
+      :after_create, :before_update, :around_update, :after_update,
+      :before_destroy, :around_destroy, :after_destroy
+    ]
 
+    included do
       [:create_or_update, :valid?, :create, :update, :destroy].each do |method|
-        base.send :alias_method_chain, method, :callbacks
+        alias_method_chain method, :callbacks
       end
 
-      base.send :include, ActiveSupport::Callbacks
-      base.define_callbacks *CALLBACKS
+      extend ActiveModel::Callbacks
+
+      define_callbacks :validation, :terminator => "result == false", :scope => [:kind, :name]
+
+      define_model_callbacks :initialize, :find, :only => :after
+      define_model_callbacks :save, :create, :update, :destroy
     end
 
-    # Is called when the object was instantiated by one of the finders, like <tt>Base.find</tt>.
-    #def after_find() end
+    module ClassMethods
+      def method_added(meth)
+        super
+        if CALLBACKS.include?(meth.to_sym)
+          ActiveSupport::Deprecation.warn("Base##{meth} has been deprecated, please use Base.#{meth} :method instead", caller[0,1])
+          send(meth.to_sym, meth.to_sym)
+        end
+      end
 
-    # Is called after the object has been instantiated by a call to <tt>Base.new</tt>.
-    #def after_initialize() end
+      def before_validation(*args, &block)
+        options = args.last
+        if options.is_a?(Hash) && options[:on]
+          options[:if] = Array(options[:if])
+          options[:if] << "@_on_validate == :#{options[:on]}"
+        end
+        set_callback(:validation, :before, *args, &block)
+      end
 
-    # Is called _before_ <tt>Base.save</tt> (regardless of whether it's a +create+ or +update+ save).
-    def before_save() end
+      def after_validation(*args, &block)
+        options = args.extract_options!
+        options[:prepend] = true
+        options[:if] = Array(options[:if])
+        options[:if] << "!halted && value != false"
+        options[:if] << "@_on_validate == :#{options[:on]}" if options[:on]
+        set_callback(:validation, :after, *(args << options), &block)
+      end
+    end
 
-    # Is called _after_ <tt>Base.save</tt> (regardless of whether it's a +create+ or +update+ save).
-    # Note that this callback is still wrapped in the transaction around +save+. For example, if you
-    # invoke an external indexer at this point it won't see the changes in the database.
-    #
-    #  class Contact < ActiveRecord::Base
-    #    after_save { logger.info( 'New contact saved!' ) }
-    #  end
-    def after_save()  end
     def create_or_update_with_callbacks #:nodoc:
-      return false if callback(:before_save) == false
-      if result = create_or_update_without_callbacks
-        callback(:after_save)
+      _run_save_callbacks do
+        create_or_update_without_callbacks
       end
-      result
     end
     private :create_or_update_with_callbacks
 
-    # Is called _before_ <tt>Base.save</tt> on new objects that haven't been saved yet (no record exists).
-    def before_create() end
-
-    # Is called _after_ <tt>Base.save</tt> on new objects that haven't been saved yet (no record exists).
-    # Note that this callback is still wrapped in the transaction around +save+. For example, if you
-    # invoke an external indexer at this point it won't see the changes in the database.
-    def after_create() end
     def create_with_callbacks #:nodoc:
-      return false if callback(:before_create) == false
-      result = create_without_callbacks
-      callback(:after_create)
-      result
+      _run_create_callbacks do
+        create_without_callbacks
+      end
     end
     private :create_with_callbacks
 
-    # Is called _before_ <tt>Base.save</tt> on existing objects that have a record.
-    def before_update() end
-
-    # Is called _after_ <tt>Base.save</tt> on existing objects that have a record.
-    # Note that this callback is still wrapped in the transaction around +save+. For example, if you
-    # invoke an external indexer at this point it won't see the changes in the database.
-    def after_update() end
-
     def update_with_callbacks(*args) #:nodoc:
-      return false if callback(:before_update) == false
-      result = update_without_callbacks(*args)
-      callback(:after_update)
-      result
+      _run_update_callbacks do
+        update_without_callbacks(*args)
+      end
     end
     private :update_with_callbacks
 
-    # Is called _before_ <tt>Validations.validate</tt> (which is part of the <tt>Base.save</tt> call).
-    def before_validation() end
-
-    # Is called _after_ <tt>Validations.validate</tt> (which is part of the <tt>Base.save</tt> call).
-    def after_validation() end
-
-    # Is called _before_ <tt>Validations.validate</tt> (which is part of the <tt>Base.save</tt> call) on new objects
-    # that haven't been saved yet (no record exists).
-    def before_validation_on_create() end
-
-    # Is called _after_ <tt>Validations.validate</tt> (which is part of the <tt>Base.save</tt> call) on new objects
-    # that haven't been saved yet (no record exists).
-    def after_validation_on_create()  end
-
-    # Is called _before_ <tt>Validations.validate</tt> (which is part of the <tt>Base.save</tt> call) on
-    # existing objects that have a record.
-    def before_validation_on_update() end
-
-    # Is called _after_ <tt>Validations.validate</tt> (which is part of the <tt>Base.save</tt> call) on
-    # existing objects that have a record.
-    def after_validation_on_update()  end
-
     def valid_with_callbacks? #:nodoc:
-      return false if callback(:before_validation) == false
-      if new_record? then result = callback(:before_validation_on_create) else result = callback(:before_validation_on_update) end
-      return false if false == result
-
-      result = valid_without_callbacks?
-
-      callback(:after_validation)
-      if new_record? then callback(:after_validation_on_create) else callback(:after_validation_on_update) end
-
-      return result
+      @_on_validate = new_record? ? :create : :update
+      _run_validation_callbacks do
+        valid_without_callbacks?
+      end
     end
 
-    # Is called _before_ <tt>Base.destroy</tt>.
-    #
-    # Note: If you need to _destroy_ or _nullify_ associated records first,
-    # use the <tt>:dependent</tt> option on your associations.
-    def before_destroy() end
-
-    # Is called _after_ <tt>Base.destroy</tt> (and all the attributes have been frozen).
-    #
-    #  class Contact < ActiveRecord::Base
-    #    after_destroy { |record| logger.info( "Contact #{record.id} was destroyed." ) }
-    #  end
-    def after_destroy()  end
     def destroy_with_callbacks #:nodoc:
-      return false if callback(:before_destroy) == false
-      result = destroy_without_callbacks
-      callback(:after_destroy)
-      result
-    end
-
-    private
-      def callback(method)
-        result = run_callbacks(method) { |result, object| false == result }
-
-        if result != false && respond_to_without_attributes?(method)
-          result = send(method)
-        end
-
-        notify(method)
-
-        return result
+      _run_destroy_callbacks do
+        destroy_without_callbacks
       end
+    end
 
-      def notify(method) #:nodoc:
-        self.class.changed
-        self.class.notify_observers(method, self)
+    def deprecated_callback_method(symbol) #:nodoc:
+      if respond_to?(symbol, true)
+        ActiveSupport::Deprecation.warn("Overwriting #{symbol} in your models has been deprecated, please use Base##{symbol} :method_name instead")
+        send(symbol)
       end
+    end
   end
 end

data/lib/active_record/connection_adapters/abstract/connection_pool.rb

@@ -1,5 +1,6 @@
 require 'monitor'
 require 'set'
+require 'active_support/core_ext/module/synchronization'
 
 module ActiveRecord
   # Raised when a connection could not be obtained within the connection
@@ -55,7 +56,7 @@ module ActiveRecord
     # * +wait_timeout+: number of seconds to block and wait for a connection
     #   before giving up and raising a timeout error (default 5 seconds).
     class ConnectionPool
-      attr_reader :spec
+      attr_reader :spec, :connections
 
       # Creates a new ConnectionPool object. +spec+ is a ConnectionSpecification
       # object which describes database connection information (e.g. adapter,
@@ -107,13 +108,14 @@ module ActiveRecord
         checkin conn if conn
       end
 
-      # Reserve a connection, and yield it to a block. Ensure the connection is
-      # checked back in when finished.
+      # If a connection already exists yield it to the block.  If no connection
+      # exists checkout a connection, yield it to the block, and checkin the 
+      # connection when finished.
       def with_connection
-        conn = checkout
-        yield conn
+        fresh_connection = true unless @reserved_connections[current_connection_id]
+        yield connection
       ensure
-        checkin conn
+        release_connection if fresh_connection
       end
 
       # Returns true if a connection has already been opened.
@@ -209,9 +211,10 @@ module ActiveRecord
       # calling +checkout+ on this pool.
       def checkin(conn)
         @connection_mutex.synchronize do
-          conn.run_callbacks :checkin
-          @checked_out.delete conn
-          @queue.signal
+          conn.run_callbacks :checkin do
+            @checked_out.delete conn
+            @queue.signal
+          end
         end
       end
 
@@ -253,9 +256,10 @@ module ActiveRecord
       end
 
       def checkout_and_verify(c)
-        c.verify!
-        c.run_callbacks :checkout
-        @checked_out << c
+        c.run_callbacks :checkout do
+          c.verify!
+          @checked_out << c
+        end
         c
       end
     end
@@ -360,7 +364,7 @@ module ActiveRecord
       def call(env)
         @app.call(env)
       ensure
-        # Don't return connection (and peform implicit rollback) if
+        # Don't return connection (and perform implicit rollback) if
         # this request is a part of integration test
         unless env.key?("rack.test")
           ActiveRecord::Base.clear_active_connections!

data/lib/active_record/connection_adapters/abstract/connection_specification.rb

@@ -10,8 +10,8 @@ module ActiveRecord
     ##
     # :singleton-method:
     # The connection handler
-    class_attribute :connection_handler
-    self.connection_handler = ConnectionAdapters::ConnectionHandler.new
+    cattr_accessor :connection_handler, :instance_writer => false
+    @@connection_handler = ConnectionAdapters::ConnectionHandler.new
 
     # Returns the connection currently associated with the class. This can
     # also be used to "borrow" the connection to do database work that isn't
@@ -51,10 +51,10 @@ module ActiveRecord
     def self.establish_connection(spec = nil)
       case spec
         when nil
-          raise AdapterNotSpecified unless defined? RAILS_ENV
-          establish_connection(RAILS_ENV)
+          raise AdapterNotSpecified unless defined?(Rails.env)
+          establish_connection(Rails.env)
         when ConnectionSpecification
-          self.connection_handler.establish_connection(name, spec)
+          @@connection_handler.establish_connection(name, spec)
         when Symbol, String
           if configuration = configurations[spec.to_s]
             establish_connection(configuration)
@@ -88,26 +88,6 @@ module ActiveRecord
     end
 
     class << self
-      # Deprecated and no longer has any effect.
-      def allow_concurrency
-        ActiveSupport::Deprecation.warn("ActiveRecord::Base.allow_concurrency has been deprecated and no longer has any effect. Please remove all references to allow_concurrency.")
-      end
-
-      # Deprecated and no longer has any effect.
-      def allow_concurrency=(flag)
-        ActiveSupport::Deprecation.warn("ActiveRecord::Base.allow_concurrency= has been deprecated and no longer has any effect. Please remove all references to allow_concurrency=.")
-      end
-
-      # Deprecated and no longer has any effect.
-      def verification_timeout
-        ActiveSupport::Deprecation.warn("ActiveRecord::Base.verification_timeout has been deprecated and no longer has any effect. Please remove all references to verification_timeout.")
-      end
-
-      # Deprecated and no longer has any effect.
-      def verification_timeout=(flag)
-        ActiveSupport::Deprecation.warn("ActiveRecord::Base.verification_timeout= has been deprecated and no longer has any effect. Please remove all references to verification_timeout=.")
-      end
-
       # Returns the connection currently associated with the class. This can
       # also be used to "borrow" the connection to do database work unrelated
       # to any of the specific Active Records.

data/lib/active_record/connection_adapters/abstract/database_statements.rb

@@ -53,7 +53,7 @@ module ActiveRecord
       def delete(sql, name = nil)
         delete_sql(sql, name)
       end
-      
+
       # Checks whether there is currently no transaction active. This is done
       # by querying the database driver, and does not use the transaction
       # house-keeping information recorded by #increment_open_transactions and
@@ -170,7 +170,7 @@ module ActiveRecord
           end
         end
       end
-      
+
       # Begins the transaction (and turns off auto-committing).
       def begin_db_transaction()    end
 
@@ -181,45 +181,6 @@ module ActiveRecord
       # done if the transaction block raises an exception or returns false.
       def rollback_db_transaction() end
 
-      # Alias for <tt>add_limit_offset!</tt>.
-      def add_limit!(sql, options)
-        add_limit_offset!(sql, options) if options
-      end
-
-      # Appends +LIMIT+ and +OFFSET+ options to an SQL statement, or some SQL
-      # fragment that has the same semantics as LIMIT and OFFSET.
-      #
-      # +options+ must be a Hash which contains a +:limit+ option (required)
-      # and an +:offset+ option (optional).
-      #
-      # This method *modifies* the +sql+ parameter.
-      #
-      # ===== Examples
-      #  add_limit_offset!('SELECT * FROM suppliers', {:limit => 10, :offset => 50})
-      # generates
-      #  SELECT * FROM suppliers LIMIT 10 OFFSET 50
-      def add_limit_offset!(sql, options)
-        if limit = options[:limit]
-          sql << " LIMIT #{sanitize_limit(limit)}"
-          if offset = options[:offset]
-            sql << " OFFSET #{offset.to_i}"
-          end
-        end
-        sql
-      end
-
-      # Appends a locking clause to an SQL statement.
-      # This method *modifies* the +sql+ parameter.
-      #   # SELECT * FROM suppliers FOR UPDATE
-      #   add_lock! 'SELECT * FROM suppliers', :lock => true
-      #   add_lock! 'SELECT * FROM suppliers', :lock => ' FOR UPDATE'
-      def add_lock!(sql, options)
-        case lock = options[:lock]
-          when true;   sql << ' FOR UPDATE'
-          when String; sql << " #{lock}"
-        end
-      end
-
       def default_sequence_name(table, column)
         nil
       end
@@ -235,8 +196,8 @@ module ActiveRecord
         execute "INSERT INTO #{quote_table_name(table_name)} (#{fixture.key_list}) VALUES (#{fixture.value_list})", 'Fixture Insert'
       end
 
-      def empty_insert_statement(table_name)
-        "INSERT INTO #{quote_table_name(table_name)} VALUES(DEFAULT)"
+      def empty_insert_statement_value
+        "VALUES(DEFAULT)"
       end
 
       def case_sensitive_equality_operator