activerecord 4.2.11.3 → 5.0.0.beta1

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(:date_time, 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/adapter_specific_registry.rb

@@ -0,0 +1,130 @@
+require 'active_model/type/registry'
+
+module ActiveRecord
+  # :stopdoc:
+  module Type
+    class AdapterSpecificRegistry < ActiveModel::Type::Registry
+      def add_modifier(options, klass, **args)
+        registrations << DecorationRegistration.new(options, klass, **args)
+      end
+
+      private
+
+      def registration_klass
+        Registration
+      end
+
+      def find_registration(symbol, *args)
+        registrations
+          .select { |registration| registration.matches?(symbol, *args) }
+          .max
+      end
+    end
+
+    class Registration
+      def initialize(name, block, adapter: nil, override: nil)
+        @name = name
+        @block = block
+        @adapter = adapter
+        @override = override
+      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
+      end
+
+      def matches?(type_name, *args, **kwargs)
+        type_name == name && matches_adapter?(**kwargs)
+      end
+
+      def <=>(other)
+        if conflicts_with?(other)
+          raise TypeConflictError.new("Type #{name} was registered for all
+                                      adapters, but shadows a native type with
+                                      the same name for #{other.adapter}".squish)
+        end
+        priority <=> other.priority
+      end
+
+      protected
+
+      attr_reader :name, :block, :adapter, :override
+
+      def priority
+        result = 0
+        if adapter
+          result |= 1
+        end
+        if override
+          result |= 2
+        end
+        result
+      end
+
+      def priority_except_adapter
+        priority & 0b111111100
+      end
+
+      private
+
+      def matches_adapter?(adapter: nil, **)
+        (self.adapter.nil? || adapter == self.adapter)
+      end
+
+      def conflicts_with?(other)
+        same_priority_except_adapter?(other) &&
+          has_adapter_conflict?(other)
+      end
+
+      def same_priority_except_adapter?(other)
+        priority_except_adapter == other.priority_except_adapter
+      end
+
+      def has_adapter_conflict?(other)
+        (override.nil? && other.adapter) ||
+          (adapter && other.override.nil?)
+      end
+    end
+
+    class DecorationRegistration < Registration
+      def initialize(options, klass, adapter: nil)
+        @options = options
+        @klass = klass
+        @adapter = adapter
+      end
+
+      def call(registry, *args, **kwargs)
+        subtype = registry.lookup(*args, **kwargs.except(*options.keys))
+        klass.new(subtype)
+      end
+
+      def matches?(*args, **kwargs)
+        matches_adapter?(**kwargs) && matches_options?(**kwargs)
+      end
+
+      def priority
+        super | 4
+      end
+
+      protected
+
+      attr_reader :options, :klass
+
+      private
+
+      def matches_options?(**kwargs)
+        options.all? do |key, value|
+          kwargs[key] == value
+        end
+      end
+    end
+  end
+
+  class TypeConflictError < StandardError
+  end
+  # :startdoc:
+end

data/lib/active_record/type/date.rb

@@ -1,50 +1,7 @@
 module ActiveRecord
   module Type
-    class Date < Value # :nodoc:
-      def type
-        :date
-      end
-
-      def klass
-        ::Date
-      end
-
-      def type_cast_for_database(value)
-        type_cast(value)
-      end
-
-      def type_cast_for_schema(value)
-        "'#{value.to_s(:db)}'"
-      end
-
-      private
-
-      def cast_value(value)
-        if value.is_a?(::String)
-          return if value.empty?
-          fast_string_to_date(value) || fallback_string_to_date(value)
-        elsif value.respond_to?(:to_date)
-          value.to_date
-        else
-          value
-        end
-      end
-
-      def fast_string_to_date(string)
-        if string =~ ConnectionAdapters::Column::Format::ISO_DATE
-          new_date $1.to_i, $2.to_i, $3.to_i
-        end
-      end
-
-      def fallback_string_to_date(string)
-        new_date(*::Date._parse(string, false).values_at(:year, :mon, :mday))
-      end
-
-      def new_date(year, mon, mday)
-        if year && year != 0
-          ::Date.new(year, mon, mday) rescue nil
-        end
-      end
+    class Date < ActiveModel::Type::Date
+      include Internal::Timezone
     end
   end
 end

data/lib/active_record/type/date_time.rb

@@ -1,54 +1,7 @@
 module ActiveRecord
   module Type
-    class DateTime < Value # :nodoc:
-      include TimeValue
-
-      def type
-        :datetime
-      end
-
-      def type_cast_for_database(value)
-        return super unless value.acts_like?(:time)
-
-        zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
-
-        if value.respond_to?(zone_conversion_method)
-          value = value.send(zone_conversion_method)
-        end
-
-        return value unless has_precision?
-
-        result = value.to_s(:db)
-        if value.respond_to?(:usec) && (1..6).cover?(precision)
-          "#{result}.#{sprintf("%0#{precision}d", value.usec / 10 ** (6 - precision))}"
-        else
-          result
-        end
-      end
-
-      private
-
-      alias has_precision? precision
-
-      def cast_value(string)
-        return string unless string.is_a?(::String)
-        return if string.empty?
-
-        fast_string_to_time(string) || fallback_string_to_time(string)
-      end
-
-      # '0.123456' -> 123456
-      # '1.123456' -> 123456
-      def microseconds(time)
-        time[:sec_fraction] ? (time[:sec_fraction] * 1_000_000).to_i : 0
-      end
-
-      def fallback_string_to_time(string)
-        time_hash = ::Date._parse(string)
-        time_hash[:sec_fraction] = microseconds(time_hash)
-
-        new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset))
-      end
+    class DateTime < ActiveModel::Type::DateTime
+      include Internal::Timezone
     end
   end
 end

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

@@ -0,0 +1,33 @@
+module ActiveRecord
+  module Type
+    module Internal # :nodoc:
+      class AbstractJson < ActiveModel::Type::Value # :nodoc:
+        include ActiveModel::Type::Helpers::Mutable
+
+        def type
+          :json
+        end
+
+        def deserialize(value)
+          if value.is_a?(::String)
+            ::ActiveSupport::JSON.decode(value) rescue nil
+          else
+            value
+          end
+        end
+
+        def serialize(value)
+          if value.is_a?(::Array) || value.is_a?(::Hash)
+            ::ActiveSupport::JSON.encode(value)
+          else
+            value
+          end
+        end
+
+        def accessor
+          ActiveRecord::Store::StringKeyedHashAccessor
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module ActiveRecord
+  module Type
+    module Internal
+      module Timezone
+        def is_utc?
+          ActiveRecord::Base.default_timezone == :utc
+        end
+
+        def default_timezone
+          ActiveRecord::Base.default_timezone
+        end
+      end
+    end
+  end
+end

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 = serialize(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

data/lib/active_record/type/time.rb

@@ -1,26 +1,8 @@
 module ActiveRecord
   module Type
-    class Time < Value # :nodoc:
-      include TimeValue
-
-      def type
-        :time
-      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))
-        end
-      end
+    class Time < ActiveModel::Type::Time
+      include Internal::Timezone
     end
   end
 end
+