human_number 0.1.9 → 0.2.0

data/lib/human_number/formatters/number.rb

@@ -1,25 +1,13 @@
 # frozen_string_literal: true
 
 require_relative "../locale_support"
+require_relative "../number_system"
 
 module HumanNumber
   module Formatters
     class Number
       extend ActionView::Helpers::NumberHelper
 
-      # Constants for string literals and magic numbers
-      ZERO_STRING = "0"
-      EMPTY_SEPARATOR = ""
-      SPACE_SEPARATOR = " "
-      DECIMAL_FORMAT_TEMPLATE = "%.%df"
-      MINIMUM_UNIT_COUNT = 1.0
-      SINGLE_DIGIT_LIMIT = 1
-
-      # I18n key templates
-      I18N_DECIMAL_UNITS_KEY = "number.human.decimal_units"
-      I18N_ABBR_UNITS_SECTION = "abbr_units"
-      I18N_UNITS_SECTION = "units"
-
       class << self
         # Internal formatter for numbers with intelligent abbreviations.
         # All parameters are required - use HumanNumber.human_number for user-friendly interface.
@@ -67,14 +55,14 @@ module HumanNumber
           currency_options[:locale] = precision_locale
           currency_options[:format] = "%n" # Always format as just the number (no currency symbol)
 
-          number_to_currency(number, **currency_options) || ZERO_STRING
+          number_to_currency(number, **currency_options) || NumberSystem::ZERO_STRING
         end
 
         # Default options for human number formatting
         def default_options
           {
             abbr_units: true,
-            max_digits: 2,
+            max_digits: nil,
             min_unit: nil,
             trim_zeros: true,
           }.freeze
@@ -82,396 +70,21 @@ module HumanNumber
 
         # Format numbers below min_unit threshold with locale-appropriate delimiters
         def format_below_min_unit(number, locale)
-          number_with_delimiter(number, locale: locale) || number.to_s
+          NumberSystem::DefaultSystem.format_below_min_unit(number, locale)
         end
 
         private
 
         def determine_system_class(locale)
-          locale_sym = locale.to_sym
+          system_type = NumberSystem.number_system(locale: locale)
 
-          case locale_sym
-          when *EastAsianSystem::TARGET_LOCALES
-            EastAsianSystem
-          when *IndianSystem::TARGET_LOCALES
-            IndianSystem
+          case system_type
+          when :east_asian
+            NumberSystem::EastAsianSystem
+          when :indian
+            NumberSystem::IndianSystem
           else
-            DefaultSystem
-          end
-        end
-      end
-
-      # Default number system (thousand, million, billion, trillion)
-      class DefaultSystem
-        TARGET_LOCALES = %i[en es fr de it pt ru nl sv da no].freeze
-
-        UNIT_DEFINITIONS = [
-          { key: :trillion, divisor: 1_000_000_000_000 },
-          { key: :billion, divisor: 1_000_000_000 },
-          { key: :million, divisor: 1_000_000 },
-          { key: :thousand, divisor: 1_000 },
-        ].freeze
-
-        class << self
-          def format_number(number, locale:, abbr_units: true, min_unit: nil, max_digits: 2, trim_zeros: true)
-            return ZERO_STRING if number.zero?
-
-            # Check if number meets minimum unit threshold for human formatting
-            return Number.format_below_min_unit(number, locale) if min_unit && number.abs < min_unit
-
-            parts = if max_digits.nil?
-                      format_in_complete_mode(number, locale, abbr_units, min_unit)
-                    else
-                      format_in_abbreviated_mode(number, locale, abbr_units, max_digits, trim_zeros, min_unit)
-                    end
-
-            return number.to_s if parts.nil?
-
-            finalize_result(number, parts)
-          end
-
-          def format_in_complete_mode(number, locale, abbr_units, _min_unit)
-            # Complete mode shows all units: "1M 234K 567"
-            unit_breakdown = break_down_into_all_units(number)
-            return nil if unit_breakdown.empty?
-
-            format_all_unit_parts(unit_breakdown, locale, abbr_units)
-          end
-
-          def format_in_abbreviated_mode(number, locale, abbr_units, max_digits, trim_zeros, _min_unit)
-            # Abbreviated mode shows single largest unit: "1.2M"
-            unit_breakdown = break_down_into_largest_unit(number)
-            return nil if unit_breakdown.empty?
-
-            format_abbreviated_unit_parts(unit_breakdown, locale, abbr_units, max_digits, trim_zeros)
-          end
-
-          private
-
-          def breakdown_number(number)
-            result = []
-            remaining = number.abs
-
-            unit_definitions.each do |unit|
-              next unless remaining >= unit[:divisor]
-
-              count = remaining.to_f / unit[:divisor]
-              result << { unit_key: unit[:key], count: count, divisor: unit[:divisor] }
-              break # Only use the largest applicable unit
-            end
-
-            # If no unit matched, use the raw number
-            result << { unit_key: :units, count: remaining, divisor: 1 } if result.empty?
-
-            result
-          end
-
-          # Find the largest applicable unit for abbreviated display
-          # Example: 1,234,567 -> [{million: 1.234567}]
-          def break_down_into_largest_unit(number)
-            absolute_amount = number.abs
-
-            # Find the first (largest) unit where the count would be >= 1.0
-            unit_definitions.each do |unit|
-              unit_count = absolute_amount.to_f / unit[:divisor]
-
-              return [create_unit_part(unit[:key], unit_count, unit[:divisor])] if unit_count >= MINIMUM_UNIT_COUNT
-            end
-
-            # If no unit is applicable, return the raw number
-            [create_unit_part(:units, absolute_amount, 1)]
-          end
-
-          def unit_definitions
-            UNIT_DEFINITIONS
-          end
-
-          # Helper method to create consistent unit part structure
-          def create_unit_part(unit_key, count, divisor)
-            { unit_key: unit_key, count: count, divisor: divisor }
-          end
-
-          # Filter out units below the minimum threshold
-          def filter_by_minimum_unit_threshold(breakdown, min_unit)
-            return breakdown unless min_unit
-
-            breakdown.select { |unit_info| unit_info[:divisor] >= min_unit }
-          end
-
-          # Format unit parts for abbreviated display (e.g., "1.2M")
-          def format_abbreviated_unit_parts(breakdown, locale, abbr_units, max_digits, trim_zeros)
-            # Check if we're in human formatting mode (any non-:units parts exist)
-            human_formatting_applied = breakdown.any? { |unit_info| unit_info[:unit_key] != :units }
-
-            breakdown.map do |unit_info|
-              if unit_info[:unit_key] == :units
-                if human_formatting_applied
-                  # Part of human formatting - no delimiters
-                  unit_info[:count].to_s
-                else
-                  # Numbers below minimum unit threshold - apply locale formatting
-                  Number.format_below_min_unit(unit_info[:count], locale)
-                end
-              else
-                # Format with unit symbol (e.g., "1.2" + "M" = "1.2M")
-                format_number_with_unit_symbol(unit_info, locale, abbr_units, max_digits, trim_zeros)
-              end
-            end
-          end
-
-          # Format raw number without unit symbols
-          def format_raw_number_count(count, max_digits, trim_zeros)
-            format_unit_count(count, max_digits:, trim_zeros:, apply_rounding: false)
-          end
-
-          # Format number with unit symbol (e.g., "1.2M")
-          def format_number_with_unit_symbol(unit_info, locale, abbr_units, max_digits, trim_zeros)
-            symbol = lookup_unit_symbol(locale, unit_info[:unit_key], abbr_units)
-            format_with_symbol(unit_info[:count], symbol, abbr_units, max_digits:, trim_zeros:)
-          end
-
-          # Format unit with symbol for complete mode (e.g., "234K")
-          def format_complete_unit_with_symbol(unit_info, locale, abbr_units)
-            symbol = lookup_unit_symbol(locale, unit_info[:unit_key], abbr_units)
-            count_text = unit_info[:count].to_i.to_s
-            separator = determine_unit_value_separator(abbr_units)
-            formatted_symbol = apply_symbol_formatting_rules(symbol, abbr_units)
-            "#{count_text}#{separator}#{formatted_symbol}"
-          end
-
-          def format_unit_count(count, max_digits: 2, trim_zeros: true, apply_rounding: true)
-            return count.to_s unless count.is_a?(Numeric)
-
-            rounded = apply_rounding ? round_to_significant_digits(count, max_digits) : count
-
-            format_rounded_count(rounded, max_digits, trim_zeros, apply_rounding, count)
-          end
-
-          def format_rounded_count(rounded, max_digits, trim_zeros, apply_rounding, original_count)
-            if trim_zeros
-              format_with_trimmed_zeros(rounded)
-            elsif apply_rounding
-              format_with_fixed_decimals(rounded, max_digits)
-            else
-              original_count.to_s
-            end
-          end
-
-          def format_with_trimmed_zeros(rounded)
-            if rounded == rounded.to_i
-              rounded.to_i.to_s
-            else
-              rounded.to_s
-            end
-          end
-
-          def format_with_fixed_decimals(rounded, max_digits)
-            integer_digits = rounded.to_i.to_s.length
-            decimal_places = [0, max_digits - integer_digits].max
-            format("%.#{decimal_places}f", rounded)
-          end
-
-          def round_to_significant_digits(number, digits)
-            return handle_edge_cases(number, digits) if should_handle_edge_case?(number, digits)
-
-            abs_num = number.abs
-
-            # Simple significant digits rounding using scientific notation
-            magnitude = Math.log10(abs_num).floor
-            scale_factor = 10**(digits - 1 - magnitude)
-
-            rounded = (abs_num * scale_factor).round / scale_factor.to_f
-            apply_sign(number, rounded)
-          end
-
-          def should_handle_edge_case?(number, digits)
-            number.zero? || digits <= 0
-          end
-
-          def handle_edge_cases(number, _digits)
-            return 0.0 if number.zero?
-
-            number
-          end
-
-          def apply_sign(original_number, result)
-            original_number.negative? ? -result : result
-          end
-
-          def count_integer_digits(int_part)
-            int_part.zero? ? SINGLE_DIGIT_LIMIT : int_part.to_s.length
-          end
-
-          # Look up the localized symbol for a unit (e.g., 'M' for million)
-          def lookup_unit_symbol(locale, unit_key, abbr_units)
-            section = abbr_units ? I18N_ABBR_UNITS_SECTION : I18N_UNITS_SECTION
-
-            I18n.t("#{I18N_DECIMAL_UNITS_KEY}.#{section}.#{unit_key}", locale:, default: nil) ||
-              I18n.t("#{I18N_DECIMAL_UNITS_KEY}.#{section}.#{unit_key}", locale: :en, default: nil) ||
-              unit_key.to_s.upcase
-          end
-
-          def format_with_symbol(value, symbol, abbr_units, max_digits: 2, trim_zeros: true)
-            # Apply significant digits rounding to unit values
-            formatted_count = format_unit_count(value, max_digits:, trim_zeros:, apply_rounding: true)
-            separator = determine_unit_value_separator(abbr_units)
-            formatted_symbol = apply_symbol_formatting_rules(symbol, abbr_units)
-            "#{formatted_count}#{separator}#{formatted_symbol}"
-          end
-
-          # Determine separator between number and unit ("1M" vs "1 million")
-          def determine_unit_value_separator(abbr_units)
-            abbr_units ? EMPTY_SEPARATOR : SPACE_SEPARATOR
-          end
-
-          # Apply locale-specific formatting rules to unit symbols
-          def apply_symbol_formatting_rules(symbol, abbr_units)
-            return symbol if abbr_units || symbol.length <= 1
-
-            symbol.downcase # Western lowercase rule for full words
-          end
-
-          # Break down number into all applicable units for complete display
-          # Example: 1,234,567 -> [{million: 1}, {thousand: 234}, {units: 567}]
-          def break_down_into_all_units(number)
-            unit_breakdown = UnitBreakdown.new(number.abs, unit_definitions)
-            unit_breakdown.extract_all_units
-          end
-
-          # Helper class to manage unit breakdown state
-          class UnitBreakdown
-            def initialize(amount, unit_definitions)
-              @remaining_amount = amount
-              @unit_definitions = unit_definitions
-              @unit_parts = []
-            end
-
-            def extract_all_units
-              extract_major_units
-              add_remaining_as_units
-              @unit_parts
-            end
-
-            private
-
-            def extract_major_units
-              @unit_definitions.each do |unit|
-                extract_single_unit(unit) if @remaining_amount >= unit[:divisor]
-              end
-            end
-
-            def extract_single_unit(unit)
-              unit_count = (@remaining_amount / unit[:divisor]).to_i
-              return if unit_count.zero?
-
-              @unit_parts << create_unit_part(unit[:key], unit_count, unit[:divisor])
-              @remaining_amount %= unit[:divisor]
-            end
-
-            def add_remaining_as_units
-              return unless @remaining_amount.positive?
-
-              @unit_parts << create_unit_part(:units, @remaining_amount, 1)
-            end
-
-            def create_unit_part(unit_key, count, divisor)
-              { unit_key: unit_key, count: count, divisor: divisor }
-            end
-          end
-
-          # Format unit parts for complete display (e.g., "1M 234K 567")
-          def format_all_unit_parts(breakdown, locale, abbr_units)
-            # Check if we're in human formatting mode (any non-:units parts exist)
-            human_formatting_applied = breakdown.any? { |unit_info| unit_info[:unit_key] != :units }
-
-            breakdown.map do |unit_info|
-              if unit_info[:unit_key] == :units
-                if human_formatting_applied
-                  # Part of human formatting - no delimiters
-                  unit_info[:count].to_i.to_s
-                else
-                  # Numbers below minimum unit threshold - apply locale formatting
-                  Number.format_below_min_unit(unit_info[:count].to_i, locale)
-                end
-              else
-                # Format each unit part with its symbol
-                format_complete_unit_with_symbol(unit_info, locale, abbr_units)
-              end
-            end
-          end
-
-          # Apply sign and join all parts into final result
-          def finalize_result(number, formatted_parts)
-            combined_result = formatted_parts.join(SPACE_SEPARATOR)
-            number.negative? ? "-#{combined_result}" : combined_result
-          end
-        end
-      end
-
-      # East Asian number system (thousand, ten_thousand, hundred_million, trillion)
-      class EastAsianSystem < DefaultSystem
-        TARGET_LOCALES = %i[ko ja zh zh-CN zh-TW].freeze
-
-        UNIT_DEFINITIONS = [
-          { key: :trillion, divisor: 1_000_000_000_000 },
-          { key: :hundred_million, divisor: 100_000_000 },
-          { key: :ten_thousand, divisor: 10_000 },
-        ].freeze
-
-        class << self
-          def format_number(number, locale:, abbr_units: true, min_unit: nil, max_digits: 2, trim_zeros: true)
-            @current_locale = locale.to_sym
-            super
-          end
-
-          private
-
-          def unit_definitions
-            UNIT_DEFINITIONS
-          end
-
-          def format_with_symbol(value, symbol, _abbr_units, max_digits: 2, trim_zeros: true)
-            # East Asian: no separator regardless of abbr_units
-            # Apply significant digits rounding to unit values
-            formatted_count = format_unit_count(value, max_digits:, trim_zeros:, apply_rounding: true)
-            formatted_symbol = apply_symbol_formatting_rules(symbol, true)
-            "#{formatted_count}#{formatted_symbol}"
-          end
-
-          # Keep original case for Asian characters (만, 억, 조)
-          def apply_symbol_formatting_rules(symbol, _abbr_units)
-            symbol
-          end
-
-          # Apply culturally appropriate separators for East Asian languages
-          def finalize_result(number, formatted_parts)
-            separator = lookup_decimal_separator(@current_locale)
-            combined_result = formatted_parts.join(separator)
-            number.negative? ? "-#{combined_result}" : combined_result
-          end
-
-          # Look up separator from locale file, default to space
-          def lookup_decimal_separator(locale)
-            I18n.t("#{I18N_DECIMAL_UNITS_KEY}.separator", locale: locale, default: SPACE_SEPARATOR)
-          end
-        end
-      end
-
-      # Indian subcontinent number system (thousand, lakh, crore)
-      class IndianSystem < DefaultSystem
-        TARGET_LOCALES = %i[hi ur bn en-IN].freeze
-
-        UNIT_DEFINITIONS = [
-          { key: :crore, divisor: 10_000_000 },
-          { key: :lakh, divisor: 100_000 },
-          { key: :thousand, divisor: 1_000 },
-        ].freeze
-
-        class << self
-          private
-
-          def unit_definitions
-            UNIT_DEFINITIONS
+            NumberSystem::DefaultSystem
           end
         end
       end