plurimath 0.11.6 → 0.11.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75b8782ef5cf11f9a85f25a801e30d2a070d8c49e1bef26deb2cd89e4172b9d1
-  data.tar.gz: 4c0c80df8bb7f55bf837e6cdc6974b8c1c5d49290403730c0c3b75fa9b442e0c
+  metadata.gz: 950039d5d3676703fbcd630f86ba5331ff73c07775564b72f54e533e41052661
+  data.tar.gz: c716654e4fc2c2fde3d3148312a87a772c2137b31a4f160ade66a21c0dc18da3
 SHA512:
-  metadata.gz: a9b9d84577013f3a4d9814f10dd623d6d8af02f649d38c1c14ef038a4e2dd51359a46ffc67395b12cb12010251ba77820656af924a0f76874a137c6d7c8c75d3
-  data.tar.gz: 60407f310306a46bc51670d0870f9c37e6dee0368d8af387042667124e680e072d42d668eaf13da20fb83b6dc9be9c5e11ba1a6d68907afaa58d558b96fcb4dc
+  metadata.gz: e7ba8db57e105ce7c1792128b621dba6dc4519f75bdb43185edf4b3b38bc7a21a214686896ed8fa8728dd037a5f7090dd9b4efa572aba62f480d7efb9dc3dc87
+  data.tar.gz: a313a02c3e4ab7d05a7d08129b07e98ba513b4953fd703ea88491fca5a1433fe282babce59e16aeb4032597e0165d65869b1180594a88f41d99fc3fbf4442346

data/lib/plurimath/asciimath/utility.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Plurimath
+  class Asciimath
+    # AsciiMath-specific helpers extracted from Plurimath::Utility (code-quality
+    # refactor). Subclasses Utility so bareword `Utility.<generic>` calls inside
+    # AsciiMath files keep resolving here and inherit the generic helpers.
+    class Utility < Plurimath::Utility
+      class << self
+        def td_values(objects, slicer)
+          sliced = objects.slice_when { |object, _| symbol_value(object, slicer) }
+          tds = sliced.map do |slice|
+            Math::Function::Td.new(
+              slice.delete_if { |d| symbol_value(d, slicer) }.compact,
+            )
+          end
+          tds << Math::Function::Td.new([]) if symbol_value(objects.last, slicer)
+          tds
+        end
+
+        def td_value(td_object)
+          str_classes = [String, Parslet::Slice]
+          if str_classes.include?(td_object.class) && td_object.to_s.empty?
+            return Math::Function::Text.new(nil)
+          end
+
+          td_object
+        end
+
+        def frac_values(object)
+          case object
+          when Math::Formula
+            object.value.any? { |d| symbol_value(d, ",") }
+          when Array
+            object.any? { |d| symbol_value(d, ",") }
+          end
+        end
+
+        def asciimath_symbol_object(value, lang: :asciimath)
+          return if value.nil?
+
+          symbols = symbols_hash(lang)
+          return symbols[value&.to_s].new if symbols.key?(value&.to_s)
+
+          symbol_object(value&.to_s, lang: lang)
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/asciimath.rb

@@ -6,6 +6,7 @@ module Plurimath
     autoload :Parse, "#{__dir__}/asciimath/parse"
     autoload :Parser, "#{__dir__}/asciimath/parser"
     autoload :Transform, "#{__dir__}/asciimath/transform"
+    autoload :Utility, "#{__dir__}/asciimath/utility"
 
     attr_accessor :text
 

data/lib/plurimath/formatter/numbers/mathml_renderer.rb

@@ -23,32 +23,32 @@ module Plurimath
           return plain_element(notation) if notation.notation_style == :e
 
           coeff = plain_element(notation.coefficient)
-          times = Utility.ox_element("mo") << notation.times_symbol.to_s
-          base_el = Utility.ox_element("mn") << "10"
-          exp_el = Utility.ox_element("mn") << notation.formatted_exponent
-          sup = Utility.ox_element("msup")
-          Utility.update_nodes(sup, [base_el, exp_el])
-          row = Utility.ox_element("mrow")
-          Utility.update_nodes(row, [coeff, times, sup])
+          times = XmlHelper.ox_element("mo") << notation.times_symbol.to_s
+          base_el = XmlHelper.ox_element("mn") << "10"
+          exp_el = XmlHelper.ox_element("mn") << notation.formatted_exponent
+          sup = XmlHelper.ox_element("msup")
+          XmlHelper.update_nodes(sup, [base_el, exp_el])
+          row = XmlHelper.ox_element("mrow")
+          XmlHelper.update_nodes(row, [coeff, times, sup])
           row
         end
 
         def render_semantic_base(formatted)
-          digits = Utility.ox_element("mn") << formatted.digits_string
-          base_el = Utility.ox_element("mn") << formatted.base_notation.base.to_s
-          sub = Utility.ox_element("msub")
-          Utility.update_nodes(sub, [digits, base_el])
+          digits = XmlHelper.ox_element("mn") << formatted.digits_string
+          base_el = XmlHelper.ox_element("mn") << formatted.base_notation.base.to_s
+          sub = XmlHelper.ox_element("msub")
+          XmlHelper.update_nodes(sub, [digits, base_el])
 
           return sub unless formatted.sign_text
 
-          sign_el = Utility.ox_element("mo") << formatted.sign_text
-          row = Utility.ox_element("mrow")
-          Utility.update_nodes(row, [sign_el, sub])
+          sign_el = XmlHelper.ox_element("mo") << formatted.sign_text
+          row = XmlHelper.ox_element("mrow")
+          XmlHelper.update_nodes(row, [sign_el, sub])
           row
         end
 
         def plain_element(result)
-          Utility.ox_element("mn") << result.to_s
+          XmlHelper.ox_element("mn") << result.to_s
         end
       end
     end

data/lib/plurimath/formatter/numbers/omml_renderer.rb

@@ -22,51 +22,51 @@ module Plurimath
         def render_notation(notation)
           return plain_element(notation) if notation.notation_style == :e
 
-          sup_struct = Utility.ox_element("sSup", namespace: "m")
-          subpr = Utility.ox_element("sSupPr", namespace: "m")
-          subpr << Utility.pr_element("ctrl", true, namespace: "m")
+          sup_struct = XmlHelper.ox_element("sSup", namespace: "m")
+          subpr = XmlHelper.ox_element("sSupPr", namespace: "m")
+          subpr << XmlHelper.pr_element("ctrl", true, namespace: "m")
 
           coeff_run = text_run(notation.coefficient.to_s)
           times_run = text_run(" #{notation.times_symbol} ")
           base_run = text_run("10")
           exp_run = text_run(notation.formatted_exponent)
 
-          e_el = Utility.ox_element("e", namespace: "m")
-          Utility.update_nodes(e_el, [coeff_run, times_run, base_run])
+          e_el = XmlHelper.ox_element("e", namespace: "m")
+          XmlHelper.update_nodes(e_el, [coeff_run, times_run, base_run])
 
-          sup_el = Utility.ox_element("sup", namespace: "m")
-          Utility.update_nodes(sup_el, [exp_run])
+          sup_el = XmlHelper.ox_element("sup", namespace: "m")
+          XmlHelper.update_nodes(sup_el, [exp_run])
 
-          Utility.update_nodes(sup_struct, [subpr, e_el, sup_el])
+          XmlHelper.update_nodes(sup_struct, [subpr, e_el, sup_el])
           sup_struct
         end
 
         def render_semantic_base(formatted)
-          sub_struct = Utility.ox_element("sSub", namespace: "m")
-          subpr = Utility.ox_element("sSubPr", namespace: "m")
-          subpr << Utility.pr_element("ctrl", true, namespace: "m")
+          sub_struct = XmlHelper.ox_element("sSub", namespace: "m")
+          subpr = XmlHelper.ox_element("sSubPr", namespace: "m")
+          subpr << XmlHelper.pr_element("ctrl", true, namespace: "m")
 
           digits_with_sign = "#{formatted.sign_text}#{formatted.digits_string}"
           base_run = text_run(digits_with_sign)
           sub_run = text_run(formatted.base_notation.base.to_s)
 
-          e_el = Utility.ox_element("e", namespace: "m")
-          Utility.update_nodes(e_el, [base_run])
+          e_el = XmlHelper.ox_element("e", namespace: "m")
+          XmlHelper.update_nodes(e_el, [base_run])
 
-          sub_el = Utility.ox_element("sub", namespace: "m")
-          Utility.update_nodes(sub_el, [sub_run])
+          sub_el = XmlHelper.ox_element("sub", namespace: "m")
+          XmlHelper.update_nodes(sub_el, [sub_run])
 
-          Utility.update_nodes(sub_struct, [subpr, e_el, sub_el])
+          XmlHelper.update_nodes(sub_struct, [subpr, e_el, sub_el])
           sub_struct
         end
 
         def plain_element(result)
-          Utility.ox_element("t", namespace: "m") << result.to_s
+          XmlHelper.ox_element("t", namespace: "m") << result.to_s
         end
 
         def text_run(text)
-          run = Utility.ox_element("r", namespace: "m")
-          run << (Utility.ox_element("t", namespace: "m") << text)
+          run = XmlHelper.ox_element("r", namespace: "m")
+          run << (XmlHelper.ox_element("t", namespace: "m") << text)
         end
       end
     end

data/lib/plurimath/html/utility.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Plurimath
+  class Html
+    # Html-specific helper extracted from Plurimath::Utility (code-quality
+    # refactor). Subclasses Utility so bareword `Utility.<generic>` calls inside
+    # Html files keep resolving here and inherit the generic helpers.
+    class Utility < Plurimath::Utility
+      class << self
+        def sub_sup_method?(sub_sup)
+          if sub_sup.methods.include?(:class_name)
+            Html::Constants::SUB_SUP_CLASSES.value?(sub_sup.class_name.to_sym)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/html.rb

@@ -7,6 +7,7 @@ module Plurimath
     autoload :Parser, "#{__dir__}/html/parser"
     autoload :Transform, "#{__dir__}/html/transform"
     autoload :TransformUtility, "#{__dir__}/html/transform_utility"
+    autoload :Utility, "#{__dir__}/html/utility"
 
     attr_accessor :text
 

data/lib/plurimath/latex/utility.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Plurimath
+  class Latex
+    # LaTeX-specific helpers extracted from Plurimath::Utility (code-quality
+    # refactor). Subclasses Utility so bareword `Utility.<generic>` calls inside
+    # LaTeX files keep resolving here and inherit the generic helpers.
+    class Utility < Plurimath::Utility
+      class << self
+        def organize_table(array, column_align: nil, options: nil)
+          table = []
+          table_data = []
+          table_row = []
+          organize_options(array, column_align) if options
+          string_columns = column_align&.map { |column| column.is_a?(Math::Symbols::Paren) ? "|" : column.value }
+          array.each do |data|
+            if data&.separate_table
+              table_row << Math::Function::Td.new(filter_table_data(table_data).compact)
+              table_data = []
+              if data.linebreak?
+                organize_tds(table_row.flatten, string_columns.dup, options)
+                table << Math::Function::Tr.new(table_row)
+                table_row = []
+              end
+              next
+            end
+            table_data << data
+          end
+          # A trailing linebreak has already flushed its row and nothing follows
+          # it, so there is no final cell to add. An empty input has flushed
+          # nothing, and still yields its one placeholder cell.
+          flushed_by_trailing_linebreak =
+            table_data.empty? && table_row.empty? && !table.empty?
+          unless flushed_by_trailing_linebreak
+            table_row << Math::Function::Td.new(table_data.compact)
+          end
+          unless table_row.nil? || table_row.empty?
+            organize_tds(table_row.flatten, string_columns.dup, options)
+            table << Math::Function::Tr.new(table_row)
+          end
+          unless column_align.nil? || column_align.empty?
+            table_separator(string_columns, table,
+                            symbol: "|")
+          end
+          table
+        end
+
+        def organize_options(table_data, column_align)
+          return column_align if column_align.length <= 1
+
+          align = [column_align&.shift]
+          table_data.insert(0, *column_align)
+          align
+        end
+
+        def table_options(table_data)
+          rowline = ""
+          table_data.each do |tr|
+            rowline += hline_row?(tr) ? "solid " : "none "
+          end
+          options = { rowline: rowline.strip } if rowline.include?("solid")
+          options || {}
+        end
+
+        def organize_tds(tr_array, column_align, options)
+          return tr_array if column_align.nil? || column_align.empty?
+
+          column_align.reject! { |string| string == "|" }
+          column_align = column_align * tr_array.length if options
+          tr_array.map.with_index do |td, ind|
+            columnalign = Plurimath::Utility::ALIGNMENT_LETTERS[column_align[ind]&.to_sym]
+            td.parameter_two = { columnalign: columnalign } if columnalign
+          end
+        end
+
+        def filter_table_data(table_data)
+          table_data.each_with_index do |object, ind|
+            if object.is_a?(Math::Symbols::Minus)
+              table_data[ind] = Math::Formula.new(
+                [object, table_data.delete_at(ind.next)],
+              )
+            end
+          end
+          table_data
+        end
+
+        def table_td(object)
+          new_object = case object
+                       when Math::Function::Td
+                         object
+                       else
+                         Math::Function::Td.new([object].compact)
+                       end
+          Array(new_object)
+        end
+
+        def left_right_objects(paren, function)
+          paren = if paren.to_s.match?(/\\\{|\\\}/)
+                    paren.to_s.gsub("\\", "")
+                  else
+                    Latex::Constants::LEFT_RIGHT_PARENTHESIS[paren.to_sym]
+                  end
+          get_class(function).new(paren)
+        end
+
+        private
+
+        # True when the row's first cell holds an Hline marker (a horizontal
+        # rule), reached through the tr -> first cell -> first content nesting.
+        def hline_row?(row)
+          first_cell = row&.parameter_one&.first
+          first_content = first_cell&.parameter_one&.first
+          first_content.is_a?(Math::Symbols::Hline)
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/latex.rb

@@ -6,6 +6,7 @@ module Plurimath
     autoload :Parse, "#{__dir__}/latex/parse"
     autoload :Parser, "#{__dir__}/latex/parser"
     autoload :Transform, "#{__dir__}/latex/transform"
+    autoload :Utility, "#{__dir__}/latex/utility"
 
     attr_accessor :text
 

data/lib/plurimath/math/core.rb

@@ -65,7 +65,7 @@ namespace: "m")
                       else
                         field.insert_t_tag(display_style, options: options)
                       end
-        Utility.update_nodes(tag, field_value)
+        XmlHelper.update_nodes(tag, field_value)
       end
 
       def validate_function_formula
@@ -103,7 +103,7 @@ namespace: "m")
 
         hashed = common_math_zone_conversion(field, options)
         options[:array] << "#{hashed[:spacing]}|_ \"#{field&.to_asciimath(options: options[:options])}\"#{hashed[:field_name]}\n"
-        return unless Utility.validate_math_zone(field, lang: :asciimath)
+        return unless ModelHelper.validate_math_zone(field, lang: :asciimath)
 
         options[:array] << field&.to_asciimath_math_zone(
           hashed[:function_spacing], hashed[:last], hashed[:indent], options: options[:options]
@@ -115,7 +115,7 @@ namespace: "m")
 
         hashed = common_math_zone_conversion(field, options)
         options[:array] << "#{hashed[:spacing]}|_ \"#{field&.to_latex(options: options[:options])}\"#{hashed[:field_name]}\n"
-        return unless Utility.validate_math_zone(field, lang: :latex)
+        return unless ModelHelper.validate_math_zone(field, lang: :latex)
 
         options[:array] << field&.to_latex_math_zone(hashed[:function_spacing],
                                                      hashed[:last], hashed[:indent], options: options[:options])
@@ -127,8 +127,8 @@ namespace: "m")
         hashed = common_math_zone_conversion(field, options)
         options[:array] << "#{hashed[:spacing]}|_ \"#{dump_mathml(field,
                                                                   options: options[:options])}\"#{hashed[:field_name]}\n"
-        return unless Utility.validate_math_zone(field, lang: :mathml,
-                                                        intent: options[:intent], options: options[:options])
+        return unless ModelHelper.validate_math_zone(field, lang: :mathml,
+                                                            intent: options[:intent], options: options[:options])
 
         options[:array] << field&.to_mathml_math_zone(
           hashed[:function_spacing], hashed[:last], hashed[:indent], options: options[:options]
@@ -142,7 +142,7 @@ namespace: "m")
         display_style = options[:display_style]
         options[:array] << "#{hashed[:spacing]}|_ \"#{dump_omml(field,
                                                                 display_style, options: options[:options])}\"#{hashed[:field_name]}\n"
-        return unless Utility.validate_math_zone(field, lang: :omml)
+        return unless ModelHelper.validate_math_zone(field, lang: :omml)
 
         options[:array] << field&.to_omml_math_zone(hashed[:function_spacing],
                                                     hashed[:last], hashed[:indent], display_style: display_style, options: options[:options])
@@ -153,7 +153,7 @@ namespace: "m")
 
         hashed = common_math_zone_conversion(field, options)
         options[:array] << "#{hashed[:spacing]}|_ \"#{field&.to_unicodemath(options: options[:options])}\"#{hashed[:field_name]}\n"
-        return unless Utility.validate_math_zone(field, lang: :unicodemath)
+        return unless ModelHelper.validate_math_zone(field, lang: :unicodemath)
 
         options[:array] << field&.to_unicodemath_math_zone(
           hashed[:function_spacing], hashed[:last], hashed[:indent], options: options[:options]
@@ -201,8 +201,8 @@ namespace: "m")
       end
 
       def filtered_values(value, lang:, options: {})
-        @values = Utility.filter_math_zone_values(value, lang: lang,
-                                                         options: options)
+        @values = ModelHelper.filter_math_zone_values(value, lang: lang,
+                                                             options: options)
       end
 
       def dump_ox_nodes(nodes)
@@ -315,7 +315,7 @@ namespace: "m")
       end
 
       def ox_element(node, attributes: [], namespace: "")
-        Utility.ox_element(
+        XmlHelper.ox_element(
           node,
           attributes: attributes,
           namespace: namespace,
@@ -523,10 +523,10 @@ namespace: "m")
           when "mover" then tag.name = "msup"
           end
         elsif options_array.include?("upper_limit_as_super_script") && tag.nodes[1].name == "mrow"
-          tag = Utility.update_nodes(
+          tag = XmlHelper.update_nodes(
             ox_element("munder"),
             [
-              Utility.update_nodes(
+              XmlHelper.update_nodes(
                 ox_element("msup"),
                 [
                   tag.nodes[0],

data/lib/plurimath/math/formula.rb

@@ -100,8 +100,8 @@ module Plurimath
           style_attrs = { displaystyle: boolean_display_style(display_style) }
           math  = ox_element("math", attributes: math_attrs)
           style = ox_element("mstyle", attributes: style_attrs)
-          Utility.update_nodes(style, mathml_content(intent, options: options))
-          Utility.update_nodes(math, [style])
+          XmlHelper.update_nodes(style, mathml_content(intent, options: options))
+          XmlHelper.update_nodes(math, [style])
           unitsml_post_processing(math, style)
           dump_nodes(math, indent: 2)
         end
@@ -127,7 +127,7 @@ module Plurimath
         mathml_value = mathml_content(intent, options: options)
         attributes = intent_attribute(mathml_value) if intent
         mrow = ox_element("mrow", attributes: attributes)
-        Utility.update_nodes(mrow, mathml_value)
+        XmlHelper.update_nodes(mrow, mathml_value)
       end
 
       def mathml_content(intent, options:)
@@ -160,11 +160,11 @@ formatter: nil, unitsml: {})
           objects = split_on_linebreak ? new_line_support : [self]
           options = { formatter: formatter, unitsml: unitsml }.compact
           options[:formula] ||= self
-          para_element = Utility.ox_element("oMathPara",
+          para_element = XmlHelper.ox_element("oMathPara",
                                             attributes: OMML_NAMESPACES, namespace: "m")
           objects.each.with_index(1) do |object, index|
-            para_element << Utility.update_nodes(
-              Utility.ox_element("oMath", namespace: "m"),
+            para_element << XmlHelper.update_nodes(
+              XmlHelper.ox_element("oMath", namespace: "m"),
               object.omml_content(boolean_display_style(display_style),
                                   options: options),
             )
@@ -505,7 +505,7 @@ options:)
       end
 
       def intent_post_processing(nodes, _intent)
-        mrow = Utility.update_nodes(ox_element("mrow"), nodes)
+        mrow = XmlHelper.update_nodes(ox_element("mrow"), nodes)
         upcase_dd_derivative(nodes) if validate_upcase_dd_derivatives?(nodes)
         subsup_dd_derivative(nodes) if validate_subsup_dd_derivatives?(nodes)
         partial_derivative(nodes) if valid_partial_derivative?(nodes)
@@ -624,7 +624,7 @@ options:)
                  node["arg"] = "f"
                  node
                else
-                 Utility.update_nodes(
+                 XmlHelper.update_nodes(
                    ox_element("mrow", attributes: { arg: "f" }),
                    nodes,
                  )
@@ -671,7 +671,7 @@ options:)
         end
         intent_name = "#{intent_names[:derivative]}(1,#{second_arg},#{third_arg})"
         mrow = ox_element("mrow", attributes: { intent: intent_name })
-        nodes.insert(0, Utility.update_nodes(mrow, mrow_nodes))
+        nodes.insert(0, XmlHelper.update_nodes(mrow, mrow_nodes))
       end
 
       def subsup_dd_derivative(nodes)
@@ -766,7 +766,7 @@ options:)
           next if node.name == "mi"
           break if node.name == "mrow"
         end
-        Utility.update_nodes(mrow, row_nodes)
+        XmlHelper.update_nodes(mrow, row_nodes)
       end
 
       def numeric_encoding(node)

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

@@ -7,11 +7,11 @@ module Plurimath
         attr_accessor :open_paren, :close_paren
 
         def to_mathml_without_math_tag(intent, options:)
-          symbol = Utility.ox_element("mo") << "|"
+          symbol = XmlHelper.ox_element("mo") << "|"
           first_value = mathml_value(intent, options: options)
           first_value&.insert(0, symbol) unless open_paren
           first_value << symbol unless close_paren
-          mrow = Utility.update_nodes(ox_element("mrow"), first_value)
+          mrow = XmlHelper.update_nodes(ox_element("mrow"), first_value)
           intentify(mrow, intent, func_name: :abs,
                                   intent_name: intent_names[:name])
         end
@@ -52,7 +52,7 @@ module Plurimath
         def md_tag
           attribute = { "m:val": "|" }
           sepchr_attr = { "m:val": "" }
-          mdpr = Utility.pr_element("d", namespace: "m")
+          mdpr = XmlHelper.pr_element("d", namespace: "m")
           unless open_paren
             mdpr << ox_element("begChr", namespace: "m",
                                          attributes: attribute)

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

@@ -22,12 +22,12 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag(intent, options:)
-          mo_tag = Utility.ox_element("mo") << "&#xaf;"
+          mo_tag = XmlHelper.ox_element("mo") << "&#xaf;"
           return mo_tag unless parameter_one
 
-          mover_tag = Utility.ox_element("mover")
+          mover_tag = XmlHelper.ox_element("mover")
           mover_tag.set_attr(attributes) if attributes && !attributes.empty?
-          Utility.update_nodes(
+          XmlHelper.update_nodes(
             mover_tag,
             [
               parameter_one&.to_mathml_without_math_tag(intent,
@@ -66,11 +66,11 @@ module Plurimath
         protected
 
         def acc_tag(display_style, options:)
-          acc = Utility.ox_element("acc", namespace: "m")
-          chr = Utility.ox_element("chr", namespace: "m",
-                                          attributes: { "m:val": "‾" })
-          acc_pr = (Utility.ox_element("accPr", namespace: "m") << chr)
-          Utility.update_nodes(
+          acc = XmlHelper.ox_element("acc", namespace: "m")
+          chr = XmlHelper.ox_element("chr", namespace: "m",
+                                            attributes: { "m:val": "‾" })
+          acc_pr = (XmlHelper.ox_element("accPr", namespace: "m") << chr)
+          XmlHelper.update_nodes(
             acc,
             [
               acc_pr,
@@ -82,8 +82,8 @@ module Plurimath
         end
 
         def bar_tag(display_style, options:)
-          bar = Utility.ox_element("bar", namespace: "m")
-          Utility.update_nodes(
+          bar = XmlHelper.ox_element("bar", namespace: "m")
+          XmlHelper.update_nodes(
             bar,
             [
               bar_pr,
@@ -96,10 +96,10 @@ module Plurimath
 
         def bar_pr
           attrs = { "m:val": "top" }
-          barpr = Utility.ox_element("barPr", namespace: "m")
-          pos   = Utility.ox_element("pos", namespace: "m", attributes: attrs)
-          ctrlp = Utility.pr_element("ctrl", true, namespace: "m")
-          Utility.update_nodes(barpr, [pos, ctrlp])
+          barpr = XmlHelper.ox_element("barPr", namespace: "m")
+          pos   = XmlHelper.ox_element("pos", namespace: "m", attributes: attrs)
+          ctrlp = XmlHelper.pr_element("ctrl", true, namespace: "m")
+          XmlHelper.update_nodes(barpr, [pos, ctrlp])
         end
       end
 

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

@@ -11,6 +11,14 @@ module Plurimath
           first_value: "base",
           second_value: "script",
         }.freeze
+        # Base values whose MathML script renders as <munder> instead of <msub>.
+        MUNDER_CLASSES = %w[
+          ubrace
+          obrace
+          right
+          max
+          min
+        ].freeze
 
         def initialize(parameter_one = nil,
                        parameter_two = nil,
@@ -34,14 +42,14 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag(intent, options:)
-          tag_name = Utility::MUNDER_CLASSES.include?(parameter_one&.class_name) ? "under" : "sub"
-          sub_tag = Utility.ox_element("m#{tag_name}")
+          tag_name = MUNDER_CLASSES.include?(parameter_one&.class_name) ? "under" : "sub"
+          sub_tag = XmlHelper.ox_element("m#{tag_name}")
           mathml_value = []
           mathml_value << validate_mathml_fields(parameter_one, intent,
                                                  options: options)
           mathml_value << validate_mathml_fields(parameter_two, intent,
                                                  options: options)
-          Utility.update_nodes(sub_tag, mathml_value)
+          XmlHelper.update_nodes(sub_tag, mathml_value)
         end
 
         def to_latex(options:)
@@ -58,10 +66,10 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(display_style, options:)
-          ssub_element  = Utility.ox_element("sSub", namespace: "m")
-          subpr_element = Utility.ox_element("sSubPr", namespace: "m")
-          subpr_element << Utility.pr_element("ctrl", true, namespace: "m")
-          Utility.update_nodes(
+          ssub_element  = XmlHelper.ox_element("sSub", namespace: "m")
+          subpr_element = XmlHelper.ox_element("sSubPr", namespace: "m")
+          subpr_element << XmlHelper.pr_element("ctrl", true, namespace: "m")
+          XmlHelper.update_nodes(
             ssub_element,
             [
               subpr_element,