activerecord 6.0.0.rc1 → 6.0.3.rc1

data/lib/active_record/touch_later.rb

@@ -9,7 +9,7 @@ module ActiveRecord
       before_commit_without_transaction_enrollment :touch_deferred_attributes
     end
 
-    def touch_later(*names) # :nodoc:
+    def touch_later(*names, **) # :nodoc:
       unless persisted?
         raise ActiveRecordError, <<-MSG.squish
           cannot touch on a new or destroyed record object. Consider using
@@ -23,6 +23,7 @@ module ActiveRecord
 
       surreptitiously_touch @_defer_touch_attrs
       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|
@@ -40,7 +41,6 @@ module ActiveRecord
     end
 
     private
-
       def surreptitiously_touch(attrs)
         attrs.each { |attr| write_attribute attr, @_touch_time }
         clear_attribute_changes attrs
@@ -48,6 +48,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

@@ -208,8 +208,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:
@@ -282,7 +282,6 @@ module ActiveRecord
       end
 
       private
-
         def set_options_for_callbacks!(args, enforced_options = {})
           options = args.extract_options!.merge!(enforced_options)
           args << options
@@ -304,22 +303,22 @@ module ActiveRecord
 
     # See ActiveRecord::Transactions::ClassMethods for detailed documentation.
     def transaction(options = {}, &block)
-      self.class.transaction(options, &block)
+      self.class.transaction(**options, &block)
     end
 
     def destroy #:nodoc:
       with_transaction_returning_status { super }
     end
 
-    def save(*) #:nodoc:
+    def save(*, **) #:nodoc:
       with_transaction_returning_status { super }
     end
 
-    def save!(*) #:nodoc:
+    def save!(*, **) #:nodoc:
       with_transaction_returning_status { super }
     end
 
-    def touch(*) #:nodoc:
+    def touch(*, **) #:nodoc:
       with_transaction_returning_status { super }
     end
 
@@ -333,14 +332,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:
-      if should_run_callbacks && (destroyed? || persisted?)
+      force_clear_transaction_record_state
+      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
+      @_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
@@ -353,6 +352,7 @@ module ActiveRecord
     ensure
       restore_transaction_record_state(force_restore_state)
       clear_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
@@ -364,7 +364,9 @@ module ActiveRecord
     def with_transaction_returning_status
       status = nil
       self.class.transaction do
-        unless has_transactional_callbacks?
+        if has_transactional_callbacks?
+          add_to_transaction
+        else
           sync_with_transaction_state if @transaction_state&.finalized?
           @transaction_state = self.class.connection.transaction_state
         end
@@ -372,15 +374,15 @@ module ActiveRecord
 
         status = yield
         raise ActiveRecord::Rollback unless status
-      ensure
-        if has_transactional_callbacks? &&
-            (@_new_record_before_last_commit && !new_record? || _trigger_update_callback || _trigger_destroy_callback)
-          add_to_transaction
-        end
       end
       status
     end
 
+    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
 
@@ -395,10 +397,7 @@ module ActiveRecord
           level: 0
         }
         @_start_transaction_state[:level] += 1
-        remember_new_record_before_last_commit
-      end
 
-      def remember_new_record_before_last_commit
         if _committed_already_called
           @_new_record_before_last_commit = false
         else

data/lib/active_record/type.rb

@@ -47,7 +47,6 @@ module ActiveRecord
       end
 
       private
-
         def current_adapter_name
           ActiveRecord::Base.connection.adapter_name.downcase.to_sym
         end

data/lib/active_record/type/adapter_specific_registry.rb

@@ -11,14 +11,13 @@ module ActiveRecord
       end
 
       private
-
         def registration_klass
           Registration
         end
 
-        def find_registration(symbol, *args)
+        def find_registration(symbol, *args, **kwargs)
           registrations
-            .select { |registration| registration.matches?(symbol, *args) }
+            .select { |registration| registration.matches?(symbol, *args, **kwargs) }
             .max
         end
     end
@@ -53,7 +52,6 @@ module ActiveRecord
       end
 
       protected
-
         attr_reader :name, :block, :adapter, :override
 
         def priority
@@ -72,7 +70,6 @@ module ActiveRecord
         end
 
       private
-
         def matches_adapter?(adapter: nil, **)
           (self.adapter.nil? || adapter == self.adapter)
         end

data/lib/active_record/type/hash_lookup_type_map.rb

@@ -16,7 +16,6 @@ module ActiveRecord
       end
 
       private
-
         def perform_fetch(type, *args, &block)
           @mapping.fetch(type, block).call(type, *args)
         end

data/lib/active_record/type/serialized.rb

@@ -56,7 +56,6 @@ module ActiveRecord
       end
 
       private
-
         def default_value?(value)
           value == coder.load(nil)
         end

data/lib/active_record/type/type_map.rb

@@ -45,7 +45,6 @@ module ActiveRecord
       end
 
       private
-
         def perform_fetch(lookup_key, *args)
           matching_pair = @mapping.reverse_each.detect do |key, _|
             key === lookup_key

data/lib/active_record/type/unsigned_integer.rb

@@ -4,7 +4,6 @@ module ActiveRecord
   module Type
     class UnsignedInteger < ActiveModel::Type::Integer # :nodoc:
       private
-
         def max_value
           super * 2
         end

data/lib/active_record/type_caster/connection.rb

@@ -8,21 +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
 
-      private
-        attr_reader :table_name
-        delegate :connection, to: :@klass
+      def type_for_attribute(attr_name)
+        schema_cache = connection.schema_cache
 
-        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
+        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
+
+        type || Type.default_value
+      end
+
+      delegate :connection, to: :@klass, private: true
+
+      private
+        attr_reader :table_name
     end
   end
 end

data/lib/active_record/validations.rb

@@ -40,15 +40,16 @@ 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 = {})
+    def save(**options)
       perform_validations(options) ? super : false
     end
 
     # Attempts to save the record just like {ActiveRecord::Base#save}[rdoc-ref:Base#save] but
     # will raise an ActiveRecord::RecordInvalid exception instead of returning +false+ if the record is not valid.
-    def save!(options = {})
+    def save!(**options)
       perform_validations(options) ? super : raise_validation_error
     end
 
@@ -71,7 +72,6 @@ module ActiveRecord
     alias_method :validate, :valid?
 
   private
-
     def default_validation_context
       new_record? ? :create : :update
     end

data/lib/active_record/validations/associated.rb

@@ -5,12 +5,11 @@ module ActiveRecord
     class AssociatedValidator < ActiveModel::EachValidator #:nodoc:
       def validate_each(record, attribute, value)
         if Array(value).reject { |r| valid_object?(r) }.any?
-          record.errors.add(attribute, :invalid, options.merge(value: value))
+          record.errors.add(attribute, :invalid, **options.merge(value: value))
         end
       end
 
       private
-
         def valid_object?(record)
           (record.respond_to?(:marked_for_destruction?) && record.marked_for_destruction?) || record.valid?
         end

data/lib/arel.rb

@@ -24,28 +24,39 @@ require "arel/update_manager"
 require "arel/delete_manager"
 require "arel/nodes"
 
-module Arel # :nodoc: all
+module Arel
   VERSION = "10.0.0"
 
+  # Wrap a known-safe SQL string for passing to query methods, e.g.
+  #
+  #   Post.order(Arel.sql("length(title)")).last
+  #
+  # Great caution should be taken to avoid SQL injection vulnerabilities.
+  # This method should not be used with unsafe values such as request
+  # parameters or model attributes.
   def self.sql(raw_sql)
     Arel::Nodes::SqlLiteral.new raw_sql
   end
 
-  def self.star
+  def self.star # :nodoc:
     sql "*"
   end
 
-  def self.arel_node?(value)
+  def self.arel_node?(value) # :nodoc:
     value.is_a?(Arel::Node) || value.is_a?(Arel::Attribute) || value.is_a?(Arel::Nodes::SqlLiteral)
   end
 
-  def self.fetch_attribute(value)
+  def self.fetch_attribute(value) # :nodoc:
     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
+      if value.left.is_a?(Arel::Attributes::Attribute)
+        yield value.left
+      elsif value.right.is_a?(Arel::Attributes::Attribute)
+        yield value.right
+      end
     end
   end
 
   ## Convenience Alias
-  Node = Arel::Nodes::Node
+  Node = Arel::Nodes::Node # :nodoc:
 end

data/lib/arel/predications.rb

@@ -38,14 +38,14 @@ module Arel # :nodoc: all
       if unboundable?(other.begin) == 1 || unboundable?(other.end) == -1
         self.in([])
       elsif open_ended?(other.begin)
-        if other.end.nil? || open_ended?(other.end)
+        if open_ended?(other.end)
           not_in([])
         elsif other.exclude_end?
           lt(other.end)
         else
           lteq(other.end)
         end
-      elsif other.end.nil? || open_ended?(other.end)
+      elsif open_ended?(other.end)
         gteq(other.begin)
       elsif other.exclude_end?
         gteq(other.begin).and(lt(other.end))
@@ -86,14 +86,14 @@ Passing a range to `#in` is deprecated. Call `#between`, instead.
       if unboundable?(other.begin) == 1 || unboundable?(other.end) == -1
         not_in([])
       elsif open_ended?(other.begin)
-        if other.end.nil? || open_ended?(other.end)
+        if open_ended?(other.end)
           self.in([])
         elsif other.exclude_end?
           gteq(other.end)
         else
           gt(other.end)
         end
-      elsif other.end.nil? || open_ended?(other.end)
+      elsif open_ended?(other.end)
         lt(other.begin)
       else
         left = lt(other.begin)
@@ -221,7 +221,6 @@ Passing a range to `#not_in` is deprecated. Call `#not_between`, instead.
     end
 
     private
-
       def grouping_any(method_id, others, *extras)
         nodes = others.map { |expr| send(method_id, expr, *extras) }
         Nodes::Grouping.new nodes.inject { |memo, node|
@@ -251,7 +250,7 @@ Passing a range to `#not_in` is deprecated. Call `#not_between`, instead.
       end
 
       def open_ended?(value)
-        infinity?(value) || unboundable?(value)
+        value.nil? || infinity?(value) || unboundable?(value)
       end
   end
 end

data/lib/arel/visitors/depth_first.rb

@@ -9,8 +9,7 @@ module Arel # :nodoc: all
       end
 
       private
-
-        def visit(o)
+        def visit(o, _ = nil)
           super
           @block.call o
         end

data/lib/arel/visitors/dot.rb

@@ -31,7 +31,6 @@ module Arel # :nodoc: all
       end
 
       private
-
         def visit_Arel_Nodes_Ordering(o)
           visit_edge o, "expr"
         end

data/lib/arel/visitors/mssql.rb

@@ -11,7 +11,6 @@ module Arel # :nodoc: all
       end
 
       private
-
         def visit_Arel_Nodes_IsNotDistinctFrom(o, collector)
           right = o.right
 

data/lib/arel/visitors/oracle.rb

@@ -4,7 +4,6 @@ module Arel # :nodoc: all
   module Visitors
     class Oracle < Arel::Visitors::ToSql
       private
-
         def visit_Arel_Nodes_SelectStatement(o, collector)
           o = order_hacks(o)
 
@@ -123,7 +122,7 @@ module Arel # :nodoc: all
           o.orders = []
           orders.each_with_index do |order, i|
             o.orders <<
-              Nodes::SqlLiteral.new("alias_#{i}__#{' DESC' if /\bdesc$/i === order}")
+              Nodes::SqlLiteral.new("alias_#{i}__#{' DESC' if /\bdesc$/i.match?(order)}")
           end
           o
         end

data/lib/arel/visitors/oracle12.rb

@@ -4,7 +4,6 @@ module Arel # :nodoc: all
   module Visitors
     class Oracle12 < Arel::Visitors::ToSql
       private
-
         def visit_Arel_Nodes_SelectStatement(o, collector)
           # Oracle does not allow LIMIT clause with select for update
           if o.limit && o.lock