activerecord 4.2.11.3 → 5.0.0

data/lib/active_record/type/serialized.rb

@@ -1,8 +1,7 @@
 module ActiveRecord
   module Type
-    class Serialized < DelegateClass(Type::Value) # :nodoc:
-      include Mutable
-      include Decorator
+    class Serialized < DelegateClass(ActiveModel::Type::Value) # :nodoc:
+      include ActiveModel::Type::Helpers::Mutable
 
       attr_reader :subtype, :coder
 
@@ -12,7 +11,7 @@ module ActiveRecord
         super(subtype)
       end
 
-      def type_cast_from_database(value)
+      def deserialize(value)
         if default_value?(value)
           value
         else
@@ -20,7 +19,7 @@ module ActiveRecord
         end
       end
 
-      def type_cast_for_database(value)
+      def serialize(value)
         return if value.nil?
         unless default_value?(value)
           super coder.dump(value)
@@ -33,7 +32,7 @@ module ActiveRecord
 
       def changed_in_place?(raw_old_value, value)
         return false if value.nil?
-        raw_new_value = type_cast_for_database(value)
+        raw_new_value = encoded(value)
         raw_old_value.nil? != raw_new_value.nil? ||
           subtype.changed_in_place?(raw_old_value, raw_new_value)
       end
@@ -42,14 +41,10 @@ module ActiveRecord
         ActiveRecord::Store::IndifferentHashAccessor
       end
 
-      def init_with(coder)
-        @coder = coder['coder']
-        super
-      end
-
-      def encode_with(coder)
-        coder['coder'] = @coder
-        super
+      def assert_valid_value(value)
+        if coder.respond_to?(:assert_valid_value)
+          coder.assert_valid_value(value)
+        end
       end
 
       private
@@ -57,6 +52,12 @@ module ActiveRecord
       def default_value?(value)
         value == coder.load(nil)
       end
+
+      def encoded(value)
+        unless default_value?(value)
+          coder.dump(value)
+        end
+      end
     end
   end
 end

data/lib/active_record/type/time.rb

@@ -1,26 +1,20 @@
 module ActiveRecord
   module Type
-    class Time < Value # :nodoc:
-      include TimeValue
+    class Time < ActiveModel::Type::Time
+      include Internal::Timezone
 
-      def type
-        :time
+      class Value < DelegateClass(::Time) # :nodoc:
       end
 
-      private
-
-      def cast_value(value)
-        return value unless value.is_a?(::String)
-        return if value.empty?
-
-        dummy_time_value = "2000-01-01 #{value}"
-
-        fast_string_to_time(dummy_time_value) || begin
-          time_hash = ::Date._parse(dummy_time_value)
-          return if time_hash[:hour].nil?
-          new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction))
+      def serialize(value)
+        case value = super
+        when ::Time
+          Value.new(value)
+        else
+          value
         end
       end
     end
   end
 end
+

data/lib/active_record/type/type_map.rb

@@ -1,12 +1,12 @@
-require 'thread_safe'
+require 'concurrent/map'
 
 module ActiveRecord
   module Type
     class TypeMap # :nodoc:
       def initialize
         @mapping = {}
-        @cache = ThreadSafe::Cache.new do |h, key|
-          h.fetch_or_store(key, ThreadSafe::Cache.new)
+        @cache = Concurrent::Map.new do |h, key|
+          h.fetch_or_store(key, Concurrent::Map.new)
         end
       end
 
@@ -57,7 +57,7 @@ module ActiveRecord
       end
 
       def default_value
-        @default_value ||= Value.new
+        @default_value ||= ActiveModel::Type::Value.new
       end
     end
   end

data/lib/active_record/type.rb

@@ -1,23 +1,72 @@
-require 'active_record/type/decorator'
-require 'active_record/type/mutable'
-require 'active_record/type/numeric'
-require 'active_record/type/time_value'
-require 'active_record/type/value'
-
-require 'active_record/type/big_integer'
-require 'active_record/type/binary'
-require 'active_record/type/boolean'
+require 'active_model/type'
+
+require 'active_record/type/internal/abstract_json'
+require 'active_record/type/internal/timezone'
+
 require 'active_record/type/date'
 require 'active_record/type/date_time'
-require 'active_record/type/decimal'
-require 'active_record/type/decimal_without_scale'
-require 'active_record/type/float'
-require 'active_record/type/integer'
-require 'active_record/type/serialized'
-require 'active_record/type/string'
-require 'active_record/type/text'
 require 'active_record/type/time'
-require 'active_record/type/unsigned_integer'
+
+require 'active_record/type/serialized'
+require 'active_record/type/adapter_specific_registry'
 
 require 'active_record/type/type_map'
 require 'active_record/type/hash_lookup_type_map'
+
+module ActiveRecord
+  module Type
+    @registry = AdapterSpecificRegistry.new
+
+    class << self
+      attr_accessor :registry # :nodoc:
+      delegate :add_modifier, to: :registry
+
+      # Add a new type to the registry, allowing it to be referenced as a
+      # symbol by {ActiveRecord::Base.attribute}[rdoc-ref:Attributes::ClassMethods#attribute].
+      # If your type is only meant to be used with a specific database adapter, you can
+      # do so by passing <tt>adapter: :postgresql</tt>. If your type has the same
+      # name as a native type for the current adapter, an exception will be
+      # raised unless you specify an +:override+ option. <tt>override: true</tt> will
+      # cause your type to be used instead of the native type. <tt>override:
+      # false</tt> will cause the native type to be used over yours if one exists.
+      def register(type_name, klass = nil, **options, &block)
+        registry.register(type_name, klass, **options, &block)
+      end
+
+      def lookup(*args, adapter: current_adapter_name, **kwargs) # :nodoc:
+        registry.lookup(*args, adapter: adapter, **kwargs)
+      end
+
+      private
+
+      def current_adapter_name
+        ActiveRecord::Base.connection.adapter_name.downcase.to_sym
+      end
+    end
+
+    Helpers = ActiveModel::Type::Helpers
+    BigInteger = ActiveModel::Type::BigInteger
+    Binary = ActiveModel::Type::Binary
+    Boolean = ActiveModel::Type::Boolean
+    Decimal = ActiveModel::Type::Decimal
+    DecimalWithoutScale = ActiveModel::Type::DecimalWithoutScale
+    Float = ActiveModel::Type::Float
+    Integer = ActiveModel::Type::Integer
+    String = ActiveModel::Type::String
+    Text = ActiveModel::Type::Text
+    UnsignedInteger = ActiveModel::Type::UnsignedInteger
+    Value = ActiveModel::Type::Value
+
+    register(:big_integer, Type::BigInteger, override: false)
+    register(:binary, Type::Binary, override: false)
+    register(:boolean, Type::Boolean, override: false)
+    register(:date, Type::Date, override: false)
+    register(:datetime, Type::DateTime, override: false)
+    register(:decimal, Type::Decimal, override: false)
+    register(:float, Type::Float, override: false)
+    register(:integer, Type::Integer, override: false)
+    register(:string, Type::String, override: false)
+    register(:text, Type::Text, override: false)
+    register(:time, Type::Time, override: false)
+  end
+end

data/lib/active_record/type_caster/connection.rb

@@ -0,0 +1,29 @@
+module ActiveRecord
+  module TypeCaster
+    class Connection # :nodoc:
+      def initialize(klass, table_name)
+        @klass = klass
+        @table_name = table_name
+      end
+
+      def type_cast_for_database(attribute_name, value)
+        return value if value.is_a?(Arel::Nodes::BindParam)
+        column = column_for(attribute_name)
+        connection.type_cast_from_column(column, value)
+      end
+
+      protected
+
+      attr_reader :table_name
+      delegate :connection, to: :@klass
+
+      private
+
+      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
+      end
+    end
+  end
+end

data/lib/active_record/type_caster/map.rb

@@ -0,0 +1,19 @@
+module ActiveRecord
+  module TypeCaster
+    class Map # :nodoc:
+      def initialize(types)
+        @types = types
+      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.to_s)
+        type.serialize(value)
+      end
+
+      protected
+
+      attr_reader :types
+    end
+  end
+end

data/lib/active_record/type_caster.rb

@@ -0,0 +1,7 @@
+require 'active_record/type_caster/map'
+require 'active_record/type_caster/connection'
+
+module ActiveRecord
+  module TypeCaster # :nodoc:
+  end
+end

data/lib/active_record/validations/absence.rb

@@ -0,0 +1,23 @@
+module ActiveRecord
+  module Validations
+    class AbsenceValidator < ActiveModel::Validations::AbsenceValidator # :nodoc:
+      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
+
+    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.
+      #
+      # See ActiveModel::Validations::HelperMethods.validates_absence_of for more information.
+      def validates_absence_of(*attr_names)
+        validates_with AbsenceValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/active_record/validations/associated.rb

@@ -2,10 +2,16 @@ module ActiveRecord
   module Validations
     class AssociatedValidator < ActiveModel::EachValidator #:nodoc:
       def validate_each(record, attribute, value)
-        if Array.wrap(value).reject {|r| r.marked_for_destruction? || r.valid?}.any?
-          record.errors.add(attribute, :invalid, options.merge(:value => value))
+        if Array(value).reject { |r| valid_object?(r) }.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?
+        end
     end
 
     module ClassMethods
@@ -24,7 +30,8 @@ module ActiveRecord
       #
       # NOTE: This validation will not fail if the association hasn't been
       # assigned. If you want to ensure that the association is both present and
-      # guaranteed to be valid, you also need to use +validates_presence_of+.
+      # guaranteed to be valid, you also need to use
+      # {validates_presence_of}[rdoc-ref:Validations::ClassMethods#validates_presence_of].
       #
       # Configuration options:
       #

data/lib/active_record/validations/length.rb

@@ -0,0 +1,24 @@
+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,11 @@
 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,12 +30,17 @@ 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.
@@ -58,7 +57,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::Validation#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

@@ -15,21 +15,16 @@ module ActiveRecord
         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, table, attribute, value)
+        if record.persisted?
+          if finder_class.primary_key
+            relation = relation.where.not(finder_class.primary_key => record.id_was || record.id)
+          else
+            raise UnknownPrimaryKey.new(finder_class, "Can not 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, table, relation)
+        relation = relation.merge(options[:conditions]) if options[:conditions]
 
         if relation.exists?
           error_options = options.except(:case_sensitive, :scope, :conditions)
@@ -61,26 +56,32 @@ module ActiveRecord
           value = value.attributes[reflection.klass.primary_key] unless value.nil?
         end
 
-        attribute_name = attribute.to_s
-
         # the attribute may be an aliased attribute
-        if klass.attribute_aliases[attribute_name]
-          attribute = klass.attribute_aliases[attribute_name]
-          attribute_name = attribute.to_s
+        if klass.attribute_alias?(attribute)
+          attribute = klass.attribute_alias(attribute)
         end
 
+        attribute_name = attribute.to_s
+
         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]
-        end
+        cast_type = klass.type_for_attribute(attribute_name)
+        value = cast_type.serialize(value)
+        value = klass.connection.type_cast(value)
 
-        if !options[:case_sensitive] && value && column.text?
+        comparison = if !options[:case_sensitive] && !value.nil?
           # 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
+        if value.nil?
+          klass.unscoped.where(comparison)
+        else
+          bind = Relation::QueryAttribute.new(attribute_name, value, Type::Value.new)
+          klass.unscoped.where(comparison, bind)
+        end
+      rescue RangeError
+        klass.none
       end
 
       def scope_relation(record, table, relation)
@@ -91,7 +92,7 @@ module ActiveRecord
           else
             scope_value = 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 +170,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
@@ -206,12 +208,12 @@ module ActiveRecord
       # 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
+      # {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
@@ -227,7 +229,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/validations.rb

@@ -1,8 +1,9 @@
 module ActiveRecord
-  # = Active Record RecordInvalid
+  # = Active Record \RecordInvalid
   #
-  # Raised by <tt>save!</tt> and <tt>create!</tt> when the record is invalid. Use the
-  # +record+ method to retrieve the record which did not validate.
+  # Raised by {ActiveRecord::Base#save!}[rdoc-ref:Persistence#save!] and
+  # {ActiveRecord::Base#create!}[rdoc-ref:Persistence::ClassMethods#create!] when the record is invalid.
+  # Use the #record method to retrieve the record which did not validate.
   #
   #   begin
   #     complex_operation_that_internally_calls_save!
@@ -12,70 +13,68 @@ module ActiveRecord
   class RecordInvalid < ActiveRecordError
     attr_reader :record
 
-    def initialize(record)
-      @record = record
-      errors = @record.errors.full_messages.join(", ")
-      super(I18n.t(:"#{@record.class.i18n_scope}.errors.messages.record_invalid", :errors => errors, :default => :"errors.messages.record_invalid"))
+    def initialize(record = nil)
+      if record
+        @record = record
+        errors = @record.errors.full_messages.join(", ")
+        message = I18n.t(:"#{@record.class.i18n_scope}.errors.messages.record_invalid", errors: errors, default: :"errors.messages.record_invalid")
+      else
+        message = "Record invalid"
+      end
+
+      super(message)
     end
   end
 
-  # = Active Record Validations
+  # = Active Record \Validations
   #
-  # Active Record includes the majority of its validations from <tt>ActiveModel::Validations</tt>
+  # 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
-  # <tt>new_record?</tt>.
+  # {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 regular Base#save method is replaced with this when the validations
-    # module is mixed in, which it is by default.
+    # 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={})
       perform_validations(options) ? super : false
     end
 
-    # Attempts to save the record just like Base#save but will raise a +RecordInvalid+
-    # exception instead of returning +false+ if the record is not valid.
+    # 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={})
-      perform_validations(options) ? super : raise_record_invalid
+      perform_validations(options) ? super : raise_validation_error
     end
 
     # Runs all the validations within the specified context. Returns +true+ if
     # no errors are found, +false+ otherwise.
     #
-    # Aliased as validate.
+    # Aliased as #validate.
     #
     # If the argument is +false+ (default is +nil+), the context is set to <tt>:create</tt> if
-    # <tt>new_record?</tt> is +true+, and to <tt>:update</tt> if it is not.
+    # {new_record?}[rdoc-ref:Persistence#new_record?] is +true+, and to <tt>:update</tt> if it is not.
     #
-    # Validations with no <tt>:on</tt> option will run no matter the context. Validations with
+    # \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.
     def valid?(context = nil)
-      context ||= (new_record? ? :create : :update)
+      context ||= default_validation_context
       output = super(context)
       errors.empty? && output
     end
 
     alias_method :validate, :valid?
 
-    # Runs all the validations within the specified context. Returns +true+ if
-    # no errors are found, raises +RecordInvalid+ otherwise.
-    #
-    # If the argument is +false+ (default is +nil+), the context is set to <tt>:create</tt> if
-    # <tt>new_record?</tt> is +true+, and to <tt>:update</tt> if it is not.
-    #
-    # 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.
-    def validate!(context = nil)
-      valid?(context) || raise_record_invalid
-    end
-
   protected
 
-    def raise_record_invalid
+    def default_validation_context
+      new_record? ? :create : :update
+    end
+
+    def raise_validation_error
       raise(RecordInvalid.new(self))
     end
 
@@ -88,3 +87,5 @@ end
 require "active_record/validations/associated"
 require "active_record/validations/uniqueness"
 require "active_record/validations/presence"
+require "active_record/validations/absence"
+require "active_record/validations/length"