plurimath 0.10.1 → 0.10.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc005169c3f0268023980ba0d02d40a3e169c73ec1c75541f1ea71d8cadf6de6
-  data.tar.gz: 0d9fb467134da2b44ad20d1952d1795f4fa7e233a657b5589ea3b5cf5e99fb26
+  metadata.gz: a2ce7ef29dd4032b83c86b06d92276325630994243ef48e193aa8d3092e2fe22
+  data.tar.gz: ebaec8740845b7f1cb76e690f95f349d98d18a0b1342528463d8af3187138d1c
 SHA512:
-  metadata.gz: c4d59a8681ab5b3b988d3a46ecfadc50661c43cc2d897816d943b3c621a6f8db202a8fca9b59c72fa732384284071aeec20851051b645cb7c29e4126fa0377d3
-  data.tar.gz: 54013f676433c00728a7b022b5c16ec3b77d2afd1949573ee56c0d90c936600289647cef2a886978e23da5be20af8d232dabf4e6ff9d3454dca77667f69d0f50
+  metadata.gz: a80a5ad2febd36bad53adc58c6a3d6406ee04bd78c05c2e3ea7eeecf0f924818798de20c745995ee38b161ffc3758389bb80d6ad6487de16183abdc12e88f166
+  data.tar.gz: 2f1258c3745a73a0c1d4336f489d1908cfc4691a19b093dc2d0a4bcd19612ad4d449a6f452ff963a27ca01aba6eada160be778e22f7705129fc44f43ad092985

data/README.adoc

@@ -1135,7 +1135,9 @@ method using a `formatter` option, which serializes the formula into an math
 representation language.
 
 The formatter should be an instance of `Plurimath::NumberFormatter` or a custom
-formatter derived from `Plurimath::Formatter::Standard`.
+formatter derived from `Plurimath::Formatter::Standard`. Custom formatters can
+define a `format(formula, number)` method to make context-aware formatting
+decisions based on the surrounding formula (see <<Contextual number formatting>>).
 
 The quick example below demonstrates how to format a number in a formula.
 
@@ -1346,6 +1348,60 @@ end
 ====
 
 
+==== Contextual number formatting
+
+In some cases, certain numbers within a formula should be formatted differently
+depending on their context. For example, a year like "2024" should not have digit
+grouping applied, while other numbers in the same formula should.
+
+The `format` method on the formatter receives both the root
+`Plurimath::Math::Formula` tree and the current `Plurimath::Math::Number` node
+being processed, allowing context-aware formatting decisions.
+
+.Signature of the `format` method
+[source,ruby]
+----
+def format(formula, number)
+  # formula: the root Plurimath::Math::Formula containing the full equation
+  # number:  the Plurimath::Math::Number node currently being formatted
+  # returns: a formatted string
+end
+----
+
+Formatters that do not define `format` will fall back to `localized_number`, so
+existing formatters continue to work without changes.
+
+To implement contextual formatting, define a `format` method in a custom
+formatter subclass.
+
+.Creating a year-aware formatter that skips digit grouping for year-like numbers
+[example]
+====
+[source,ruby]
+----
+class YearFormatter < Plurimath::Formatter::Standard
+  def format(formula, number) <1>
+    int_value = Integer(number.value, exception: false)
+    if int_value && int_value > 1800 && int_value < 2200 <2>
+      number.value.to_s
+    else
+      localized_number(number.value.to_s) <3>
+    end
+  end
+end
+
+formatter = YearFormatter.new
+formula = Plurimath::Math.parse("2024 + 1000000", :asciimath)
+formula.to_latex(formatter: formatter)
+# => "2024 + 1,000,000" <4>
+----
+<1> Define `format` to receive the formula tree and number node.
+<2> Detect year-like numbers and return them unformatted.
+<3> Call `localized_number` to apply locale-based formatting for other numbers.
+<4> "2024" is left as-is, while "1000000" is formatted with digit grouping.
+====
+
+
 [[standard_configuration]]
 === Default number formatting configuration
 

data/lib/plurimath/cli.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 require "thor"
+require_relative "../plurimath"
 
 module Plurimath
-  self.autoload :Math, "plurimath/math"
 
   class Cli < Thor
     desc "convert", "Convert between math formats"
@@ -43,6 +43,11 @@ module Plurimath
            desc: "Splits only MathML and OMML equations into multiple equations, Boolean only",
            force: :boolean
 
+    option :xml_engine,
+           aliases: "-e",
+           default: "ox",
+           desc: "XML engine to use for parsing and rendering (ox or oga)"
+
     def convert
       input          = options[:input]
       input_string   = options[:file_path] ? File.read(options[:file_path]) : input
@@ -50,6 +55,7 @@ module Plurimath
 
       input_format   = options[:input_format]
       output_format  = options[:output_format]
+      configure_xml_engine(input_format, output_format)
       formula        = Plurimath::Math.parse(input_string, input_format)
       return puts formula.to_display(output_format.to_sym) if YAML.safe_load(options[:math_rendering])
 
@@ -75,6 +81,27 @@ module Plurimath
     end
 
     no_commands do
+      def configure_xml_engine(input_format, output_format)
+        xml_formats = %w[mathml omml]
+        return unless xml_formats.include?(input_format) || xml_formats.include?(output_format)
+
+        set_xml_engine(options[:xml_engine])
+      end
+
+      def set_xml_engine(engine)
+        engine_class = case engine
+                       when "ox"
+                         require_relative "setup/ox_engine"
+                         Plurimath::XmlEngine::OxEngine
+                       when "oga"
+                         require_relative "setup/oga"
+                         Plurimath::XmlEngine::Oga
+                       else
+                         warn_and_exit("Invalid XML engine: #{engine}. Use 'ox' or 'oga'.")
+                       end
+        Plurimath.xml_engine = engine_class
+      end
+
       def warn_and_exit(message)
         warn(message)
         abort

data/lib/plurimath/formatter/numeric_formatter.rb

@@ -78,7 +78,10 @@ module Plurimath
       end
 
       def notation_chars(num_str)
-        notation_array = BigDecimal(num_str).to_s("e").split("e")
+        bd = BigDecimal(num_str)
+        return [num_str, 0] if bd.zero?
+
+        notation_array = bd.to_s("e").split("e")
         notation_array[1] = update_exponent_value(notation_array[1])
         number_str = notation_array[0]
         number_str = number_str.gsub(/0\.(\d)/, '\1.')

data/lib/plurimath/math/formula.rb

@@ -55,6 +55,7 @@ module Plurimath
 
       def to_asciimath(formatter: nil, unitsml: {}, options: nil)
         options ||= { formatter: formatter, unitsml: unitsml }.compact
+        options[:formula] ||= self
         wrap_render_error(:asciimath) do
           value.map do |val|
             val.to_asciimath(options: asciimath_table_options(options, val))
@@ -75,6 +76,7 @@ module Plurimath
           unitsml: unitsml,
           unary_function_spacing: unary_function_spacing
         }.compact
+        options[:formula] ||= self
         return line_breaked_mathml(display_style, intent, options: options) if split_on_linebreak
 
         wrap_render_error(:mathml) do
@@ -120,6 +122,7 @@ module Plurimath
 
       def to_latex(formatter: nil, unitsml: {}, options: nil)
         options ||= { formatter: formatter, unitsml: unitsml }.compact
+        options[:formula] ||= self
         wrap_render_error(:latex) do
           value.map { |val| val.to_latex(options: options) }.join(" ")
         end
@@ -127,6 +130,7 @@ module Plurimath
 
       def to_html(formatter: nil, unitsml: {}, options: nil)
         options ||= { formatter: formatter, unitsml: unitsml }.compact
+        options[:formula] ||= self
         wrap_render_error(:html) do
           value&.map { |val| val.to_html(options: options) }&.join(" ")
         end
@@ -136,6 +140,7 @@ module Plurimath
         wrap_render_error(:omml) do
           objects = split_on_linebreak ? new_line_support : [self]
           options = { formatter: formatter, unitsml: unitsml }.compact
+          options[:formula] ||= self
           para_element = Utility.ox_element("oMathPara", attributes: OMML_NAMESPACES, namespace: "m")
           objects.each.with_index(1) do |object, index|
             para_element << Utility.update_nodes(
@@ -160,6 +165,7 @@ module Plurimath
 
       def to_unicodemath(formatter: nil, unitsml: {}, options: nil)
         options ||= { formatter: formatter, unitsml: unitsml }.compact
+        options[:formula] ||= self
         wrap_render_error(:unicodemath) do
           Utility.html_entity_to_unicode(unicodemath_value(options: options)).gsub(/\s\/\s/, "/")
         end
@@ -171,6 +177,7 @@ module Plurimath
           unitsml: unitsml,
           unary_function_spacing: unary_function_spacing
         }
+        options[:formula] ||= self
         return type_error!(type) unless MATH_ZONE_TYPES.include?(type.downcase.to_sym)
 
         math_zone = case type

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

@@ -97,7 +97,7 @@ module Plurimath
           text = text.join if text.is_a?(Array)
           entities = HTMLEntities.new
           symbols  = Mathml::Constants::UNICODE_SYMBOLS.transform_keys(&:to_s)
-          text     = entities.encode(text, :hexadecimal)
+          text     = entities.encode(entities.decode(text), :hexadecimal)
           symbols.each do |code, string|
             text = text.gsub(code.downcase, "unicode[:#{string}]")
           end

data/lib/plurimath/math/number.rb

@@ -92,9 +92,14 @@ module Plurimath
       end
 
       def format_value_with_options(options)
-        return value unless options[:formatter]&.respond_to?(:localized_number)
-
-        options[:formatter].localized_number(value.to_s)
+        formatter = options[:formatter]
+        if formatter&.respond_to?(:format)
+          formatter.format(options[:formula], self)
+        elsif formatter&.respond_to?(:localized_number)
+          formatter.localized_number(value.to_s)
+        else
+          value
+        end
       end
     end
   end

data/lib/plurimath/mathml/constants.rb

@@ -141,6 +141,7 @@ module Plurimath
         "⏟": "ubrace",
         "→": "vec",
         "̂": "hat",
+        "̅": "bar",
         "̲": "ul",
         "¯": "bar",
         "&": "&",

data/lib/plurimath/omml/parser.rb

@@ -50,12 +50,16 @@ module Plurimath
           if node.is_a?(String)
             node == "​" ? nil : node
           elsif !node.attributes.empty?
-            {
-              node.name => {
-                attributes: node.attributes,
-                value: parse_nodes(node.nodes),
-              },
-            }
+            if node.attributes.key?("val")
+              { node.name => node.attributes["val"] }
+            else
+              {
+                node.name => {
+                  attributes: node.attributes,
+                  value: parse_nodes(node.nodes),
+                },
+              }
+            end
           else
             customize_tags(node) if CUSTOMIZABLE_TAGS.include?(node.name)
             { node.name => parse_nodes(node.nodes) }

data/lib/plurimath/omml/transform.rb

@@ -109,8 +109,10 @@ module Plurimath
 
       rule(dPr: subtree(:dpr)) do
         flatten_dpr = dpr.flatten.compact
-        open_paren  = Utility.string_to_html_entity(flatten_dpr.find { |hash| hash[:begChr] }&.values&.first)
-        close_paren = Utility.string_to_html_entity(flatten_dpr.find { |hash| hash[:endChr] }&.values&.first)
+        beg_entry = flatten_dpr.find { |hash| hash[:begChr] }
+        end_entry = flatten_dpr.find { |hash| hash[:endChr] }
+        open_paren  = Utility.string_to_html_entity(beg_entry ? beg_entry.values.first : "(")
+        close_paren = Utility.string_to_html_entity(end_entry ? end_entry.values.first : ")")
         sep_chr     = flatten_dpr.find { |hash| hash[:sepChr] }
         open_paren_object = Utility.symbol_object(open_paren, lang: :omml) if open_paren && !open_paren.empty?
         close_paren_object = Utility.symbol_object(close_paren, lang: :omml) if close_paren && !close_paren.empty?
@@ -165,8 +167,17 @@ module Plurimath
         index = acc_value.index { |d| d[:chr] }
         acc_value[index] = chr_value
         Utility.unary_function_classes(acc_value, lang: :omml)
-        acc_value.first.attributes = { accent: true }
-        acc_value.first
+        first = acc_value.first
+        if first.is_a?(Math::Function::UnaryFunction)
+          first.attributes = { accent: true }
+          first
+        else
+          # chr resolved to a Symbol, wrap in Overset
+          Math::Function::Overset.new(
+            acc_value.last,
+            first,
+          )
+        end
       end
 
       rule(func: subtree(:func)) do

data/lib/plurimath/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plurimath
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.10.2
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-23 00:00:00.000000000 Z
+date: 2026-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ox