activerecord 5.0.7.2 → 6.1.1

data/lib/active_record/transactions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # See ActiveRecord::Transactions::ClassMethods for documentation.
   module Transactions
@@ -8,10 +10,6 @@ module ActiveRecord
     included do
       define_callbacks :commit, :rollback,
                        :before_commit,
-                       :before_commit_without_transaction_enrollment,
-                       :commit_without_transaction_enrollment,
-                       :rollback_without_transaction_enrollment,
-                       terminator: deprecated_false_terminator,
                        scope: [:kind, :name]
     end
 
@@ -163,13 +161,13 @@ module ActiveRecord
     #     end
     #   end
     #
-    # only "Kotori" is created. This works on MySQL and PostgreSQL. SQLite3 version >= '3.6.8' also supports it.
+    # only "Kotori" is created.
     #
     # Most databases don't support true nested transactions. At the time of
     # 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.7/en/savepoint.html
+    # transactions by using savepoints. See
+    # https://dev.mysql.com/doc/refman/en/savepoint.html
     # for more information about savepoints.
     #
     # === \Callbacks
@@ -189,8 +187,8 @@ module ActiveRecord
     #
     # === 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
+    # If you're on MySQL, then do not use Data Definition Language (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+
     # is finished and tries to release the savepoint it created earlier, a
@@ -207,8 +205,8 @@ module ActiveRecord
     # Note that "TRUNCATE" is also a MySQL DDL statement!
     module ClassMethods
       # See the ConnectionAdapters::DatabaseStatements#transaction API docs.
-      def transaction(options = {}, &block)
-        connection.transaction(options, &block)
+      def transaction(**options, &block)
+        connection.transaction(**options, &block)
       end
 
       def before_commit(*args, &block) # :nodoc:
@@ -233,6 +231,12 @@ module ActiveRecord
         set_callback(:commit, :after, *args, &block)
       end
 
+      # Shortcut for <tt>after_commit :hook, on: [ :create, :update ]</tt>.
+      def after_save_commit(*args, &block)
+        set_options_for_callbacks!(args, on: [ :create, :update ])
+        set_callback(:commit, :after, *args, &block)
+      end
+
       # Shortcut for <tt>after_commit :hook, on: :create</tt>.
       def after_create_commit(*args, &block)
         set_options_for_callbacks!(args, on: :create)
@@ -259,88 +263,50 @@ module ActiveRecord
         set_callback(:rollback, :after, *args, &block)
       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, 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])
-          options[:if] << "transaction_include_any_action?(#{fire_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] = [
+              -> { transaction_include_any_action?(fire_on) },
+              *options[:if]
+            ]
+          end
         end
-      end
 
-      def assert_valid_transaction_action(actions)
-        if (actions - ACTIONS).any?
-          raise ArgumentError, ":on conditions for after_commit and after_rollback callbacks have to be one of #{ACTIONS}"
+        def assert_valid_transaction_action(actions)
+          if (actions - ACTIONS).any?
+            raise ArgumentError, ":on conditions for after_commit and after_rollback callbacks have to be one of #{ACTIONS}"
+          end
         end
-      end
     end
 
     # See ActiveRecord::Transactions::ClassMethods for detailed documentation.
-    def transaction(options = {}, &block)
-      self.class.transaction(options, &block)
+    def transaction(**options, &block)
+      self.class.transaction(**options, &block)
     end
 
     def destroy #:nodoc:
       with_transaction_returning_status { super }
     end
 
-    def save(*) #:nodoc:
-      rollback_active_record_state! do
-        with_transaction_returning_status { super }
-      end
-    end
-
-    def save!(*) #:nodoc:
+    def save(**) #:nodoc:
       with_transaction_returning_status { super }
     end
 
-    def touch(*) #:nodoc:
+    def save!(**) #:nodoc:
       with_transaction_returning_status { super }
     end
 
-    # Reset id and @new_record if the transaction rolls back.
-    def rollback_active_record_state!
-      remember_transaction_record_state
-      yield
-    rescue Exception
-      restore_transaction_record_state
-      raise
-    ensure
-      clear_transaction_record_state
+    def touch(*, **) #:nodoc:
+      with_transaction_returning_status { super }
     end
 
     def before_committed! # :nodoc:
-      _run_before_commit_without_transaction_enrollment_callbacks
       _run_before_commit_callbacks
     end
 
@@ -349,12 +315,13 @@ module ActiveRecord
     # 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:
-      if should_run_callbacks && destroyed? || persisted?
-        _run_commit_without_transaction_enrollment_callbacks
+      force_clear_transaction_record_state
+      if should_run_callbacks
+        @_committed_already_called = true
         _run_commit_callbacks
       end
     ensure
-      force_clear_transaction_record_state
+      @_committed_already_called = @_trigger_update_callback = @_trigger_destroy_callback = false
     end
 
     # Call the #after_rollback callbacks. The +force_restore_state+ argument indicates if the record
@@ -362,23 +329,11 @@ module ActiveRecord
     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
-    # can be called.
-    def add_to_transaction
-      if has_transactional_callbacks?
-        self.class.connection.add_transaction_record(self)
-      else
-        sync_with_transaction_state
-        set_transaction_state(self.class.connection.transaction_state)
-      end
-      remember_transaction_record_state
+      @_trigger_update_callback = @_trigger_destroy_callback = false if force_restore_state
     end
 
     # Executes +method+ within a transaction and captures its return value as a
@@ -389,121 +344,103 @@ module ActiveRecord
     # instance.
     def with_transaction_returning_status
       status = nil
-      self.class.transaction do
-        add_to_transaction
-        begin
-          status = yield
-        rescue ActiveRecord::Rollback
-          clear_transaction_record_state
-          status = nil
-        end
+      connection = self.class.connection
+      ensure_finalize = !connection.transaction_open?
+
+      connection.transaction do
+        add_to_transaction(ensure_finalize || has_transactional_callbacks?)
+        remember_transaction_record_state
 
+        status = yield
         raise ActiveRecord::Rollback unless status
       end
       status
-    ensure
-      if @transaction_state && @transaction_state.committed?
-        clear_transaction_record_state
-      end
     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[:id] = id
-      @_start_transaction_state.reverse_merge!(
-        new_record: @new_record,
-        destroyed: @destroyed,
-        frozen?: frozen?,
-      )
-      @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) + 1
+    def trigger_transactional_callbacks? # :nodoc:
+      (@_new_record_before_last_commit || _trigger_update_callback) && persisted? ||
+        _trigger_destroy_callback && destroyed?
     end
 
-    # Clear the new record state and id of a record.
-    def clear_transaction_record_state #:nodoc:
-      @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
-      force_clear_transaction_record_state if @_start_transaction_state[:level] < 1
-    end
+    private
+      attr_reader :_committed_already_called, :_trigger_update_callback, :_trigger_destroy_callback
+
+      # 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
+        @_start_transaction_state ||= {
+          id: id,
+          new_record: @new_record,
+          previously_new_record: @previously_new_record,
+          destroyed: @destroyed,
+          attributes: @attributes,
+          frozen?: frozen?,
+          level: 0
+        }
+        @_start_transaction_state[:level] += 1
+
+        if _committed_already_called
+          @_new_record_before_last_commit = false
+        else
+          @_new_record_before_last_commit = @_start_transaction_state[:new_record]
+        end
+      end
 
-    # Force to clear the transaction record state.
-    def force_clear_transaction_record_state #:nodoc:
-      @_start_transaction_state.clear
-    end
+      # Clear the new record state and id of a record.
+      def clear_transaction_record_state
+        return unless @_start_transaction_state
+        @_start_transaction_state[:level] -= 1
+        force_clear_transaction_record_state if @_start_transaction_state[:level] < 1
+      end
+
+      # Force to clear the transaction record state.
+      def force_clear_transaction_record_state
+        @_start_transaction_state = nil
+      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:
-      unless @_start_transaction_state.empty?
-        transaction_level = (@_start_transaction_state[:level] || 0) - 1
-        if transaction_level < 1 || force
-          restore_state = @_start_transaction_state
-          thaw
-          @new_record = restore_state[:new_record]
-          @destroyed  = restore_state[:destroyed]
-          pk = self.class.primary_key
-          if pk && read_attribute(pk) != restore_state[:id]
-            write_attribute(pk, restore_state[:id])
+      # 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_restore_state = false)
+        if restore_state = @_start_transaction_state
+          if force_restore_state || restore_state[:level] <= 1
+            @new_record = restore_state[:new_record]
+            @previously_new_record = restore_state[:previously_new_record]
+            @destroyed  = restore_state[:destroyed]
+            @attributes = restore_state[:attributes].map do |attr|
+              value = @attributes.fetch_value(attr.name)
+              attr = attr.with_value_from_user(value) if attr.value != value
+              attr
+            end
+            @mutations_from_database = nil
+            @mutations_before_last_save = nil
+            if @attributes.fetch_value(@primary_key) != restore_state[:id]
+              @attributes.write_from_user(@primary_key, restore_state[:id])
+            end
+            freeze if restore_state[:frozen?]
           end
-          freeze if restore_state[:frozen?]
         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]
-    end
 
-    # Determine if a transaction included an action for :create, :update, or :destroy. Used in filtering callbacks.
-    def transaction_include_any_action?(actions) #:nodoc:
-      actions.any? do |action|
-        case action
-        when :create
-          transaction_record_state(:new_record)
-        when :destroy
-          destroyed?
-        when :update
-          !(transaction_record_state(:new_record) || destroyed?)
+      # Determine if a transaction included an action for :create, :update, or :destroy. Used in filtering callbacks.
+      def transaction_include_any_action?(actions)
+        actions.any? do |action|
+          case action
+          when :create
+            persisted? && @_new_record_before_last_commit
+          when :update
+            !(@_new_record_before_last_commit || destroyed?) && _trigger_update_callback
+          when :destroy
+            _trigger_destroy_callback
+          end
         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
+      # Add the record to the current transaction so that the #after_rollback and #after_commit
+      # callbacks can be called.
+      def add_to_transaction(ensure_finalize = true)
+        self.class.connection.add_transaction_record(self, ensure_finalize)
+      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
+      def has_transactional_callbacks?
+        !_rollback_callbacks.empty? || !_commit_callbacks.empty? || !_before_commit_callbacks.empty?
       end
-    end
   end
 end

data/lib/active_record/translation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Translation
     include ActiveModel::Translation
@@ -8,7 +10,7 @@ module ActiveRecord
       classes = [klass]
       return classes if klass == ActiveRecord::Base
 
-      while klass != klass.base_class
+      while !klass.base_class?
         classes << klass = klass.superclass
       end
       classes

data/lib/active_record/type.rb

@@ -1,17 +1,22 @@
-require 'active_model/type'
+# frozen_string_literal: true
 
-require 'active_record/type/internal/abstract_json'
-require 'active_record/type/internal/timezone'
+require "active_model/type"
 
-require 'active_record/type/date'
-require 'active_record/type/date_time'
-require 'active_record/type/time'
+require "active_record/type/internal/timezone"
 
-require 'active_record/type/serialized'
-require 'active_record/type/adapter_specific_registry'
+require "active_record/type/date"
+require "active_record/type/date_time"
+require "active_record/type/decimal_without_scale"
+require "active_record/type/json"
+require "active_record/type/time"
+require "active_record/type/text"
+require "active_record/type/unsigned_integer"
 
-require 'active_record/type/type_map'
-require 'active_record/type/hash_lookup_type_map'
+require "active_record/type/serialized"
+require "active_record/type/adapter_specific_registry"
+
+require "active_record/type/type_map"
+require "active_record/type/hash_lookup_type_map"
 
 module ActiveRecord
   module Type
@@ -37,24 +42,29 @@ module ActiveRecord
         registry.lookup(*args, adapter: adapter, **kwargs)
       end
 
-      private
+      def default_value # :nodoc:
+        @default_value ||= Value.new
+      end
 
-      def current_adapter_name
-        ActiveRecord::Base.connection.adapter_name.downcase.to_sym
+      def adapter_name_from(model) # :nodoc:
+        # TODO: this shouldn't depend on a connection to the database
+        model.connection.adapter_name.downcase.to_sym
       end
+
+      private
+        def current_adapter_name
+          adapter_name_from(ActiveRecord::Base)
+        end
     end
 
-    Helpers = ActiveModel::Type::Helpers
     BigInteger = ActiveModel::Type::BigInteger
     Binary = ActiveModel::Type::Binary
     Boolean = ActiveModel::Type::Boolean
     Decimal = ActiveModel::Type::Decimal
-    DecimalWithoutScale = ActiveModel::Type::DecimalWithoutScale
     Float = ActiveModel::Type::Float
     Integer = ActiveModel::Type::Integer
+    ImmutableString = ActiveModel::Type::ImmutableString
     String = ActiveModel::Type::String
-    Text = ActiveModel::Type::Text
-    UnsignedInteger = ActiveModel::Type::UnsignedInteger
     Value = ActiveModel::Type::Value
 
     register(:big_integer, Type::BigInteger, override: false)
@@ -65,6 +75,8 @@ module ActiveRecord
     register(:decimal, Type::Decimal, override: false)
     register(:float, Type::Float, override: false)
     register(:integer, Type::Integer, override: false)
+    register(:immutable_string, Type::ImmutableString, override: false)
+    register(:json, Type::Json, override: false)
     register(:string, Type::String, override: false)
     register(:text, Type::Text, override: false)
     register(:time, Type::Time, override: false)