activerecord 6.0.1 → 6.1.0

data/lib/active_record/type/time.rb

@@ -16,6 +16,16 @@ module ActiveRecord
           value
         end
       end
+
+      private
+        def cast_value(value)
+          case value = super
+          when Value
+            value.__getobj__
+          else
+            value
+          end
+        end
     end
   end
 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.rb

@@ -46,10 +46,14 @@ module ActiveRecord
         @default_value ||= Value.new
       end
 
-      private
+      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
-          ActiveRecord::Base.connection.adapter_name.downcase.to_sym
+          adapter_name_from(ActiveRecord::Base)
         end
     end
 
@@ -59,6 +63,7 @@ module ActiveRecord
     Decimal = ActiveModel::Type::Decimal
     Float = ActiveModel::Type::Float
     Integer = ActiveModel::Type::Integer
+    ImmutableString = ActiveModel::Type::ImmutableString
     String = ActiveModel::Type::String
     Value = ActiveModel::Type::Value
 
@@ -70,6 +75,7 @@ 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)

data/lib/active_record/type_caster/connection.rb

@@ -9,7 +9,6 @@ module ActiveRecord
       end
 
       def type_cast_for_database(attr_name, value)
-        return value if value.is_a?(Arel::Nodes::BindParam)
         type = type_for_attribute(attr_name)
         type.serialize(value)
       end

data/lib/active_record/type_caster/map.rb

@@ -3,18 +3,21 @@
 module ActiveRecord
   module TypeCaster
     class Map # :nodoc:
-      def initialize(types)
-        @types = types
+      def initialize(klass)
+        @klass = klass
       end
 
       def type_cast_for_database(attr_name, value)
-        return value if value.is_a?(Arel::Nodes::BindParam)
-        type = types.type_for_attribute(attr_name)
+        type = type_for_attribute(attr_name)
         type.serialize(value)
       end
 
+      def type_for_attribute(name)
+        klass.type_for_attribute(name)
+      end
+
       private
-        attr_reader :types
+        attr_reader :klass
     end
   end
 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/active_record/validations/numericality.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Validations
+    class NumericalityValidator < ActiveModel::Validations::NumericalityValidator # :nodoc:
+      def validate_each(record, attribute, value, precision: nil, scale: nil)
+        precision = [column_precision_for(record, attribute) || BigDecimal.double_fig, BigDecimal.double_fig].min
+        scale     = column_scale_for(record, attribute)
+        super(record, attribute, value, precision: precision, scale: scale)
+      end
+
+      private
+        def column_precision_for(record, attribute)
+          record.class.type_for_attribute(attribute.to_s)&.precision
+        end
+
+        def column_scale_for(record, attribute)
+          record.class.type_for_attribute(attribute.to_s)&.scale
+        end
+    end
+
+    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.
+      #
+      # See ActiveModel::Validations::HelperMethods.validates_numericality_of for more information.
+      def validates_numericality_of(*attr_names)
+        validates_with NumericalityValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/active_record/validations/uniqueness.rb

@@ -29,13 +29,22 @@ module ActiveRecord
           end
         end
         relation = scope_relation(record, relation)
-        relation = relation.merge(options[:conditions]) if options[:conditions]
+
+        if options[:conditions]
+          conditions = options[:conditions]
+
+          relation = if conditions.arity.zero?
+            relation.instance_exec(&conditions)
+          else
+            relation.instance_exec(record, &conditions)
+          end
+        end
 
         if relation.exists?
           error_options = options.except(:case_sensitive, :scope, :conditions)
           error_options[:value] = value
 
-          record.errors.add(attribute, :taken, error_options)
+          record.errors.add(attribute, :taken, **error_options)
         end
       end
 
@@ -61,7 +70,7 @@ module ActiveRecord
           return relation.none! if bind.unboundable?
 
           if !options.key?(:case_sensitive) || bind.nil?
-            klass.connection.default_uniqueness_comparison(attr, bind, klass)
+            klass.connection.default_uniqueness_comparison(attr, bind)
           elsif options[:case_sensitive]
             klass.connection.case_sensitive_comparison(attr, bind)
           else
@@ -78,7 +87,7 @@ module ActiveRecord
           scope_value = if record.class._reflect_on_association(scope_item)
             record.association(scope_item).reader
           else
-            record._read_attribute(scope_item)
+            record.read_attribute(scope_item)
           end
           relation = relation.where(scope_item => scope_value)
         end
@@ -126,6 +135,17 @@ module ActiveRecord
       #     validates_uniqueness_of :title, conditions: -> { where.not(status: 'archived') }
       #   end
       #
+      # To build conditions based on the record's state, define the conditions
+      # callable with a parameter, which will be the record itself. This
+      # example validates the title is unique for the year of publication:
+      #
+      #   class Article < ActiveRecord::Base
+      #     validates_uniqueness_of :title, conditions: ->(article) {
+      #       published_at = article.published_at
+      #       where(published_at: published_at.beginning_of_year..published_at.end_of_year)
+      #     }
+      #   end
+      #
       # When the record is created, a check is performed to make sure that no
       # record exists in the database with the given value for the specified
       # attribute (that maps to a column). When the record is updated,

data/lib/active_record/validations.rb

@@ -43,13 +43,13 @@ module ActiveRecord
     # 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
 
@@ -72,7 +72,6 @@ module ActiveRecord
     alias_method :validate, :valid?
 
   private
-
     def default_validation_context
       new_record? ? :create : :update
     end
@@ -92,3 +91,4 @@ require "active_record/validations/uniqueness"
 require "active_record/validations/presence"
 require "active_record/validations/absence"
 require "active_record/validations/length"
+require "active_record/validations/numericality"

data/lib/active_record.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #--
-# Copyright (c) 2004-2019 David Heinemeier Hansson
+# Copyright (c) 2004-2020 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -31,6 +31,7 @@ require "yaml"
 
 require "active_record/version"
 require "active_model/attribute_set"
+require "active_record/errors"
 
 module ActiveRecord
   extend ActiveSupport::Autoload
@@ -41,6 +42,7 @@ module ActiveRecord
   autoload :ConnectionHandling
   autoload :CounterCache
   autoload :DynamicMatchers
+  autoload :DelegatedType
   autoload :Enum
   autoload :InternalMetadata
   autoload :Explain
@@ -67,18 +69,17 @@ module ActiveRecord
   autoload :Serialization
   autoload :StatementCache
   autoload :Store
+  autoload :SignedId
   autoload :Suppressor
   autoload :Timestamp
   autoload :Transactions
   autoload :Translation
   autoload :Validations
   autoload :SecureToken
-  autoload :DatabaseSelector, "active_record/middleware/database_selector"
+  autoload :DestroyAssociationAsyncJob
 
   eager_autoload do
-    autoload :ActiveRecordError, "active_record/errors"
-    autoload :ConnectionNotEstablished, "active_record/errors"
-    autoload :ConnectionAdapters, "active_record/connection_adapters/abstract_adapter"
+    autoload :ConnectionAdapters
 
     autoload :Aggregations
     autoload :Associations
@@ -136,14 +137,6 @@ module ActiveRecord
     end
   end
 
-  module ConnectionAdapters
-    extend ActiveSupport::Autoload
-
-    eager_autoload do
-      autoload :AbstractAdapter
-    end
-  end
-
   module Scoping
     extend ActiveSupport::Autoload
 
@@ -193,3 +186,4 @@ end
 YAML.load_tags["!ruby/object:ActiveRecord::AttributeSet"] = "ActiveModel::AttributeSet"
 YAML.load_tags["!ruby/object:ActiveRecord::Attribute::FromDatabase"] = "ActiveModel::Attribute::FromDatabase"
 YAML.load_tags["!ruby/object:ActiveRecord::LazyAttributeHash"] = "ActiveModel::LazyAttributeHash"
+YAML.load_tags["!ruby/object:ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter::MysqlString"] = "ActiveRecord::Type::String"

data/lib/arel/attributes/attribute.rb

@@ -9,6 +9,10 @@ module Arel # :nodoc: all
       include Arel::OrderPredications
       include Arel::Math
 
+      def type_caster
+        relation.type_for_attribute(name)
+      end
+
       ###
       # Create a node for lowering this attribute
       def lower

data/lib/arel/collectors/bind.rb

@@ -16,6 +16,11 @@ module Arel # :nodoc: all
         self
       end
 
+      def add_binds(binds)
+        @binds.concat binds
+        self
+      end
+
       def value
         @binds
       end

data/lib/arel/collectors/composite.rb

@@ -3,6 +3,8 @@
 module Arel # :nodoc: all
   module Collectors
     class Composite
+      attr_accessor :preparable
+
       def initialize(left, right)
         @left = left
         @right = right
@@ -20,6 +22,12 @@ module Arel # :nodoc: all
         self
       end
 
+      def add_binds(binds, &block)
+        left.add_binds(binds, &block)
+        right.add_binds(binds, &block)
+        self
+      end
+
       def value
         [left.value, right.value]
       end

data/lib/arel/collectors/sql_string.rb

@@ -5,6 +5,8 @@ require "arel/collectors/plain_string"
 module Arel # :nodoc: all
   module Collectors
     class SQLString < PlainString
+      attr_accessor :preparable
+
       def initialize(*)
         super
         @bind_index = 1
@@ -15,6 +17,11 @@ module Arel # :nodoc: all
         @bind_index += 1
         self
       end
+
+      def add_binds(binds, &block)
+        self << (@bind_index...@bind_index += binds.size).map(&block).join(", ")
+        self
+      end
     end
   end
 end

data/lib/arel/collectors/substitute_binds.rb

@@ -3,6 +3,8 @@
 module Arel # :nodoc: all
   module Collectors
     class SubstituteBinds
+      attr_accessor :preparable
+
       def initialize(quoter, delegate_collector)
         @quoter = quoter
         @delegate = delegate_collector
@@ -14,9 +16,14 @@ module Arel # :nodoc: all
       end
 
       def add_bind(bind)
+        bind = bind.value_for_database if bind.respond_to?(:value_for_database)
         self << quoter.quote(bind)
       end
 
+      def add_binds(binds)
+        self << binds.map { |bind| quoter.quote(bind) }.join(", ")
+      end
+
       def value
         delegate.value
       end

data/lib/arel/nodes/binary.rb

@@ -29,18 +29,92 @@ module Arel # :nodoc: all
       alias :== :eql?
     end
 
+    module FetchAttribute
+      def fetch_attribute
+        if left.is_a?(Arel::Attributes::Attribute)
+          yield left
+        elsif right.is_a?(Arel::Attributes::Attribute)
+          yield right
+        end
+      end
+    end
+
+    class Between < Binary; include FetchAttribute; end
+
+    class GreaterThan < Binary
+      include FetchAttribute
+
+      def invert
+        Arel::Nodes::LessThanOrEqual.new(left, right)
+      end
+    end
+
+    class GreaterThanOrEqual < Binary
+      include FetchAttribute
+
+      def invert
+        Arel::Nodes::LessThan.new(left, right)
+      end
+    end
+
+    class LessThan < Binary
+      include FetchAttribute
+
+      def invert
+        Arel::Nodes::GreaterThanOrEqual.new(left, right)
+      end
+    end
+
+    class LessThanOrEqual < Binary
+      include FetchAttribute
+
+      def invert
+        Arel::Nodes::GreaterThan.new(left, right)
+      end
+    end
+
+    class IsDistinctFrom < Binary
+      include FetchAttribute
+
+      def invert
+        Arel::Nodes::IsNotDistinctFrom.new(left, right)
+      end
+    end
+
+    class IsNotDistinctFrom < Binary
+      include FetchAttribute
+
+      def invert
+        Arel::Nodes::IsDistinctFrom.new(left, right)
+      end
+    end
+
+    class NotEqual < Binary
+      include FetchAttribute
+
+      def invert
+        Arel::Nodes::Equality.new(left, right)
+      end
+    end
+
+    class NotIn < Binary
+      include FetchAttribute
+
+      def invert
+        Arel::Nodes::In.new(left, right)
+      end
+    end
+
+    class Or < Binary
+      def fetch_attribute(&block)
+        left.fetch_attribute(&block) && right.fetch_attribute(&block)
+      end
+    end
+
     %w{
       As
       Assignment
-      Between
-      GreaterThan
-      GreaterThanOrEqual
       Join
-      LessThan
-      LessThanOrEqual
-      NotEqual
-      NotIn
-      Or
       Union
       UnionAll
       Intersect

data/lib/arel/nodes/bind_param.rb

@@ -24,6 +24,14 @@ module Arel # :nodoc: all
         value.nil?
       end
 
+      def value_before_type_cast
+        if value.respond_to?(:value_before_type_cast)
+          value.value_before_type_cast
+        else
+          value
+        end
+      end
+
       def infinite?
         value.respond_to?(:infinite?) && value.infinite?
       end

data/lib/arel/nodes/casted.rb

@@ -3,30 +3,42 @@
 module Arel # :nodoc: all
   module Nodes
     class Casted < Arel::Nodes::NodeExpression # :nodoc:
-      attr_reader :val, :attribute
-      def initialize(val, attribute)
-        @val       = val
+      attr_reader :value, :attribute
+      alias :value_before_type_cast :value
+
+      def initialize(value, attribute)
+        @value     = value
         @attribute = attribute
         super()
       end
 
-      def nil?; @val.nil?; end
+      def nil?; value.nil?; end
+
+      def value_for_database
+        if attribute.able_to_type_cast?
+          attribute.type_cast_for_database(value)
+        else
+          value
+        end
+      end
 
       def hash
-        [self.class, val, attribute].hash
+        [self.class, value, attribute].hash
       end
 
       def eql?(other)
         self.class == other.class &&
-            self.val == other.val &&
-            self.attribute == other.attribute
+          self.value == other.value &&
+          self.attribute == other.attribute
       end
       alias :== :eql?
     end
 
     class Quoted < Arel::Nodes::Unary # :nodoc:
-      alias :val :value
-      def nil?; val.nil?; end
+      alias :value_for_database :value
+      alias :value_before_type_cast :value
+
+      def nil?; value.nil?; end
 
       def infinite?
         value.respond_to?(:infinite?) && value.infinite?

data/lib/arel/nodes/equality.rb

@@ -3,16 +3,13 @@
 module Arel # :nodoc: all
   module Nodes
     class Equality < Arel::Nodes::Binary
-      def operator; :== end
-      alias :operand1 :left
-      alias :operand2 :right
-    end
+      include FetchAttribute
+
+      def equality?; true; end
 
-    %w{
-      IsDistinctFrom
-      IsNotDistinctFrom
-    }.each do |name|
-      const_set name, Class.new(Equality)
+      def invert
+        Arel::Nodes::NotEqual.new(left, right)
+      end
     end
   end
 end

data/lib/arel/nodes/grouping.rb

@@ -3,6 +3,9 @@
 module Arel # :nodoc: all
   module Nodes
     class Grouping < Unary
+      def fetch_attribute(&block)
+        expr.fetch_attribute(&block)
+      end
     end
   end
 end

data/lib/arel/nodes/homogeneous_in.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class HomogeneousIn < Node
+      attr_reader :attribute, :values, :type
+
+      def initialize(values, attribute, type)
+        @values = values
+        @attribute = attribute
+        @type = type
+      end
+
+      def hash
+        ivars.hash
+      end
+
+      def eql?(other)
+        super || (self.class == other.class && self.ivars == other.ivars)
+      end
+      alias :== :eql?
+
+      def equality?
+        type == :in
+      end
+
+      def invert
+        Arel::Nodes::HomogeneousIn.new(values, attribute, type == :in ? :notin : :in)
+      end
+
+      def left
+        attribute
+      end
+
+      def right
+        attribute.quoted_array(values)
+      end
+
+      def table_name
+        attribute.relation.table_alias || attribute.relation.name
+      end
+
+      def column_name
+        attribute.name
+      end
+
+      def casted_values
+        type = attribute.type_caster
+
+        casted_values = values.map do |raw_value|
+          type.serialize(raw_value) if type.serializable?(raw_value)
+        end
+
+        casted_values.compact!
+        casted_values
+      end
+
+      def fetch_attribute(&block)
+        if attribute
+          yield attribute
+        else
+          expr.fetch_attribute(&block)
+        end
+      end
+
+      protected
+        def ivars
+          [@attribute, @values, @type]
+        end
+    end
+  end
+end