activemodel 4.2.0 → 6.1.0

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    module Helpers # :nodoc: all
+      module Numeric
+        def serialize(value)
+          cast(value)
+        end
+
+        def cast(value)
+          # Checks whether the value is numeric. Spaceship operator
+          # will return nil if value is not numeric.
+          value = if value <=> 0
+            value
+          else
+            case value
+            when true then 1
+            when false then 0
+            else value.presence
+            end
+          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,90 @@
+# 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)
+            if is_utc?
+              value = value.getutc if value.respond_to?(:getutc) && !value.utc?
+            else
+              value = value.getlocal if value.respond_to?(: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_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 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
+
+          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 = $8 == "Z" ? 0 : $8.to_i * 3600 + $9.to_i * 60
+            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

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.match?("UTC")
+        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,35 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    class ImmutableString < Value # :nodoc:
+      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
+
+      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,67 @@
+# 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
+
+      def serializable?(value)
+        cast_value = cast(value)
+        in_range?(cast_value) && super
+      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,70 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  # :stopdoc:
+  module Type
+    class Registry
+      def initialize
+        @registrations = []
+      end
+
+      def initialize_dup(other)
+        @registrations = @registrations.dup
+        super
+      end
+
+      def register(type_name, klass = nil, **options, &block)
+        unless block_given?
+          block = proc { |_, *args| klass.new(*args) }
+          block.ruby2_keywords if block.respond_to?(:ruby2_keywords)
+        end
+        registrations << registration_klass.new(type_name, block, **options)
+      end
+
+      def lookup(symbol, *args, **kwargs)
+        registration = find_registration(symbol, *args, **kwargs)
+
+        if registration
+          registration.call(self, symbol, *args, **kwargs)
+        else
+          raise ArgumentError, "Unknown type #{symbol.inspect}"
+        end
+      end
+
+      private
+        attr_reader :registrations
+
+        def registration_klass
+          Registration
+        end
+
+        def find_registration(symbol, *args, **kwargs)
+          registrations.find { |r| r.matches?(symbol, *args, **kwargs) }
+        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,35 @@
+# 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
+
+      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,46 @@
+# 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

data/lib/active_model/type/value.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    class Value
+      attr_reader :precision, :scale, :limit
+
+      def initialize(precision: nil, limit: nil, scale: nil)
+        @precision = precision
+        @scale = scale
+        @limit = limit
+      end
+
+      # Returns true if this type can convert +value+ to a type that is usable
+      # by the database.  For example a boolean type can return +true+ if the
+      # value parameter is a Ruby boolean, but may return +false+ if the value
+      # parameter is some other object.
+      def serializable?(value)
+        true
+      end
+
+      def type # :nodoc:
+      end
+
+      # Converts a value from database input to the appropriate ruby type. The
+      # return value of this method will be returned from
+      # ActiveRecord::AttributeMethods::Read#read_attribute. The default
+      # implementation just calls Value#cast.
+      #
+      # +value+ The raw input, as provided from the database.
+      def deserialize(value)
+        cast(value)
+      end
+
+      # Type casts a value from user input (e.g. from a setter). This value may
+      # be a string from the form builder, or a ruby object passed to a setter.
+      # There is currently no way to differentiate between which source it came
+      # from.
+      #
+      # The return value of this method will be returned from
+      # ActiveRecord::AttributeMethods::Read#read_attribute. See also:
+      # Value#cast_value.
+      #
+      # +value+ The raw input, as provided to the attribute setter.
+      def cast(value)
+        cast_value(value) unless value.nil?
+      end
+
+      # Casts a value from the ruby type to a type that the database knows how
+      # to understand. The returned value from this method should be a
+      # +String+, +Numeric+, +Date+, +Time+, +Symbol+, +true+, +false+, or
+      # +nil+.
+      def serialize(value)
+        value
+      end
+
+      # Type casts a value for schema dumping. This method is private, as we are
+      # hoping to remove it entirely.
+      def type_cast_for_schema(value) # :nodoc:
+        value.inspect
+      end
+
+      # These predicates are not documented, as I need to look further into
+      # their use, and see if they can be removed entirely.
+      def binary? # :nodoc:
+        false
+      end
+
+      # Determines whether a value has changed for dirty checking. +old_value+
+      # and +new_value+ will always be type-cast. Types should not need to
+      # override this method.
+      def changed?(old_value, new_value, _new_value_before_type_cast)
+        old_value != new_value
+      end
+
+      # Determines whether the mutable value has been modified since it was
+      # read. Returns +false+ by default. If your type returns an object
+      # which could be mutated, you should override this method. You will need
+      # to either:
+      #
+      # - pass +new_value+ to Value#serialize and compare it to
+      #   +raw_old_value+
+      #
+      # or
+      #
+      # - pass +raw_old_value+ to Value#deserialize and compare it to
+      #   +new_value+
+      #
+      # +raw_old_value+ The original value, before being passed to
+      # +deserialize+.
+      #
+      # +new_value+ The current value, after type casting.
+      def changed_in_place?(raw_old_value, new_value)
+        false
+      end
+
+      def value_constructed_by_mass_assignment?(_value) # :nodoc:
+        false
+      end
+
+      def force_equality?(_value) # :nodoc:
+        false
+      end
+
+      def map(value) # :nodoc:
+        yield value
+      end
+
+      def ==(other)
+        self.class == other.class &&
+          precision == other.precision &&
+          scale == other.scale &&
+          limit == other.limit
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, precision, scale, limit].hash
+      end
+
+      def assert_valid_value(_)
+      end
+
+      private
+        # Convenience method for types which do not need separate type casting
+        # behavior for user and database inputs. Called by Value#cast for
+        # values except +nil+.
+        def cast_value(value) # :doc:
+          value
+        end
+    end
+  end
+end

data/lib/active_model/type.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "active_model/type/helpers"
+require "active_model/type/value"
+
+require "active_model/type/big_integer"
+require "active_model/type/binary"
+require "active_model/type/boolean"
+require "active_model/type/date"
+require "active_model/type/date_time"
+require "active_model/type/decimal"
+require "active_model/type/float"
+require "active_model/type/immutable_string"
+require "active_model/type/integer"
+require "active_model/type/string"
+require "active_model/type/time"
+
+require "active_model/type/registry"
+
+module ActiveModel
+  module Type
+    @registry = Registry.new
+
+    class << self
+      attr_accessor :registry # :nodoc:
+
+      # Add a new type to the registry, allowing it to be gotten through ActiveModel::Type#lookup
+      def register(type_name, klass = nil, **options, &block)
+        registry.register(type_name, klass, **options, &block)
+      end
+
+      def lookup(*args, **kwargs) # :nodoc:
+        registry.lookup(*args, **kwargs)
+      end
+
+      def default_value # :nodoc:
+        @default_value ||= Value.new
+      end
+    end
+
+    register(:big_integer, Type::BigInteger)
+    register(:binary, Type::Binary)
+    register(:boolean, Type::Boolean)
+    register(:date, Type::Date)
+    register(:datetime, Type::DateTime)
+    register(:decimal, Type::Decimal)
+    register(:float, Type::Float)
+    register(:immutable_string, Type::ImmutableString)
+    register(:integer, Type::Integer)
+    register(:string, Type::String)
+    register(:time, Type::Time)
+  end
+end

data/lib/active_model/validations/absence.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 module ActiveModel
   module Validations
-    # == Active Model Absence Validator
+    # == \Active \Model Absence Validator
     class AbsenceValidator < EachValidator #:nodoc:
       def validate_each(record, attr_name, value)
-        record.errors.add(attr_name, :present, options) if value.present?
+        record.errors.add(attr_name, :present, **options) if value.present?
       end
     end
 
     module HelperMethods
       # Validates that the specified attributes are blank (as defined by
-      # Object#blank?). Happens by default on save.
+      # Object#present?). Happens by default on save.
       #
       #   class Person < ActiveRecord::Base
       #     validates_absence_of :first_name
@@ -22,7 +24,7 @@ module ActiveModel
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See <tt>ActiveModel::Validation#validates</tt> for more information
+      # See <tt>ActiveModel::Validations#validates</tt> for more information
       def validates_absence_of(*attr_names)
         validates_with AbsenceValidator, _merge_attributes(attr_names)
       end