plurimath 0.11.0 → 0.11.1

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

@@ -5,17 +5,30 @@ module Plurimath
     module Numbers
       # Chooses which precision source wins for one render call.
       class PrecisionResolver
-        def resolve(source, precision:, base:, significant:, notation_supported:)
+        def resolve(source, precision:, base:, significant:,
+notation_supported:, digit_count: 0)
           return precision if precision
 
-          significant_precision = significant_base_precision(source, base, significant)
+          significant_precision = significant_base_precision(source, base,
+                                                             significant)
           return significant_precision if significant_precision
 
           # Source owns input-derived digit lengths; this resolver only decides
           # which precision rule wins. Plain decimal rendering preserves
           # fractional scale, while notation precision controls coefficient
           # digits after the leading digit.
-          return source.notation_precision if notation_supported
+          if notation_supported
+            # A requested digit budget (significant or digit_count) widens the
+            # coefficient fraction beyond the source's own significant digits
+            # (one digit leads, so the fraction allowance is budget - 1).
+            budget = [significant, digit_count].max
+            if budget.positive?
+              return [budget - 1,
+                      source.notation_precision].max
+            end
+
+            return source.notation_precision
+          end
 
           source.decimal_precision
         end

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

@@ -20,7 +20,8 @@ module Plurimath
         def prefix(number)
           return "-" if number.negative?
 
-          "+" if positive_sign&.to_sym == :plus
+          # FormatOptions delivers a normalized Symbol (or nil) here.
+          "+" if positive_sign == :plus
         end
       end
     end

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

@@ -75,7 +75,8 @@ module Plurimath
 
           fraction = reversed[0...decimal_index]
           integer = reversed[(decimal_index + 1)..]
-          fraction, carry = digit_sequence.increment_reversed(fraction, overflow: EMPTY_STRING)
+          fraction, carry = digit_sequence.increment_reversed(fraction,
+                                                              overflow: EMPTY_STRING)
           return fraction + [CANONICAL_DECIMAL] + integer unless carry.positive?
 
           integer = increment_integer(integer)
@@ -83,7 +84,8 @@ module Plurimath
         end
 
         def increment_integer(reversed)
-          digits, carry = digit_sequence.increment_reversed(reversed, overflow: ZERO)
+          digits, carry = digit_sequence.increment_reversed(reversed,
+                                                            overflow: ZERO)
           digits << "1" if carry.positive?
           digits
         end

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

@@ -13,9 +13,13 @@ module Plurimath
 
         DEFAULT_INTEGER = "0"
         EMPTY_STRING = ""
+        # Stricter than BigDecimal(), which tolerates underscores, surrounding
+        # junk after partial parses, and Infinity/NaN spellings.
+        NUMERIC_PATTERN = /\A[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?\z/
 
         def initialize(value)
           @raw = value.to_s
+          validate_numeric!(value)
           @decimal = BigDecimal(raw)
           @sign = raw.start_with?("-") ? -1 : 1
 
@@ -33,9 +37,13 @@ module Plurimath
         end
 
         def notation_precision
-          precision = integer_digits.length + fraction_digits.length - 1
-          precision += 1 if sign.negative?
-          [precision, 0].max
+          # A zero coefficient keeps the source's stated fraction width.
+          return fraction_digits.length if decimal.zero?
+
+          # The coefficient's fraction width is its significant-digit count
+          # minus the single leading digit; the sign and leading zeros carry
+          # no precision.
+          [significant_digit_count - 1, 0].max
         end
 
         def significant_digit_count
@@ -71,6 +79,13 @@ module Plurimath
 
         private
 
+        def validate_numeric!(value)
+          valid_type = value.is_a?(Numeric) || value.is_a?(String)
+          return if valid_type && NUMERIC_PATTERN.match?(raw)
+
+          raise Plurimath::Errors::InvalidNumber, value
+        end
+
         def decimal_parts_integer_length
           parts = to_parts
           return 0 if parts.integer_zero?

data/lib/plurimath/formatter/standard.rb

@@ -35,6 +35,12 @@ module Plurimath
       end
 
       def set_default_options(options)
+        unless options.nil? || options.is_a?(Hash)
+          raise Plurimath::ConfigurationError.new(
+            :invalid_formatter_option, option: :options, value: options, supported: "a Hash"
+          )
+        end
+
         options = options ? options.dup : {}
         apply_default_symbols(options)
         options

data/lib/plurimath/formatter/supported_locales.rb

@@ -118,7 +118,7 @@ module Plurimath
           locale_key = key_for(locale)
           return locale_key if locale.nil? || locale_key
 
-          raise UnsupportedLocale.new(locale, LOCALES.keys)
+          raise Plurimath::Errors::UnsupportedLocale.new(locale, LOCALES.keys)
         end
 
         def key_for(locale)

data/lib/plurimath/formatter.rb

@@ -3,8 +3,6 @@
 module Plurimath
   module 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/transform.rb

@@ -202,25 +202,29 @@ module Plurimath
       rule(sub_sup: simple(:sub_sup),
            sub_value: simple(:sub_value),
            sup_value: simple(:sup_value)) do
-        TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value)
+        TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value,
+                                                sup_value: sup_value)
       end
 
       rule(sub_sup: simple(:sub_sup),
            sub_value: simple(:sub_value),
            sup_value: sequence(:sup_value)) do
-        TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value)
+        TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value,
+                                                sup_value: sup_value)
       end
 
       rule(sub_sup: simple(:sub_sup),
            sub_value: sequence(:sub_value),
            sup_value: simple(:sup_value)) do
-        TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value)
+        TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value,
+                                                sup_value: sup_value)
       end
 
       rule(sub_sup: simple(:sub_sup),
            sub_value: sequence(:sub_value),
            sup_value: sequence(:sup_value)) do
-        TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value)
+        TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value,
+                                                sup_value: sup_value)
       end
 
       # Parslet emits separate shapes for each sub/sup value combination and
@@ -303,7 +307,8 @@ module Plurimath
            sup_value: simple(:sup_value),
            expression: simple(:expression)) do
         TransformUtility.append_expression(
-          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value),
+          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value,
+                                                  sup_value: sup_value),
           expression,
         )
       end
@@ -313,7 +318,8 @@ module Plurimath
            sup_value: simple(:sup_value),
            expression: sequence(:expression)) do
         TransformUtility.append_expression(
-          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value),
+          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value,
+                                                  sup_value: sup_value),
           expression,
         )
       end
@@ -323,7 +329,8 @@ module Plurimath
            sup_value: sequence(:sup_value),
            expression: simple(:expression)) do
         TransformUtility.append_expression(
-          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value),
+          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value,
+                                                  sup_value: sup_value),
           expression,
         )
       end
@@ -333,7 +340,8 @@ module Plurimath
            sup_value: sequence(:sup_value),
            expression: sequence(:expression)) do
         TransformUtility.append_expression(
-          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value),
+          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value,
+                                                  sup_value: sup_value),
           expression,
         )
       end
@@ -343,7 +351,8 @@ module Plurimath
            sup_value: simple(:sup_value),
            expression: simple(:expression)) do
         TransformUtility.append_expression(
-          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value),
+          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value,
+                                                  sup_value: sup_value),
           expression,
         )
       end
@@ -353,7 +362,8 @@ module Plurimath
            sup_value: simple(:sup_value),
            expression: sequence(:expression)) do
         TransformUtility.append_expression(
-          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value),
+          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value,
+                                                  sup_value: sup_value),
           expression,
         )
       end
@@ -363,7 +373,8 @@ module Plurimath
            sup_value: sequence(:sup_value),
            expression: simple(:expression)) do
         TransformUtility.append_expression(
-          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value),
+          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value,
+                                                  sup_value: sup_value),
           expression,
         )
       end
@@ -373,7 +384,8 @@ module Plurimath
            sup_value: sequence(:sup_value),
            expression: sequence(:expression)) do
         TransformUtility.append_expression(
-          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value),
+          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value,
+                                                  sup_value: sup_value),
           expression,
         )
       end

data/lib/plurimath/math/core.rb

@@ -53,14 +53,15 @@ module Plurimath
         wrapper_tag << r_tag
       end
 
-      def omml_parameter(field, display_style, tag_name:, options:, namespace: "m")
+      def omml_parameter(field, display_style, tag_name:, options:,
+namespace: "m")
         tag = ox_element(tag_name, namespace: namespace)
         return empty_tag(tag) unless field
 
         field_value = if field.is_a?(Array)
-                        field.map { |object|
- object.insert_t_tag(display_style, options: options)
-}
+                        field.map do |object|
+                          object.insert_t_tag(display_style, options: options)
+                        end
                       else
                         field.insert_t_tag(display_style, options: options)
                       end
@@ -106,7 +107,7 @@ module Plurimath
 
         options[:array] << field&.to_asciimath_math_zone(
           hashed[:function_spacing], hashed[:last], hashed[:indent], options: options[:options]
-)
+        )
       end
 
       def latex_fields_to_print(field, options = {})
@@ -131,7 +132,7 @@ module Plurimath
 
         options[:array] << field&.to_mathml_math_zone(
           hashed[:function_spacing], hashed[:last], hashed[:indent], options: options[:options]
-)
+        )
       end
 
       def omml_fields_to_print(field, options = {})
@@ -156,13 +157,13 @@ module Plurimath
 
         options[:array] << field&.to_unicodemath_math_zone(
           hashed[:function_spacing], hashed[:last], hashed[:indent], options: options[:options]
-)
+        )
       end
 
       def dump_mathml(field, intent = false, options:)
         dump_ox_nodes(field.mathml_nodes(intent, options: options)).gsub(
           /\n\s*/, ""
-)
+        )
       end
 
       def dump_omml(field, display_style, options:)
@@ -170,7 +171,7 @@ module Plurimath
 
         dump_ox_nodes(field.omml_nodes(display_style, options: options)).gsub(
           /\n\s*/, ""
-)
+        )
       end
 
       def mathml_nodes(intent, options:)
@@ -260,8 +261,10 @@ module Plurimath
           case field
           when Core
             field.line_breaking(obj)
-            updated_object_values(variable, obj: obj,
-                                            update_value: true) if obj.value_exist?
+            if obj.value_exist?
+              updated_object_values(variable, obj: obj,
+                                              update_value: true)
+            end
           when Array
             array_line_break_field(field, variable, obj)
           end
@@ -361,9 +364,9 @@ module Plurimath
         return false unless field.is_a?(Math::Symbols::Symbol)
         return true if field&.value&.include?("&#x27;")
 
-        Utility.primes_constants.any? { |_prefix, prime|
- unicodemath_field_value(field).include?(prime)
-}
+        Utility.primes_constants.any? do |_prefix, prime|
+          unicodemath_field_value(field).include?(prime)
+        end
       end
 
       def paren?

data/lib/plurimath/math/function/overleftrightarrow.rb

@@ -14,7 +14,7 @@ module Plurimath
         def to_mathml_without_math_tag(intent, options:)
           mover = ox_element("mover")
           first_value = parameter_one&.to_mathml_without_math_tag(intent,
-                                                                    options: options)
+                                                                  options: options)
           if attributes && attributes[:accent]
             mover[:accent] =
               attributes[:accent]
@@ -36,7 +36,7 @@ module Plurimath
           else
             symbol = Symbols::Symbol.new("\u20e1")
             Overset.new(parameter_one, symbol).to_omml_without_math_tag(true,
-                                                                          options: options)
+                                                                        options: options)
           end
         end
 

data/lib/plurimath/math/number.rb

@@ -103,11 +103,21 @@ module Plurimath
         elsif formatter.respond_to?(:format)
           formatter.format(options[:formula], self)
         elsif formatter.respond_to?(:localized_number)
-          formatter.localized_number(value.to_s)
+          formatter.localized_number(value.to_s,
+                                     **format_kwargs(options[:format]))
         else
           value
         end
       end
+
+      private
+
+      # Empty splat is silently dropped by Ruby, so simple formatter signatures still work.
+      def format_kwargs(format)
+        return {} unless format.is_a?(Hash) && !format.empty?
+
+        { format: format }
+      end
     end
   end
 end

data/lib/plurimath/math.rb

@@ -32,7 +32,10 @@ module Plurimath
       unknown_options = options.keys - SUPPORTED_PARSE_OPTIONS
       raise_unknown_parse_options!(unknown_options) unless unknown_options.empty?
 
-      raise_unsupported_parse_option!(type, :locale) if options.key?(:locale) && !localized_parse_type?(type)
+      if options.key?(:locale) && !localized_parse_type?(type)
+        raise_unsupported_parse_option!(type,
+                                        :locale)
+      end
       options = normalize_parse_options(options)
 
       begin

data/lib/plurimath/number_formatter.rb

@@ -2,7 +2,7 @@
 
 module Plurimath
   class NumberFormatter
-    attr_accessor :locale, :localize_number, :localizer_symbols, :precision
+    attr_accessor :locale, :precision, :localize_number, :localizer_symbols
 
     def initialize(
       locale = "en",
@@ -24,7 +24,8 @@ module Plurimath
     )
       locale = supported_locale(locale)
       source = Formatter::Numbers::Source.new(number_string)
-      options = format_options(source, locale, precision, format)
+      options = format_options(source, locale, precision,
+                               validated_format(format))
 
       if options.notation_supported?
         return notation_renderer(options).render(source, options.notation)
@@ -39,6 +40,28 @@ module Plurimath
 
     private
 
+    # localize_number/localizer_symbols are not per-option-hardened — they feed
+    # SymbolResolver directly — so validate their types at the point of use (see
+    # #symbol_resolver). That single check covers the constructor, the public
+    # writers, and any later mutation, raising a clean ConfigurationError
+    # instead of leaking a TypeError out of SymbolResolver.
+    def validated_localize_number(value)
+      return value if value.nil? || value.is_a?(String)
+
+      raise Plurimath::ConfigurationError.new(
+        :invalid_formatter_option, option: :localize_number, value: value, supported: "a String"
+      )
+    end
+
+    def validated_localizer_symbols(value)
+      return {} if value.nil?
+      return value if value.is_a?(Hash)
+
+      raise Plurimath::ConfigurationError.new(
+        :invalid_formatter_option, option: :localizer_symbols, value: value, supported: "a Hash"
+      )
+    end
+
     def format_options(source, locale, precision, format)
       Formatter::Numbers::FormatOptions.new(
         source,
@@ -66,8 +89,8 @@ module Plurimath
     def symbol_resolver(locale)
       Formatter::Numbers::SymbolResolver.new(
         locale,
-        localizer_symbols: localizer_symbols,
-        localize_number: localize_number,
+        localizer_symbols: validated_localizer_symbols(localizer_symbols),
+        localize_number: validated_localize_number(localize_number),
       )
     end
 
@@ -76,7 +99,25 @@ module Plurimath
     end
 
     def supported_locale(locale)
+      # Locale always falls back to :en for any unsupported value, including
+      # nil and non-string/symbol types; it never raises.
+      return :en unless locale.is_a?(String) || locale.is_a?(Symbol)
+
       Formatter::SupportedLocales::LOCALES.key?(locale.to_sym) ? locale.to_sym : :en
     end
+
+    def validated_format(format)
+      return {} if format.nil?
+      unless format.is_a?(Hash)
+        raise Plurimath::ConfigurationError.new(
+          :invalid_formatter_option,
+          option: :format,
+          value: format,
+          supported: "a Hash of formatter options",
+        )
+      end
+
+      format
+    end
   end
 end

data/lib/plurimath/omml/formula_transformation.rb

@@ -216,7 +216,8 @@ module Plurimath
       def accent_value(value)
         accent = value.first
         unless accent.is_a?(Math::Function::UnaryFunction)
-          return Math::Function::Overset.new(accent, value.last, { accent: true })
+          return Math::Function::Overset.new(accent, value.last,
+                                             { accent: true })
         end
 
         accent.attributes = { accent: true }

data/lib/plurimath/omml/translator.rb

@@ -241,7 +241,10 @@ module Plurimath
         chr = first_omml_child(pr&.chr)&.val
         value = omml_argument_value(node.e)
 
-        return group_character_above_value(chr, value) if group_character_above?(pr)
+        if group_character_above?(pr)
+          return group_character_above_value(chr,
+                                             value)
+        end
 
         group_character_below_value(chr, value)
       end