activesupport 6.0.0

data/lib/active_support/number_helper/number_converter.rb

@@ -0,0 +1,184 @@
+# 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 (eg.: 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/lib/active_support/number_helper/number_to_currency_converter.rb

@@ -0,0 +1,46 @@
+# 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.to_f.negative?
+          format = options[:negative_format]
+          number = absolute_value(number)
+        end
+
+        rounded_number = NumberToRoundedConverter.convert(number, options)
+        format.gsub("%n", rounded_number).gsub("%u", options[:unit])
+      end
+
+      private
+
+        def absolute_value(number)
+          number.respond_to?(:abs) ? number.abs : number.sub(/\A-/, "")
+        end
+
+        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/lib/active_support/number_helper/number_to_delimited_converter.rb

@@ -0,0 +1,31 @@
+# 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/lib/active_support/number_helper/number_to_human_converter.rb

@@ -0,0 +1,70 @@
+# 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/lib/active_support/number_helper/number_to_human_size_converter.rb

@@ -0,0 +1,61 @@
+# 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/lib/active_support/number_helper/number_to_percentage_converter.rb

@@ -0,0 +1,16 @@
+# 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/lib/active_support/number_helper/number_to_phone_converter.rb

@@ -0,0 +1,60 @@
+# 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