activerecord 6.1.7 → 7.2.2

data/lib/active_record/type/adapter_specific_registry.rb

@@ -1,19 +1,41 @@
 # frozen_string_literal: true
 
-require "active_model/type/registry"
-
 module ActiveRecord
   # :stopdoc:
   module Type
-    class AdapterSpecificRegistry < ActiveModel::Type::Registry
+    class AdapterSpecificRegistry # :nodoc:
+      def initialize
+        @registrations = []
+      end
+
+      def initialize_copy(other)
+        @registrations = @registrations.dup
+      end
+
       def add_modifier(options, klass, **args)
         registrations << DecorationRegistration.new(options, klass, **args)
       end
 
-      private
-        def registration_klass
-          Registration
+      def register(type_name, klass = nil, **options, &block)
+        unless block_given?
+          block = proc { |_, *args| klass.new(*args) }
+          block.ruby2_keywords if block.respond_to?(:ruby2_keywords)
+        end
+        registrations << Registration.new(type_name, block, **options)
+      end
+
+      def lookup(symbol, *args, **kwargs)
+        registration = find_registration(symbol, *args, **kwargs)
+
+        if registration
+          registration.call(self, symbol, *args, **kwargs)
+        else
+          raise ArgumentError, "Unknown type #{symbol.inspect}"
         end
+      end
+
+      private
+        attr_reader :registrations
 
         def find_registration(symbol, *args, **kwargs)
           registrations
@@ -22,7 +44,7 @@ module ActiveRecord
         end
     end
 
-    class Registration
+    class Registration # :nodoc:
       def initialize(name, block, adapter: nil, override: nil)
         @name = name
         @block = block
@@ -31,11 +53,7 @@ module ActiveRecord
       end
 
       def call(_registry, *args, adapter: nil, **kwargs)
-        if kwargs.any? # https://bugs.ruby-lang.org/issues/10856
-          block.call(*args, **kwargs)
-        else
-          block.call(*args)
-        end
+        block.call(*args, **kwargs)
       end
 
       def matches?(type_name, *args, **kwargs)
@@ -89,7 +107,7 @@ module ActiveRecord
         end
     end
 
-    class DecorationRegistration < Registration
+    class DecorationRegistration < Registration # :nodoc:
       def initialize(options, klass, adapter: nil)
         @options = options
         @klass = klass
@@ -120,7 +138,7 @@ module ActiveRecord
     end
   end
 
-  class TypeConflictError < StandardError
+  class TypeConflictError < StandardError # :nodoc:
   end
   # :startdoc:
 end

data/lib/active_record/type/hash_lookup_type_map.rb

@@ -2,7 +2,40 @@
 
 module ActiveRecord
   module Type
-    class HashLookupTypeMap < TypeMap # :nodoc:
+    class HashLookupTypeMap # :nodoc:
+      def initialize(parent = nil)
+        @mapping = {}
+        @cache = Concurrent::Map.new do |h, key|
+          h.fetch_or_store(key, Concurrent::Map.new)
+        end
+      end
+
+      def lookup(lookup_key, *args)
+        fetch(lookup_key, *args) { Type.default_value }
+      end
+
+      def fetch(lookup_key, *args, &block)
+        @cache[lookup_key].fetch_or_store(args) do
+          perform_fetch(lookup_key, *args, &block)
+        end
+      end
+
+      def register_type(key, value = nil, &block)
+        raise ::ArgumentError unless value || block
+
+        if block
+          @mapping[key] = block
+        else
+          @mapping[key] = proc { value }
+        end
+        @cache.clear
+      end
+
+      def clear
+        @mapping.clear
+        @cache.clear
+      end
+
       def alias_type(type, alias_type)
         register_type(type) { |_, *args| lookup(alias_type, *args) }
       end

data/lib/active_record/type/internal/timezone.rb

@@ -4,12 +4,17 @@ module ActiveRecord
   module Type
     module Internal
       module Timezone
+        def initialize(timezone: nil, **kwargs)
+          super(**kwargs)
+          @timezone = timezone
+        end
+
         def is_utc?
-          ActiveRecord::Base.default_timezone == :utc
+          default_timezone == :utc
         end
 
         def default_timezone
-          ActiveRecord::Base.default_timezone
+          @timezone || ActiveRecord.default_timezone
         end
       end
     end

data/lib/active_record/type/serialized.rb

@@ -30,9 +30,7 @@ module ActiveRecord
         end
       end
 
-      def inspect
-        Kernel.instance_method(:inspect).bind(self).call
-      end
+      define_method(:inspect, Kernel.instance_method(:inspect))
 
       def changed_in_place?(raw_old_value, value)
         return false if value.nil?
@@ -55,6 +53,10 @@ module ActiveRecord
         coder.respond_to?(:object_class) && value.is_a?(coder.object_class)
       end
 
+      def serialized? # :nodoc:
+        true
+      end
+
       private
         def default_value?(value)
           value == coder.load(nil)
@@ -63,11 +65,11 @@ module ActiveRecord
         def encoded(value)
           return if default_value?(value)
           payload = coder.dump(value)
-          if payload && binary? && payload.encoding != Encoding::BINARY
-            payload = payload.dup if payload.frozen?
-            payload.force_encoding(Encoding::BINARY)
+          if payload && @subtype.binary?
+            ActiveModel::Type::Binary::Data.new(payload)
+          else
+            payload
           end
-          payload
         end
     end
   end

data/lib/active_record/type/time.rb

@@ -17,6 +17,10 @@ module ActiveRecord
         end
       end
 
+      def serialize_cast_value(value) # :nodoc:
+        Value.new(super) if value
+      end
+
       private
         def cast_value(value)
           case value = super

data/lib/active_record/type/type_map.rb

@@ -5,55 +5,52 @@ require "concurrent/map"
 module ActiveRecord
   module Type
     class TypeMap # :nodoc:
-      def initialize
+      def initialize(parent = nil)
         @mapping = {}
-        @cache = Concurrent::Map.new do |h, key|
-          h.fetch_or_store(key, Concurrent::Map.new)
-        end
+        @parent = parent
+        @cache = Concurrent::Map.new
       end
 
-      def lookup(lookup_key, *args)
-        fetch(lookup_key, *args) { Type.default_value }
+      def lookup(lookup_key)
+        fetch(lookup_key) { Type.default_value }
       end
 
-      def fetch(lookup_key, *args, &block)
-        @cache[lookup_key].fetch_or_store(args) do
-          perform_fetch(lookup_key, *args, &block)
+      def fetch(lookup_key, &block)
+        @cache.fetch_or_store(lookup_key) do
+          perform_fetch(lookup_key, &block)
         end
       end
 
       def register_type(key, value = nil, &block)
         raise ::ArgumentError unless value || block
-        @cache.clear
 
         if block
           @mapping[key] = block
         else
           @mapping[key] = proc { value }
         end
+        @cache.clear
       end
 
       def alias_type(key, target_key)
-        register_type(key) do |sql_type, *args|
+        register_type(key) do |sql_type|
           metadata = sql_type[/\(.*\)/, 0]
-          lookup("#{target_key}#{metadata}", *args)
+          lookup("#{target_key}#{metadata}")
         end
       end
 
-      def clear
-        @mapping.clear
-      end
-
-      private
-        def perform_fetch(lookup_key, *args)
+      protected
+        def perform_fetch(lookup_key, &block)
           matching_pair = @mapping.reverse_each.detect do |key, _|
             key === lookup_key
           end
 
           if matching_pair
-            matching_pair.last.call(lookup_key, *args)
+            matching_pair.last.call(lookup_key)
+          elsif @parent
+            @parent.perform_fetch(lookup_key, &block)
           else
-            yield lookup_key, *args
+            yield lookup_key
           end
         end
     end

data/lib/active_record/type.rb

@@ -47,8 +47,7 @@ module ActiveRecord
       end
 
       def adapter_name_from(model) # :nodoc:
-        # TODO: this shouldn't depend on a connection to the database
-        model.connection.adapter_name.downcase.to_sym
+        model.connection_db_config.adapter.to_sym
       end
 
       private

data/lib/active_record/type_caster/connection.rb

@@ -14,18 +14,18 @@ module ActiveRecord
       end
 
       def type_for_attribute(attr_name)
-        schema_cache = connection.schema_cache
+        schema_cache = @klass.schema_cache
 
         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
+          if column
+            type = @klass.with_connection { |connection| connection.lookup_cast_type_from_column(column) }
+          end
         end
 
         type || Type.default_value
       end
 
-      delegate :connection, to: :@klass, private: true
-
       private
         attr_reader :table_name
     end

data/lib/active_record/validations/absence.rb

@@ -14,7 +14,7 @@ module ActiveRecord
     module ClassMethods
       # Validates that the specified attributes are not present (as defined by
       # Object#present?). If the attribute is an association, the associated object
-      # is considered absent if it was marked for destruction.
+      # is also considered not present if it is marked for destruction.
       #
       # See ActiveModel::Validations::HelperMethods.validates_absence_of for more information.
       def validates_absence_of(*attr_names)

data/lib/active_record/validations/associated.rb

@@ -2,16 +2,22 @@
 
 module ActiveRecord
   module Validations
-    class AssociatedValidator < ActiveModel::EachValidator #:nodoc:
+    class AssociatedValidator < ActiveModel::EachValidator # :nodoc:
       def validate_each(record, attribute, value)
-        if Array(value).reject { |r| valid_object?(r) }.any?
+        context = record_validation_context_for_association(record)
+
+        if Array(value).reject { |association| valid_object?(association, context) }.any?
           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?
+        def valid_object?(record, context)
+          (record.respond_to?(:marked_for_destruction?) && record.marked_for_destruction?) || record.valid?(context)
+        end
+
+        def record_validation_context_for_association(record)
+          record.custom_validation_context? ? record.validation_context : nil
         end
     end
 
@@ -42,14 +48,14 @@ module ActiveRecord
       #   or an array of symbols. (e.g. <tt>on: :create</tt> or
       #   <tt>on: :custom_validation_context</tt> or
       #   <tt>on: [:create, :custom_validation_context]</tt>)
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
+      # * <tt>:if</tt> - Specifies a method, proc, or string to call to determine
       #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
       #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
       #   proc or string should return or evaluate to a +true+ or +false+ value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to
+      # * <tt>:unless</tt> - Specifies a method, proc, or string to call to
       #   determine if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
       #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The
-      #   method, proc or string should return or evaluate to a +true+ or +false+
+      #   method, proc, or string should return or evaluate to a +true+ or +false+
       #   value.
       def validates_associated(*attr_names)
         validates_with AssociatedValidator, _merge_attributes(attr_names)

data/lib/active_record/validations/numericality.rb

@@ -21,10 +21,11 @@ module ActiveRecord
 
     module ClassMethods
       # Validates whether the value of the specified attribute is numeric by
-      # trying to convert it to a float with Kernel.Float (if <tt>only_integer</tt>
-      # is +false+) or applying it to the regular expression <tt>/\A[\+\-]?\d+\z/</tt>
-      # (if <tt>only_integer</tt> is set to +true+). Kernel.Float precision
-      # defaults to the column's precision value or 15.
+      # trying to convert it to a float with +Kernel.Float+ (if
+      # <tt>only_integer</tt> is +false+) or applying it to the regular
+      # expression <tt>/\A[\+\-]?\d+\z/</tt> (if <tt>only_integer</tt> is set to
+      # +true+). +Kernel.Float+ precision defaults to the column's precision
+      # value or 15.
       #
       # See ActiveModel::Validations::HelperMethods.validates_numericality_of for more information.
       def validates_numericality_of(*attr_names)

data/lib/active_record/validations/presence.rb

@@ -13,9 +13,8 @@ module ActiveRecord
 
     module ClassMethods
       # Validates that the specified attributes are not blank (as defined by
-      # Object#blank?), and, if the attribute is an association, that the
-      # associated object is not marked for destruction. Happens by default
-      # on save.
+      # Object#blank?). If the attribute is an association, the associated object
+      # is also considered blank if it is marked for destruction.
       #
       #   class Person < ActiveRecord::Base
       #     has_one :face
@@ -25,41 +24,19 @@ module ActiveRecord
       # The face attribute must be in the object and it cannot be blank or marked
       # for destruction.
       #
-      # If you want to validate the presence of a boolean field (where the real values
-      # are true and false), you will want to use
-      # <tt>validates_inclusion_of :field_name, in: [true, false]</tt>.
-      #
-      # This is due to the way Object#blank? handles boolean values:
-      # <tt>false.blank? # => true</tt>.
-      #
       # This validator defers to the Active Model validation for presence, adding the
       # check to see that an associated object is not marked for destruction. This
       # prevents the parent object from validating successfully and saving, which then
       # deletes the associated object, thus putting the parent object into an invalid
       # state.
       #
+      # See ActiveModel::Validations::HelperMethods.validates_presence_of for
+      # more information.
+      #
       # NOTE: This validation will not fail while using it with an association
       # if the latter was assigned but not valid. If you want to ensure that
       # it is both present and valid, you also need to use
       # {validates_associated}[rdoc-ref:Validations::ClassMethods#validates_associated].
-      #
-      # Configuration options:
-      # * <tt>:message</tt> - A custom error message (default is: "can't be blank").
-      # * <tt>:on</tt> - Specifies the contexts where this validation is active.
-      #   Runs in all validation contexts by default +nil+. You can pass a symbol
-      #   or an array of symbols. (e.g. <tt>on: :create</tt> or
-      #   <tt>on: :custom_validation_context</tt> or
-      #   <tt>on: [:create, :custom_validation_context]</tt>)
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if
-      #   the validation should occur (e.g. <tt>if: :allow_validation</tt>, or
-      #   <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method, proc
-      #   or string should return or evaluate to a +true+ or +false+ value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine
-      #   if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
-      #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The method,
-      #   proc or string should return or evaluate to a +true+ or +false+ value.
-      # * <tt>:strict</tt> - Specifies whether validation should be strict.
-      #   See ActiveModel::Validations#validates! for more information.
       def validates_presence_of(*attr_names)
         validates_with PresenceValidator, _merge_attributes(attr_names)
       end

data/lib/active_record/validations/uniqueness.rb

@@ -14,16 +14,19 @@ module ActiveRecord
         end
         super
         @klass = options[:class]
+        @klass = @klass.superclass if @klass.singleton_class?
       end
 
       def validate_each(record, attribute, value)
         finder_class = find_finder_class_for(record)
         value = map_enum_attribute(finder_class, attribute, value)
 
+        return if record.persisted? && !validation_needed?(finder_class, record, attribute)
+
         relation = build_relation(finder_class, attribute, value)
         if record.persisted?
           if finder_class.primary_key
-            relation = relation.where.not(finder_class.primary_key => record.id_in_database)
+            relation = relation.where.not(finder_class.primary_key => [record.id_in_database])
           else
             raise UnknownPrimaryKey.new(finder_class, "Cannot validate uniqueness for persisted record without primary key.")
           end
@@ -64,18 +67,64 @@ module ActiveRecord
         class_hierarchy.detect { |klass| !klass.abstract_class? }
       end
 
+      def validation_needed?(klass, record, attribute)
+        return true if options[:conditions] || options.key?(:case_sensitive)
+
+        scope = Array(options[:scope])
+        attributes = scope + [attribute]
+        attributes = resolve_attributes(record, attributes)
+
+        return true if attributes.any? { |attr| record.attribute_changed?(attr) ||
+                                                record.read_attribute(attr).nil? }
+
+        !covered_by_unique_index?(klass, record, attribute, scope)
+      end
+
+      def covered_by_unique_index?(klass, record, attribute, scope)
+        @covered ||= self.attributes.map(&:to_s).select do |attr|
+          attributes = scope + [attr]
+          attributes = resolve_attributes(record, attributes)
+
+          klass.schema_cache.indexes(klass.table_name).any? do |index|
+            index.unique &&
+              index.where.nil? &&
+              (Array(index.columns) - attributes).empty?
+          end
+        end
+
+        @covered.include?(attribute.to_s)
+      end
+
+      def resolve_attributes(record, attributes)
+        attributes.flat_map do |attribute|
+          reflection = record.class._reflect_on_association(attribute)
+
+          if reflection.nil?
+            attribute.to_s
+          elsif reflection.polymorphic?
+            [reflection.foreign_key, reflection.foreign_type]
+          else
+            reflection.foreign_key
+          end
+        end
+      end
+
       def build_relation(klass, attribute, value)
         relation = klass.unscoped
-        comparison = relation.bind_attribute(attribute, value) do |attr, bind|
-          return relation.none! if bind.unboundable?
+        # TODO: Add case-sensitive / case-insensitive operators to Arel
+        # to no longer need to checkout a connection here.
+        comparison = klass.with_connection do |connection|
+          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)
-          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)
+            if !options.key?(:case_sensitive) || bind.nil?
+              connection.default_uniqueness_comparison(attr, bind)
+            elsif options[:case_sensitive]
+              connection.case_sensitive_comparison(attr, bind)
+            else
+              # will use SQL LOWER function before comparison, unless it detects a case insensitive collation
+              connection.case_insensitive_comparison(attr, bind)
+            end
           end
         end
 
@@ -161,19 +210,19 @@ module ActiveRecord
       #   <tt>WHERE</tt> SQL fragment to limit the uniqueness constraint lookup
       #   (e.g. <tt>conditions: -> { where(status: 'active') }</tt>).
       # * <tt>:case_sensitive</tt> - Looks for an exact match. Ignored by
-      #   non-text columns (+true+ by default).
+      #   non-text columns. The default behavior respects the default database collation.
       # * <tt>:allow_nil</tt> - If set to +true+, skips this validation if the
       #   attribute is +nil+ (default is +false+).
       # * <tt>:allow_blank</tt> - If set to +true+, skips this validation if the
       #   attribute is blank (default is +false+).
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
+      # * <tt>:if</tt> - Specifies a method, proc, or string to call to determine
       #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
       #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
       #   proc or string should return or evaluate to a +true+ or +false+ value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to
+      # * <tt>:unless</tt> - Specifies a method, proc, or string to call to
       #   determine if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
       #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The
-      #   method, proc or string should return or evaluate to a +true+ or +false+
+      #   method, proc, or string should return or evaluate to a +true+ or +false+
       #   value.
       #
       # === Concurrency and integrity
@@ -221,7 +270,7 @@ module ActiveRecord
       # When the database catches such a duplicate insertion,
       # {ActiveRecord::Base#save}[rdoc-ref:Persistence#save] will raise an ActiveRecord::StatementInvalid
       # exception. You can either choose to let this error propagate (which
-      # will result in the default Rails exception page being shown), or you
+      # will result in the default \Rails exception page being shown), or you
       # can catch it and restart the transaction (e.g. by telling the user
       # that the title already exists, and asking them to re-enter the title).
       # This technique is also known as
@@ -236,6 +285,7 @@ module ActiveRecord
       # The following bundled adapters throw the ActiveRecord::RecordNotUnique exception:
       #
       # * ActiveRecord::ConnectionAdapters::Mysql2Adapter.
+      # * ActiveRecord::ConnectionAdapters::TrilogyAdapter.
       # * ActiveRecord::ConnectionAdapters::SQLite3Adapter.
       # * ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.
       def validates_uniqueness_of(*attr_names)

data/lib/active_record/validations.rb

@@ -30,14 +30,15 @@ module ActiveRecord
 
   # = Active Record \Validations
   #
-  # Active Record includes the majority of its validations from ActiveModel::Validations
-  # all of which accept the <tt>:on</tt> argument to define the context where the
-  # validations are active. Active Record will always supply either the context of
-  # <tt>:create</tt> or <tt>:update</tt> dependent on whether the model is a
+  # Active Record includes the majority of its validations from ActiveModel::Validations.
+  #
+  # In Active Record, all validations are performed on save by default.
+  # Validations accept the <tt>:on</tt> argument to define the context where
+  # the validations are active. Active Record will pass either the context of
+  # <tt>:create</tt> or <tt>:update</tt> depending on whether the model is a
   # {new_record?}[rdoc-ref:Persistence#new_record?].
   module Validations
     extend ActiveSupport::Concern
-    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>.
@@ -60,6 +61,8 @@ module ActiveRecord
     #
     # If the argument is +false+ (default is +nil+), the context is set to <tt>:create</tt> if
     # {new_record?}[rdoc-ref:Persistence#new_record?] is +true+, and to <tt>:update</tt> if it is not.
+    # If the argument is an array of contexts, <tt>post.valid?([:create, :update])</tt>, the validations are
+    # run within multiple contexts.
     #
     # \Validations with no <tt>:on</tt> option will run no matter the context. \Validations with
     # some <tt>:on</tt> option will only run in the specified context.
@@ -71,6 +74,10 @@ module ActiveRecord
 
     alias_method :validate, :valid?
 
+    def custom_validation_context? # :nodoc:
+      validation_context && [:create, :update].exclude?(validation_context)
+    end
+
   private
     def default_validation_context
       new_record? ? :create : :update

data/lib/active_record/version.rb

@@ -3,7 +3,7 @@
 require_relative "gem_version"
 
 module ActiveRecord
-  # Returns the version of the currently loaded ActiveRecord as a <tt>Gem::Version</tt>
+  # Returns the currently loaded version of Active Record as a +Gem::Version+.
   def self.version
     gem_version
   end