activerecord 3.0.0.beta3 → 3.0.0.beta4

data/lib/active_record/session_store.rb

@@ -307,7 +307,7 @@ module ActiveRecord
           end
         end
 
-        return true
+        sid
       end
       
       def get_session_model(env, sid)

data/lib/active_record/timestamp.rb

@@ -11,9 +11,6 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     included do
-      alias_method_chain :create, :timestamps
-      alias_method_chain :update, :timestamps
-
       class_inheritable_accessor :record_timestamps, :instance_writer => false
       self.record_timestamps = true
     end
@@ -39,35 +36,34 @@ module ActiveRecord
       save!
     end
 
+  private
+    def create #:nodoc:
+      if record_timestamps
+        current_time = current_time_from_proper_timezone
 
-    private
-      def create_with_timestamps #:nodoc:
-        if record_timestamps
-          current_time = current_time_from_proper_timezone
-
-          write_attribute('created_at', current_time) if respond_to?(:created_at) && created_at.nil?
-          write_attribute('created_on', current_time) if respond_to?(:created_on) && created_on.nil?
-
-          write_attribute('updated_at', current_time) if respond_to?(:updated_at) && updated_at.nil?
-          write_attribute('updated_on', current_time) if respond_to?(:updated_on) && updated_on.nil?
-        end
+        write_attribute('created_at', current_time) if respond_to?(:created_at) && created_at.nil?
+        write_attribute('created_on', current_time) if respond_to?(:created_on) && created_on.nil?
 
-        create_without_timestamps
+        write_attribute('updated_at', current_time) if respond_to?(:updated_at) && updated_at.nil?
+        write_attribute('updated_on', current_time) if respond_to?(:updated_on) && updated_on.nil?
       end
 
-      def update_with_timestamps(*args) #:nodoc:
-        if record_timestamps && (!partial_updates? || changed?)
-          current_time = current_time_from_proper_timezone
+      super
+    end
 
-          write_attribute('updated_at', current_time) if respond_to?(:updated_at)
-          write_attribute('updated_on', current_time) if respond_to?(:updated_on)
-        end
+    def update(*args) #:nodoc:
+      if record_timestamps && (!partial_updates? || changed?)
+        current_time = current_time_from_proper_timezone
 
-        update_without_timestamps(*args)
-      end
-      
-      def current_time_from_proper_timezone
-        self.class.default_timezone == :utc ? Time.now.utc : Time.now
+        write_attribute('updated_at', current_time) if respond_to?(:updated_at)
+        write_attribute('updated_on', current_time) if respond_to?(:updated_on)
       end
+
+      super
+    end
+    
+    def current_time_from_proper_timezone
+      self.class.default_timezone == :utc ? Time.now.utc : Time.now
+    end
   end
 end

data/lib/active_record/transactions.rb

@@ -9,9 +9,7 @@ module ActiveRecord
     end
 
     included do
-      [:destroy, :save, :save!].each do |method|
-        alias_method_chain method, :transactions
-      end
+      define_callbacks :commit, :rollback, :terminator => "result == false", :scope => [:kind, :name]
     end
 
     # Transactions are protective blocks where SQL statements are only permanent
@@ -28,10 +26,10 @@ module ActiveRecord
     #     mary.deposit(100)
     #   end
     #
-    # This example will only take money from David and give to Mary if neither
-    # +withdrawal+ nor +deposit+ raises an exception. Exceptions will force a
-    # ROLLBACK that returns the database to the state before the transaction was
-    # begun. Be aware, though, that the objects will _not_ have their instance
+    # This example will only take money from David and give it to Mary if neither
+    # +withdrawal+ nor +deposit+ raise an exception. Exceptions will force a
+    # ROLLBACK that returns the database to the state before the transaction
+    # began. Be aware, though, that the objects will _not_ have their instance
     # data returned to their pre-transactional state.
     #
     # == Different Active Record classes in a single transaction
@@ -41,16 +39,16 @@ module ActiveRecord
     # that class. This is because transactions are per-database connection, not
     # per-model.
     #
-    # In this example a <tt>Balance</tt> record is transactionally saved even
-    # though <tt>transaction</tt> is called on the <tt>Account</tt> class:
+    # In this example a +balance+ record is transactionally saved even
+    # though +transaction+ is called on the +Account+ class:
     #
     #   Account.transaction do
     #     balance.save!
     #     account.save!
     #   end
     #
-    # Note that the +transaction+ method is also available as a model instance
-    # method. For example, you can also do this:
+    # The +transaction+ method is also available as a model instance method.
+    # For example, you can also do this:
     #
     #   balance.transaction do
     #     balance.save!
@@ -59,9 +57,9 @@ module ActiveRecord
     #
     # == Transactions are not distributed across database connections
     #
-    # A transaction acts on a single database connection.  If you have
+    # A transaction acts on a single database connection. If you have
     # multiple class-specific databases, the transaction will not protect
-    # interaction among them.  One workaround is to begin a transaction
+    # interaction among them. One workaround is to begin a transaction
     # on each class whose models you alter:
     #
     #   Student.transaction do
@@ -71,16 +69,22 @@ module ActiveRecord
     #     end
     #   end
     #
-    # This is a poor solution, but full distributed transactions are beyond
+    # This is a poor solution, but fully distributed transactions are beyond
     # the scope of Active Record.
     #
-    # == Save and destroy are automatically wrapped in a transaction
+    # == +save+ and +destroy+ are automatically wrapped in a transaction
+    #
+    # Both +save+ and +destroy+ come wrapped in a transaction that ensures
+    # that whatever you do in validations or callbacks will happen under its
+    # protected cover. So you can use validations to check for values that
+    # the transaction depends on or you can raise exceptions in the callbacks
+    # to rollback, including <tt>after_*</tt> callbacks.
     #
-    # Both Base#save and Base#destroy come wrapped in a transaction that ensures
-    # that whatever you do in validations or callbacks will happen under the
-    # protected cover of a transaction. So you can use validations to check for
-    # values that the transaction depends on or you can raise exceptions in the
-    # callbacks to rollback, including <tt>after_*</tt> callbacks.
+    # As a consequence changes to the database are not seen outside your connection
+    # until the operation is complete. For example, if you try to update the index
+    # of a search engine in +after_save+ the indexer won't see the updated record.
+    # The +after_commit+ callback is the only one that is triggered once the update
+    # is committed. See below.
     #
     # == Exception handling and rolling back
     #
@@ -88,14 +92,14 @@ module ActiveRecord
     # be propagated (after triggering the ROLLBACK), so you should be ready to
     # catch those in your application code.
     #
-    # One exception is the ActiveRecord::Rollback exception, which will trigger
+    # One exception is the <tt>ActiveRecord::Rollback</tt> exception, which will trigger
     # a ROLLBACK when raised, but not be re-raised by the transaction block.
     #
-    # *Warning*: one should not catch ActiveRecord::StatementInvalid exceptions
-    # inside a transaction block. StatementInvalid exceptions indicate that an
+    # *Warning*: one should not catch <tt>ActiveRecord::StatementInvalid</tt> exceptions
+    # inside a transaction block. <tt>ActiveRecord::StatementInvalid</tt> exceptions indicate that an
     # error occurred at the database level, for example when a unique constraint
     # is violated. On some database systems, such as PostgreSQL, database errors
-    # inside a transaction causes the entire transaction to become unusable
+    # inside a transaction cause the entire transaction to become unusable
     # until it's restarted from the beginning. Here is an example which
     # demonstrates the problem:
     #
@@ -108,7 +112,7 @@ module ActiveRecord
     #     rescue ActiveRecord::StatementInvalid
     #       # ...which we ignore.
     #     end
-    #     
+    #
     #     # On PostgreSQL, the transaction is now unusable. The following
     #     # statement will cause a PostgreSQL error, even though the unique
     #     # constraint is no longer violated:
@@ -117,11 +121,12 @@ module ActiveRecord
     #     #     ignored until end of transaction block"
     #   end
     #
-    # One should restart the entire transaction if a StatementError occurred.
+    # One should restart the entire transaction if an
+    # <tt>ActiveRecord::StatementInvalid</tt> occurred.
     #
     # == Nested transactions
     #
-    # #transaction calls can be nested. By default, this makes all database
+    # +transaction+ calls can be nested. By default, this makes all database
     # statements in the nested transaction block become part of the parent
     # transaction. For example:
     #
@@ -132,11 +137,11 @@ module ActiveRecord
     #       raise ActiveRecord::Rollback
     #     end
     #   end
-    #   
+    #
     #   User.find(:all)  # => empty
     #
     # It is also possible to requires a sub-transaction by passing
-    # <tt>:requires_new => true</tt>.  If anything goes wrong, the
+    # <tt>:requires_new => true</tt>. If anything goes wrong, the
     # database rolls back to the beginning of the sub-transaction
     # without rolling back the parent transaction. For example:
     #
@@ -147,7 +152,7 @@ module ActiveRecord
     #       raise ActiveRecord::Rollback
     #     end
     #   end
-    #   
+    #
     #   User.find(:all)  # => Returns only Kotori
     #
     # Most databases don't support true nested transactions. At the time of
@@ -157,16 +162,31 @@ module ActiveRecord
     # http://dev.mysql.com/doc/refman/5.0/en/savepoints.html
     # for more information about savepoints.
     #
+    # === Callbacks
+    #
+    # There are two types of callbacks associated with committing and rolling back transactions:
+    # +after_commit+ and +after_rollback+.
+    #
+    # +after_commit+ callbacks are called on every record saved or destroyed within a
+    # transaction immediately after the transaction is committed. +after_rollback+ callbacks
+    # are called on every record saved or destroyed within a transaction immediately after the
+    # transaction or savepoint is rolled back.
+    #
+    # These callbacks are useful for interacting with other systems since you will be guaranteed
+    # that the callback is only executed when the database is in a permanent state. For example,
+    # +after_commit+ is a good spot to put in a hook to clearing a cache since clearing it from
+    # within a transaction could trigger the cache to be regenerated before the database is updated.
+    #
     # === Caveats
     #
     # If you're on MySQL, then do not use DDL operations in nested transactions
     # blocks that are emulated with savepoints. That is, do not execute statements
     # like 'CREATE TABLE' inside such blocks. This is because MySQL automatically
-    # releases all savepoints upon executing a DDL operation. When #transaction
+    # releases all savepoints upon executing a DDL operation. When +transaction+
     # is finished and tries to release the savepoint it created earlier, a
     # database error will occur because the savepoint has already been
     # automatically released. The following example demonstrates the problem:
-    # 
+    #
     #   Model.connection.transaction do                           # BEGIN
     #     Model.connection.transaction(:requires_new => true) do  # CREATE SAVEPOINT active_record_1
     #       Model.connection.create_table(...)                    # active_record_1 now automatically released
@@ -181,6 +201,24 @@ module ActiveRecord
         # See the ConnectionAdapters::DatabaseStatements#transaction API docs.
         connection.transaction(options, &block)
       end
+
+      def after_commit(*args, &block)
+        options = args.last
+        if options.is_a?(Hash) && options[:on]
+          options[:if] = Array.wrap(options[:if])
+          options[:if] << "transaction_include_action?(:#{options[:on]})"
+        end
+        set_callback(:commit, :after, *args, &block)
+      end
+
+      def after_rollback(*args, &block)
+        options = args.last
+        if options.is_a?(Hash) && options[:on]
+          options[:if] = Array.wrap(options[:if])
+          options[:if] << "transaction_include_action?(:#{options[:on]})"
+        end
+        set_callback(:rollback, :after, *args, &block)
+      end
     end
 
     # See ActiveRecord::Transactions::ClassMethods for detailed documentation.
@@ -188,33 +226,52 @@ module ActiveRecord
       self.class.transaction(&block)
     end
 
-    def destroy_with_transactions #:nodoc:
-      with_transaction_returning_status(:destroy_without_transactions)
+    def destroy #:nodoc:
+      with_transaction_returning_status { super }
     end
 
-    def save_with_transactions(*args) #:nodoc:
-      rollback_active_record_state! { with_transaction_returning_status(:save_without_transactions, *args) }
+    def save(*) #:nodoc:
+      rollback_active_record_state! do
+        with_transaction_returning_status { super }
+      end
     end
 
-    def save_with_transactions! #:nodoc:
-      rollback_active_record_state! { self.class.transaction { save_without_transactions! } }
+    def save!(*) #:nodoc:
+      with_transaction_returning_status { super }
     end
 
     # Reset id and @new_record if the transaction rolls back.
     def rollback_active_record_state!
-      id_present = has_attribute?(self.class.primary_key)
-      previous_id = id
-      previous_new_record = new_record?
+      remember_transaction_record_state
       yield
     rescue Exception
-      @new_record = previous_new_record
-      if id_present
-        self.id = previous_id
-      else
-        @attributes.delete(self.class.primary_key)
-        @attributes_cache.delete(self.class.primary_key)
-      end
+      restore_transaction_record_state
       raise
+    ensure
+      clear_transaction_record_state
+    end
+
+    # Call the after_commit callbacks
+    def committed! #:nodoc:
+      _run_commit_callbacks
+    ensure
+      clear_transaction_record_state
+    end
+
+    # Call the after rollback callbacks. The restore_state argument indicates if the record
+    # state should be rolled back to the beginning or just to the last savepoint.
+    def rolledback!(force_restore_state = false) #:nodoc:
+      _run_rollback_callbacks
+    ensure
+      restore_transaction_record_state(force_restore_state)
+    end
+
+    # Add the record to the current transaction so that the :after_rollback and :after_commit callbacks
+    # can be called.
+    def add_to_transaction
+      if self.class.connection.add_transaction_record(self)
+        remember_transaction_record_state
+      end
     end
 
     # Executes +method+ within a transaction and captures its return value as a
@@ -223,13 +280,74 @@ module ActiveRecord
     #
     # This method is available within the context of an ActiveRecord::Base
     # instance.
-    def with_transaction_returning_status(method, *args)
+    def with_transaction_returning_status
       status = nil
       self.class.transaction do
-        status = send(method, *args)
+        add_to_transaction
+        status = yield
         raise ActiveRecord::Rollback unless status
       end
       status
     end
+
+    protected
+
+    # Save the new record state and id of a record so it can be restored later if a transaction fails.
+    def remember_transaction_record_state #:nodoc
+      @_start_transaction_state ||= {}
+      unless @_start_transaction_state.include?(:new_record)
+        @_start_transaction_state[:id] = id if has_attribute?(self.class.primary_key)
+        @_start_transaction_state[:new_record] = @new_record
+      end
+      unless @_start_transaction_state.include?(:destroyed)
+        @_start_transaction_state[:destroyed] = @destroyed
+      end
+      @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) + 1
+    end
+
+    # Clear the new record state and id of a record.
+    def clear_transaction_record_state #:nodoc
+      if defined?(@_start_transaction_state)
+        @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
+        remove_instance_variable(:@_start_transaction_state) if @_start_transaction_state[:level] < 1
+      end
+    end
+
+    # Restore the new record state and id of a record that was previously saved by a call to save_record_state.
+    def restore_transaction_record_state(force = false) #:nodoc
+      if defined?(@_start_transaction_state)
+        @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
+        if @_start_transaction_state[:level] < 1
+          restore_state = remove_instance_variable(:@_start_transaction_state)
+          if restore_state
+            @new_record = restore_state[:new_record]
+            @destroyed = restore_state[:destroyed]
+            if restore_state[:id]
+              self.id = restore_state[:id]
+            else
+              @attributes.delete(self.class.primary_key)
+              @attributes_cache.delete(self.class.primary_key)
+            end
+          end
+        end
+      end
+    end
+
+    # Determine if a record was created or destroyed in a transaction. State should be one of :new_record or :destroyed.
+    def transaction_record_state(state) #:nodoc
+      @_start_transaction_state[state] if defined?(@_start_transaction_state)
+    end
+
+    # Determine if a transaction included an action for :create, :update, or :destroy. Used in filtering callbacks.
+    def transaction_include_action?(action) #:nodoc
+      case action
+      when :create
+        transaction_record_state(:new_record)
+      when :destroy
+        destroyed?
+      when :update
+        !(transaction_record_state(:new_record) || destroyed?)
+      end
+    end
   end
 end

data/lib/active_record/validations.rb

@@ -19,11 +19,6 @@ module ActiveRecord
     extend ActiveSupport::Concern
     include ActiveModel::Validations
 
-    included do
-      alias_method_chain :save, :validation
-      alias_method_chain :save!, :validation
-    end
-
     module ClassMethods
       # Creates an object just like Base.create but calls save! instead of save
       # so an exception is raised if the record is invalid.
@@ -39,59 +34,48 @@ module ActiveRecord
       end
     end
 
-    module InstanceMethods
-      # The validation process on save can be skipped by passing false. The regular Base#save method is
-      # replaced with this when the validations module is mixed in, which it is by default.
-      def save_with_validation(options=nil)
-        perform_validation = case options
-          when NilClass
-            true
-          when Hash
-            options[:validate] != false
-          else
-            ActiveSupport::Deprecation.warn "save(#{options}) is deprecated, please give save(:validate => #{options}) instead", caller
-            options
-        end
+    # The validation process on save can be skipped by passing false. The regular Base#save method is
+    # replaced with this when the validations module is mixed in, which it is by default.
+    def save(options={})
+      perform_validations(options) ? super : false
+    end
 
-        if perform_validation && valid? || !perform_validation
-          save_without_validation
-        else
-          false
-        end
-      end
+    # Attempts to save the record just like Base#save but will raise a RecordInvalid exception instead of returning false
+    # if the record is not valid.
+    def save!(options={})
+      perform_validations(options) ? super : raise(RecordInvalid.new(self))
+    end
 
-      # Attempts to save the record just like Base#save but will raise a RecordInvalid exception instead of returning false
-      # if the record is not valid.
-      def save_with_validation!
-        if valid?
-          save_without_validation!
-        else
-          raise RecordInvalid.new(self)
-        end
-      end
+    # Runs all the specified validations and returns true if no errors were added otherwise false.
+    def valid?(context = nil)
+      context ||= (new_record? ? :create : :update)
+      super(context)
 
-      # Runs all the specified validations and returns true if no errors were added otherwise false.
-      def valid?
-        errors.clear
+      deprecated_callback_method(:validate)
+      deprecated_callback_method(:"validate_on_#{context}")
 
-        @_on_validate = new_record? ? :create : :update
-        _run_validate_callbacks
+      errors.empty?
+    end
 
-        deprecated_callback_method(:validate)
+  protected
 
-        if new_record?
-          deprecated_callback_method(:validate_on_create)
-        else
-          deprecated_callback_method(:validate_on_update)
-        end
+    def perform_validations(options={})
+      perform_validation = case options
+      when Hash
+        options[:validate] != false
+      else
+        ActiveSupport::Deprecation.warn "save(#{options}) is deprecated, please give save(:validate => #{options}) instead", caller
+        options
+      end
 
-        errors.empty?
+      if perform_validation
+        valid?(options.is_a?(Hash) ? options[:context] : nil)
+      else
+        true
       end
     end
   end
 end
 
-Dir[File.dirname(__FILE__) + "/validations/*.rb"].sort.each do |path|
-  filename = File.basename(path)
-  require "active_record/validations/#{filename}"
-end
+require "active_record/validations/associated"
+require "active_record/validations/uniqueness"