omg-activemodel 8.0.0.alpha1

data/lib/active_model/type/helpers/time_value.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/zones"
+require "active_support/core_ext/time/zones"
+
+module ActiveModel
+  module Type
+    module Helpers # :nodoc: all
+      module TimeValue
+        def serialize_cast_value(value)
+          value = apply_seconds_precision(value)
+
+          if value.acts_like?(:time)
+            if is_utc?
+              value = value.getutc if !value.utc?
+            else
+              value = value.getlocal
+            end
+          end
+
+          value
+        end
+
+        def apply_seconds_precision(value)
+          return value unless precision && value.respond_to?(:nsec)
+
+          number_of_insignificant_digits = 9 - precision
+          round_power = 10**number_of_insignificant_digits
+          rounded_off_nsec = value.nsec % round_power
+
+          if rounded_off_nsec > 0
+            value.change(nsec: value.nsec - rounded_off_nsec)
+          else
+            value
+          end
+        end
+
+        def type_cast_for_schema(value)
+          value.to_fs(:db).inspect
+        end
+
+        def user_input_in_time_zone(value)
+          value.in_time_zone
+        end
+
+        private
+          def new_time(year, mon, mday, hour, min, sec, microsec, offset = nil)
+            # Treat 0000-00-00 00:00:00 as nil.
+            return if year.nil? || (year == 0 && mon == 0 && mday == 0)
+
+            if offset
+              time = ::Time.utc(year, mon, mday, hour, min, sec, microsec) rescue nil
+              return unless time
+
+              time -= offset unless offset == 0
+              is_utc? ? time : time.getlocal
+            elsif is_utc?
+              ::Time.utc(year, mon, mday, hour, min, sec, microsec) rescue nil
+            else
+              ::Time.local(year, mon, mday, hour, min, sec, microsec) rescue nil
+            end
+          end
+
+          ISO_DATETIME = /
+            \A
+            (\d{4})-(\d\d)-(\d\d)(?:T|\s)            # 2020-06-20T
+            (\d\d):(\d\d):(\d\d)(?:\.(\d{1,6})\d*)?  # 10:20:30.123456
+            (?:(Z(?=\z)|[+-]\d\d)(?::?(\d\d))?)?     # +09:00
+            \z
+          /x
+
+          if RUBY_VERSION >= "3.2"
+            if Time.new(2000, 1, 1, 0, 0, 0, "-00:00").yday != 1 # Early 3.2.x had a bug
+              # BUG: Wrapping the Time object with Time.at because Time.new with `in:` in Ruby 3.2.0
+              # used to return an invalid Time object
+              # see: https://bugs.ruby-lang.org/issues/19292
+              def fast_string_to_time(string)
+                return unless string.include?("-") #  Time.new("1234") # => 1234-01-01 00:00:00
+
+                if is_utc?
+                  ::Time.at(::Time.new(string, in: "UTC"))
+                else
+                  ::Time.new(string)
+                end
+              rescue ArgumentError
+                nil
+              end
+            else
+              def fast_string_to_time(string)
+                return unless string.include?("-") #  Time.new("1234") # => 1234-01-01 00:00:00
+
+                if is_utc?
+                  ::Time.new(string, in: "UTC")
+                else
+                  ::Time.new(string)
+                end
+              rescue ArgumentError
+                nil
+              end
+            end
+          else
+            def fast_string_to_time(string)
+              return unless ISO_DATETIME =~ string
+
+              usec = $7.to_i
+              usec_len = $7&.length
+              if usec_len&.< 6
+                usec *= 10**(6 - usec_len)
+              end
+
+              if $8
+                offset = \
+                  if $8 == "Z"
+                    0
+                  else
+                    offset_h, offset_m = $8.to_i, $9.to_i
+                    offset_h.to_i * 3600 + (offset_h.negative? ? -1 : 1) * offset_m * 60
+                  end
+              end
+
+              new_time($1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, usec, offset)
+            end
+          end
+      end
+    end
+  end
+end

data/lib/active_model/type/helpers/timezone.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/time/zones"
+
+module ActiveModel
+  module Type
+    module Helpers # :nodoc: all
+      module Timezone
+        def is_utc?
+          if default = ::Time.zone_default
+            default.name == "UTC"
+          else
+            true
+          end
+        end
+
+        def default_timezone
+          is_utc? ? :utc : :local
+        end
+      end
+    end
+  end
+end

data/lib/active_model/type/helpers.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "active_model/type/helpers/accepts_multiparameter_time"
+require "active_model/type/helpers/numeric"
+require "active_model/type/helpers/mutable"
+require "active_model/type/helpers/time_value"
+require "active_model/type/helpers/timezone"

data/lib/active_model/type/immutable_string.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    # = Active Model \ImmutableString \Type
+    #
+    # Attribute type to represent immutable strings. It casts incoming values to
+    # frozen strings.
+    #
+    #   class Person
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :name, :immutable_string
+    #   end
+    #
+    #   person = Person.new
+    #   person.name = 1
+    #
+    #   person.name # => "1"
+    #   person.name.frozen? # => true
+    #
+    # Values are coerced to strings using their +to_s+ method. Boolean values
+    # are treated differently, however: +true+ will be cast to <tt>"t"</tt> and
+    # +false+ will be cast to <tt>"f"</tt>. These strings can be customized when
+    # declaring an attribute:
+    #
+    #   class Person
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :active, :immutable_string, true: "aye", false: "nay"
+    #   end
+    #
+    #   person = Person.new
+    #   person.active = true
+    #
+    #   person.active # => "aye"
+    class ImmutableString < Value
+      def initialize(**args)
+        @true  = -(args.delete(:true)&.to_s  || "t")
+        @false = -(args.delete(:false)&.to_s || "f")
+        super
+      end
+
+      def type
+        :string
+      end
+
+      def serialize(value)
+        case value
+        when ::Numeric, ::Symbol, ActiveSupport::Duration then value.to_s
+        when true then @true
+        when false then @false
+        else super
+        end
+      end
+
+      def serialize_cast_value(value) # :nodoc:
+        value
+      end
+
+      private
+        def cast_value(value)
+          case value
+          when true then @true
+          when false then @false
+          else value.to_s.freeze
+          end
+        end
+    end
+  end
+end

data/lib/active_model/type/integer.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    # = Active Model \Integer \Type
+    #
+    # Attribute type for integer representation. This type is registered under
+    # the +:integer+ key.
+    #
+    #   class Person
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :age, :integer
+    #   end
+    #
+    # Values are cast using their +to_i+ method, except for blank strings, which
+    # are cast to +nil+. If a +to_i+ method is not defined or raises an error,
+    # the value will be cast to +nil+.
+    #
+    #   person = Person.new
+    #
+    #   person.age = "18"
+    #   person.age # => 18
+    #
+    #   person.age = ""
+    #   person.age # => nil
+    #
+    #   person.age = :not_an_integer
+    #   person.age # => nil (because Symbol does not define #to_i)
+    #
+    # Serialization also works under the same principle. Non-numeric strings are
+    # serialized as +nil+, for example.
+    #
+    # Serialization also validates that the integer can be stored using a
+    # limited number of bytes. If it cannot, an ActiveModel::RangeError will be
+    # raised. The default limit is 4 bytes, and can be customized when declaring
+    # an attribute:
+    #
+    #   class Person
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :age, :integer, limit: 6
+    #   end
+    class Integer < Value
+      include Helpers::Numeric
+
+      # Column storage size in bytes.
+      # 4 bytes means an integer as opposed to smallint etc.
+      DEFAULT_LIMIT = 4
+
+      def initialize(**)
+        super
+        @range = min_value...max_value
+      end
+
+      def type
+        :integer
+      end
+
+      def deserialize(value)
+        return if value.blank?
+        value.to_i
+      end
+
+      def serialize(value)
+        return if value.is_a?(::String) && non_numeric_string?(value)
+        ensure_in_range(super)
+      end
+
+      def serialize_cast_value(value) # :nodoc:
+        ensure_in_range(value)
+      end
+
+      def serializable?(value)
+        cast_value = cast(value)
+        in_range?(cast_value) || begin
+          yield cast_value if block_given?
+          false
+        end
+      end
+
+      private
+        attr_reader :range
+
+        def in_range?(value)
+          !value || range.member?(value)
+        end
+
+        def cast_value(value)
+          value.to_i rescue nil
+        end
+
+        def ensure_in_range(value)
+          unless in_range?(value)
+            raise ActiveModel::RangeError, "#{value} is out of range for #{self.class} with limit #{_limit} bytes"
+          end
+          value
+        end
+
+        def max_value
+          1 << (_limit * 8 - 1) # 8 bits per byte with one bit for sign
+        end
+
+        def min_value
+          -max_value
+        end
+
+        def _limit
+          limit || DEFAULT_LIMIT
+        end
+    end
+  end
+end

data/lib/active_model/type/registry.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    class Registry # :nodoc:
+      def initialize
+        @registrations = {}
+      end
+
+      def initialize_copy(other)
+        @registrations = @registrations.dup
+        super
+      end
+
+      def register(type_name, klass = nil, &block)
+        unless block_given?
+          block = proc { |_, *args| klass.new(*args) }
+          block.ruby2_keywords if block.respond_to?(:ruby2_keywords)
+        end
+        registrations[type_name] = block
+      end
+
+      def lookup(symbol, ...)
+        registration = registrations[symbol]
+
+        if registration
+          registration.call(symbol, ...)
+        else
+          raise ArgumentError, "Unknown type #{symbol.inspect}"
+        end
+      end
+
+      private
+        attr_reader :registrations
+    end
+  end
+end

data/lib/active_model/type/serialize_cast_value.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    module SerializeCastValue # :nodoc:
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def serialize_cast_value_compatible?
+          return @serialize_cast_value_compatible if defined?(@serialize_cast_value_compatible)
+          @serialize_cast_value_compatible = ancestors.index(instance_method(:serialize_cast_value).owner) <= ancestors.index(instance_method(:serialize).owner)
+        end
+      end
+
+      module DefaultImplementation
+        def serialize_cast_value(value)
+          value
+        end
+      end
+
+      def self.included(klass)
+        klass.include DefaultImplementation unless klass.method_defined?(:serialize_cast_value)
+      end
+
+      def self.serialize(type, value)
+        # Using `type.equal?(type.itself_if_...)` is a performant way to also
+        # ensure that `type` is not just a DelegateClass instance (e.g.
+        # ActiveRecord::Type::Serialized) unintentionally delegating
+        # SerializeCastValue methods.
+        if type.equal?((type.itself_if_serialize_cast_value_compatible rescue nil))
+          type.serialize_cast_value(value)
+        else
+          type.serialize(value)
+        end
+      end
+
+      def itself_if_serialize_cast_value_compatible
+        self if self.class.serialize_cast_value_compatible?
+      end
+
+      def initialize(...)
+        super
+        self.class.serialize_cast_value_compatible? # eagerly compute
+      end
+    end
+  end
+end

data/lib/active_model/type/string.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "active_model/type/immutable_string"
+
+module ActiveModel
+  module Type
+    # = Active Model \String \Type
+    #
+    # Attribute type for strings. It is registered under the +:string+ key.
+    #
+    # This class is a specialization of ActiveModel::Type::ImmutableString. It
+    # performs coercion in the same way, and can be configured in the same way.
+    # However, it accounts for mutable strings, so dirty tracking can properly
+    # check if a string has changed.
+    class String < ImmutableString
+      def changed_in_place?(raw_old_value, new_value)
+        if new_value.is_a?(::String)
+          raw_old_value != new_value
+        end
+      end
+
+      def to_immutable_string
+        ImmutableString.new(
+          true: @true,
+          false: @false,
+          limit: limit,
+          precision: precision,
+          scale: scale,
+        )
+      end
+
+      private
+        def cast_value(value)
+          case value
+          when ::String then ::String.new(value)
+          when true then @true
+          when false then @false
+          else value.to_s
+          end
+        end
+    end
+  end
+end

data/lib/active_model/type/time.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    # = Active Model \Time \Type
+    #
+    # Attribute type for time of day representation. It is registered under the
+    # +:time+ key.
+    #
+    #   class Event
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :start, :time
+    #   end
+    #
+    # String values are parsed using the ISO 8601 datetime format, but are
+    # normalized to have a date of 2000-01-01 and be in the UTC time zone.
+    #
+    #   event = Event.new
+    #   event.start = "2004-10-25T01:23:45-06:00"
+    #
+    #   event.start.class # => Time
+    #   event.start       # => 2000-01-01 07:23:45 UTC
+    #
+    # Partial time-only formats are also accepted.
+    #
+    #   event.start = "00:01:02+03:00"
+    #   event.start # => 1999-12-31 21:01:02 UTC
+    #
+    # The degree of sub-second precision can be customized when declaring an
+    # attribute:
+    #
+    #   class Event
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :start, :time, precision: 4
+    #   end
+    class Time < Value
+      include Helpers::Timezone
+      include Helpers::AcceptsMultiparameterTime.new(
+        defaults: { 1 => 2000, 2 => 1, 3 => 1, 4 => 0, 5 => 0 }
+      )
+      include Helpers::TimeValue
+
+      def type
+        :time
+      end
+
+      def user_input_in_time_zone(value)
+        return unless value.present?
+
+        case value
+        when ::String
+          value = "2000-01-01 #{value}"
+          time_hash = begin
+            ::Date._parse(value)
+          rescue ArgumentError
+          end
+
+          return if time_hash.nil? || time_hash[:hour].nil?
+        when ::Time
+          value = value.change(year: 2000, day: 1, month: 1)
+        end
+
+        super(value)
+      end
+
+      private
+        def cast_value(value)
+          return apply_seconds_precision(value) unless value.is_a?(::String)
+          return if value.blank?
+
+          dummy_time_value = value.sub(/\A\d{4}-\d\d-\d\d(?:T|\s)|/, "2000-01-01 ")
+
+          fast_string_to_time(dummy_time_value) || begin
+            time_hash = begin
+              ::Date._parse(dummy_time_value)
+            rescue ArgumentError
+            end
+
+            return if time_hash.nil? || time_hash[:hour].nil?
+            new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset))
+          end
+        end
+    end
+  end
+end