activerecord 4.2.11.3 → 5.0.0.beta1

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -44,8 +44,17 @@ module ActiveRecord
 
       def structure_dump(filename)
         set_psql_env
+
+        search_path = case ActiveRecord::Base.dump_schemas
+        when :schema_search_path
+          configuration['schema_search_path']
+        when :all
+          nil
+        when String
+          ActiveRecord::Base.dump_schemas
+        end
+
         args = ['-s', '-x', '-O', '-f', filename]
-        search_path = configuration['schema_search_path']
         unless search_path.blank?
           args += search_path.split(',').map do |part|
             "--schema=#{part.strip}"
@@ -59,7 +68,7 @@ module ActiveRecord
       def structure_load(filename)
         set_psql_env
         args = [ '-q', '-f', filename, configuration['database'] ]
-        run_cmd('psql', args, 'loading')
+        run_cmd('psql', args, 'loading' )
       end
 
       private

data/lib/active_record/tasks/sqlite_database_tasks.rb

@@ -19,11 +19,15 @@ module ActiveRecord
         path = Pathname.new configuration['database']
         file = path.absolute? ? path.to_s : File.join(root, path)
 
-        FileUtils.rm(file) if File.exist?(file)
+        FileUtils.rm(file)
+      rescue Errno::ENOENT => error
+        raise NoDatabaseError.new(error.message, error)
       end
 
       def purge
         drop
+      rescue NoDatabaseError
+      ensure
         create
       end
 

data/lib/active_record/timestamp.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
-  # = Active Record Timestamp
+  # = Active Record \Timestamp
   #
   # Active Record automatically timestamps create and update operations if the
   # table has fields named <tt>created_at/created_on</tt> or
@@ -15,14 +15,21 @@ module ActiveRecord
   #
   # == Time Zone aware attributes
   #
-  # By default, ActiveRecord::Base keeps all the datetime columns time zone aware by executing following code.
+  # Active Record keeps all the <tt>datetime</tt> and <tt>time</tt> columns
+  # time-zone aware. By default, these values are stored in the database as UTC
+  # and converted back to the current <tt>Time.zone</tt> when pulled from the database.
   #
-  #   config.active_record.time_zone_aware_attributes = true
+  # This feature can be turned off completely by setting:
   #
-  # This feature can easily be turned off by assigning value <tt>false</tt> .
+  #   config.active_record.time_zone_aware_attributes = false
   #
-  # If your attributes are time zone aware and you desire to skip time zone conversion to the current Time.zone
-  # when reading certain attributes then you can do following:
+  # You can also specify that only <tt>datetime</tt> columns should be time-zone
+  # aware (while <tt>time</tt> should not) by setting:
+  #
+  #   ActiveRecord::Base.time_zone_aware_types = [:datetime]
+  #
+  # Finally, you can indicate specific attributes of a model for which time zone
+  # conversion should not applied, for instance by setting:
   #
   #   class Topic < ActiveRecord::Base
   #     self.skip_time_zone_conversion_for_attributes = [:written_on]
@@ -57,8 +64,8 @@ module ActiveRecord
       super
     end
 
-    def _update_record(*args)
-      if should_record_timestamps?
+    def _update_record(*args, touch: true, **options)
+      if touch && should_record_timestamps?
         current_time = current_time_from_proper_timezone
 
         timestamp_attributes_for_update_in_model.each do |column|
@@ -67,7 +74,7 @@ module ActiveRecord
           write_attribute(column, current_time)
         end
       end
-      super
+      super(*args)
     end
 
     def should_record_timestamps?

data/lib/active_record/touch_later.rb

@@ -0,0 +1,58 @@
+module ActiveRecord
+  # = Active Record Touch Later
+  module TouchLater
+    extend ActiveSupport::Concern
+
+    included do
+      before_commit_without_transaction_enrollment :touch_deferred_attributes
+    end
+
+    def touch_later(*names) # :nodoc:
+      raise ActiveRecordError, "cannot touch on a new record object" unless persisted?
+
+      @_defer_touch_attrs ||= timestamp_attributes_for_update_in_model
+      @_defer_touch_attrs |= names
+      @_touch_time = current_time_from_proper_timezone
+
+      surreptitiously_touch @_defer_touch_attrs
+      self.class.connection.add_transaction_record self
+
+      # touch the parents as we are not calling the after_save callbacks
+      self.class.reflect_on_all_associations(:belongs_to).each do |r|
+        if touch = r.options[:touch]
+          ActiveRecord::Associations::Builder::BelongsTo.touch_record(self, r.foreign_key, r.name, touch, :touch_later)
+        end
+      end
+    end
+
+    def touch(*names, time: nil) # :nodoc:
+      if has_defer_touch_attrs?
+        names |= @_defer_touch_attrs
+      end
+      super(*names, time: time)
+    end
+
+    private
+
+      def surreptitiously_touch(attrs)
+        attrs.each { |attr| write_attribute attr, @_touch_time }
+        clear_attribute_changes attrs
+      end
+
+      def touch_deferred_attributes
+        if has_defer_touch_attrs? && persisted?
+          touch(*@_defer_touch_attrs, time: @_touch_time)
+          @_defer_touch_attrs, @_touch_time = nil, nil
+        end
+      end
+
+      def has_defer_touch_attrs?
+        defined?(@_defer_touch_attrs) && @_defer_touch_attrs.present?
+      end
+
+      def belongs_to_touch_method
+        :touch_later
+      end
+
+  end
+end

data/lib/active_record/transactions.rb

@@ -4,32 +4,23 @@ module ActiveRecord
     extend ActiveSupport::Concern
     #:nodoc:
     ACTIONS = [:create, :destroy, :update]
-    #:nodoc:
-    CALLBACK_WARN_MESSAGE = "Currently, Active Record suppresses errors raised " \
-      "within `after_rollback`/`after_commit` callbacks and only print them to " \
-      "the logs. In the next version, these errors will no longer be suppressed. " \
-      "Instead, the errors will propagate normally just like in other Active " \
-      "Record callbacks.\n" \
-      "\n" \
-      "You can opt into the new behavior and remove this warning by setting:\n" \
-      "\n" \
-      "  config.active_record.raise_in_transactional_callbacks = true\n\n"
 
     included do
       define_callbacks :commit, :rollback,
-                       terminator: ->(_, result) { result == false },
+                       :before_commit,
+                       :before_commit_without_transaction_enrollment,
+                       :commit_without_transaction_enrollment,
+                       :rollback_without_transaction_enrollment,
+                       terminator: deprecated_false_terminator,
                        scope: [:kind, :name]
-
-      mattr_accessor :raise_in_transactional_callbacks, instance_writer: false
-      self.raise_in_transactional_callbacks = false
     end
 
     # = Active Record Transactions
     #
-    # Transactions are protective blocks where SQL statements are only permanent
+    # \Transactions are protective blocks where SQL statements are only permanent
     # if they can all succeed as one atomic action. The classic example is a
     # transfer between two accounts where you can only have a deposit if the
-    # withdrawal succeeded and vice versa. Transactions enforce the integrity of
+    # withdrawal succeeded and vice versa. \Transactions enforce the integrity of
     # the database and guard the data against program errors or database
     # break-downs. So basically you should use transaction blocks whenever you
     # have a number of statements that must be executed together or not at all.
@@ -49,20 +40,20 @@ module ActiveRecord
     #
     # == Different Active Record classes in a single transaction
     #
-    # Though the transaction class method is called on some Active Record class,
+    # Though the #transaction class method is called on some Active Record class,
     # the objects within the transaction block need not all be instances of
     # that class. This is because transactions are per-database connection, not
     # per-model.
     #
     # In this example a +balance+ record is transactionally saved even
-    # though +transaction+ is called on the +Account+ class:
+    # though #transaction is called on the +Account+ class:
     #
     #   Account.transaction do
     #     balance.save!
     #     account.save!
     #   end
     #
-    # The +transaction+ method is also available as a model instance method.
+    # The #transaction method is also available as a model instance method.
     # For example, you can also do this:
     #
     #   balance.transaction do
@@ -89,7 +80,8 @@ module ActiveRecord
     #
     # == +save+ and +destroy+ are automatically wrapped in a transaction
     #
-    # Both +save+ and +destroy+ come wrapped in a transaction that ensures
+    # Both {#save}[rdoc-ref:Persistence#save] and
+    # {#destroy}[rdoc-ref:Persistence#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
@@ -98,7 +90,7 @@ module ActiveRecord
     # 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
+    # The #after_commit callback is the only one that is triggered once the update
     # is committed. See below.
     #
     # == Exception handling and rolling back
@@ -107,11 +99,11 @@ module ActiveRecord
     # be propagated (after triggering the ROLLBACK), so you should be ready to
     # catch those in your application code.
     #
-    # One exception is the <tt>ActiveRecord::Rollback</tt> exception, which will trigger
+    # One exception is the ActiveRecord::Rollback exception, which will trigger
     # a ROLLBACK when raised, but not be re-raised by the transaction block.
     #
-    # *Warning*: one should not catch <tt>ActiveRecord::StatementInvalid</tt> exceptions
-    # inside a transaction block. <tt>ActiveRecord::StatementInvalid</tt> exceptions indicate that an
+    # *Warning*: one should not catch ActiveRecord::StatementInvalid exceptions
+    # inside a transaction block. ActiveRecord::StatementInvalid 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 cause the entire transaction to become unusable
@@ -137,11 +129,11 @@ module ActiveRecord
     #   end
     #
     # One should restart the entire transaction if an
-    # <tt>ActiveRecord::StatementInvalid</tt> occurred.
+    # ActiveRecord::StatementInvalid 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, the following behavior may be surprising:
     #
@@ -153,7 +145,7 @@ module ActiveRecord
     #     end
     #   end
     #
-    # creates both "Kotori" and "Nemu". Reason is the <tt>ActiveRecord::Rollback</tt>
+    # creates both "Kotori" and "Nemu". Reason is the ActiveRecord::Rollback
     # exception in the nested block does not issue a ROLLBACK. Since these exceptions
     # are captured in transaction blocks, the parent block does not see it and the
     # real transaction is committed.
@@ -177,22 +169,22 @@ module ActiveRecord
     # writing, the only database that we're aware of that supports true nested
     # transactions, is MS-SQL. Because of this, Active Record emulates nested
     # transactions by using savepoints on MySQL and PostgreSQL. See
-    # http://dev.mysql.com/doc/refman/5.6/en/savepoint.html
+    # http://dev.mysql.com/doc/refman/5.7/en/savepoint.html
     # for more information about savepoints.
     #
-    # === Callbacks
+    # === \Callbacks
     #
     # There are two types of callbacks associated with committing and rolling back transactions:
-    # +after_commit+ and +after_rollback+.
+    # #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
+    # #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
+    # #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
@@ -206,20 +198,24 @@ module ActiveRecord
     # 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.transaction(requires_new: true) do     # CREATE SAVEPOINT active_record_1
     #       Model.connection.create_table(...)                    # active_record_1 now automatically released
-    #     end                                                     # RELEASE savepoint active_record_1
+    #     end                                                     # RELEASE SAVEPOINT active_record_1
     #                                                             # ^^^^ BOOM! database error!
     #   end
     #
     # Note that "TRUNCATE" is also a MySQL DDL statement!
     module ClassMethods
-      # See ActiveRecord::Transactions::ClassMethods for detailed documentation.
+      # See the ConnectionAdapters::DatabaseStatements#transaction API docs.
       def transaction(options = {}, &block)
-        # See the ConnectionAdapters::DatabaseStatements#transaction API docs.
         connection.transaction(options, &block)
       end
 
+      def before_commit(*args, &block) # :nodoc:
+        set_options_for_callbacks!(args)
+        set_callback(:before_commit, :before, *args, &block)
+      end
+
       # This callback is called after a record has been created, updated, or destroyed.
       #
       # You can specify that the callback should only be fired by a certain action with
@@ -232,32 +228,69 @@ module ActiveRecord
       #   after_commit :do_foo_bar, on: [:create, :update]
       #   after_commit :do_bar_baz, on: [:update, :destroy]
       #
-      # Note that transactional fixtures do not play well with this feature. Please
-      # use the +test_after_commit+ gem to have these hooks fired in tests.
       def after_commit(*args, &block)
         set_options_for_callbacks!(args)
         set_callback(:commit, :after, *args, &block)
-        unless ActiveRecord::Base.raise_in_transactional_callbacks
-          ActiveSupport::Deprecation.warn(CALLBACK_WARN_MESSAGE)
-        end
+      end
+
+      # Shortcut for +after_commit :hook, on: :create+.
+      def after_create_commit(*args, &block)
+        set_options_for_callbacks!(args, on: :create)
+        set_callback(:commit, :after, *args, &block)
+      end
+
+      # Shortcut for +after_commit :hook, on: :update+.
+      def after_update_commit(*args, &block)
+        set_options_for_callbacks!(args, on: :update)
+        set_callback(:commit, :after, *args, &block)
+      end
+
+      # Shortcut for +after_commit :hook, on: :destroy+.
+      def after_destroy_commit(*args, &block)
+        set_options_for_callbacks!(args, on: :destroy)
+        set_callback(:commit, :after, *args, &block)
       end
 
       # This callback is called after a create, update, or destroy are rolled back.
       #
-      # Please check the documentation of +after_commit+ for options.
+      # Please check the documentation of #after_commit for options.
       def after_rollback(*args, &block)
         set_options_for_callbacks!(args)
         set_callback(:rollback, :after, *args, &block)
-        unless ActiveRecord::Base.raise_in_transactional_callbacks
-          ActiveSupport::Deprecation.warn(CALLBACK_WARN_MESSAGE)
-        end
+      end
+
+      def before_commit_without_transaction_enrollment(*args, &block) # :nodoc:
+        set_options_for_callbacks!(args)
+        set_callback(:before_commit_without_transaction_enrollment, :before, *args, &block)
+      end
+
+      def after_commit_without_transaction_enrollment(*args, &block) # :nodoc:
+        set_options_for_callbacks!(args)
+        set_callback(:commit_without_transaction_enrollment, :after, *args, &block)
+      end
+
+      def after_rollback_without_transaction_enrollment(*args, &block) # :nodoc:
+        set_options_for_callbacks!(args)
+        set_callback(:rollback_without_transaction_enrollment, :after, *args, &block)
+      end
+
+      def raise_in_transactional_callbacks
+        ActiveSupport::Deprecation.warn('ActiveRecord::Base.raise_in_transactional_callbacks is deprecated and will be removed without replacement.')
+        true
+      end
+
+      def raise_in_transactional_callbacks=(value)
+        ActiveSupport::Deprecation.warn('ActiveRecord::Base.raise_in_transactional_callbacks= is deprecated, has no effect and will be removed without replacement.')
+        value
       end
 
       private
 
-      def set_options_for_callbacks!(args)
-        options = args.last
-        if options.is_a?(Hash) && options[:on]
+      def set_options_for_callbacks!(args, enforced_options = {})
+        options = args.extract_options!.merge!(enforced_options)
+        args << options
+
+        if options[:on]
           fire_on = Array(options[:on])
           assert_valid_transaction_action(fire_on)
           options[:if] = Array(options[:if])
@@ -306,26 +339,37 @@ module ActiveRecord
       clear_transaction_record_state
     end
 
-    # Call the +after_commit+ callbacks.
+    def before_committed! # :nodoc:
+      _run_before_commit_without_transaction_enrollment_callbacks
+      _run_before_commit_callbacks
+    end
+
+    # Call the #after_commit callbacks.
     #
     # Ensure that it is not called if the object was never persisted (failed create),
     # but call it after the commit of a destroyed object.
-    def committed!(should_run_callbacks = true) #:nodoc:
-      _run_commit_callbacks if should_run_callbacks && destroyed? || persisted?
+    def committed!(should_run_callbacks: true) #:nodoc:
+      if should_run_callbacks && destroyed? || persisted?
+        _run_commit_without_transaction_enrollment_callbacks
+        _run_commit_callbacks
+      end
     ensure
       force_clear_transaction_record_state
     end
 
-    # Call the +after_rollback+ callbacks. The +force_restore_state+ argument indicates if the record
+    # Call the #after_rollback callbacks. The +force_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, should_run_callbacks = true) #:nodoc:
-      _run_rollback_callbacks if should_run_callbacks
+    def rolledback!(force_restore_state: false, should_run_callbacks: true) #:nodoc:
+      if should_run_callbacks
+        _run_rollback_callbacks
+        _run_rollback_without_transaction_enrollment_callbacks
+      end
     ensure
       restore_transaction_record_state(force_restore_state)
       clear_transaction_record_state
     end
 
-    # Add the record to the current transaction so that the +after_rollback+ and +after_commit+ callbacks
+    # Add the record to the current transaction so that the #after_rollback and #after_commit callbacks
     # can be called.
     def add_to_transaction
       if has_transactional_callbacks?
@@ -423,5 +467,43 @@ module ActiveRecord
         end
       end
     end
+
+    private
+
+    def set_transaction_state(state) # :nodoc:
+      @transaction_state = state
+    end
+
+    def has_transactional_callbacks? # :nodoc:
+      !_rollback_callbacks.empty? || !_commit_callbacks.empty? || !_before_commit_callbacks.empty?
+    end
+
+    # Updates the attributes on this particular Active Record object so that
+    # if it's associated with a transaction, then the state of the Active Record
+    # object will be updated to reflect the current state of the transaction
+    #
+    # The +@transaction_state+ variable stores the states of the associated
+    # transaction. This relies on the fact that a transaction can only be in
+    # one rollback or commit (otherwise a list of states would be required)
+    # Each Active Record object inside of a transaction carries that transaction's
+    # TransactionState.
+    #
+    # This method checks to see if the ActiveRecord object's state reflects
+    # the TransactionState, and rolls back or commits the Active Record object
+    # as appropriate.
+    #
+    # Since Active Record objects can be inside multiple transactions, this
+    # method recursively goes through the parent of the TransactionState and
+    # checks if the Active Record object reflects the state of the object.
+    def sync_with_transaction_state
+      update_attributes_from_transaction_state(@transaction_state)
+    end
+
+    def update_attributes_from_transaction_state(transaction_state)
+      if transaction_state && transaction_state.finalized?
+        restore_transaction_record_state if transaction_state.rolledback?
+        clear_transaction_record_state
+      end
+    end
   end
 end