ric 0.14.2 → 0.14.6

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/number_helper/number_converter.rb

@@ -1,183 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/big_decimal/conversions"
-require "active_support/core_ext/object/blank"
-require "active_support/core_ext/hash/keys"
-require "active_support/i18n"
-require "active_support/core_ext/class/attribute"
-
-module ActiveSupport
-  module NumberHelper
-    class NumberConverter # :nodoc:
-      # Default and i18n option namespace per class
-      class_attribute :namespace
-
-      # Does the object need a number that is a valid float?
-      class_attribute :validate_float
-
-      attr_reader :number, :opts
-
-      DEFAULTS = {
-        # Used in number_to_delimited
-        # These are also the defaults for 'currency', 'percentage', 'precision', and 'human'
-        format: {
-          # Sets the separator between the units, for more precision (e.g. 1.0 / 2.0 == 0.5)
-          separator: ".",
-          # Delimits thousands (e.g. 1,000,000 is a million) (always in groups of three)
-          delimiter: ",",
-          # Number of decimals, behind the separator (the number 1 with a precision of 2 gives: 1.00)
-          precision: 3,
-          # If set to true, precision will mean the number of significant digits instead
-          # of the number of decimal digits (1234 with precision 2 becomes 1200, 1.23543 becomes 1.2)
-          significant: false,
-          # If set, the zeros after the decimal separator will always be stripped (e.g.: 1.200 will be 1.2)
-          strip_insignificant_zeros: false
-        },
-
-        # Used in number_to_currency
-        currency: {
-          format: {
-            format: "%u%n",
-            negative_format: "-%u%n",
-            unit: "$",
-            # These five are to override number.format and are optional
-            separator: ".",
-            delimiter: ",",
-            precision: 2,
-            significant: false,
-            strip_insignificant_zeros: false
-          }
-        },
-
-        # Used in number_to_percentage
-        percentage: {
-          format: {
-            delimiter: "",
-            format: "%n%"
-          }
-        },
-
-        # Used in number_to_rounded
-        precision: {
-          format: {
-            delimiter: ""
-          }
-        },
-
-        # Used in number_to_human_size and number_to_human
-        human: {
-          format: {
-            # These five are to override number.format and are optional
-            delimiter: "",
-            precision: 3,
-            significant: true,
-            strip_insignificant_zeros: true
-          },
-          # Used in number_to_human_size
-          storage_units: {
-            # Storage units output formatting.
-            # %u is the storage unit, %n is the number (default: 2 MB)
-            format: "%n %u",
-            units: {
-              byte: "Bytes",
-              kb: "KB",
-              mb: "MB",
-              gb: "GB",
-              tb: "TB"
-            }
-          },
-          # Used in number_to_human
-          decimal_units: {
-            format: "%n %u",
-            # Decimal units output formatting
-            # By default we will only quantify some of the exponents
-            # but the commented ones might be defined or overridden
-            # by the user.
-            units: {
-              # femto: Quadrillionth
-              # pico: Trillionth
-              # nano: Billionth
-              # micro: Millionth
-              # mili: Thousandth
-              # centi: Hundredth
-              # deci: Tenth
-              unit: "",
-              # ten:
-              #   one: Ten
-              #   other: Tens
-              # hundred: Hundred
-              thousand: "Thousand",
-              million: "Million",
-              billion: "Billion",
-              trillion: "Trillion",
-              quadrillion: "Quadrillion"
-            }
-          }
-        }
-      }
-
-      def self.convert(number, options)
-        new(number, options).execute
-      end
-
-      def initialize(number, options)
-        @number = number
-        @opts   = options.symbolize_keys
-      end
-
-      def execute
-        if !number
-          nil
-        elsif validate_float? && !valid_float?
-          number
-        else
-          convert
-        end
-      end
-
-      private
-        def options
-          @options ||= format_options.merge(opts)
-        end
-
-        def format_options
-          default_format_options.merge!(i18n_format_options)
-        end
-
-        def default_format_options
-          options = DEFAULTS[:format].dup
-          options.merge!(DEFAULTS[namespace][:format]) if namespace
-          options
-        end
-
-        def i18n_format_options
-          locale = opts[:locale]
-          options = I18n.translate(:'number.format', locale: locale, default: {}).dup
-
-          if namespace
-            options.merge!(I18n.translate(:"number.#{namespace}.format", locale: locale, default: {}))
-          end
-
-          options
-        end
-
-        def translate_number_value_with_default(key, **i18n_options)
-          I18n.translate(key, **{ default: default_value(key), scope: :number }.merge!(i18n_options))
-        end
-
-        def translate_in_locale(key, **i18n_options)
-          translate_number_value_with_default(key, **{ locale: options[:locale] }.merge(i18n_options))
-        end
-
-        def default_value(key)
-          key.split(".").reduce(DEFAULTS) { |defaults, k| defaults[k.to_sym] }
-        end
-
-        def valid_float?
-          Float(number)
-        rescue ArgumentError, TypeError
-          false
-        end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/number_helper/number_to_currency_converter.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/number_helper/number_converter"
-
-module ActiveSupport
-  module NumberHelper
-    class NumberToCurrencyConverter < NumberConverter # :nodoc:
-      self.namespace = :currency
-
-      def convert
-        number = self.number.to_s.strip
-        format = options[:format]
-
-        if number.sub!(/^-/, "") &&
-           (options[:precision] != 0 || number.to_f > 0.5)
-          format = options[:negative_format]
-        end
-
-        rounded_number = NumberToRoundedConverter.convert(number, options)
-        format.gsub("%n", rounded_number).gsub("%u", options[:unit])
-      end
-
-      private
-        def options
-          @options ||= begin
-            defaults = default_format_options.merge(i18n_opts)
-            # Override negative format if format options are given
-            defaults[:negative_format] = "-#{opts[:format]}" if opts[:format]
-            defaults.merge!(opts)
-          end
-        end
-
-        def i18n_opts
-          # Set International negative format if it does not exist
-          i18n = i18n_format_options
-          i18n[:negative_format] ||= "-#{i18n[:format]}" if i18n[:format]
-          i18n
-        end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/number_helper/number_to_delimited_converter.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/number_helper/number_converter"
-
-module ActiveSupport
-  module NumberHelper
-    class NumberToDelimitedConverter < NumberConverter #:nodoc:
-      self.validate_float = true
-
-      DEFAULT_DELIMITER_REGEX = /(\d)(?=(\d\d\d)+(?!\d))/
-
-      def convert
-        parts.join(options[:separator])
-      end
-
-      private
-        def parts
-          left, right = number.to_s.split(".")
-          left.gsub!(delimiter_pattern) do |digit_to_delimit|
-            "#{digit_to_delimit}#{options[:delimiter]}"
-          end
-          [left, right].compact
-        end
-
-        def delimiter_pattern
-          options.fetch(:delimiter_pattern, DEFAULT_DELIMITER_REGEX)
-        end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/number_helper/number_to_human_converter.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/number_helper/number_converter"
-
-module ActiveSupport
-  module NumberHelper
-    class NumberToHumanConverter < NumberConverter # :nodoc:
-      DECIMAL_UNITS = { 0 => :unit, 1 => :ten, 2 => :hundred, 3 => :thousand, 6 => :million, 9 => :billion, 12 => :trillion, 15 => :quadrillion,
-        -1 => :deci, -2 => :centi, -3 => :mili, -6 => :micro, -9 => :nano, -12 => :pico, -15 => :femto }
-      INVERTED_DECIMAL_UNITS = DECIMAL_UNITS.invert
-
-      self.namespace      = :human
-      self.validate_float = true
-
-      def convert # :nodoc:
-        @number = RoundingHelper.new(options).round(number)
-        @number = Float(number)
-
-        # For backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files.
-        unless options.key?(:strip_insignificant_zeros)
-          options[:strip_insignificant_zeros] = true
-        end
-
-        units = opts[:units]
-        exponent = calculate_exponent(units)
-        @number = number / (10**exponent)
-
-        rounded_number = NumberToRoundedConverter.convert(number, options)
-        unit = determine_unit(units, exponent)
-        format.gsub("%n", rounded_number).gsub("%u", unit).strip
-      end
-
-      private
-        def format
-          options[:format] || translate_in_locale("human.decimal_units.format")
-        end
-
-        def determine_unit(units, exponent)
-          exp = DECIMAL_UNITS[exponent]
-          case units
-          when Hash
-            units[exp] || ""
-          when String, Symbol
-            I18n.translate("#{units}.#{exp}", locale: options[:locale], count: number.to_i)
-          else
-            translate_in_locale("human.decimal_units.units.#{exp}", count: number.to_i)
-          end
-        end
-
-        def calculate_exponent(units)
-          exponent = number != 0 ? Math.log10(number.abs).floor : 0
-          unit_exponents(units).find { |e| exponent >= e } || 0
-        end
-
-        def unit_exponents(units)
-          case units
-          when Hash
-            units
-          when String, Symbol
-            I18n.translate(units.to_s, locale: options[:locale], raise: true)
-          when nil
-            translate_in_locale("human.decimal_units.units", raise: true)
-          else
-            raise ArgumentError, ":units must be a Hash or String translation scope."
-          end.keys.map { |e_name| INVERTED_DECIMAL_UNITS[e_name] }.sort_by(&:-@)
-        end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/number_helper/number_to_human_size_converter.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/number_helper/number_converter"
-
-module ActiveSupport
-  module NumberHelper
-    class NumberToHumanSizeConverter < NumberConverter #:nodoc:
-      STORAGE_UNITS = [:byte, :kb, :mb, :gb, :tb, :pb, :eb]
-
-      self.namespace      = :human
-      self.validate_float = true
-
-      def convert
-        @number = Float(number)
-
-        # For backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files.
-        unless options.key?(:strip_insignificant_zeros)
-          options[:strip_insignificant_zeros] = true
-        end
-
-        if smaller_than_base?
-          number_to_format = number.to_i.to_s
-        else
-          human_size = number / (base**exponent)
-          number_to_format = NumberToRoundedConverter.convert(human_size, options)
-        end
-        conversion_format.gsub("%n", number_to_format).gsub("%u", unit)
-      end
-
-      private
-        def conversion_format
-          translate_number_value_with_default("human.storage_units.format", locale: options[:locale], raise: true)
-        end
-
-        def unit
-          translate_number_value_with_default(storage_unit_key, locale: options[:locale], count: number.to_i, raise: true)
-        end
-
-        def storage_unit_key
-          key_end = smaller_than_base? ? "byte" : STORAGE_UNITS[exponent]
-          "human.storage_units.units.#{key_end}"
-        end
-
-        def exponent
-          max = STORAGE_UNITS.size - 1
-          exp = (Math.log(number) / Math.log(base)).to_i
-          exp = max if exp > max # avoid overflow for the highest unit
-          exp
-        end
-
-        def smaller_than_base?
-          number.to_i < base
-        end
-
-        def base
-          1024
-        end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/number_helper/number_to_percentage_converter.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/number_helper/number_converter"
-
-module ActiveSupport
-  module NumberHelper
-    class NumberToPercentageConverter < NumberConverter # :nodoc:
-      self.namespace = :percentage
-
-      def convert
-        rounded_number = NumberToRoundedConverter.convert(number, options)
-        options[:format].gsub("%n", rounded_number)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/number_helper/number_to_phone_converter.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/number_helper/number_converter"
-
-module ActiveSupport
-  module NumberHelper
-    class NumberToPhoneConverter < NumberConverter #:nodoc:
-      def convert
-        str = country_code(opts[:country_code]).dup
-        str << convert_to_phone_number(number.to_s.strip)
-        str << phone_ext(opts[:extension])
-      end
-
-      private
-        def convert_to_phone_number(number)
-          if opts[:area_code]
-            convert_with_area_code(number)
-          else
-            convert_without_area_code(number)
-          end
-        end
-
-        def convert_with_area_code(number)
-          default_pattern = /(\d{1,3})(\d{3})(\d{4}$)/
-          number.gsub!(regexp_pattern(default_pattern),
-                       "(\\1) \\2#{delimiter}\\3")
-          number
-        end
-
-        def convert_without_area_code(number)
-          default_pattern = /(\d{0,3})(\d{3})(\d{4})$/
-          number.gsub!(regexp_pattern(default_pattern),
-                       "\\1#{delimiter}\\2#{delimiter}\\3")
-          number.slice!(0, 1) if start_with_delimiter?(number)
-          number
-        end
-
-        def start_with_delimiter?(number)
-          delimiter.present? && number.start_with?(delimiter)
-        end
-
-        def delimiter
-          opts[:delimiter] || "-"
-        end
-
-        def country_code(code)
-          code.blank? ? "" : "+#{code}#{delimiter}"
-        end
-
-        def phone_ext(ext)
-          ext.blank? ? "" : " x #{ext}"
-        end
-
-        def regexp_pattern(default_pattern)
-          opts.fetch :pattern, default_pattern
-        end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/number_helper/number_to_rounded_converter.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/number_helper/number_converter"
-
-module ActiveSupport
-  module NumberHelper
-    class NumberToRoundedConverter < NumberConverter # :nodoc:
-      self.namespace      = :precision
-      self.validate_float = true
-
-      def convert
-        helper = RoundingHelper.new(options)
-        rounded_number = helper.round(number)
-
-        if precision = options[:precision]
-          if options[:significant] && precision > 0
-            digits = helper.digit_count(rounded_number)
-            precision -= digits
-            precision = 0 if precision < 0 # don't let it be negative
-          end
-
-          formatted_string =
-            if rounded_number.finite?
-              s = rounded_number.to_s("F")
-              a, b = s.split(".", 2)
-              if precision != 0
-                b << "0" * precision
-                a << "."
-                a << b[0, precision]
-              end
-              a
-            else
-              # Infinity/NaN
-              "%f" % rounded_number
-            end
-        else
-          formatted_string = rounded_number
-        end
-
-        delimited_number = NumberToDelimitedConverter.convert(formatted_string, options)
-        format_number(delimited_number)
-      end
-
-      private
-        def strip_insignificant_zeros
-          options[:strip_insignificant_zeros]
-        end
-
-        def format_number(number)
-          if strip_insignificant_zeros
-            escaped_separator = Regexp.escape(options[:separator])
-            number.sub(/(#{escaped_separator})(\d*[1-9])?0+\z/, '\1\2').sub(/#{escaped_separator}\z/, "")
-          else
-            number
-          end
-        end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/number_helper/rounding_helper.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  module NumberHelper
-    class RoundingHelper # :nodoc:
-      attr_reader :options
-
-      def initialize(options)
-        @options = options
-      end
-
-      def round(number)
-        precision = absolute_precision(number)
-        return number unless precision
-
-        rounded_number = convert_to_decimal(number).round(precision, options.fetch(:round_mode, :default).to_sym)
-        rounded_number.zero? ? rounded_number.abs : rounded_number # prevent showing negative zeros
-      end
-
-      def digit_count(number)
-        return 1 if number.zero?
-        (Math.log10(number.abs) + 1).floor
-      end
-
-      private
-        def convert_to_decimal(number)
-          case number
-          when Float, String
-            BigDecimal(number.to_s)
-          when Rational
-            BigDecimal(number, digit_count(number.to_i) + options[:precision])
-          else
-            number.to_d
-          end
-        end
-
-        def absolute_precision(number)
-          if significant && options[:precision] > 0
-            options[:precision] - digit_count(convert_to_decimal(number))
-          else
-            options[:precision]
-          end
-        end
-
-        def significant
-          options[:significant]
-        end
-    end
-  end
-end