activerecord 6.0.6 → 6.1.0

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,7 +5,7 @@ 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
 

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

@@ -91,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,17 +31,18 @@ require "yaml"
 
 require "active_record/version"
 require "active_model/attribute_set"
+require "active_record/errors"
 
 module ActiveRecord
   extend ActiveSupport::Autoload
 
-  autoload :AdvisoryLockBase
   autoload :Base
   autoload :Callbacks
   autoload :Core
   autoload :ConnectionHandling
   autoload :CounterCache
   autoload :DynamicMatchers
+  autoload :DelegatedType
   autoload :Enum
   autoload :InternalMetadata
   autoload :Explain
@@ -68,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
@@ -137,14 +137,6 @@ module ActiveRecord
     end
   end
 
-  module ConnectionAdapters
-    extend ActiveSupport::Autoload
-
-    eager_autoload do
-      autoload :AbstractAdapter
-    end
-  end
-
   module Scoping
     extend ActiveSupport::Autoload
 
@@ -194,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

data/lib/arel/nodes/in.rb

@@ -2,7 +2,14 @@
 
 module Arel # :nodoc: all
   module Nodes
-    class In < Equality
+    class In < Arel::Nodes::Binary
+      include FetchAttribute
+
+      def equality?; true; end
+
+      def invert
+        Arel::Nodes::NotIn.new(left, right)
+      end
     end
   end
 end

data/lib/arel/nodes/infix_operation.rb

@@ -43,7 +43,19 @@ module Arel # :nodoc: all
 
     class Concat < InfixOperation
       def initialize(left, right)
-        super("||", left, right)
+        super(:"||", left, right)
+      end
+    end
+
+    class Contains < InfixOperation
+      def initialize(left, right)
+        super(:"@>", left, right)
+      end
+    end
+
+    class Overlaps < InfixOperation
+      def initialize(left, right)
+        super(:"&&", left, right)
       end
     end
 

data/lib/arel/nodes/join_source.rb

@@ -5,7 +5,7 @@ module Arel # :nodoc: all
     ###
     # Class that represents a join source
     #
-    #   http://www.sqlite.org/syntaxdiagrams.html#join-source
+    #   https://www.sqlite.org/syntaxdiagrams.html#join-source
 
     class JoinSource < Arel::Nodes::Binary
       def initialize(single_source, joinop = [])

data/lib/arel/nodes/node.rb

@@ -6,7 +6,6 @@ module Arel # :nodoc: all
     # Abstract base class for all AST nodes
     class Node
       include Arel::FactoryMethods
-      include Enumerable
 
       ###
       # Factory method to create a Nodes::Not node that has the recipient of
@@ -28,6 +27,10 @@ module Arel # :nodoc: all
         Nodes::And.new [self, right]
       end
 
+      def invert
+        Arel::Nodes::Not.new(self)
+      end
+
       # FIXME: this method should go away.  I don't like people calling
       # to_sql on non-head nodes.  This forces us to walk the AST until we
       # can find a node that has a "relation" member.
@@ -39,12 +42,10 @@ module Arel # :nodoc: all
         collector.value
       end
 
-      # Iterate through AST, nodes will be yielded depth-first
-      def each(&block)
-        return enum_for(:each) unless block_given?
-
-        ::Arel::Visitors::DepthFirst.new(block).accept self
+      def fetch_attribute
       end
+
+      def equality?; false; end
     end
   end
 end

data/lib/arel/nodes/ordering.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Ordering < Unary
+      def nulls_first
+        NullsFirst.new(self)
+      end
+
+      def nulls_last
+        NullsLast.new(self)
+      end
+    end
+
+    class NullsFirst < Ordering
+      def reverse
+        NullsLast.new(expr.reverse)
+      end
+    end
+
+    class NullsLast < Ordering
+      def reverse
+        NullsFirst.new(expr.reverse)
+      end
+    end
+  end
+end