plurimath 0.10.7 → 0.11.0

data/lib/plurimath/latex/transform.rb

@@ -5,7 +5,7 @@ module Plurimath
     class Transform < Parslet::Transform
       rule(base: simple(:base))       { base }
       rule(over: simple(:over))       { over }
-      rule(number: simple(:num))      { Math::Number.new(num) }
+      rule(number: simple(:num))      { Math::Number.new(Utility.html_entity_to_unicode(num.to_s)) }
       rule(power: simple(:power))     { power }
       rule(unary: simple(:unary))     { Utility.get_class(unary).new }
       rule(space: simple(:space))     { Math::Function::Text.new(" ") }
@@ -188,7 +188,7 @@ module Plurimath
            number: simple(:number)) do
         Math::Function::Power.new(
           power,
-          Math::Number.new(number),
+          Math::Number.new(Utility.html_entity_to_unicode(number.to_s)),
         )
       end
 
@@ -428,7 +428,7 @@ module Plurimath
       rule(number: simple(:number),
            subscript: simple(:subscript)) do
         Math::Function::Base.new(
-          Math::Number.new(number),
+          Math::Number.new(Utility.html_entity_to_unicode(number.to_s)),
           subscript,
         )
       end
@@ -436,7 +436,7 @@ module Plurimath
       rule(number: simple(:number),
            supscript: simple(:supscript)) do
         Math::Function::Power.new(
-          Math::Number.new(number),
+          Math::Number.new(Utility.html_entity_to_unicode(number.to_s)),
           supscript,
         )
       end
@@ -445,7 +445,7 @@ module Plurimath
            subscript: simple(:subscript),
            supscript: simple(:supscript)) do
         Math::Function::PowerBase.new(
-          Math::Number.new(number),
+          Math::Number.new(Utility.html_entity_to_unicode(number.to_s)),
           subscript,
           supscript,
         )

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

@@ -28,6 +28,12 @@ module Plurimath
           "\\#{class_name}#{first_value}#{second_value}"
         end
 
+        def to_html(options:)
+          first_value = "<i>#{parameter_one.to_html(options: options)}</i>" if parameter_one
+          second_value = "<i>#{parameter_two.to_html(options: options)}</i>" if parameter_two
+          "<i>lim</i>#{first_value}#{second_value}"
+        end
+
         def to_mathml_without_math_tag(intent, options:)
           first_value = Utility.ox_element("mo") << "lim"
           return first_value unless any_value_exist?

data/lib/plurimath/math/number.rb

@@ -93,8 +93,14 @@ module Plurimath
       end
 
       def format_value_with_options(options)
-        formatter = options[:formatter]
-        if formatter.respond_to?(:format)
+        formatter = options.fetch(:formatter) do
+          Plurimath.configuration.number_formatter
+        end
+        return value unless formatter
+
+        if formatter.respond_to?(:format_number)
+          formatter.format_number(options[:formula], self)
+        elsif formatter.respond_to?(:format)
           formatter.format(options[:formula], self)
         elsif formatter.respond_to?(:localized_number)
           formatter.localized_number(value.to_s)

data/lib/plurimath/math/symbols/cdot.rb

@@ -9,7 +9,7 @@ module Plurimath
           mathml: ["⋅"],
           latex: [["cdot", "⋅"], parsing_wrapper(["*"], lang: :latex)],
           omml: ["⋅"],
-          html: ["⋅"],
+          html: ["⋅", "⋅"],
         }.freeze
 
         # output methods

data/lib/plurimath/math/symbols/exclam.rb

@@ -10,7 +10,7 @@ module Plurimath
           mathml: ["!"],
           latex: [["exclam", "!", "!"]],
           omml: ["!"],
-          html: ["!"],
+          html: ["!", "!"],
         }.freeze
 
         # output methods

data/lib/plurimath/math/symbols/minus.rb

@@ -10,7 +10,7 @@ module Plurimath
           mathml: ["−", "-"],
           latex: [["minus", "-", "−"]],
           omml: ["−"],
-          html: ["−"],
+          html: ["−", "-"],
         }.freeze
 
         # output methods

data/lib/plurimath/math/symbols/percent.rb

@@ -10,7 +10,7 @@ module Plurimath
           mathml: ["%"],
           latex: [["percent", "%", "%"]],
           omml: ["%"],
-          html: ["%"],
+          html: ["%", "%"],
         }.freeze
 
         # output methods

data/lib/plurimath/math/symbols/pi.rb

@@ -10,7 +10,7 @@ module Plurimath
           mathml: ["π", "𝜋"],
           latex: ["pi", "uppi", "π", "𝜋"],
           omml: ["π", "𝜋"],
-          html: ["π", "𝜋"],
+          html: ["π", "π", "𝜋"],
         }.freeze
 
         # output methods

data/lib/plurimath/math/symbols/slash.rb

@@ -10,7 +10,7 @@ module Plurimath
           mathml: ["∕"],
           latex: [["divslash", "slash", "/", "∕"]],
           omml: ["∕"],
-          html: ["∕"],
+          html: ["∕", "/"],
         }.freeze
 
         # output methods

data/lib/plurimath/math.rb

@@ -7,6 +7,7 @@ module Plurimath
     autoload :Function, "#{__dir__}/math/function"
     autoload :InvalidTypeError, "#{__dir__}/errors/invalid_type_error"
     autoload :Number, "#{__dir__}/math/number"
+    autoload :ParseOptionError, "#{__dir__}/errors/parse_option_error"
     autoload :ParseError, "#{__dir__}/errors/parse_error"
     autoload :Symbols, "#{__dir__}/math/symbols"
 
@@ -19,15 +20,23 @@ module Plurimath
       unicode: UnicodeMath,
       asciimath: Asciimath,
     }.freeze
+    SUPPORTED_PARSE_OPTIONS = %i[locale].freeze
+    LOCALIZED_PARSE_TYPES = %i[asciimath html latex unicode].freeze
 
-    def parse(text, type)
+    module_function
+
+    def parse(text, type, **options)
       raise InvalidTypeError.new unless valid_type?(type)
 
+      type = type.to_sym
+      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)
+      options = normalize_parse_options(options)
+
       begin
-        klass = klass_from_type(type)
-        formula = klass.new(text).to_formula
-        formula.input_string = text
-        formula
+        parse_with_configuration(text, type, options)
       rescue ParseError
         # Re-raise ParseError from lower layers unchanged to preserve specialized error types
         raise
@@ -36,17 +45,56 @@ module Plurimath
       end
     end
 
-    private
+    def parse_with_configuration(text, type, options)
+      return parse_formula(text, type) unless options.key?(:locale)
+
+      Plurimath.with_configuration do |config|
+        config.locale = options.fetch(:locale)
+        parse_formula(text, type)
+      end
+    end
+
+    def parse_formula(text, type)
+      klass = klass_from_type(type)
+      formula = klass.new(text).to_formula
+      formula.input_string = text
+      formula
+    end
 
     def klass_from_type(type_string_or_sym)
       VALID_TYPES[type_string_or_sym.to_sym]
     end
 
+    def normalize_parse_options(options)
+      return options unless options.key?(:locale)
+
+      options.merge(
+        locale: Formatter::SupportedLocales.key_for!(options.fetch(:locale)),
+      )
+    end
+
+    def localized_parse_type?(type)
+      LOCALIZED_PARSE_TYPES.include?(type)
+    end
+
+    def raise_unknown_parse_options!(options)
+      raise ParseOptionError.unknown_options(
+        options,
+        supported_options: SUPPORTED_PARSE_OPTIONS,
+      )
+    end
+
+    def raise_unsupported_parse_option!(type, option)
+      raise ParseOptionError.unsupported_options(
+        type,
+        [option],
+        supported_types: LOCALIZED_PARSE_TYPES,
+      )
+    end
+
     def valid_type?(type)
       (type.is_a?(::Symbol) || type.is_a?(String)) &&
         VALID_TYPES.key?(type.to_sym)
     end
-
-    module_function :parse, :klass_from_type, :valid_type?
   end
 end

data/lib/plurimath/number_formatter.rb

@@ -1,52 +1,82 @@
 # frozen_string_literal: true
 
-require "bigdecimal"
-
 module Plurimath
   class NumberFormatter
     attr_accessor :locale, :localize_number, :localizer_symbols, :precision
 
-    def initialize(locale = "en", localize_number: nil, localizer_symbols: {},
-precision: nil)
+    def initialize(
+      locale = "en",
+      localize_number: nil,
+      localizer_symbols: {},
+      precision: nil
+    )
       @locale = supported_locale(locale)
       @localize_number = localize_number
       @localizer_symbols = localizer_symbols
       @precision = precision
     end
 
-    def localized_number(number_string, locale: @locale, precision: @precision,
-format: {})
-      prev_symbols = symbols(locale.to_sym).dup
-      Formatter::NumericFormatter.new(
-        supported_locale(locale),
-        localize_number: localize_number,
-        localizer_symbols: localizer_symbols,
-      ).localized_number(
-        number_string,
-        locale: supported_locale(locale),
+    def localized_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, format)
+
+      if options.notation_supported?
+        return notation_renderer(options).render(source, options.notation)
+      end
+
+      render_localized_number(source, options)
+    end
+
+    def twitter_cldr_reader(locale: @locale)
+      symbols_for(supported_locale(locale), {})
+    end
+
+    private
+
+    def format_options(source, locale, precision, format)
+      Formatter::Numbers::FormatOptions.new(
+        source,
+        symbols: symbols_for(locale, format),
         precision: precision,
-        format: format,
+        precision_resolver: precision_resolver,
       )
-    ensure
-      symbols(locale.to_sym).replace(prev_symbols)
     end
 
-    def twitter_cldr_reader(locale: @locale)
-      Formatter::NumericFormatter.new(
-        supported_locale(locale),
-        localize_number: localize_number,
+    def notation_renderer(options)
+      Formatter::Numbers::NotationRenderer.new(options)
+    end
+
+    def precision_resolver
+      @precision_resolver ||= Formatter::Numbers::PrecisionResolver.new
+    end
+
+    def render_localized_number(source, options)
+      Formatter::Numbers::NumberRenderer.new(
+        source,
+        options,
+      ).format
+    end
+
+    def symbol_resolver(locale)
+      Formatter::Numbers::SymbolResolver.new(
+        locale,
         localizer_symbols: localizer_symbols,
-      ).twitter_cldr_reader
+        localize_number: localize_number,
+      )
     end
 
-    private
+    def symbols_for(locale, format)
+      symbol_resolver(locale).resolve.merge(format)
+    end
 
     def supported_locale(locale)
       Formatter::SupportedLocales::LOCALES.key?(locale.to_sym) ? locale.to_sym : :en
     end
-
-    def symbols(locale)
-      Formatter::SupportedLocales::LOCALES[locale]
-    end
   end
 end

data/lib/plurimath/unicode_math/parse.rb

@@ -35,7 +35,7 @@ module Plurimath
       rule(:op_opener) { open_paren | op_open_unicode | op_open_paren | op_open }
       rule(:op_closer) { op_close_unicode | close_paren | op_close_paren | op_close }
 
-      rule(:op_decimal) { str(",") | str(".") }
+      rule(:op_decimal) { decimal_marker | str(",") | str(".") }
       rule(:diacritics) { (char.as(:char) >> diacritics.as(:diacritics)) | char.as(:char) }
       rule(:open_paren) { (op_masked_open >> (op_closer | op_opener)).as(:open_paren) | op_masked_open }
 
@@ -242,6 +242,12 @@ module Plurimath
       end
 
       root :expression
+
+      def decimal_marker
+        # UnicodeMath::Parser entity-encodes input before Parslet sees it, so
+        # non-ASCII locale markers must match that encoded parser input.
+        str(Utility.string_to_html_entity(Plurimath.configuration.decimal))
+      end
     end
   end
 end

data/lib/plurimath/unicode_math/transform.rb

@@ -185,7 +185,7 @@ module Plurimath
 
       rule(decimal: simple(:decimal),
            whole: simple(:whole)) do
-        Math::Number.new("#{decimal}#{whole.value}")
+        Math::Number.new(Utility.html_entity_to_unicode("#{decimal}#{whole.value}"))
       end
 
       rule(positive: simple(:positive),
@@ -2222,7 +2222,7 @@ module Plurimath
       rule(whole: simple(:whole),
            decimal: simple(:decimal),
            fractional: simple(:fractional)) do
-        Math::Number.new("#{whole.value}#{decimal}#{fractional.value}")
+        Math::Number.new(Utility.html_entity_to_unicode("#{whole.value}#{decimal}#{fractional.value}"))
       end
 
       rule(factor: simple(:factor),

data/lib/plurimath/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Plurimath
-  VERSION = "0.10.7"
+  VERSION = "0.11.0"
 end

data/lib/plurimath.rb

@@ -8,6 +8,11 @@ require "plurimath/xml_engine"
 module Plurimath
   autoload :Asciimath, "plurimath/asciimath"
   autoload :Cli, "plurimath/cli" unless RUBY_ENGINE == "opal"
+  autoload :Configuration, "plurimath/configuration"
+  autoload :Deprecation, "plurimath/deprecation"
+  autoload :Error, "plurimath/errors/error"
+  autoload :ConfigurationError, "plurimath/errors/configuration_error"
+  autoload :DeprecationError, "plurimath/errors/deprecation_error"
   autoload :Formatter, "plurimath/formatter"
   autoload :Html, "plurimath/html"
   autoload :Latex, "plurimath/latex"
@@ -28,7 +33,24 @@ module Plurimath
     Mml::V4::Configuration.adapter = adapter unless Mml::V4::Configuration.adapter
   end
 
-  module_function :mml_adapter
+  def configuration
+    @configuration ||= Configuration.new
+  end
+
+  def configure
+    yield(configuration)
+  end
+
+  def with_configuration
+    # Swap the global config to an isolated copy so block mutations are scoped.
+    previous_configuration = configuration
+    @configuration = previous_configuration.dup
+    yield(configuration)
+  ensure
+    @configuration = previous_configuration
+  end
+
+  module_function :mml_adapter, :configuration, :configure, :with_configuration
 end
 
 default_adapter =

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plurimath
 version: !ruby/object:Gem::Version
-  version: 0.10.7
+  version: 0.11.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-09 00:00:00.000000000 Z
+date: 2026-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -193,19 +193,35 @@ files:
 - lib/plurimath/asciimath/parser.rb
 - lib/plurimath/asciimath/transform.rb
 - lib/plurimath/cli.rb
+- lib/plurimath/configuration.rb
+- lib/plurimath/deprecation.rb
 - lib/plurimath/errors.rb
+- lib/plurimath/errors/configuration_error.rb
+- lib/plurimath/errors/deprecation_error.rb
+- lib/plurimath/errors/error.rb
 - lib/plurimath/errors/formatter/unsupported_base.rb
+- lib/plurimath/errors/formatter/unsupported_locale.rb
 - lib/plurimath/errors/invalid_type_error.rb
 - lib/plurimath/errors/omml/unsupported_node_error.rb
 - lib/plurimath/errors/parse_error.rb
+- lib/plurimath/errors/parse_option_error.rb
 - lib/plurimath/formatter.rb
-- lib/plurimath/formatter/number_formatter.rb
 - lib/plurimath/formatter/numbers.rb
 - lib/plurimath/formatter/numbers/base.rb
+- lib/plurimath/formatter/numbers/base_notation.rb
+- lib/plurimath/formatter/numbers/digit_sequence.rb
+- lib/plurimath/formatter/numbers/format_options.rb
 - lib/plurimath/formatter/numbers/fraction.rb
 - lib/plurimath/formatter/numbers/integer.rb
+- lib/plurimath/formatter/numbers/notation_renderer.rb
+- lib/plurimath/formatter/numbers/number_renderer.rb
+- lib/plurimath/formatter/numbers/parts.rb
+- lib/plurimath/formatter/numbers/parts_renderer.rb
+- lib/plurimath/formatter/numbers/precision_resolver.rb
+- lib/plurimath/formatter/numbers/sign_renderer.rb
 - lib/plurimath/formatter/numbers/significant.rb
-- lib/plurimath/formatter/numeric_formatter.rb
+- lib/plurimath/formatter/numbers/source.rb
+- lib/plurimath/formatter/numbers/symbol_resolver.rb
 - lib/plurimath/formatter/standard.rb
 - lib/plurimath/formatter/supported_locales.rb
 - lib/plurimath/html.rb
@@ -213,6 +229,7 @@ files:
 - lib/plurimath/html/parse.rb
 - lib/plurimath/html/parser.rb
 - lib/plurimath/html/transform.rb
+- lib/plurimath/html/transform_utility.rb
 - lib/plurimath/latex.rb
 - lib/plurimath/latex/constants.rb
 - lib/plurimath/latex/parse.rb

data/lib/plurimath/formatter/number_formatter.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-module Plurimath
-  module Formatter
-    class NumberFormatter
-      attr_reader :number, :data_reader
-
-      DEFAULT_BASE = Numbers::Base::DEFAULT_BASE
-      HEX_ALPHABETS = "abcdef"
-      STRING_SYMBOLS = {
-        dot: ".",
-        f: "F",
-      }.freeze
-      DEFAULT_BASE_PREFIXES = {
-        2 => "0b",
-        8 => "0o",
-        10 => "",
-        16 => "0x",
-      }.freeze
-
-      def initialize(number, data_reader = {})
-        @number = number
-        @data_reader = data_reader
-        @base = data_reader[:base] || DEFAULT_BASE
-        unless DEFAULT_BASE_PREFIXES.key?(@base)
-          raise UnsupportedBase.new(@base,
-                                    DEFAULT_BASE_PREFIXES)
-        end
-
-        # Handle base_prefix: if explicitly provided (even as nil), use it; otherwise use default
-        @base_prefix = if data_reader.key?(:base_prefix)
-                         data_reader[:base_prefix].to_s
-                       else
-                         DEFAULT_BASE_PREFIXES[@base]
-                       end
-      end
-
-      def format(precision: nil)
-        data_reader[:precision] = precision || precision_from(number)
-        int, frac, integer_format, fraction_format, signif_format = *partition_tokens(number)
-        # FIX FOR:
-        #   NotImplementedError: String#<< not supported. Mutable String methods are not supported in Opal.
-        result = []
-        result << integer_format.apply(int)
-        result << fraction_format.apply(frac, result, integer_format) # use formatted int for correct fraction formatting
-        result = result.join
-        result = signif_format.apply(result, integer_format, fraction_format)
-        result = result.tr(HEX_ALPHABETS, HEX_ALPHABETS.upcase) if upcase_hex?
-        result = pre_post_fixed(result) unless base_default?
-        "#{prefix_symbol}#{result}"
-      end
-
-      private
-
-      def upcase_hex?
-        @base == 16 && data_reader[:hex_capital]
-      end
-
-      def prefix_symbol
-        if number.negative?
-          "-"
-        elsif data_reader[:number_sign]&.to_sym == :plus
-          "+"
-        end
-      end
-
-      def pre_post_fixed(result)
-        if data_reader.key?(:base_postfix)
-          "#{result}#{data_reader[:base_postfix]}"
-        else
-          "#{@base_prefix}#{result}"
-        end
-      end
-
-      def partition_tokens(number)
-        int, fraction = parse_number(number)
-        [
-          int,
-          fraction,
-          Numbers::Integer.new(data_reader),
-          Numbers::Fraction.new(data_reader),
-          Numbers::Significant.new(data_reader),
-        ]
-      end
-
-      def precision_from(number)
-        return 0 if number.fix == number
-
-        parts = number.to_s(STRING_SYMBOLS[:f]).split(STRING_SYMBOLS[:dot])
-        parts.size == 2 ? parts[1].size : 0
-      end
-
-      def parse_number(number, options = data_reader)
-        precision = options[:precision] || precision_from(number)
-
-        abs = round_to(number, precision).abs
-        num = if precision.zero?
-                abs.fix.to_s(STRING_SYMBOLS[:f])
-              else
-                abs.round(precision).to_s(STRING_SYMBOLS[:f])
-              end
-        num.split(STRING_SYMBOLS[:dot])
-      end
-
-      def round_to(number, precision)
-        factor = BigDecimal(10).power(precision)
-        (number * factor).fix / factor
-      end
-
-      def base_default?
-        @base == DEFAULT_BASE
-      end
-    end
-  end
-end