plurimath 0.10.7 → 0.11.0

data/lib/plurimath/formatter/numbers/significant.rb

@@ -3,132 +3,121 @@
 module Plurimath
   module Formatter
     module Numbers
+      # Applies significant-digit rounding on Parts before localized rendering.
       class Significant < Base
-        attr_accessor :decimal, :significant
+        attr_reader :significant
 
-        def initialize(symbols)
+        CANONICAL_DECIMAL = "."
+        EMPTY_STRING = ""
+        ZERO = "0"
+
+        def initialize(options)
           super
-          @decimal = symbols[:decimal]
-          @significant = symbols[:significant].to_i
+          @significant = self.options.significant
         end
 
-        def apply(string, int_format, frac_format)
-          return string if significant.zero?
-
-          # Check if string contains any non-zero digit (works across all bases 2-16)
-          chars = string.chars
-          return string if skip_significant_processing?(chars)
+        def active?
+          significant.positive?
+        end
 
-          string = signify(chars)
-          integer, fraction = string.split(decimal)
-          string = [format_groups(int_format, integer)]
-          string << format_groups(frac_format, fraction) if fraction
-          string.join(decimal)
+        def apply_parts(parts)
+          significant_parts(parts)
         end
 
         protected
 
+        # Apply significant-digit rules before localization so rounding never
+        # reparses grouped or decimal-localized output.
+        def significant_parts(parts)
+          integer = parts.integer_digits
+          fraction = parts.fraction_digits
+          string = fraction.empty? ? integer : "#{integer}#{CANONICAL_DECIMAL}#{fraction}"
+          chars = string.chars
+          return parts if skip_significant_processing?(chars)
+
+          integer, fraction = signify(chars).split(CANONICAL_DECIMAL, 2)
+          parts.with_digits(
+            integer_digits: integer,
+            fraction_digits: fraction.to_s,
+          )
+        end
+
         def signify(chars)
           new_chars, frac_part, sig_count = process_chars(chars)
           if sig_count.positive?
-            new_chars << decimal unless frac_part
+            new_chars << CANONICAL_DECIMAL unless frac_part
           else
-            remain_chars = count_chars(chars, frac_part) - significant
+            remain_chars = digit_count(chars, fraction: frac_part) - significant
             if remain_chars.positive?
-              round_str(chars, new_chars, frac_part)
-              # After rounding, recalculate remain_chars only for fractional numbers
-              # where we need to adjust padding based on actual significant digits
-              if frac_part
-                # Check if decimal point still exists after rounding
-                has_decimal = new_chars.include?(decimal)
-                if has_decimal
-                  # Fractional part still exists, recalculate padding
-                  actual_sig = count_significant_digits(new_chars)
-                  remain_chars = [significant - actual_sig, 0].max
-                else
-                  # Rounding eliminated the fractional part from a number that originally had one
-                  # Don't add trailing zeros in this case
-                  remain_chars = 0
-                  frac_part = false
-                end
-              end
-              # For integer-only numbers (frac_part = false from the start),
-              # remain_chars stays as calculated initially
+              round_chars(chars, new_chars, frac_part)
+              remain_chars = remaining_fraction_chars(new_chars) if frac_part
             end
-            new_chars << ("0" * remain_chars) unless frac_part && sig_char_count?(new_chars)
+            new_chars << (ZERO * remain_chars) unless frac_part && sig_char_count?(new_chars)
           end
           new_chars.join
         end
 
-        def round_str(chars, array, frac_part)
-          arr_len = array.length
-          char_ind = DIGIT_VALUE.key?(chars[arr_len]) ? arr_len : arr_len.next
-          return unless char_ind < chars.length && DIGIT_VALUE[chars[char_ind]] >= threshold
-
-          frac_part = false if chars[arr_len] == decimal
-          carry = false
-          array.reverse!.each_with_index do |char, ind|
-            if char == decimal
-              array[ind] = ""
-              frac_part  = false
-              next
-            end
-            next unless DIGIT_VALUE.key?(char)
-
-            if DIGIT_VALUE[char] == base.pred
-              carry = true
-              array[ind] = frac_part ? "" : "0"
-            else
-              array[ind] = next_mapping_char(char)
-              carry = false
-              break
-            end
-          end
-          array << "1" if carry
-          array.reverse!
+        def round_chars(chars, result, frac_part)
+          char_index = round_char_index(chars, result.length)
+          return unless char_index < chars.length && digit_sequence.round_up?(chars[char_index])
+
+          rounded = if frac_part
+                      increment_fractional(result.reverse)
+                    else
+                      increment_integer(result.reverse)
+                    end
+          result.replace(rounded.reverse)
         end
 
-        def count_chars(chars, fraction)
-          char_count = 0
-          chars.each do |char|
-            break if char == decimal && !fraction
+        def increment_fractional(reversed)
+          decimal_index = reversed.index(CANONICAL_DECIMAL)
+          return increment_integer(reversed) unless decimal_index
 
-            char_count += 1 if DIGIT_VALUE.key?(char)
-          end
-          char_count
+          fraction = reversed[0...decimal_index]
+          integer = reversed[(decimal_index + 1)..]
+          fraction, carry = digit_sequence.increment_reversed(fraction, overflow: EMPTY_STRING)
+          return fraction + [CANONICAL_DECIMAL] + integer unless carry.positive?
+
+          integer = increment_integer(integer)
+          fraction + [EMPTY_STRING] + integer
         end
 
-        def format_groups(format, string)
-          format.format_groups(numeric_string(string, format))
+        def increment_integer(reversed)
+          digits, carry = digit_sequence.increment_reversed(reversed, overflow: ZERO)
+          digits << "1" if carry.positive?
+          digits
         end
 
-        def numeric_string(string, format)
-          string.split(format.separator).join
+        def round_char_index(chars, result_length)
+          digit_sequence.digit?(chars[result_length]) ? result_length : result_length.next
         end
 
-        def sig_char_count?(chars)
-          start_counting = false
-          char_count = 0
-          chars.each do |char|
-            start_counting = true if DIGIT_VALUE[char]&.positive?
-            next unless start_counting
+        def remaining_fraction_chars(chars)
+          return 0 unless chars.include?(CANONICAL_DECIMAL)
 
-            char_count += 1 if DIGIT_VALUE.key?(char)
-          end
-          char_count == significant
+          [significant - digit_sequence.significant_digit_count(chars), 0].max
+        end
+
+        def digit_count(chars, fraction:)
+          stop_at = fraction ? nil : CANONICAL_DECIMAL
+          digit_sequence.digit_count(chars, stop_at: stop_at)
+        end
+
+        def sig_char_count?(chars)
+          digit_sequence.significant_digit_count(chars) == significant
         end
 
         def process_chars(chars, sig_num: false, frac_part: false)
           sig_count = significant
           new_chars = []
           chars.each do |char|
-            frac_part ||= char == decimal
-            sig_num ||= DIGIT_VALUE[char]&.positive?
+            frac_part ||= char == CANONICAL_DECIMAL
+            sig_num ||= digit_sequence.significant?(char)
             break if sig_count.zero?
 
             new_chars << char
             next unless sig_num
-            next unless DIGIT_VALUE.key?(char)
+            next unless digit_sequence.digit?(char)
 
             sig_count -= 1
           end
@@ -137,23 +126,8 @@ module Plurimath
         end
 
         def skip_significant_processing?(chars)
-          # Skip if no significant digits exist, or if we already have the exact count needed
-          chars.none? { |c| DIGIT_VALUE.key?(c) && DIGIT_VALUE[c].positive? } ||
-            count_chars(chars, true) == significant
-        end
-
-        def count_significant_digits(chars)
-          # Count actual significant digits in the character array
-          # Leading zeros don't count as significant
-          start_counting = false
-          char_count = 0
-          chars.each do |char|
-            start_counting = true if DIGIT_VALUE[char]&.positive?
-            next unless start_counting
-
-            char_count += 1 if DIGIT_VALUE.key?(char)
-          end
-          char_count
+          digit_sequence.significant_digit_count(chars).zero? ||
+            digit_count(chars, fraction: true) == significant
         end
       end
     end

data/lib/plurimath/formatter/numbers/source.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module Plurimath
+  module Formatter
+    module Numbers
+      # Captures raw input, BigDecimal interpretation, and source digit metadata
+      # before formatter transforms run.
+      class Source
+        attr_reader :decimal, :exponent, :exponent_text, :fraction_digits,
+                    :integer_digits, :raw, :sign
+
+        DEFAULT_INTEGER = "0"
+        EMPTY_STRING = ""
+
+        def initialize(value)
+          @raw = value.to_s
+          @decimal = BigDecimal(raw)
+          @sign = raw.start_with?("-") ? -1 : 1
+
+          mantissa, @exponent_text = unsigned_value.split("e", 2)
+          @exponent = exponent_text.to_i
+          @integer_digits, @fraction_digits = split_mantissa(mantissa)
+        end
+
+        def fractional?
+          fraction_digits.length > exponent
+        end
+
+        def decimal_precision
+          decimal_digits.last.length
+        end
+
+        def notation_precision
+          precision = integer_digits.length + fraction_digits.length - 1
+          precision += 1 if sign.negative?
+          [precision, 0].max
+        end
+
+        def significant_digit_count
+          significant_digits.length
+        end
+
+        def target_base_integer_length(base)
+          return decimal_parts_integer_length if base == Base::DEFAULT_BASE
+
+          integer = decimal.abs.to_i
+          return 0 if integer.zero?
+
+          integer.to_s(base).length
+        end
+
+        def to_parts(base: nil, precision: nil)
+          integer, fraction = decimal_digits
+          fraction = apply_precision(fraction, precision)
+
+          Parts.new(
+            sign: sign,
+            base: base || Base::DEFAULT_BASE,
+            integer_digits: integer,
+            fraction_digits: fraction,
+          )
+        end
+
+        def trailing_fraction_zero_count
+          return 0 if fraction_digits.empty?
+
+          fraction_digits.length - fraction_digits.sub(/0+\z/, "").length
+        end
+
+        private
+
+        def decimal_parts_integer_length
+          parts = to_parts
+          return 0 if parts.integer_zero?
+
+          parts.integer_digits.length
+        end
+
+        def apply_precision(fraction, precision)
+          return fraction unless precision
+
+          size = precision.to_i
+          return EMPTY_STRING unless size.positive?
+
+          fraction[0...size]
+        end
+
+        def decimal_digits
+          digits = "#{integer_digits}#{fraction_digits}"
+          decimal_index = integer_digits.length + exponent
+
+          if decimal_index <= 0
+            [DEFAULT_INTEGER, "#{'0' * decimal_index.abs}#{digits}"]
+          elsif decimal_index >= digits.length
+            ["#{digits}#{'0' * (decimal_index - digits.length)}", EMPTY_STRING]
+          else
+            [digits[0...decimal_index], digits[decimal_index..]]
+          end
+        end
+
+        def significant_digits
+          "#{integer_digits}#{fraction_digits}".sub(/\A0+/, "")
+        end
+
+        def split_mantissa(mantissa)
+          integer, fraction = mantissa.split(".", 2)
+          integer = DEFAULT_INTEGER if integer.to_s.empty?
+
+          [integer, fraction.to_s]
+        end
+
+        def unsigned_value
+          raw.downcase.sub(/\A[-+]/, "")
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/formatter/numbers/symbol_resolver.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Formatter
+    module Numbers
+      # Merges locale defaults, explicit symbols, and localize_number templates
+      # into a fresh symbol hash for one formatter call.
+      class SymbolResolver
+        LOCALIZE_NUMBER_REGEX = %r{(?<group>[^#])?(?<groupdigits>#+0)(?<decimal>.)(?<fractdigits>#+)(?<fractgroup>[^#])?}
+
+        def initialize(locale, localizer_symbols:, localize_number:)
+          @locale = locale
+          @localizer_symbols = localizer_symbols
+          @localize_number = localize_number
+        end
+
+        def resolve
+          locale_symbols
+            .merge(localizer_symbols_hash)
+            .merge(localize_number_symbols)
+        end
+
+        private
+
+        attr_reader :locale, :localizer_symbols, :localize_number
+
+        def locale_symbols
+          Formatter::SupportedLocales::LOCALES[locale.to_sym].dup
+        end
+
+        def localizer_symbols_hash
+          return {} unless localizer_symbols
+
+          localizer_symbols.respond_to?(:to_h) ? localizer_symbols.to_h : localizer_symbols
+        end
+
+        def localize_number_symbols
+          localize_number or return {}
+          match = LOCALIZE_NUMBER_REGEX.match(localize_number) or return {}
+          {
+            decimal: match[:decimal],
+            group_digits: match[:groupdigits].size,
+            fraction_group_digits: match[:fractdigits].size,
+            group: normalize_space(match[:group] || ""),
+            fraction_group: normalize_space(match[:fractgroup] || ""),
+          }.compact
+        end
+
+        def normalize_space(value)
+          value == " " ? "\u00A0" : value
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/formatter/numbers.rb

@@ -4,9 +4,20 @@ module Plurimath
   module Formatter
     module Numbers
       autoload :Base, "#{__dir__}/numbers/base"
+      autoload :DigitSequence, "#{__dir__}/numbers/digit_sequence"
+      autoload :BaseNotation, "#{__dir__}/numbers/base_notation"
       autoload :Fraction, "#{__dir__}/numbers/fraction"
+      autoload :FormatOptions, "#{__dir__}/numbers/format_options"
       autoload :Integer, "#{__dir__}/numbers/integer"
+      autoload :NumberRenderer, "#{__dir__}/numbers/number_renderer"
+      autoload :NotationRenderer, "#{__dir__}/numbers/notation_renderer"
+      autoload :Parts, "#{__dir__}/numbers/parts"
+      autoload :PartsRenderer, "#{__dir__}/numbers/parts_renderer"
+      autoload :PrecisionResolver, "#{__dir__}/numbers/precision_resolver"
+      autoload :SignRenderer, "#{__dir__}/numbers/sign_renderer"
       autoload :Significant, "#{__dir__}/numbers/significant"
+      autoload :Source, "#{__dir__}/numbers/source"
+      autoload :SymbolResolver, "#{__dir__}/numbers/symbol_resolver"
     end
   end
 end

data/lib/plurimath/formatter/standard.rb

@@ -3,14 +3,13 @@
 module Plurimath
   module Formatter
     class Standard < Plurimath::NumberFormatter
-      attr_accessor :precision
-
       DEFAULT_OPTIONS = {
         fraction_group_digits: 3,
         exponent_sign: nil,
         fraction_group: "'",
         number_sign: nil,
         notation: :basic,
+        padding: "0",
         group_digits: 3,
         significant: 0,
         digit_count: 0,
@@ -21,8 +20,12 @@ module Plurimath
         e: "e",
       }.freeze
 
-      def initialize(locale: "en", string_format: nil, options: {},
-precision: nil)
+      def initialize(
+        locale: "en",
+        string_format: nil,
+        options: {},
+        precision: nil
+      )
         super(
           locale,
           localize_number: string_format,
@@ -32,46 +35,33 @@ precision: nil)
       end
 
       def set_default_options(options)
-        default_options = self.class::DEFAULT_OPTIONS
-        self.precision ||= default_options[:precision]
-        options ||= default_options
-        unless options.key?(:fraction_group_digits)
-          options[:fraction_group_digits] =
-            default_options[:fraction_group_digits]
-        end
-        unless options.key?(:fraction_group)
-          options[:fraction_group] =
-            default_options[:fraction_group]
-        end
-        unless options.key?(:exponent_sign)
-          options[:exponent_sign] =
-            default_options[:exponent_sign]
-        end
-        unless options.key?(:group_digits)
-          options[:group_digits] =
-            default_options[:group_digits]
-        end
-        unless options.key?(:number_sign)
-          options[:number_sign] =
-            default_options[:number_sign]
-        end
-        unless options.key?(:significant)
-          options[:significant] =
-            default_options[:significant]
-        end
-        unless options.key?(:notation)
-          options[:notation] =
-            default_options[:notation]
-        end
-        unless options.key?(:decimal)
-          options[:decimal] =
-            default_options[:decimal]
-        end
-        options[:group] = default_options[:group] unless options.key?(:group)
-        options[:times] = default_options[:times] unless options.key?(:times)
-        options[:e] = default_options[:e] unless options.key?(:e)
+        options = options ? options.dup : {}
+        apply_default_symbols(options)
         options
       end
+
+      private
+
+      def apply_default_symbols(options)
+        %i[
+          fraction_group_digits
+          fraction_group
+          exponent_sign
+          group_digits
+          padding
+          number_sign
+          significant
+          notation
+          decimal
+          group
+          times
+          e
+        ].each { |key| default_key(options, key) }
+      end
+
+      def default_key(options, key)
+        options[key] = self.class::DEFAULT_OPTIONS[key] unless options.key?(key)
+      end
     end
   end
 end

data/lib/plurimath/formatter/supported_locales.rb

@@ -101,6 +101,33 @@ module Plurimath
         zh: { decimal: ".", group: "," },
         zu: { decimal: ".", group: "," },
       }.freeze
+
+      class << self
+        def decimal_for(locale, default:)
+          symbols_for(locale).fetch(:decimal, default)
+        end
+
+        def symbols_for(locale)
+          locale_key = key_for(locale)
+          return {} unless locale_key
+
+          LOCALES.fetch(locale_key)
+        end
+
+        def key_for!(locale)
+          locale_key = key_for(locale)
+          return locale_key if locale.nil? || locale_key
+
+          raise UnsupportedLocale.new(locale, LOCALES.keys)
+        end
+
+        def key_for(locale)
+          return locale if LOCALES.key?(locale)
+
+          symbol_key = locale.to_sym if locale.respond_to?(:to_sym)
+          symbol_key if LOCALES.key?(symbol_key)
+        end
+      end
     end
   end
 end

data/lib/plurimath/formatter.rb

@@ -2,10 +2,9 @@
 
 module Plurimath
   module Formatter
-    autoload :NumericFormatter, "#{__dir__}/formatter/numeric_formatter"
-    autoload :NumberFormatter, "#{__dir__}/formatter/number_formatter"
     autoload :SupportedLocales, "#{__dir__}/formatter/supported_locales"
     autoload :UnsupportedBase, "#{__dir__}/errors/formatter/unsupported_base"
+    autoload :UnsupportedLocale, "#{__dir__}/errors/formatter/unsupported_locale"
     autoload :Numbers, "#{__dir__}/formatter/numbers"
     autoload :Standard, "#{__dir__}/formatter/standard"
   end

data/lib/plurimath/html/constants.rb

@@ -38,6 +38,8 @@ module Plurimath
       SUB_SUP_CLASSES = {
         "∏": :prod,
         "∑": :sum,
+        "∏": :prod,
+        "∑": :sum,
         log: :log,
         lim: :lim,
         "∏": :prod,