plurimath 0.11.6 → 0.11.7

data/lib/plurimath/math/model_helper.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Math
+    # Display/serialization support helpers for the Math node classes,
+    # extracted from Plurimath::Utility (macro refactor). Deliberately a
+    # standalone class — NOT a Utility subclass — so it does not shadow
+    # bareword `Utility` references inside math files.
+    class ModelHelper
+      TEXT_CLASSES = %w[
+        symbol
+        number
+        text
+      ].freeze
+
+      class << self
+        def validate_left_right(fields = [])
+          fields.each do |field|
+            if field.is_a?(Math::Formula) && field.value.first.is_a?(Math::Function::Left)
+              field.left_right_wrapper = true
+            end
+          end
+        end
+
+        def validate_math_zone(object, lang:, intent: false, options: nil)
+          return false unless object
+
+          if object.is_a?(Math::Formula)
+            filter_math_zone_values(object.value, lang: lang, intent: intent,
+                                                  options: options).find do |value|
+              !(value.is_a?(Math::Function::Text) || value.is_a?(Math::Symbols::Symbol))
+            end
+          else
+            !(TEXT_CLASSES.include?(object.class_name) || object.is_a?(Math::Symbols::Symbol))
+          end
+        end
+
+        def filter_math_zone_values(value, lang:, intent: false, options: nil)
+          return [] if value.nil? || value.empty?
+
+          new_arr = []
+          temp_array = []
+          skip_index = nil
+          value.each_with_index do |obj, index|
+            object = obj.dup
+            next if index == skip_index
+            if TEXT_CLASSES.include?(object.class_name) || math_display_text_objects(object)
+              next temp_array << (if object.is_a?(Math::Symbols::Symbol)
+                                    symbol_to_text(
+                                      object, lang: lang, intent: intent, options: options
+                                    )
+                                  else
+                                    object.value
+                                  end)
+            end
+
+            if temp_array.any?
+              new_arr << Math::Function::Text.new(temp_array.join(" "),
+                                                  lang: lang)
+            end
+            temp_array = []
+            new_arr << object
+          end
+          if temp_array.any?
+            new_arr << Math::Function::Text.new(temp_array.join(" "),
+                                                lang: lang)
+          end
+          new_arr
+        end
+
+        def notations_to_mask(notations)
+          mask = notations.split.map do |notation|
+            Utility::MASK_CLASSES.key(notation)
+          end
+          mask.compact.sum ^ 15
+        end
+
+        private
+
+        def symbol_to_text(symbol, lang:, options:, intent: false)
+          case lang
+          when :asciimath
+            symbol.to_asciimath(options: options)
+          when :latex
+            symbol.to_latex(options: options)
+          when :mathml
+            symbol.to_mathml_without_math_tag(intent,
+                                              options: options).nodes.first
+          when :omml
+            symbol.to_omml_without_math_tag(true, options: options)
+          when :unicodemath
+            symbol.to_unicodemath(options: options)
+          end
+        end
+
+        def math_display_text_objects(object)
+          class_names = ["plus", "minus", "circ", "equal", "symbol"].freeze
+          class_names.include?(object.class_name)
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/math/number.rb

@@ -60,7 +60,7 @@ module Plurimath
 
       def insert_t_tag(_, options:)
         [
-          Utility.ox_element("r", namespace: "m") << t_tag(options: options),
+          XmlHelper.ox_element("r", namespace: "m") << t_tag(options: options),
         ]
       end
 
@@ -69,7 +69,7 @@ module Plurimath
       end
 
       def t_tag(options:)
-        Utility.ox_element("t",
+        XmlHelper.ox_element("t",
                            namespace: "m") << formatted_value(options)
       end
 

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

@@ -83,7 +83,7 @@ module Plurimath
           # TODO: remove this condition once to word rendering issue is resolved, plurimath/plurimath/pull/328
           return if value == "⁢"
 
-          [Utility.ox_element("r", namespace: "m") << t_tag(options: options)]
+          [XmlHelper.ox_element("r", namespace: "m") << t_tag(options: options)]
         end
 
         def tag_name
@@ -234,7 +234,7 @@ options:)
         end
 
         def t_element
-          Utility.ox_element("t", namespace: "m")
+          XmlHelper.ox_element("t", namespace: "m")
         end
 
         def explicit_checks(unicode)

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

@@ -3,7 +3,7 @@ module Plurimath
     module Symbols
       class Tilde < Symbol
         INPUT = {
-          unicodemath: [["~"]],
+          unicodemath: [["&#x303;", "~"]],
           asciimath: [["~"]],
           mathml: ["~"],
           latex: [["~"]],

data/lib/plurimath/math.rb

@@ -5,6 +5,7 @@ module Plurimath
     autoload :Core, "#{__dir__}/math/core"
     autoload :Evaluation, "#{__dir__}/math/evaluation"
     autoload :Formula, "#{__dir__}/math/formula"
+    autoload :ModelHelper, "#{__dir__}/math/model_helper"
     autoload :Function, "#{__dir__}/math/function"
     autoload :InvalidTypeError, "#{__dir__}/errors/invalid_type_error"
     autoload :Number, "#{__dir__}/math/number"

data/lib/plurimath/mathml/constants.rb

@@ -29,7 +29,7 @@ module Plurimath
         "π": "pi",
         "Π": "Pi",
         "ρ": "rho",
-        "ς": "beta",
+        "ς": "varsigma",
         "σ": "sigma",
         "Σ": "Sigma",
         "τ": "tau",
@@ -41,7 +41,7 @@ module Plurimath
         "ψ": "psi",
         "Ψ": "Psi",
         "ω": "omega",
-        "Ω": "omega",
+        "Ω": "Omega",
         "⋅": "cdot",
         "∙": "*",
         ".": ".",
@@ -155,6 +155,16 @@ module Plurimath
         "¯": "bar",
         _: "ul",
       }.freeze
+
+      # Accent characters promoted to their function class ONLY in an accent
+      # position (MathML <mover>, OMML <m:acc>). Kept separate from
+      # UNICODE_SYMBOLS because Text#value= consumes that map as a global
+      # substitution table, so an entry there would also rewrite the character
+      # inside ordinary text runs and bare tokens.
+      CONTEXTUAL_ACCENT_FUNCTIONS = {
+        "&#x303;": "tilde",
+      }.freeze
+
       SYMBOLS = {
         "|": "|",
         "/": "//",
@@ -174,22 +184,25 @@ module Plurimath
         "+": "+",
         "-": "-",
       }.freeze
-      # Over/under accent decorations. In MathML these are only ever expressed
-      # as <mover>/<munder> with a base (recovered from their diacritic
-      # CHARACTER), never as a bare <mi>/<mo> identifier word. So a bare token
-      # whose text is one of these names is a literal identifier (e.g. the unit
-      # "bar"), not the accent. See unitsml/unitsdb#123.
-      ACCENT_WORDS = %w[
-        bar overline ul hat vec tilde dot ddot obrace ubrace overleftrightarrow
+      # Named operators that have no dedicated MathML/OMML representation — no
+      # unicode character and no structural element — so a bare <mi>/<mo>/<m:t>
+      # word (e.g. <mi>sin</mi>, <m:t>min</m:t>) is their only written form and
+      # resolves to the function class. Every other CLASSES entry has a proper
+      # form — a diacritic character (bar/hat/vec via <mover>), a unicode symbol
+      # (sum/prod/int via &#x2211; etc.), or a structural element (frac via
+      # <mfrac>/<m:f>, sqrt via <msqrt>) — so its bare word is a literal
+      # identifier, not the function. See PR #450 (which introduced this for accents).
+      NAMED_FUNCTION_WORDS = %w[
+        arccos arcsin arctan sin cos tan sec csc cot sinh cosh tanh coth sech
+        csch log ln exp det dim gcd lcm glb lub max min mod
       ].freeze
 
-      # True when +string+ is a bare word naming an over/under accent. Such
-      # tokens are literal identifiers in MathML (the accent itself is a
-      # diacritic character inside <mover>/<munder>), so callers must not
-      # promote them to accent operators. AsciiMath/LaTeX word forms
-      # (bar(x), \bar{x}) are parsed elsewhere and never reach this predicate.
-      def self.accent_word?(string)
-        ACCENT_WORDS.include?(string&.strip)
+      # True when +string+ is a bare word naming an operator that has no other
+      # MathML/OMML representation, so it legitimately resolves to its function
+      # class. Words for constructs that DO have a character/structural form
+      # (accents, sum/prod/int, frac/sqrt/...) return false and stay literal.
+      def self.named_function_word?(string)
+        NAMED_FUNCTION_WORDS.include?(string&.strip)
       end
 
       CLASSES = %w[
@@ -255,145 +268,6 @@ module Plurimath
         ul
         ln
       ].freeze
-      OPERATORS = [
-        "&#x00a0;&#x00a0;&#x00a0;&#x00a0;",
-        "&#x00a0;&#x00a0;",
-        "&#x002a;",
-        "&#x003c;",
-        "&#x003e;",
-        "&#x00a0;",
-        "&#x00ac;",
-        "&#x00b1;",
-        "&#x00d7;",
-        "&#x00f7;",
-        "&#x0393;",
-        "&#x0394;",
-        "&#x0398;",
-        "&#x039b;",
-        "&#x039e;",
-        "&#x03a0;",
-        "&#x03a3;",
-        "&#x03a9;",
-        "&#x2026;",
-        "&#x2032;",
-        "&#x2102;",
-        "&#x2115;",
-        "&#x211a;",
-        "&#x211d;",
-        "&#x2124;",
-        "&#x2135;",
-        "&#x2190;",
-        "&#x2191;",
-        "&#x2192;",
-        "&#x2192;",
-        "&#x2193;",
-        "&#x2194;",
-        "&#x21a0;",
-        "&#x21a3;",
-        "&#x21a6;",
-        "&#x21d0;",
-        "&#x21d2;",
-        "&#x21d2;",
-        "&#x21d4;",
-        "&#x21d4;",
-        "&#x2200;",
-        "&#x2202;",
-        "&#x2203;",
-        "&#x2205;",
-        "&#x2207;",
-        "&#x2208;",
-        "&#x2209;",
-        "&#x220f;",
-        "&#x2211;",
-        "&#x2212;",
-        "&#x2213;",
-        "&#x221d;",
-        "&#x221e;",
-        "&#x2220;",
-        "&#x2227;",
-        "&#x2228;",
-        "&#x2229;",
-        "&#x222a;",
-        "&#x222b;",
-        "&#x222e;",
-        "&#x2234;",
-        "&#x2235;",
-        "&#x223c;",
-        "&#x2245;",
-        "&#x2248;",
-        "&#x2254;",
-        "&#x2260;",
-        "&#x2261;",
-        "&#x2264;",
-        "&#x2265;",
-        "&#x226a;",
-        "&#x226b;",
-        "&#x227a;",
-        "&#x227b;",
-        "&#x2282;",
-        "&#x2283;",
-        "&#x2286;",
-        "&#x2287;",
-        "&#x2295;",
-        "&#x2297;",
-        "&#x2299;",
-        "&#x22a2;",
-        "&#x22a4;",
-        "&#x22a5;",
-        "&#x22a8;",
-        "&#x22c0;",
-        "&#x22c1;",
-        "&#x22c2;",
-        "&#x22c3;",
-        "&#x22c4;",
-        "&#x22c5;",
-        "&#x22c6;",
-        "&#x22c8;",
-        "&#x22c9;",
-        "&#x22ca;",
-        "&#x22ee;",
-        "&#x22ef;",
-        "&#x22f1;",
-        "&#x2308;",
-        "&#x2309;",
-        "&#x230a;",
-        "&#x230b;",
-        "&#x2322;",
-        "&#x25a1;",
-        "&#x25b3;",
-        "&#x26ac;",
-        "&#x2916;",
-        "&#x2aaf;",
-        "&#x2ab0;",
-        "&#x2b;",
-        "&#x3d;",
-        "&#x3a;",
-        "&#x3c;",
-        "&#xd7;",
-        "&#xb1;",
-        "&#x26;",
-        "&#x3b;",
-        "&#x3e;",
-        "&#x7c;",
-        "lim",
-        "max",
-        "min",
-        "\\",
-        "//",
-        "/",
-        "if",
-        "^",
-        "_",
-        "+",
-        "/",
-        "=",
-        ":",
-        ",",
-        ")",
-        "(",
-        "[",
-        "]",
-      ].freeze
       SUPPORTED_FONT_STYLES = {
         "sans-serif-bold-italic": Math::Function::FontStyle::SansSerifBoldItalic,
         "sans-serif-italic": Math::Function::FontStyle::SansSerifItalic,

data/lib/plurimath/mathml/formula_transformation.rb

@@ -28,7 +28,7 @@ module Plurimath
       end
 
       def mathml_symbol(value)
-        Plurimath::Utility.mathml_unary_classes([value], lang: :mathml)
+        Utility.resolve_token(value)
       end
 
       # Alignment markers affect MathML layout only; the old parser dropped them
@@ -423,10 +423,7 @@ module Plurimath
       end
 
       def mathml_symbol_to_class(symbol)
-        Plurimath::Utility.mathml_unary_classes(
-          Array(symbol),
-          lang: :mathml,
-        )
+        Utility.resolve_token(symbol)
       end
 
       def value_is_ternary_or_nary?(value)

data/lib/plurimath/mathml/translator.rb

@@ -122,6 +122,12 @@ module Plurimath
         children = content_children(mover)
         base = filter_child(mml_to_plurimath(children[0]))
         overscript = filter_child(mml_to_plurimath(children[1]))
+        # An accent character that has no function mapping arrives as a plain
+        # symbol; promote it here, where it is unambiguously an accent.
+        if overscript.instance_of?(Plurimath::Math::Symbols::Symbol)
+          overscript =
+            Utility.contextual_accent_from_token(overscript.value) || overscript
+        end
         options = {}
         options[:accent] = true if truthy_mathml_bool?(mover.accent)
 

data/lib/plurimath/mathml/utility.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Plurimath
+  class Mathml
+    module FunctionTokenResolver
+      # Promotes an accent character to its function class. Callers must only
+      # use this from an accent position; elsewhere the character has to stay a
+      # plain symbol/text. Decode-then-encode normalizes both call sites: MathML
+      # passes an already-encoded "̃", OMML passes the raw U+0303.
+      def contextual_accent_from_token(value)
+        return nil if value.nil?
+
+        entity = string_to_html_entity(html_entity_to_unicode(value.to_s))
+        function_name =
+          Mathml::Constants::CONTEXTUAL_ACCENT_FUNCTIONS[entity.strip.to_sym]
+        get_class(function_name).new if function_name
+      end
+
+      private
+
+      def function_from_token(value)
+        return nil if value.nil?
+
+        string = value.to_s
+        word = string.strip
+        unicode = string_to_html_entity(string)
+        symbol = Mathml::Constants::UNICODE_SYMBOLS[unicode.strip.to_sym]&.strip
+        function_name =
+          if Mathml::Constants::CLASSES.include?(symbol)
+            symbol
+          elsif Mathml::Constants::CLASSES.include?(word) &&
+              Mathml::Constants.named_function_word?(word)
+            word
+          end
+
+        get_class(function_name).new if function_name
+      end
+    end
+
+    class Utility < Plurimath::Utility
+      extend FunctionTokenResolver
+
+      class << self
+        def resolve_token(value)
+          return nil if value.nil?
+
+          function_from_token(value) ||
+            symbols_class(string_to_html_entity(value.to_s), lang: :mathml)
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/mathml.rb

@@ -6,6 +6,7 @@ module Plurimath
     autoload :FormulaTransformation, "#{__dir__}/mathml/formula_transformation"
     autoload :Parser, "#{__dir__}/mathml/parser"
     autoload :Translator, "#{__dir__}/mathml/translator"
+    autoload :Utility, "#{__dir__}/mathml/utility"
 
     attr_accessor :text
 

data/lib/plurimath/omml/formula_transformation.rb

@@ -62,7 +62,7 @@ module Plurimath
         return Math::Function::Text.new("", lang: :omml) if value == ""
         return nil if value == "\u200B"
 
-        Utility.mathml_unary_classes([value], omml: true, lang: :omml)
+        Utility.resolve_text_token(value)
       end
 
       def omml_argument_value(node)
@@ -182,7 +182,7 @@ module Plurimath
       end
 
       def nary_operator(character)
-        character && Utility.mathml_unary_classes([character], lang: :omml)
+        character && Utility.resolve_symbol_token(character)
       end
 
       def nary_type(properties)
@@ -228,13 +228,13 @@ module Plurimath
         delimiter_symbol(character.val)
       end
 
-      def accent_value(value)
-        accent = value.first
+      def accent_value(accent, argument)
         unless accent.is_a?(Math::Function::UnaryFunction)
-          return Math::Function::Overset.new(accent, value.last,
+          return Math::Function::Overset.new(accent, argument,
                                              { accent: true })
         end
 
+        accent.parameter_one ||= argument
         accent.attributes = { accent: true }
         accent
       end

data/lib/plurimath/omml/translator.rb

@@ -169,7 +169,6 @@ module Plurimath
               omml_argument_value(node.f_name),
               omml_argument_value(node.e),
             ],
-            lang: :omml,
           ),
         )
       end
@@ -204,10 +203,14 @@ module Plurimath
       def accent_to_plurimath(node)
         pr = first_omml_child(node.acc_pr)
         chr = first_omml_child(pr&.chr)&.val
-        accent = chr ? Utility.mathml_unary_classes([chr], lang: :omml) : Math::Function::Hat.new
-        value = [accent, omml_argument_value(node.e)]
-        Utility.unary_function_classes(value, lang: :omml)
-        accent_value(value)
+        accent =
+          if chr
+            Utility.contextual_accent_from_token(chr) ||
+              Utility.resolve_symbol_token(chr)
+          else
+            Math::Function::Hat.new
+          end
+        accent_value(accent, omml_argument_value(node.e))
       end
 
       def bar_to_plurimath(node)

data/lib/plurimath/omml/utility.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "plurimath/mathml/utility"
+
+module Plurimath
+  class Omml
+    # Omml-specific helper extracted from Plurimath::Utility (code-quality
+    # refactor). Subclasses Utility so bareword `Utility.<generic>` calls inside
+    # Omml files keep resolving here and inherit the generic helpers.
+    class Utility < Plurimath::Utility
+      extend Plurimath::Mathml::FunctionTokenResolver
+
+      class << self
+        def valid_class(object)
+          text = object.extract_class_name_from_text
+          (object.extractable? && Asciimath::Constants::SUB_SUP_CLASSES.include?(text)) ||
+            Latex::Constants::SYMBOLS[text&.to_sym] == :power_base
+        end
+
+        def resolve_text_token(value)
+          return nil if value.nil?
+
+          function_from_token(value) || text_token(value)
+        end
+
+        def resolve_symbol_token(value)
+          return nil if value.nil?
+
+          function_from_token(value) ||
+            symbols_class(string_to_html_entity(value.to_s), lang: :omml)
+        end
+
+        def populate_function_classes(mrow = [])
+          flatten_mrow = mrow.flatten.compact
+          unary_function_classes(flatten_mrow)
+          binary_function_classes(flatten_mrow)
+          ternary_function_classes(flatten_mrow)
+          flatten_mrow
+        end
+
+        private
+
+        def binary_function_classes(mrow)
+          mrow.each_with_index do |object, ind|
+            mrow[ind] = resolve_symbol_token(object) if object.is_a?(String)
+            object = mrow[ind]
+            next unless object.is_a?(Math::Function::Mod)
+
+            object.parameter_one = mrow.delete_at(ind - 1) unless ind.zero?
+            object.parameter_two = mrow.delete_at(ind)
+          end
+        end
+
+        def unary_function_classes(mrow)
+          unary_class = Math::Function::UnaryFunction
+          if mrow.any?(String) || mrow.any?(unary_class)
+            mrow.each_with_index do |object, ind|
+              if object.is_a?(String)
+                mrow[ind] = resolve_symbol_token(object)
+                object = mrow[ind]
+              end
+              next unless object.is_a?(unary_class)
+              next if object.is_a?(Math::Function::Text)
+              next if object.parameter_one || mrow[ind + 1].nil?
+              next unless ind.zero?
+
+              object.parameter_one = mrow.delete_at(ind + 1)
+            end
+          end
+        end
+
+        def ternary_function_classes(mrow)
+          ternary_class = Math::Function::TernaryFunction
+          if mrow.any?(ternary_class) && mrow.length > 1
+            mrow.each_with_index do |object, ind|
+              if object.is_a?(ternary_class)
+                next if [Math::Function::Fenced, Math::Function::Multiscript].include?(object.class)
+                next unless object.parameter_one || object.parameter_two
+                next if object.parameter_three
+
+                object.parameter_three = filter_values(mrow.delete_at(ind + 1))
+              end
+            end
+          end
+        end
+
+        def text_token(text)
+          text = filter_values(text) unless text.is_a?(String)
+          return text if text.is_a?(Math::Core)
+
+          if text.scan(/[[:digit:]]/).length == text.length
+            Math::Number.new(text)
+          elsif text.match?(/[a-zA-Z]/)
+            Math::Function::Text.new(text, lang: :omml)
+          else
+            text = string_to_html_entity(text)
+              .gsub("&#x26;", "&")
+              .gsub("&#x3c;", "<")
+              .gsub("&#x27;", "'")
+              .gsub("&#xa0;", "\u00A0")
+              .gsub("&#x3e;", ">")
+              .gsub("&#xa;", "\n")
+            symbols_class(text, lang: :omml)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/omml.rb

@@ -22,6 +22,7 @@ module Plurimath
     autoload :FormulaTransformation, "#{__dir__}/omml/formula_transformation"
     autoload :Parser, "#{__dir__}/omml/parser"
     autoload :Translator, "#{__dir__}/omml/translator"
+    autoload :Utility, "#{__dir__}/omml/utility"
     autoload :UnsupportedNodeError,
              "#{__dir__}/errors/omml/unsupported_node_error"
 

data/lib/plurimath/unicode_math/transform.rb

@@ -116,7 +116,11 @@ module Plurimath
       end
 
       rule(prefixed_prime: simple(:prime)) do
-        Utility.updated_primes(prime)
+        # Normalize the slash-prefixed name (\prime, \pprime, ...) to its entity
+        # so the enclosing prime_accent_symbols handling resolves it like the
+        # direct entity forms. Resolving to a node here instead would be dropped
+        # by the outer updated_primes re-scan (which only matches entities).
+        Constants::PREFIXED_PRIMES[prime.to_s.to_sym] || prime
       end
 
       rule(unary_functions: simple(:unary)) do