activemodel 6.0.0

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/helpers/accepts_multiparameter_time.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    module Helpers # :nodoc: all
+      class AcceptsMultiparameterTime < Module
+        def initialize(defaults: {})
+          define_method(:serialize) do |value|
+            super(cast(value))
+          end
+
+          define_method(:cast) do |value|
+            if value.is_a?(Hash)
+              value_from_multiparameter_assignment(value)
+            else
+              super(value)
+            end
+          end
+
+          define_method(:assert_valid_value) do |value|
+            if value.is_a?(Hash)
+              value_from_multiparameter_assignment(value)
+            else
+              super(value)
+            end
+          end
+
+          define_method(:value_constructed_by_mass_assignment?) do |value|
+            value.is_a?(Hash)
+          end
+
+          define_method(:value_from_multiparameter_assignment) do |values_hash|
+            defaults.each do |k, v|
+              values_hash[k] ||= v
+            end
+            return unless values_hash[1] && values_hash[2] && values_hash[3]
+            values = values_hash.sort.map(&:last)
+            ::Time.send(default_timezone, *values)
+          end
+          private :value_from_multiparameter_assignment
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    module Helpers # :nodoc: all
+      module Mutable
+        def cast(value)
+          deserialize(serialize(value))
+        end
+
+        # +raw_old_value+ will be the `_before_type_cast` version of the
+        # value (likely a string). +new_value+ will be the current, type
+        # cast value.
+        def changed_in_place?(raw_old_value, new_value)
+          raw_old_value != serialize(new_value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    module Helpers # :nodoc: all
+      module Numeric
+        def serialize(value)
+          cast(value)
+        end
+
+        def cast(value)
+          value = \
+            case value
+            when true then 1
+            when false then 0
+            when ::String then value.presence
+            else value
+            end
+          super(value)
+        end
+
+        def changed?(old_value, _new_value, new_value_before_type_cast) # :nodoc:
+          super || number_to_non_number?(old_value, new_value_before_type_cast)
+        end
+
+        private
+
+          def number_to_non_number?(old_value, new_value_before_type_cast)
+            old_value != nil && non_numeric_string?(new_value_before_type_cast.to_s)
+          end
+
+          def non_numeric_string?(value)
+            # 'wibble'.to_i will give zero, we want to make sure
+            # that we aren't marking int zero to string zero as
+            # changed.
+            !NUMERIC_REGEX.match?(value)
+          end
+
+          NUMERIC_REGEX = /\A\s*[+-]?\d/
+          private_constant :NUMERIC_REGEX
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# 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(value)
+          value = apply_seconds_precision(value)
+
+          if value.acts_like?(:time)
+            zone_conversion_method = is_utc? ? :getutc : :getlocal
+
+            if value.respond_to?(zone_conversion_method)
+              value = value.send(zone_conversion_method)
+            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_s(: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
+              is_utc? ? time : time.getlocal
+            else
+              ::Time.public_send(default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
+            end
+          end
+
+          ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
+
+          # Doesn't handle time zones.
+          def fast_string_to_time(string)
+            if string =~ ISO_DATETIME
+              microsec_part = $7
+              if microsec_part && microsec_part.start_with?(".") && microsec_part.length == 7
+                microsec_part[0] = ""
+                microsec = microsec_part.to_i
+              else
+                microsec = (microsec_part.to_r * 1_000_000).to_i
+              end
+              new_time $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
+            end
+          end
+      end
+    end
+  end
+end

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

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

data/lib/active_model/type/immutable_string.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    class ImmutableString < Value # :nodoc:
+      def type
+        :string
+      end
+
+      def serialize(value)
+        case value
+        when ::Numeric, ActiveSupport::Duration then value.to_s
+        when true then "t"
+        when false then "f"
+        else super
+        end
+      end
+
+      private
+
+        def cast_value(value)
+          result = \
+            case value
+            when true then "t"
+            when false then "f"
+            else value.to_s
+            end
+          result.freeze
+        end
+    end
+  end
+end

data/lib/active_model/type/integer.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    class Integer < Value # :nodoc:
+      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
+
+      private
+        attr_reader :range
+
+        def cast_value(value)
+          value.to_i rescue nil
+        end
+
+        def ensure_in_range(value)
+          if value && !range.cover?(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,62 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  # :stopdoc:
+  module Type
+    class Registry
+      def initialize
+        @registrations = []
+      end
+
+      def register(type_name, klass = nil, **options, &block)
+        block ||= proc { |_, *args| klass.new(*args) }
+        registrations << registration_klass.new(type_name, block, **options)
+      end
+
+      def lookup(symbol, *args)
+        registration = find_registration(symbol, *args)
+
+        if registration
+          registration.call(self, symbol, *args)
+        else
+          raise ArgumentError, "Unknown type #{symbol.inspect}"
+        end
+      end
+
+      private
+        attr_reader :registrations
+
+        def registration_klass
+          Registration
+        end
+
+        def find_registration(symbol, *args)
+          registrations.find { |r| r.matches?(symbol, *args) }
+        end
+    end
+
+    class Registration
+      # Options must be taken because of https://bugs.ruby-lang.org/issues/10856
+      def initialize(name, block, **)
+        @name = name
+        @block = block
+      end
+
+      def call(_registry, *args, **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
+      end
+
+      private
+        attr_reader :name, :block
+    end
+  end
+  # :startdoc:
+end

data/lib/active_model/type/string.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "active_model/type/immutable_string"
+
+module ActiveModel
+  module Type
+    class String < ImmutableString # :nodoc:
+      def changed_in_place?(raw_old_value, new_value)
+        if new_value.is_a?(::String)
+          raw_old_value != new_value
+        end
+      end
+
+      private
+
+        def cast_value(value)
+          case value
+          when ::String then ::String.new(value)
+          when true then "t"
+          when false then "f"
+          else value.to_s
+          end
+        end
+    end
+  end
+end

data/lib/active_model/type/time.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    class Time < Value # :nodoc:
+      include Helpers::Timezone
+      include Helpers::TimeValue
+      include Helpers::AcceptsMultiparameterTime.new(
+        defaults: { 1 => 2000, 2 => 1, 3 => 1, 4 => 0, 5 => 0 }
+      )
+
+      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 = ::Date._parse(value)
+          return if 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.empty?
+
+          dummy_time_value = value.sub(/\A(\d\d\d\d-\d\d-\d\d |)/, "2000-01-01 ")
+
+          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, :offset))
+          end
+        end
+    end
+  end
+end