plurimath 0.11.1 → 0.11.4

data/lib/plurimath/number_formatter.rb

@@ -2,7 +2,7 @@
 
 module Plurimath
   class NumberFormatter
-    attr_accessor :locale, :precision, :localize_number, :localizer_symbols
+    attr_accessor :locale, :localize_number, :localizer_symbols, :precision
 
     def initialize(
       locale = "en",
@@ -21,11 +21,27 @@ module Plurimath
       locale: @locale,
       precision: @precision,
       format: {}
+    )
+      result = formatted_number(
+        number_string,
+        locale: locale,
+        precision: precision,
+        format: format,
+      )
+      result.to_s
+    end
+
+    def formatted_number(
+      number_string,
+      locale: @locale,
+      precision: @precision,
+      format: {}
     )
       locale = supported_locale(locale)
-      source = Formatter::Numbers::Source.new(number_string)
-      options = format_options(source, locale, precision,
-                               validated_format(format))
+      format = validated_format(format)
+      base = format.fetch(:base, Formatter::Numbers::Base::DEFAULT_BASE)
+      source = Formatter::Numbers::Source.new(number_string, base: base)
+      options = format_options(source, locale, precision, format)
 
       if options.notation_supported?
         return notation_renderer(options).render(source, options.notation)
@@ -34,34 +50,20 @@ module Plurimath
       render_localized_number(source, options)
     end
 
+    # Formula-aware entry point. Returns a FormattedNumber,
+    # FormattedNotation, or String. Override in subclasses that need the
+    # Formula/Number context for rendering decisions; the default delegates
+    # to #formatted_number with the merged format hash.
+    def format_number(_formula, number, format: {})
+      formatted_number(number.value.to_s, format: format)
+    end
+
     def twitter_cldr_reader(locale: @locale)
       symbols_for(supported_locale(locale), {})
     end
 
     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,
@@ -98,9 +100,9 @@ module Plurimath
       symbol_resolver(locale).resolve.merge(format)
     end
 
+    # Locale always falls back to :en for any unsupported value, including
+    # nil and non-string/symbol types; it never raises.
     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
@@ -119,5 +121,22 @@ module Plurimath
 
       format
     end
+
+    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
   end
 end

data/lib/plurimath/omml/formula_transformation.rb

@@ -102,21 +102,36 @@ module Plurimath
       end
 
       def linebreak_child?(node, child)
+        return true if ct_br_child?(child)
+
         child == "" && node.respond_to?(:br) && node.br == ""
       end
 
+      def ct_br_child?(child)
+        return false unless child.is_a?(Object)
+
+        Lutaml::Model::Utils.base_class_name(child.class.name) == "CTBr"
+      end
+
       def styled_run?(children)
         children.length > 1 && !children.first.is_a?(Math::Core)
       end
 
       def styled_run_value(children)
-        font = children.first
+        fonts, content = children.partition do |child|
+          font_style_class?(child)
+        end
+        font = fonts.first
         font.new(
-          Utility.filter_values(children.drop(1)),
+          Utility.filter_values(content),
           Utility::FONT_STYLES.key(font).to_s,
         )
       end
 
+      def font_style_class?(value)
+        value.is_a?(Class) && value <= Math::Function::FontStyle
+      end
+
       def script_function_value(script_class, node)
         script_class.new(
           omml_argument_value(node.sub),

data/lib/plurimath/omml/translator.rb

@@ -58,6 +58,8 @@ module Plurimath
              "CTCtrlPr", "CTBoxPr" then nil
         when "CTRPr" then word_run_properties_to_plurimath(node)
         when "CTRPR" then math_run_properties_to_plurimath(node)
+        when "CTBr" then Math::Function::Linebreak.new
+        when "CTWordprocessingEmpty", "CTWordprocessingText" then nil
         else
           unsupported_node!(node)
         end

data/lib/plurimath/setup/opal.rb.erb

@@ -1,6 +1,19 @@
 # Preload Math namespace/core so symbol classes resolve correctly in Opal.
 require 'plurimath/math'
 require 'plurimath/math/core'
+require 'plurimath/math/evaluation'
+require 'plurimath/errors/evaluation'
+require 'plurimath/errors/evaluation/error'
+require 'plurimath/errors/evaluation/missing_variable_error'
+require 'plurimath/errors/evaluation/unsupported_expression_error'
+require 'plurimath/errors/evaluation/division_by_zero_error'
+require 'plurimath/errors/evaluation/invalid_binding_error'
+require 'plurimath/errors/evaluation/invalid_binding_key_error'
+require 'plurimath/errors/evaluation/math_domain_error'
+require 'plurimath/errors/evaluation/non_finite_result_error'
+require 'plurimath/math/evaluation/evaluator'
+require 'plurimath/math/evaluation/expression_parser'
+require 'plurimath/math/evaluation/iteration'
 require 'plurimath/math/symbols/symbol'
 require 'plurimath/math/symbols/paren'
 

data/lib/plurimath/unicode_math/parse.rb

@@ -3,6 +3,7 @@
 module Plurimath
   class UnicodeMath
     class Parse < Parslet::Parser
+      include Plurimath::BaseNumberPrefix::Parser
       include ParsingRules::Masked
       include ParsingRules::SubSup
       include ParsingRules::CommonRules
@@ -162,7 +163,10 @@ module Plurimath
       end
 
       rule(:number) do
-        (digits.as(:whole) >> op_decimal.as(:decimal) >> digits.as(:fractional)).as(:decimal_number) |
+        hex_number |
+          binary_number |
+          octal_number |
+          (digits.as(:whole) >> op_decimal.as(:decimal) >> digits.as(:fractional)).as(:decimal_number) |
           (op_decimal.as(:decimal) >> digits.as(:whole) >> space?).as(:decimal_number) |
           digits.as(:digit)
       end