activerecord 5.2.4.4 → 6.0.0

data/lib/active_record/touch_later.rb

@@ -2,7 +2,7 @@
 
 module ActiveRecord
   # = Active Record Touch Later
-  module TouchLater
+  module TouchLater # :nodoc:
     extend ActiveSupport::Concern
 
     included do
@@ -22,7 +22,8 @@ module ActiveRecord
       @_touch_time = current_time_from_proper_timezone
 
       surreptitiously_touch @_defer_touch_attrs
-      self.class.connection.add_transaction_record self
+      add_to_transaction
+      @_new_record_before_last_commit ||= false
 
       # touch the parents as we are not calling the after_save callbacks
       self.class.reflect_on_all_associations(:belongs_to).each do |r|
@@ -48,6 +49,7 @@ module ActiveRecord
 
       def touch_deferred_attributes
         if has_defer_touch_attrs? && persisted?
+          @_skip_dirty_tracking = true
           touch(*@_defer_touch_attrs, time: @_touch_time)
           @_defer_touch_attrs, @_touch_time = nil, nil
         end

data/lib/active_record/transactions.rb

@@ -234,6 +234,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)
@@ -306,9 +312,7 @@ module ActiveRecord
     end
 
     def save(*) #:nodoc:
-      rollback_active_record_state! do
-        with_transaction_returning_status { super }
-      end
+      with_transaction_returning_status { super }
     end
 
     def save!(*) #:nodoc:
@@ -319,17 +323,6 @@ module ActiveRecord
       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
-    end
-
     def before_committed! # :nodoc:
       _run_before_commit_without_transaction_enrollment_callbacks
       _run_before_commit_callbacks
@@ -340,14 +333,14 @@ 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:
-      force_clear_transaction_record_state
-      if should_run_callbacks && (destroyed? || persisted?)
+      if should_run_callbacks
         @_committed_already_called = true
         _run_commit_without_transaction_enrollment_callbacks
         _run_commit_callbacks
       end
     ensure
       @_committed_already_called = false
+      force_clear_transaction_record_state
     end
 
     # Call the #after_rollback callbacks. The +force_restore_state+ argument indicates if the record
@@ -362,18 +355,6 @@ module ActiveRecord
       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
-    end
-
     # Executes +method+ within a transaction and captures its return value as a
     # status flag. If the status is true the transaction is committed, otherwise
     # a ROLLBACK is issued. In any case the status flag is returned.
@@ -383,35 +364,40 @@ module ActiveRecord
     def with_transaction_returning_status
       status = nil
       self.class.transaction do
-        add_to_transaction
+        if has_transactional_callbacks?
+          add_to_transaction
+        else
+          sync_with_transaction_state if @transaction_state&.finalized?
+          @transaction_state = self.class.connection.transaction_state
+        end
+        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
-      attr_reader :_committed_already_called, :_trigger_update_callback, :_trigger_destroy_callback
+    def trigger_transactional_callbacks? # :nodoc:
+      (@_new_record_before_last_commit || _trigger_update_callback) && persisted? ||
+        _trigger_destroy_callback && destroyed?
+    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.reverse_merge!(
+        @_start_transaction_state ||= {
           id: id,
           new_record: @new_record,
           destroyed: @destroyed,
+          attributes: @attributes,
           frozen?: frozen?,
-        )
-        @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) + 1
-        remember_new_record_before_last_commit
-      end
+          level: 0
+        }
+        @_start_transaction_state[:level] += 1
 
-      def remember_new_record_before_last_commit
         if _committed_already_called
           @_new_record_before_last_commit = false
         else
@@ -421,27 +407,32 @@ module ActiveRecord
 
       # Clear the new record state and id of a record.
       def clear_transaction_record_state
-        @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
+        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.clear
+        @_start_transaction_state = nil
+        @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)
-        unless @_start_transaction_state.empty?
-          transaction_level = (@_start_transaction_state[:level] || 0) - 1
-          if transaction_level < 1 || force
-            restore_state = @_start_transaction_state
-            thaw
+      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]
             @destroyed  = restore_state[:destroyed]
-            pk = self.class.primary_key
-            if pk && _read_attribute(pk) != restore_state[:id]
-              _write_attribute(pk, restore_state[:id])
+            @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
@@ -462,8 +453,10 @@ module ActiveRecord
         end
       end
 
-      def set_transaction_state(state)
-        @transaction_state = state
+      # Add the record to the current transaction so that the #after_rollback and #after_commit
+      # callbacks can be called.
+      def add_to_transaction
+        self.class.connection.add_transaction_record(self)
       end
 
       def has_transactional_callbacks?
@@ -483,19 +476,17 @@ module ActiveRecord
       # 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(transaction_state.fully_rolledback?) if transaction_state.rolledback?
-          force_clear_transaction_record_state if transaction_state.fully_committed?
-          clear_transaction_record_state if transaction_state.fully_completed?
+        if transaction_state = @transaction_state
+          if transaction_state.fully_committed?
+            force_clear_transaction_record_state
+          elsif transaction_state.committed?
+            clear_transaction_record_state
+          elsif transaction_state.rolledback?
+            force_restore_state = transaction_state.fully_rolledback?
+            restore_transaction_record_state(force_restore_state)
+            clear_transaction_record_state
+          end
         end
       end
   end

data/lib/active_record/translation.rb

@@ -10,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

@@ -48,12 +48,11 @@ module ActiveRecord
 
       private
 
-      def current_adapter_name
-        ActiveRecord::Base.connection.adapter_name.downcase.to_sym
-      end
+        def current_adapter_name
+          ActiveRecord::Base.connection.adapter_name.downcase.to_sym
+        end
     end
 
-    Helpers = ActiveModel::Type::Helpers
     BigInteger = ActiveModel::Type::BigInteger
     Binary = ActiveModel::Type::Binary
     Boolean = ActiveModel::Type::Boolean

data/lib/active_record/type/adapter_specific_registry.rb

@@ -52,8 +52,6 @@ module ActiveRecord
         priority <=> other.priority
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
       protected
 
         attr_reader :name, :block, :adapter, :override
@@ -114,13 +112,8 @@ module ActiveRecord
         super | 4
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
-        attr_reader :options, :klass
-
       private
+        attr_reader :options, :klass
 
         def matches_options?(**kwargs)
           options.all? do |key, value|

data/lib/active_record/type_caster/connection.rb

@@ -8,26 +8,27 @@ module ActiveRecord
         @table_name = table_name
       end
 
-      def type_cast_for_database(attribute_name, value)
+      def type_cast_for_database(attr_name, value)
         return value if value.is_a?(Arel::Nodes::BindParam)
-        column = column_for(attribute_name)
-        connection.type_cast_from_column(column, value)
+        type = type_for_attribute(attr_name)
+        type.serialize(value)
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
+      def type_for_attribute(attr_name)
+        schema_cache = connection.schema_cache
 
-        attr_reader :table_name
-        delegate :connection, to: :@klass
+        if schema_cache.data_source_exists?(table_name)
+          column = schema_cache.columns_hash(table_name)[attr_name.to_s]
+          type = connection.lookup_cast_type_from_column(column) if column
+        end
 
-      private
+        type || Type.default_value
+      end
 
-        def column_for(attribute_name)
-          if connection.schema_cache.data_source_exists?(table_name)
-            connection.schema_cache.columns_hash(table_name)[attribute_name.to_s]
-          end
-        end
+      delegate :connection, to: :@klass, private: true
+
+      private
+        attr_reader :table_name
     end
   end
 end

data/lib/active_record/type_caster/map.rb

@@ -13,10 +13,7 @@ module ActiveRecord
         type.serialize(value)
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
+      private
         attr_reader :types
     end
   end

data/lib/active_record/validations.rb

@@ -40,6 +40,7 @@ module ActiveRecord
     include ActiveModel::Validations
 
     # The validation process on save can be skipped by passing <tt>validate: false</tt>.
+    # The validation context can be changed by passing <tt>context: context</tt>.
     # The regular {ActiveRecord::Base#save}[rdoc-ref:Persistence#save] method is replaced
     # with this when the validations module is mixed in, which it is by default.
     def save(options = {})

data/lib/active_record/validations/uniqueness.rb

@@ -12,7 +12,7 @@ module ActiveRecord
           raise ArgumentError, "#{options[:scope]} is not supported format for :scope option. " \
             "Pass a symbol or an array of symbols instead: `scope: :user_id`"
         end
-        super({ case_sensitive: true }.merge!(options))
+        super
         @klass = options[:class]
       end
 
@@ -25,7 +25,7 @@ module ActiveRecord
           if finder_class.primary_key
             relation = relation.where.not(finder_class.primary_key => record.id_in_database)
           else
-            raise UnknownPrimaryKey.new(finder_class, "Can not validate uniqueness for persisted record without primary key.")
+            raise UnknownPrimaryKey.new(finder_class, "Cannot validate uniqueness for persisted record without primary key.")
           end
         end
         relation = scope_relation(record, relation)
@@ -56,33 +56,21 @@ module ActiveRecord
       end
 
       def build_relation(klass, attribute, value)
-        if reflection = klass._reflect_on_association(attribute)
-          attribute = reflection.foreign_key
-          value = value.attributes[reflection.klass.primary_key] unless value.nil?
-        end
-
-        if value.nil?
-          return klass.unscoped.where!(attribute => value)
-        end
-
-        # the attribute may be an aliased attribute
-        if klass.attribute_alias?(attribute)
-          attribute = klass.attribute_alias(attribute)
+        relation = klass.unscoped
+        comparison = relation.bind_attribute(attribute, value) do |attr, bind|
+          return relation.none! if bind.unboundable?
+
+          if !options.key?(:case_sensitive) || bind.nil?
+            klass.connection.default_uniqueness_comparison(attr, bind, klass)
+          elsif options[:case_sensitive]
+            klass.connection.case_sensitive_comparison(attr, bind)
+          else
+            # will use SQL LOWER function before comparison, unless it detects a case insensitive collation
+            klass.connection.case_insensitive_comparison(attr, bind)
+          end
         end
 
-        attribute_name = attribute.to_s
-        value = klass.predicate_builder.build_bind_attribute(attribute_name, value)
-
-        table = klass.arel_table
-        column = klass.columns_hash[attribute_name]
-
-        comparison = if !options[:case_sensitive]
-          # will use SQL LOWER function before comparison, unless it detects a case insensitive collation
-          klass.connection.case_insensitive_comparison(table, attribute, column, value)
-        else
-          klass.connection.case_sensitive_comparison(table, attribute, column, value)
-        end
-        klass.unscoped.where!(comparison)
+        relation.where!(comparison)
       end
 
       def scope_relation(record, relation)

data/lib/arel.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "arel/errors"
+
+require "arel/crud"
+require "arel/factory_methods"
+
+require "arel/expressions"
+require "arel/predications"
+require "arel/window_predications"
+require "arel/math"
+require "arel/alias_predication"
+require "arel/order_predications"
+require "arel/table"
+require "arel/attributes"
+
+require "arel/visitors"
+require "arel/collectors/sql_string"
+
+require "arel/tree_manager"
+require "arel/insert_manager"
+require "arel/select_manager"
+require "arel/update_manager"
+require "arel/delete_manager"
+require "arel/nodes"
+
+module Arel # :nodoc: all
+  VERSION = "10.0.0"
+
+  def self.sql(raw_sql)
+    Arel::Nodes::SqlLiteral.new raw_sql
+  end
+
+  def self.star
+    sql "*"
+  end
+
+  def self.arel_node?(value)
+    value.is_a?(Arel::Node) || value.is_a?(Arel::Attribute) || value.is_a?(Arel::Nodes::SqlLiteral)
+  end
+
+  def self.fetch_attribute(value)
+    case value
+    when Arel::Nodes::Between, Arel::Nodes::In, Arel::Nodes::NotIn, Arel::Nodes::Equality, Arel::Nodes::NotEqual, Arel::Nodes::LessThan, Arel::Nodes::LessThanOrEqual, Arel::Nodes::GreaterThan, Arel::Nodes::GreaterThanOrEqual
+      yield value.left.is_a?(Arel::Attributes::Attribute) ? value.left : value.right
+    end
+  end
+
+  ## Convenience Alias
+  Node = Arel::Nodes::Node
+end