plurimath 0.11.11 → 0.11.13

data/lib/plurimath/omml/translator.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../mathml/uncertainty_marker"
+
 module Plurimath
   class Omml
     class Translator
@@ -261,9 +263,75 @@ module Plurimath
       end
 
       def box_to_plurimath(node)
+        children = ordered_omml_children(first_omml_child(node.e))
+        marker = uncertainty_marker_text(children.first)
+        return box_to_uncertainty(marker, children.drop(1)) if marker
+
         omml_argument_value(node.e)
       end
 
+      # An m:box whose first child is a hidden m:phant holding an
+      # uncertainty marker (plurimath#493). The marker is authoritative; the
+      # visible content is regenerated on output, so only the inner m:box
+      # holding the unit is read.
+      def box_to_uncertainty(marker, visible)
+        Mathml::UncertaintyMarker.build(marker) do
+          units = visible.select { |child| omml_class?(child, "CTBox") }
+          if units.length > 1
+            raise Errors::InvalidUncertainty.new(
+              "marker #{marker.inspect}: more than one m:box could hold the unit",
+            )
+          end
+
+          unit = units.first && box_to_plurimath(units.first)
+          unit.nil? || unit.is_a?(Math::Formula) ? unit : Math::Formula.new([unit])
+        end
+      end
+
+      def uncertainty_marker_text(phantom)
+        return unless omml_class?(phantom, "CTPhant") && hidden_phantom?(phantom)
+
+        text = phantom_run_text(phantom)
+        text if Mathml::UncertaintyMarker.marker?(text)
+      end
+
+      # The text of a phantom made only of runs, or nil. A phantom whose
+      # leading runs spell a marker but which also holds anything other than
+      # runs is a malformed marker: it raises rather than being read as
+      # ordinary content.
+      def phantom_run_text(phantom)
+        children = ordered_omml_children(first_omml_child(phantom.e))
+        runs = children.take_while { |child| omml_class?(child, "CTR") }
+        text = runs.map { |run| run_text(run) }.join
+        return text if runs.any? && runs.length == children.length
+
+        reject_mixed_phantom(text)
+      end
+
+      def reject_mixed_phantom(text)
+        return unless Mathml::UncertaintyMarker.marker?(text)
+
+        raise Errors::InvalidUncertainty.new(
+          "marker #{text.inspect}: the hidden m:phant must hold only m:r runs",
+        )
+      end
+
+      def hidden_phantom?(phantom)
+        show = first_omml_child(first_omml_child(phantom.phant_pr)&.show)
+        show && %w[0 false off].include?(show.val.to_s)
+      end
+
+      def run_text(run)
+        ordered_omml_children(run).filter_map do |child|
+          child.content.to_s if omml_class?(child, "CTText")
+        end.join
+      end
+
+      def omml_class?(node, name)
+        !node.nil? && !node.is_a?(String) &&
+          Lutaml::Model::Utils.base_class_name(node.class.name) == name
+      end
+
       def word_run_properties_to_plurimath(node)
         word_run_font(node)
       end

data/lib/plurimath/omml/utility.rb

@@ -10,6 +10,14 @@ module Plurimath
     class Utility < Plurimath::Utility
       extend Plurimath::Mathml::FunctionTokenResolver
 
+      # A run whose whole text is a number: digits with an optional
+      # decimal part. OMML has no <mn>/<mi> split, so the run's text
+      # decides. A mixed run such as "2x" stays text, "1,5" stays a
+      # symbol (list or decimal is ambiguous), and a signed run such as
+      # "-1" stays a symbol: the shared testsuite expects that for
+      # superscripts like sin^-1, and to_omml writes the sign as its own run.
+      NUMBER_RUN = /\A[[:digit:]]+(?:\.[[:digit:]]+)?\z/
+
       class << self
         def valid_class(object)
           text = object.extract_class_name_from_text
@@ -88,7 +96,7 @@ module Plurimath
           text = filter_values(text) unless text.is_a?(String)
           return text if text.is_a?(Math::Core)
 
-          if text.scan(/[[:digit:]]/).length == text.length
+          if text.match?(NUMBER_RUN)
             Math::Number.new(text)
           elsif text.match?(/[a-zA-Z]/)
             Math::Function::Text.new(text, lang: :omml)

data/lib/plurimath/symbol_documentation.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Plurimath
+  # Per-symbol metadata for the catalog (see Plurimath::Catalog), extended into
+  # Symbols::Symbol. Symbols are documented differently from functions: a symbol
+  # is an atomic glyph with no arguments, so it needs no hand-authored
+  # description, reference, or example — its four renderings ARE its
+  # documentation. Everything here is derived, so every concrete symbol is
+  # catalogued without per-class declarations. (Functions, by contrast, each
+  # explain themselves via the separate Plurimath::Documentation.)
+  module SymbolDocumentation
+    # Slug for the /symbols/<name>/ page and YAML filename: Alpha -> "alpha".
+    def catalog_name
+      name.split("::").last.downcase
+    end
+
+    def catalog_type
+      :symbol
+    end
+
+    def catalog_kind
+      :symbol
+    end
+
+    def catalog_arity
+      nil
+    end
+
+    # The glyph itself, wrapped in a Formula for rendering.
+    def example_formula
+      Math::Formula.new([new])
+    end
+
+    # Anonymous subclasses have no stable catalog name and are excluded.
+    # Catalogued when the symbol is a concrete glyph — i.e. not one of the
+    # abstract bases (Symbol, Paren), which exist only to be subclassed. Checked
+    # by identity rather than by rendering: cheaper across the ~1,459 symbols and
+    # independent of which formats a given glyph happens to serialize to.
+    def documented?
+      !name.nil? && ![Math::Symbols::Symbol, Math::Symbols::Paren].include?(self)
+    end
+
+    # The YAML-ready entry: the glyph's name, type, and rendering in each format.
+    # Leaner than a function entry — a symbol carries no description or reference.
+    def catalog_entry
+      limitations = if const_defined?(:CATALOG_FORMAT_LIMITATIONS, false)
+                      const_get(:CATALOG_FORMAT_LIMITATIONS, false)
+                    else
+                      {}
+                    end
+      Catalog::Entry.build(
+        name: catalog_name, type: catalog_type, kind: catalog_kind,
+        arity: catalog_arity, formula: example_formula, limitations: limitations
+      )
+    end
+  end
+end

data/lib/plurimath/unicode_math/parsing_rules/common_rules.rb

@@ -56,7 +56,8 @@ module Plurimath
             (str("\\") >> custom_fonts.as(:unicoded_font_class) >> str("H").as(:symbol)) |
             (str("\\") >> str("mitBbb").as(:unicoded_font_class) >> match(/D|d|e|i|j/).as(:symbol)) |
             (op_fonts >> match["A-Za-z"].as(:symbol)) |
-            (op_alphanumeric_fonts >> (match["A-Za-z"].as(:symbol) | match("[0-9]").as(:number)))
+            (op_alphanumeric_fonts >> (match["A-Za-z"].as(:symbol) | match("[0-9]").as(:number))) |
+            ((op_fonts | op_alphanumeric_fonts) >> parsing_text)
         end
 
         rule(:unary_arg_functions) do

data/lib/plurimath/unicode_math/parsing_rules/masked.rb

@@ -35,8 +35,11 @@ module Plurimath
         rule(:root_symbols) do
           str("⒭") | str("√") | str("\\root") | str("\\surd")
         end
+        # The middle form takes content of several terms, e.g. ⓐ(unit \mupkg);
+        # `expression` alone stops after the first term (plurimath#493).
         rule(:arg_function) do
           (str("ⓐ").as(:arg) >> str("(") >> a_ascii.as(:arg_arguments).maybe >> space? >> expression.as(:first_value).maybe >> str(")")) |
+            (str("ⓐ").as(:arg) >> str("(") >> a_ascii.as(:arg_arguments) >> space? >> masked_recursive_value.as(:first_value) >> space? >> str(")")) |
             (str("ⓐ").as(:arg) >> a_ascii.as(:arg_arguments).maybe >> space? >> expression.as(:first_value).maybe)
         end
 

data/lib/plurimath/unicode_math/transform.rb

@@ -233,6 +233,13 @@ module Plurimath
         Utility.symbols_class((unicode || symbol), lang: :unicodemath)
       end
 
+      # \mup"g" is how a font over text is written (e.g. a unit read from
+      # OMML, plurimath#493).
+      rule(font_class: simple(:fonts),
+           text: simple(:text)) do
+        Utility::FONT_STYLES[fonts.to_sym].new(Math::Function::Text.new(text))
+      end
+
       rule(font_class: simple(:fonts),
            symbol: simple(:symbol)) do
         Utility::FONT_STYLES[fonts.to_sym].new(
@@ -530,6 +537,18 @@ module Plurimath
         [Utility.symbols_class(symbol, lang: :unicodemath), exp]
       end
 
+      rule(combined_symbols: simple(:combined_symbols),
+           expr: simple(:expr)) do
+        symbol = Constants::COMBINING_SYMBOLS[combined_symbols.to_sym] || combined_symbols
+        [Utility.symbols_class(symbol, lang: :unicodemath), expr]
+      end
+
+      rule(combined_symbols: simple(:combined_symbols),
+           expr: sequence(:expr)) do
+        symbol = Constants::COMBINING_SYMBOLS[combined_symbols.to_sym] || combined_symbols
+        [Utility.symbols_class(symbol, lang: :unicodemath)] + expr
+      end
+
       rule(operator: simple(:operator),
            sub_script: simple(:sub_script)) do
         [Utility.symbols_class(operator, lang: :unicodemath), sub_script]
@@ -960,7 +979,7 @@ module Plurimath
       rule(intent: simple(:intent),
            intent_expr: simple(:expr)) do
         intent_string = expr.parameter_two.shift
-        Math::Function::Intent.new(
+        Utility.intent_or_uncertainty(
           Utility.filter_values(expr.parameter_two),
           intent_string,
         )
@@ -2218,12 +2237,30 @@ module Plurimath
         )
       end
 
+      # Any other ⓐ shape has no Arg reading; fail here rather than leave
+      # the raw parse tree inside the Formula. Parslet tries later rules
+      # first, so these catch-alls must stay above the Arg rules below.
+      rule(arg: simple(:arg)) { Utility.unsupported_arg! }
+      rule(arg: simple(:arg), arg_arguments: simple(:args)) { Utility.unsupported_arg! }
+      rule(arg: simple(:arg), first_value: subtree(:first_value)) { Utility.unsupported_arg! }
+      rule(arg: simple(:arg),
+           arg_arguments: simple(:args),
+           first_value: subtree(:first_value)) { Utility.unsupported_arg! }
+
       rule(arg: simple(:arg),
            arg_arguments: simple(:args),
            first_value: simple(:first_value)) do
         Math::Function::Arg.new(first_value, args)
       end
 
+      # ⓐ(unit \mupkg) reads its content as several nodes; keep them together
+      # so the argument (e.g. an uncertainty unit, plurimath#493) is not lost.
+      rule(arg: simple(:arg),
+           arg_arguments: simple(:args),
+           first_value: sequence(:first_value)) do
+        Math::Function::Arg.new(Math::Formula.new(first_value), args)
+      end
+
       rule(whole: simple(:whole),
            decimal: simple(:decimal),
            fractional: simple(:fractional)) do
@@ -3585,6 +3622,30 @@ module Plurimath
         )
       end
 
+      rule(open_paren: simple(:open_paren),
+           text: simple(:text),
+           operand: sequence(:operand),
+           exp: simple(:exp),
+           close_paren: simple(:close_paren)) do
+        Math::Function::Fenced.new(
+          open_paren.is_a?(Slice) ? Utility.symbols_class(open_paren, lang: :unicodemath) : open_paren,
+          [Math::Function::Text.new(text)] + operand + [exp],
+          close_paren.is_a?(Slice) ? Utility.symbols_class(close_paren, lang: :unicodemath) : close_paren,
+        )
+      end
+
+      rule(open_paren: simple(:open_paren),
+           text: simple(:text),
+           operand: sequence(:operand),
+           exp: sequence(:exp),
+           close_paren: simple(:close_paren)) do
+        Math::Function::Fenced.new(
+          open_paren.is_a?(Slice) ? Utility.symbols_class(open_paren, lang: :unicodemath) : open_paren,
+          [Math::Function::Text.new(text)] + operand + exp,
+          close_paren.is_a?(Slice) ? Utility.symbols_class(close_paren, lang: :unicodemath) : close_paren,
+        )
+      end
+
       rule(nary_class: simple(:nary_class),
            mask: simple(:mask),
            sub: simple(:sub),
@@ -3871,7 +3932,7 @@ module Plurimath
            intent_arguments: simple(:args),
            first_value: simple(:value),
            close_paren: simple(:close_paren)) do
-        Math::Function::Intent.new(value, args)
+        Utility.intent_or_uncertainty(value, args)
       end
 
       rule(intent: simple(:intent),
@@ -3879,7 +3940,7 @@ module Plurimath
            intent_arguments: simple(:args),
            first_value: sequence(:value),
            close_paren: simple(:close_paren)) do
-        Math::Function::Intent.new(Utility.filter_values(value), args)
+        Utility.intent_or_uncertainty(Utility.filter_values(value), args)
       end
 
       rule(paren_open_prefix: simple(:open_paren),

data/lib/plurimath/unicode_math/utility.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../mathml/uncertainty_marker"
+
 module Plurimath
   class UnicodeMath
     # UnicodeMath-specific helpers extracted from Plurimath::Utility (code-quality
@@ -7,6 +9,42 @@ module Plurimath
     # UnicodeMath files keep resolving here and inherit the generic helpers.
     class Utility < Plurimath::Utility
       class << self
+        # ⓘ("marker" content) is a measurement uncertainty (plurimath#493)
+        # when the marker uses one of its concept names; any other intent
+        # stays a Function::Intent. The marker is authoritative, so only the
+        # ⓐ(unit ...) argument of the content is read.
+        def intent_or_uncertainty(content, intent)
+          marker = intent.is_a?(Math::Function::Text) ? intent.parameter_one : intent.to_s
+          unless Mathml::UncertaintyMarker.marker?(marker)
+            return Math::Function::Intent.new(content, intent)
+          end
+
+          Mathml::UncertaintyMarker.build(marker) do
+            uncertainty_unit(content, marker)
+          end
+        end
+
+        def uncertainty_unit(content, marker)
+          values = content.is_a?(Math::Formula) ? content.value : Array(content)
+          units = values.select do |value|
+            value.is_a?(Math::Function::Arg) &&
+              value.parameter_two.is_a?(Math::Symbols::Symbol) &&
+              value.parameter_two.value == "unit"
+          end
+          if units.length > 1
+            raise Errors::InvalidUncertainty.new(
+              "marker #{marker.inspect}: more than one ⓐ(unit ...) argument",
+            )
+          end
+
+          unit = units.first&.parameter_one
+          unit.nil? || unit.is_a?(Math::Formula) ? unit : Math::Formula.new([unit])
+        end
+
+        def unsupported_arg!
+          raise ArgumentError, "ⓐ needs a name and content, as in ⓐ(name content)"
+        end
+
         def unicode_accents(accents, lang: :unicodemath)
           if accents.is_a?(Math::Function::BinaryFunction)
             accents

data/lib/plurimath/version.rb

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

data/lib/plurimath.rb

@@ -8,9 +8,12 @@ require "plurimath/xml_engine"
 module Plurimath
   autoload :Asciimath, "plurimath/asciimath"
   autoload :BaseNumberPrefix, "plurimath/base_number_prefix"
+  autoload :Catalog, "plurimath/catalog"
   autoload :Cli, "plurimath/cli" unless RUBY_ENGINE == "opal"
   autoload :Configuration, "plurimath/configuration"
   autoload :Deprecation, "plurimath/deprecation"
+  autoload :Documentation, "plurimath/documentation"
+  autoload :SymbolDocumentation, "plurimath/symbol_documentation"
   autoload :Error, "plurimath/errors/error"
   autoload :ConfigurationError, "plurimath/errors/configuration_error"
   autoload :DeprecationError, "plurimath/errors/deprecation_error"

data/plurimath.gemspec

@@ -27,9 +27,11 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
+  # amath comes from the Gemfile (GitHub) until it is published; then:
+  # spec.add_dependency "amath", "~> 0.1"
   spec.add_dependency "bigdecimal"
   spec.add_dependency "htmlentities"
-  spec.add_dependency "lutaml-model", "~> 0.8.65"
+  spec.add_dependency "lutaml-model", "~> 0.8.155"
   spec.add_dependency "mml", "~> 2.4.2"
   spec.add_dependency "omml", "~> 0.2.5"
   spec.add_dependency "ostruct"