activerecord 6.0.1

data/lib/active_record/translation.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Translation
+    include ActiveModel::Translation
+
+    # Set the lookup ancestors for ActiveModel.
+    def lookup_ancestors #:nodoc:
+      klass = self
+      classes = [klass]
+      return classes if klass == ActiveRecord::Base
+
+      while !klass.base_class?
+        classes << klass = klass.superclass
+      end
+      classes
+    end
+
+    # Set the i18n scope to overwrite ActiveModel.
+    def i18n_scope #:nodoc:
+      :activerecord
+    end
+  end
+end

data/lib/active_record/type.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "active_model/type"
+
+require "active_record/type/internal/timezone"
+
+require "active_record/type/date"
+require "active_record/type/date_time"
+require "active_record/type/decimal_without_scale"
+require "active_record/type/json"
+require "active_record/type/time"
+require "active_record/type/text"
+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
+
+      def default_value # :nodoc:
+        @default_value ||= Value.new
+      end
+
+      private
+
+        def current_adapter_name
+          ActiveRecord::Base.connection.adapter_name.downcase.to_sym
+        end
+    end
+
+    BigInteger = ActiveModel::Type::BigInteger
+    Binary = ActiveModel::Type::Binary
+    Boolean = ActiveModel::Type::Boolean
+    Decimal = ActiveModel::Type::Decimal
+    Float = ActiveModel::Type::Float
+    Integer = ActiveModel::Type::Integer
+    String = ActiveModel::Type::String
+    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(:json, Type::Json, 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,129 @@
+# frozen_string_literal: true
+
+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
+
+      private
+        attr_reader :options, :klass
+
+        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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Type
+    class Date < ActiveModel::Type::Date
+      include Internal::Timezone
+    end
+  end
+end

data/lib/active_record/type/date_time.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Type
+    class DateTime < ActiveModel::Type::DateTime
+      include Internal::Timezone
+    end
+  end
+end

data/lib/active_record/type/decimal_without_scale.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Type
+    class DecimalWithoutScale < ActiveModel::Type::BigInteger # :nodoc:
+      def type
+        :decimal
+      end
+
+      def type_cast_for_schema(value)
+        value.to_s.inspect
+      end
+    end
+  end
+end

data/lib/active_record/type/hash_lookup_type_map.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Type
+    class HashLookupTypeMap < TypeMap # :nodoc:
+      def alias_type(type, alias_type)
+        register_type(type) { |_, *args| lookup(alias_type, *args) }
+      end
+
+      def key?(key)
+        @mapping.key?(key)
+      end
+
+      def keys
+        @mapping.keys
+      end
+
+      private
+
+        def perform_fetch(type, *args, &block)
+          @mapping.fetch(type, block).call(type, *args)
+        end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+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/json.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Type
+    class Json < ActiveModel::Type::Value
+      include ActiveModel::Type::Helpers::Mutable
+
+      def type
+        :json
+      end
+
+      def deserialize(value)
+        return value unless value.is_a?(::String)
+        ActiveSupport::JSON.decode(value) rescue nil
+      end
+
+      def serialize(value)
+        ActiveSupport::JSON.encode(value) unless value.nil?
+      end
+
+      def changed_in_place?(raw_old_value, new_value)
+        deserialize(raw_old_value) != new_value
+      end
+
+      def accessor
+        ActiveRecord::Store::StringKeyedHashAccessor
+      end
+    end
+  end
+end

data/lib/active_record/type/serialized.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Type
+    class Serialized < DelegateClass(ActiveModel::Type::Value) # :nodoc:
+      undef to_yaml if method_defined?(:to_yaml)
+
+      include ActiveModel::Type::Helpers::Mutable
+
+      attr_reader :subtype, :coder
+
+      def initialize(subtype, coder)
+        @subtype = subtype
+        @coder = coder
+        super(subtype)
+      end
+
+      def deserialize(value)
+        if default_value?(value)
+          value
+        else
+          coder.load(super)
+        end
+      end
+
+      def serialize(value)
+        return if value.nil?
+        unless default_value?(value)
+          super coder.dump(value)
+        end
+      end
+
+      def inspect
+        Kernel.instance_method(:inspect).bind(self).call
+      end
+
+      def changed_in_place?(raw_old_value, value)
+        return false if value.nil?
+        raw_new_value = encoded(value)
+        raw_old_value.nil? != raw_new_value.nil? ||
+          subtype.changed_in_place?(raw_old_value, raw_new_value)
+      end
+
+      def accessor
+        ActiveRecord::Store::IndifferentHashAccessor
+      end
+
+      def assert_valid_value(value)
+        if coder.respond_to?(:assert_valid_value)
+          coder.assert_valid_value(value, action: "serialize")
+        end
+      end
+
+      def force_equality?(value)
+        coder.respond_to?(:object_class) && value.is_a?(coder.object_class)
+      end
+
+      private
+
+        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/text.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Type
+    class Text < ActiveModel::Type::String # :nodoc:
+      def type
+        :text
+      end
+    end
+  end
+end

data/lib/active_record/type/time.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Type
+    class Time < ActiveModel::Type::Time
+      include Internal::Timezone
+
+      class Value < DelegateClass(::Time) # :nodoc:
+      end
+
+      def serialize(value)
+        case value = super
+        when ::Time
+          Value.new(value)
+        else
+          value
+        end
+      end
+    end
+  end
+end