activerecord 4.2.11.3 → 6.0.0

data/lib/active_record/validations/length.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Validations
+    class LengthValidator < ActiveModel::Validations::LengthValidator # :nodoc:
+      def validate_each(record, attribute, association_or_value)
+        if association_or_value.respond_to?(:loaded?) && association_or_value.loaded?
+          association_or_value = association_or_value.target.reject(&:marked_for_destruction?)
+        end
+        super
+      end
+    end
+
+    module ClassMethods
+      # Validates that the specified attributes match the length restrictions supplied.
+      # If the attribute is an association, records that are marked for destruction are not counted.
+      #
+      # See ActiveModel::Validations::HelperMethods.validates_length_of for more information.
+      def validates_length_of(*attr_names)
+        validates_with LengthValidator, _merge_attributes(attr_names)
+      end
+
+      alias_method :validates_size_of, :validates_length_of
+    end
+  end
+end

data/lib/active_record/validations/presence.rb

@@ -1,17 +1,13 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Validations
     class PresenceValidator < ActiveModel::Validations::PresenceValidator # :nodoc:
-      def validate(record)
-        super
-        attributes.each do |attribute|
-          next unless record.class._reflect_on_association(attribute)
-          associated_records = Array.wrap(record.send(attribute))
-
-          # Superclass validates presence. Ensure present records aren't about to be destroyed.
-          if associated_records.present? && associated_records.all? { |r| r.marked_for_destruction? }
-            record.errors.add(attribute, :blank, options)
-          end
+      def validate_each(record, attribute, association_or_value)
+        if record.class._reflect_on_association(attribute)
+          association_or_value = Array.wrap(association_or_value).reject(&:marked_for_destruction?)
         end
+        super
       end
     end
 
@@ -36,16 +32,21 @@ module ActiveRecord
       # This is due to the way Object#blank? handles boolean values:
       # <tt>false.blank? # => true</tt>.
       #
-      # This validator defers to the ActiveModel validation for presence, adding the
+      # 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.
       #
+      # 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
+      #   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>)
@@ -58,7 +59,7 @@ module ActiveRecord
       #   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 <tt>ActiveModel::Validation#validates!</tt> for more information.
+      #   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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Validations
     class UniquenessValidator < ActiveModel::EachValidator # :nodoc:
@@ -6,30 +8,28 @@ module ActiveRecord
           raise ArgumentError, "#{options[:conditions]} was passed as :conditions but is not callable. " \
                                "Pass a callable instead: `conditions: -> { where(approved: true) }`"
         end
-        super({ case_sensitive: true }.merge!(options))
+        unless Array(options[:scope]).all? { |scope| scope.respond_to?(:to_sym) }
+          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
         @klass = options[:class]
       end
 
       def validate_each(record, attribute, value)
         finder_class = find_finder_class_for(record)
-        table = finder_class.arel_table
         value = map_enum_attribute(finder_class, attribute, value)
 
-        begin
-          relation = build_relation(finder_class, table, attribute, value)
-          if record.persisted?
-            if finder_class.primary_key
-              relation = relation.and(table[finder_class.primary_key.to_sym].not_eq(record.id))
-            else
-              raise UnknownPrimaryKey.new(finder_class, "Can not validate uniqueness for persisted record without primary key.")
-            end
+        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)
+          else
+            raise UnknownPrimaryKey.new(finder_class, "Cannot validate uniqueness for persisted record without primary key.")
           end
-          relation = scope_relation(record, table, relation)
-          relation = finder_class.unscoped.where(relation)
-          relation = relation.merge(options[:conditions]) if options[:conditions]
-        rescue RangeError
-          relation = finder_class.none
         end
+        relation = scope_relation(record, relation)
+        relation = relation.merge(options[:conditions]) if options[:conditions]
 
         if relation.exists?
           error_options = options.except(:case_sensitive, :scope, :conditions)
@@ -39,13 +39,13 @@ module ActiveRecord
         end
       end
 
-    protected
+    private
       # The check for an existing value should be run from a class that
       # isn't abstract. This means working down from the current class
       # (self), to the first non-abstract class. Since classes don't know
       # their subclasses, we have to build the hierarchy between self and
       # the record's class.
-      def find_finder_class_for(record) #:nodoc:
+      def find_finder_class_for(record)
         class_hierarchy = [record.class]
 
         while class_hierarchy.first != @klass
@@ -55,43 +55,32 @@ module ActiveRecord
         class_hierarchy.detect { |klass| !klass.abstract_class? }
       end
 
-      def build_relation(klass, table, attribute, value) #:nodoc:
-        if reflection = klass._reflect_on_association(attribute)
-          attribute = reflection.foreign_key
-          value = value.attributes[reflection.klass.primary_key] unless value.nil?
-        end
-
-        attribute_name = attribute.to_s
+      def build_relation(klass, attribute, value)
+        relation = klass.unscoped
+        comparison = relation.bind_attribute(attribute, value) do |attr, bind|
+          return relation.none! if bind.unboundable?
 
-        # the attribute may be an aliased attribute
-        if klass.attribute_aliases[attribute_name]
-          attribute = klass.attribute_aliases[attribute_name]
-          attribute_name = attribute.to_s
-        end
-
-        column = klass.columns_hash[attribute_name]
-        value  = klass.connection.type_cast(value, column)
-        if value.is_a?(String) && column.limit
-          value = value.to_s[0, column.limit]
+          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
 
-        if !options[:case_sensitive] && value && column.text?
-          # 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
+        relation.where!(comparison)
       end
 
-      def scope_relation(record, table, relation)
+      def scope_relation(record, relation)
         Array(options[:scope]).each do |scope_item|
-          if reflection = record.class._reflect_on_association(scope_item)
-            scope_value = record.send(reflection.foreign_key)
-            scope_item  = reflection.foreign_key
+          scope_value = if record.class._reflect_on_association(scope_item)
+            record.association(scope_item).reader
           else
-            scope_value = record._read_attribute(scope_item)
+            record._read_attribute(scope_item)
           end
-          relation = relation.and(table[scope_item].eq(scope_value))
+          relation = relation.where(scope_item => scope_value)
         end
 
         relation
@@ -169,7 +158,8 @@ module ActiveRecord
       #
       # === Concurrency and integrity
       #
-      # Using this validation method in conjunction with ActiveRecord::Base#save
+      # Using this validation method in conjunction with
+      # {ActiveRecord::Base#save}[rdoc-ref:Persistence#save]
       # does not guarantee the absence of duplicate record insertions, because
       # uniqueness checks on the application level are inherently prone to race
       # conditions. For example, suppose that two users try to post a Comment at
@@ -203,21 +193,19 @@ module ActiveRecord
       #                                      | # Boom! We now have a duplicate
       #                                      | # title!
       #
-      # This could even happen if you use transactions with the 'serializable'
-      # isolation level. The best way to work around this problem is to add a unique
-      # index to the database table using
-      # ActiveRecord::ConnectionAdapters::SchemaStatements#add_index. In the
-      # rare case that a race condition occurs, the database will guarantee
+      # The best way to work around this problem is to add a unique index to the database table using
+      # {connection.add_index}[rdoc-ref:ConnectionAdapters::SchemaStatements#add_index].
+      # In the rare case that a race condition occurs, the database will guarantee
       # the field's uniqueness.
       #
       # When the database catches such a duplicate insertion,
-      # ActiveRecord::Base#save will raise an ActiveRecord::StatementInvalid
+      # {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
       # 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
-      # {optimistic concurrency control}[http://en.wikipedia.org/wiki/Optimistic_concurrency_control].
+      # {optimistic concurrency control}[https://en.wikipedia.org/wiki/Optimistic_concurrency_control].
       #
       # The bundled ActiveRecord::ConnectionAdapters distinguish unique index
       # constraint errors from other types of database errors by throwing an
@@ -227,7 +215,6 @@ module ActiveRecord
       #
       # The following bundled adapters throw the ActiveRecord::RecordNotUnique exception:
       #
-      # * ActiveRecord::ConnectionAdapters::MysqlAdapter.
       # * ActiveRecord::ConnectionAdapters::Mysql2Adapter.
       # * ActiveRecord::ConnectionAdapters::SQLite3Adapter.
       # * ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.

data/lib/active_record/version.rb

@@ -1,4 +1,6 @@
-require_relative 'gem_version'
+# frozen_string_literal: true
+
+require_relative "gem_version"
 
 module ActiveRecord
   # Returns the version of the currently loaded ActiveRecord as a <tt>Gem::Version</tt>

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

data/lib/arel/alias_predication.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module AliasPredication
+    def as(other)
+      Nodes::As.new self, Nodes::SqlLiteral.new(other)
+    end
+  end
+end

data/lib/arel/attributes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "arel/attributes/attribute"
+
+module Arel # :nodoc: all
+  module Attributes
+    ###
+    # Factory method to wrap a raw database +column+ to an Arel Attribute.
+    def self.for(column)
+      case column.type
+      when :string, :text, :binary             then String
+      when :integer                            then Integer
+      when :float                              then Float
+      when :decimal                            then Decimal
+      when :date, :datetime, :timestamp, :time then Time
+      when :boolean                            then Boolean
+      else
+        Undefined
+      end
+    end
+  end
+end

data/lib/arel/attributes/attribute.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Attributes
+    class Attribute < Struct.new :relation, :name
+      include Arel::Expressions
+      include Arel::Predications
+      include Arel::AliasPredication
+      include Arel::OrderPredications
+      include Arel::Math
+
+      ###
+      # Create a node for lowering this attribute
+      def lower
+        relation.lower self
+      end
+
+      def type_cast_for_database(value)
+        relation.type_cast_for_database(name, value)
+      end
+
+      def able_to_type_cast?
+        relation.able_to_type_cast?
+      end
+    end
+
+    class String    < Attribute; end
+    class Time      < Attribute; end
+    class Boolean   < Attribute; end
+    class Decimal   < Attribute; end
+    class Float     < Attribute; end
+    class Integer   < Attribute; end
+    class Undefined < Attribute; end
+  end
+
+  Attribute = Attributes::Attribute
+end

data/lib/arel/collectors/bind.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Collectors
+    class Bind
+      def initialize
+        @binds = []
+      end
+
+      def <<(str)
+        self
+      end
+
+      def add_bind(bind)
+        @binds << bind
+        self
+      end
+
+      def value
+        @binds
+      end
+    end
+  end
+end

data/lib/arel/collectors/composite.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Collectors
+    class Composite
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      def <<(str)
+        left << str
+        right << str
+        self
+      end
+
+      def add_bind(bind, &block)
+        left.add_bind bind, &block
+        right.add_bind bind, &block
+        self
+      end
+
+      def value
+        [left.value, right.value]
+      end
+
+      private
+        attr_reader :left, :right
+    end
+  end
+end

data/lib/arel/collectors/plain_string.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Collectors
+    class PlainString
+      def initialize
+        @str = +""
+      end
+
+      def value
+        @str
+      end
+
+      def <<(str)
+        @str << str
+        self
+      end
+    end
+  end
+end