ric 0.11.19 → 0.14.0

data/vendor/bundle/ruby/2.7.0/gems/activemodel-6.1.4.4/lib/active_model/type/date.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    class Date < Value # :nodoc:
+      include Helpers::Timezone
+      include Helpers::AcceptsMultiparameterTime.new
+
+      def type
+        :date
+      end
+
+      def type_cast_for_schema(value)
+        value.to_s(:db).inspect
+      end
+
+      private
+        def cast_value(value)
+          if value.is_a?(::String)
+            return if value.empty?
+            fast_string_to_date(value) || fallback_string_to_date(value)
+          elsif value.respond_to?(:to_date)
+            value.to_date
+          else
+            value
+          end
+        end
+
+        ISO_DATE = /\A(\d{4})-(\d\d)-(\d\d)\z/
+        def fast_string_to_date(string)
+          if string =~ ISO_DATE
+            new_date $1.to_i, $2.to_i, $3.to_i
+          end
+        end
+
+        def fallback_string_to_date(string)
+          new_date(*::Date._parse(string, false).values_at(:year, :mon, :mday))
+        end
+
+        def new_date(year, mon, mday)
+          unless year.nil? || (year == 0 && mon == 0 && mday == 0)
+            ::Date.new(year, mon, mday) rescue nil
+          end
+        end
+
+        def value_from_multiparameter_assignment(*)
+          time = super
+          time && new_date(time.year, time.mon, time.mday)
+        end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/activemodel-6.1.4.4/lib/active_model/type/date_time.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    class DateTime < Value # :nodoc:
+      include Helpers::Timezone
+      include Helpers::TimeValue
+      include Helpers::AcceptsMultiparameterTime.new(
+        defaults: { 4 => 0, 5 => 0 }
+      )
+
+      def type
+        :datetime
+      end
+
+      private
+        def cast_value(value)
+          return apply_seconds_precision(value) unless value.is_a?(::String)
+          return if value.empty?
+
+          fast_string_to_time(value) || fallback_string_to_time(value)
+        end
+
+        # '0.123456' -> 123456
+        # '1.123456' -> 123456
+        def microseconds(time)
+          time[:sec_fraction] ? (time[:sec_fraction] * 1_000_000).to_i : 0
+        end
+
+        def fallback_string_to_time(string)
+          time_hash = ::Date._parse(string)
+          time_hash[:sec_fraction] = microseconds(time_hash)
+
+          new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset))
+        end
+
+        def value_from_multiparameter_assignment(values_hash)
+          missing_parameters = [1, 2, 3].delete_if { |key| values_hash.key?(key) }
+          unless missing_parameters.empty?
+            raise ArgumentError, "Provided hash #{values_hash} doesn't contain necessary keys: #{missing_parameters}"
+          end
+          super
+        end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/activemodel-6.1.4.4/lib/active_model/type/decimal.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "bigdecimal/util"
+
+module ActiveModel
+  module Type
+    class Decimal < Value # :nodoc:
+      include Helpers::Numeric
+      BIGDECIMAL_PRECISION = 18
+
+      def type
+        :decimal
+      end
+
+      def type_cast_for_schema(value)
+        value.to_s.inspect
+      end
+
+      private
+        def cast_value(value)
+          casted_value = \
+            case value
+            when ::Float
+              convert_float_to_big_decimal(value)
+            when ::Numeric
+              BigDecimal(value, precision || BIGDECIMAL_PRECISION)
+            when ::String
+              begin
+                value.to_d
+              rescue ArgumentError
+                BigDecimal(0)
+              end
+            else
+              if value.respond_to?(:to_d)
+                value.to_d
+              else
+                cast_value(value.to_s)
+              end
+            end
+
+          apply_scale(casted_value)
+        end
+
+        def convert_float_to_big_decimal(value)
+          if precision
+            BigDecimal(apply_scale(value), float_precision)
+          else
+            value.to_d
+          end
+        end
+
+        def float_precision
+          if precision.to_i > ::Float::DIG + 1
+            ::Float::DIG + 1
+          else
+            precision.to_i
+          end
+        end
+
+        def apply_scale(value)
+          if scale
+            value.round(scale)
+          else
+            value
+          end
+        end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/activemodel-6.1.4.4/lib/active_model/type/float.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/try"
+
+module ActiveModel
+  module Type
+    class Float < Value # :nodoc:
+      include Helpers::Numeric
+
+      def type
+        :float
+      end
+
+      def type_cast_for_schema(value)
+        return "::Float::NAN" if value.try(:nan?)
+        case value
+        when ::Float::INFINITY then "::Float::INFINITY"
+        when -::Float::INFINITY then "-::Float::INFINITY"
+        else super
+        end
+      end
+
+      private
+        def cast_value(value)
+          case value
+          when ::Float then value
+          when "Infinity" then ::Float::INFINITY
+          when "-Infinity" then -::Float::INFINITY
+          when "NaN" then ::Float::NAN
+          else value.to_f
+          end
+        end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/activemodel-6.1.4.4/lib/active_model/type/helpers/accepts_multiparameter_time.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    module Helpers # :nodoc: all
+      class AcceptsMultiparameterTime < Module
+        module InstanceMethods
+          def serialize(value)
+            super(cast(value))
+          end
+
+          def cast(value)
+            if value.is_a?(Hash)
+              value_from_multiparameter_assignment(value)
+            else
+              super(value)
+            end
+          end
+
+          def assert_valid_value(value)
+            if value.is_a?(Hash)
+              value_from_multiparameter_assignment(value)
+            else
+              super(value)
+            end
+          end
+
+          def value_constructed_by_mass_assignment?(value)
+            value.is_a?(Hash)
+          end
+        end
+
+        def initialize(defaults: {})
+          include InstanceMethods
+
+          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.public_send(default_timezone, *values)
+          end
+          private :value_from_multiparameter_assignment
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/activemodel-6.1.4.4/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/vendor/bundle/ruby/2.7.0/gems/activemodel-6.1.4.4/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/vendor/bundle/ruby/2.7.0/gems/activemodel-6.1.4.4/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/vendor/bundle/ruby/2.7.0/gems/activemodel-6.1.4.4/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/vendor/bundle/ruby/2.7.0/gems/activemodel-6.1.4.4/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/vendor/bundle/ruby/2.7.0/gems/activemodel-6.1.4.4/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/vendor/bundle/ruby/2.7.0/gems/activemodel-6.1.4.4/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/vendor/bundle/ruby/2.7.0/gems/activemodel-6.1.4.4/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/vendor/bundle/ruby/2.7.0/gems/activemodel-6.1.4.4/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/vendor/bundle/ruby/2.7.0/gems/activemodel-6.1.4.4/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