omg-activerecord 8.0.0.alpha1

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,57 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Type
+    class HashLookupTypeMap # :nodoc:
+      def initialize(parent = nil)
+        @mapping = {}
+        @cache = Concurrent::Map.new do |h, key|
+          h.fetch_or_store(key, Concurrent::Map.new)
+        end
+      end
+
+      def lookup(lookup_key, *args)
+        fetch(lookup_key, *args) { Type.default_value }
+      end
+
+      def fetch(lookup_key, *args, &block)
+        @cache[lookup_key].fetch_or_store(args) do
+          perform_fetch(lookup_key, *args, &block)
+        end
+      end
+
+      def register_type(key, value = nil, &block)
+        raise ::ArgumentError unless value || block
+
+        if block
+          @mapping[key] = block
+        else
+          @mapping[key] = proc { value }
+        end
+        @cache.clear
+      end
+
+      def clear
+        @mapping.clear
+        @cache.clear
+      end
+
+      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,22 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Type
+    module Internal
+      module Timezone
+        def initialize(timezone: nil, **kwargs)
+          super(**kwargs)
+          @timezone = timezone
+        end
+
+        def is_utc?
+          default_timezone == :utc
+        end
+
+        def default_timezone
+          @timezone || ActiveRecord.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,76 @@
+# 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
+
+      define_method(:inspect, Kernel.instance_method(:inspect))
+
+      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
+
+      def serialized? # :nodoc:
+        true
+      end
+
+      private
+        def default_value?(value)
+          value == coder.load(nil)
+        end
+
+        def encoded(value)
+          return if default_value?(value)
+          payload = coder.dump(value)
+          if payload && @subtype.binary?
+            ActiveModel::Type::Binary::Data.new(payload)
+          else
+            payload
+          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,35 @@
+# 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
+
+      def serialize_cast_value(value) # :nodoc:
+        Value.new(super) if value
+      end
+
+      private
+        def cast_value(value)
+          case value = super
+          when Value
+            value.__getobj__
+          else
+            value
+          end
+        end
+    end
+  end
+end

data/lib/active_record/type/type_map.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+
+module ActiveRecord
+  module Type
+    class TypeMap # :nodoc:
+      def initialize(parent = nil)
+        @mapping = {}
+        @parent = parent
+        @cache = Concurrent::Map.new
+      end
+
+      def lookup(lookup_key)
+        fetch(lookup_key) { Type.default_value }
+      end
+
+      def fetch(lookup_key, &block)
+        @cache.fetch_or_store(lookup_key) do
+          perform_fetch(lookup_key, &block)
+        end
+      end
+
+      def register_type(key, value = nil, &block)
+        raise ::ArgumentError unless value || block
+
+        if block
+          @mapping[key] = block
+        else
+          @mapping[key] = proc { value }
+        end
+        @cache.clear
+      end
+
+      def alias_type(key, target_key)
+        register_type(key) do |sql_type|
+          metadata = sql_type[/\(.*\)/, 0]
+          lookup("#{target_key}#{metadata}")
+        end
+      end
+
+      protected
+        def perform_fetch(lookup_key, &block)
+          matching_pair = @mapping.reverse_each.detect do |key, _|
+            key === lookup_key
+          end
+
+          if matching_pair
+            matching_pair.last.call(lookup_key)
+          elsif @parent
+            @parent.perform_fetch(lookup_key, &block)
+          else
+            yield lookup_key
+          end
+        end
+    end
+  end
+end

data/lib/active_record/type/unsigned_integer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Type
+    class UnsignedInteger < ActiveModel::Type::Integer # :nodoc:
+      private
+        def max_value
+          super * 2
+        end
+
+        def min_value
+          0
+        end
+    end
+  end
+end

data/lib/active_record/type.rb

@@ -0,0 +1,83 @@
+# 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
+
+      def adapter_name_from(model) # :nodoc:
+        model.connection_db_config.adapter.to_sym
+      end
+
+      private
+        def current_adapter_name
+          adapter_name_from(ActiveRecord::Base)
+        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
+    ImmutableString = ActiveModel::Type::ImmutableString
+    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(:immutable_string, Type::ImmutableString, 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_caster/connection.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module TypeCaster
+    class Connection # :nodoc:
+      def initialize(klass, table_name)
+        @klass = klass
+        @table_name = table_name
+      end
+
+      def type_cast_for_database(attr_name, value)
+        type = type_for_attribute(attr_name)
+        type.serialize(value)
+      end
+
+      def type_for_attribute(attr_name)
+        schema_cache = @klass.schema_cache
+
+        if schema_cache.data_source_exists?(table_name)
+          column = schema_cache.columns_hash(table_name)[attr_name.to_s]
+          if column
+            type = @klass.with_connection { |connection| connection.lookup_cast_type_from_column(column) }
+          end
+        end
+
+        type || Type.default_value
+      end
+
+      private
+        attr_reader :table_name
+    end
+  end
+end

data/lib/active_record/type_caster/map.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module TypeCaster
+    class Map # :nodoc:
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def type_cast_for_database(attr_name, value)
+        type = type_for_attribute(attr_name)
+        type.serialize(value)
+      end
+
+      def type_for_attribute(name)
+        klass.type_for_attribute(name)
+      end
+
+      private
+        attr_reader :klass
+    end
+  end
+end

data/lib/active_record/type_caster.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+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,25 @@
+# frozen_string_literal: true
+
+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 also considered not present if it is 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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Validations
+    class AssociatedValidator < ActiveModel::EachValidator # :nodoc:
+      def validate_each(record, attribute, value)
+        context = record_validation_context_for_association(record)
+
+        if Array(value).reject { |association| valid_object?(association, context) }.any?
+          record.errors.add(attribute, :invalid, **options.merge(value: value))
+        end
+      end
+
+      private
+        def valid_object?(record, context)
+          (record.respond_to?(:marked_for_destruction?) && record.marked_for_destruction?) || record.valid?(context)
+        end
+
+        def record_validation_context_for_association(record)
+          record.custom_validation_context? ? record.validation_context : nil
+        end
+    end
+
+    module ClassMethods
+      # Validates whether the associated object or objects are all valid.
+      # Works with any kind of association.
+      #
+      #   class Book < ActiveRecord::Base
+      #     has_many :pages
+      #     belongs_to :library
+      #
+      #     validates_associated :pages, :library
+      #   end
+      #
+      # WARNING: This validation must not be used on both ends of an association.
+      # Doing so will lead to a circular dependency and cause infinite recursion.
+      #
+      # 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}[rdoc-ref:Validations::ClassMethods#validates_presence_of].
+      #
+      # Configuration options:
+      #
+      # * <tt>:message</tt> - A custom error message (default is: "is invalid").
+      # * <tt>:on</tt> - Specifies the contexts where this validation is active.
+      #   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>)
+      # * <tt>:if</tt> - Specifies a method, proc, or string to call to determine
+      #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
+      #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
+      #   proc or string should return or evaluate to a +true+ or +false+ value.
+      # * <tt>:unless</tt> - Specifies a method, proc, or string to call to
+      #   determine if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
+      #   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.
+      def validates_associated(*attr_names)
+        validates_with AssociatedValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

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/numericality.rb

@@ -0,0 +1,36 @@
+# 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) || Float::DIG, Float::DIG].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