plurimath 0.3.8 → 0.4.1

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

@@ -5,16 +5,16 @@ module Plurimath
   module Math
     module Function
       class Multiscript < TernaryFunction
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           pre_element = Utility.ox_element("sPre", namespace: "m")
           pr_element  = Utility.ox_element("sPrePr", namespace: "m")
           Utility.update_nodes(
             pre_element,
             [
               pr_element << Utility.pr_element("ctrl", true, namespace: "m"),
-              omml_parameter(parameter_two, tag_name: "sub"),
-              omml_parameter(parameter_three, tag_name: "sup"),
-              omml_parameter(parameter_one, tag_name: "e"),
+              omml_parameter(parameter_two, display_style, tag_name: "sub"),
+              omml_parameter(parameter_three, display_style, tag_name: "sup"),
+              omml_parameter(parameter_one, display_style, tag_name: "e"),
             ],
           )
           [pre_element]

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

@@ -27,10 +27,10 @@ module Plurimath
           )
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           [
             r_element("∥"),
-            omml_value,
+            omml_value(display_style),
             r_element("∥"),
           ]
         end

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

@@ -1,11 +1,16 @@
 # frozen_string_literal: true
 
-require_relative "unary_function"
+require_relative "binary_function"
 
 module Plurimath
   module Math
     module Function
-      class Obrace < UnaryFunction
+      class Obrace < BinaryFunction
+        def to_asciimath
+          first_value = "(#{parameter_one.to_asciimath})" if parameter_one
+          "obrace#{first_value}"
+        end
+
         def to_latex
           first_value = "{#{parameter_one.to_latex}}" if parameter_one
           "\\overbrace#{first_value}"
@@ -13,46 +18,48 @@ module Plurimath
 
         def to_mathml_without_math_tag
           mo_tag = (Utility.ox_element("mo") << "&#x23de;")
-          if parameter_one
-            over_tag = Utility.ox_element("mover")
-            arr_value = mathml_value
-            Utility.update_nodes(over_tag, (arr_value << mo_tag))
-          else
-            mo_tag
-          end
+          return mo_tag unless parameter_one
+
+          over_tag = Utility.ox_element("mover")
+          over_tag.attributes.merge!(parameter_two) if parameter_two && !parameter_two.empty?
+          Utility.update_nodes(
+            over_tag,
+            [
+              parameter_one.to_mathml_without_math_tag,
+              mo_tag,
+            ],
+          )
         end
 
         def validate_function_formula
           false
         end
 
-        def to_omml_without_math_tag
-          groupchr = Utility.ox_element("groupChr", namespace: "m")
-          Utility.update_nodes(
-            groupchr,
-            [
-              group_chr_pr,
-              omml_parameter(parameter_one, tag_name: "e"),
-            ],
-          )
-          [groupchr]
+        def to_omml_without_math_tag(display_style)
+          return r_element("⏞", rpr_tag: false) unless all_values_exist?
+
+          if parameter_two && parameter_two[:accent]
+            acc_tag(display_style)
+          else
+            symbol = Symbol.new("⏞")
+            Overset.new(parameter_one, symbol).to_omml_without_math_tag(true)
+          end
         end
 
         protected
 
-        def group_chr_pr
-          groupchrpr = Utility.ox_element("groupChrPr", namespace: "m")
-          vert_jc = Utility.ox_element("vertJc", namespace: "m", attributes: { "m:val": "bot" })
-          chr = Utility.ox_element("chr", namespace: "m", attributes: { "m:val": "⏞" })
-          pos = Utility.ox_element("pos", namespace: "m", attributes: { "m:val": "top" })
+        def acc_tag(display_style)
+          acc_tag    = Utility.ox_element("acc", namespace: "m")
+          acc_pr_tag = Utility.ox_element("accPr", namespace: "m")
+          acc_pr_tag << (Utility.ox_element("chr", namespace: "m", attributes: { "m:val": "⏞" }))
           Utility.update_nodes(
-            groupchrpr,
+            acc_tag,
             [
-              chr,
-              pos,
-              vert_jc,
+              acc_pr_tag,
+              omml_parameter(parameter_one, display_style, tag_name: "e", namespace: "m"),
             ],
           )
+          [acc_tag]
         end
       end
 

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

@@ -22,17 +22,16 @@ module Plurimath
           mo_tag = Utility.ox_element("mo") << invert_unicode_symbols.to_s
           return mo_tag unless all_values_exist?
 
-          msubsup_tag = Utility.ox_element("msubsup")
-          first_value = parameter_one&.to_mathml_without_math_tag if parameter_one
-          second_value = parameter_two&.to_mathml_without_math_tag if parameter_two
-          Utility.update_nodes(
-            msubsup_tag,
-            [
-              mo_tag,
-              first_value,
-              second_value,
-            ],
-          )
+          value_array = [mo_tag]
+          value_array << parameter_one&.to_mathml_without_math_tag
+          value_array << parameter_two&.to_mathml_without_math_tag
+          tag_name = if parameter_one && parameter_two
+                       "subsup"
+                     else
+                       parameter_one ? "sub" : "sup"
+                     end
+          msubsup_tag = Utility.ox_element("m#{tag_name}")
+          Utility.update_nodes(msubsup_tag, value_array)
           return msubsup_tag if parameter_three.nil?
 
           Utility.update_nodes(
@@ -40,20 +39,20 @@ module Plurimath
             [
               msubsup_tag,
               parameter_three&.to_mathml_without_math_tag,
-            ].flatten.compact,
+            ].compact,
           )
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           if all_values_exist?
             nary = Utility.ox_element("nary", namespace: "m")
             Utility.update_nodes(
               nary,
               [
                 narypr("∮", function_type: "subSup"),
-                omml_parameter(parameter_one, tag_name: "sub"),
-                omml_parameter(parameter_two, tag_name: "sup"),
-                omml_parameter(parameter_three, tag_name: "e"),
+                omml_parameter(parameter_one, display_style, tag_name: "sub"),
+                omml_parameter(parameter_two, display_style, tag_name: "sup"),
+                omml_parameter(parameter_three, display_style, tag_name: "e"),
               ],
             )
             [nary]

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

@@ -31,15 +31,15 @@ module Plurimath
           "{#{first_value} \\over #{two_value}}"
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           f_element   = Utility.ox_element("f", namespace: "m")
           fpr_element = Utility.ox_element("fPr", namespace: "m")
           Utility.update_nodes(
             f_element,
             [
               fpr_element << Utility.pr_element("ctrl", true, namespace: "m"),
-              omml_parameter(parameter_one, tag_name: "num"),
-              omml_parameter(parameter_two, tag_name: "den"),
+              omml_parameter(parameter_one, display_style, tag_name: "num"),
+              omml_parameter(parameter_two, display_style, tag_name: "den"),
             ],
           )
           [f_element]

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

@@ -19,7 +19,12 @@ module Plurimath
           )
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
+          if !display_style
+            power = Power.new(parameter_one, parameter_two)
+            return power.to_omml_without_math_tag(display_style)
+          end
+
           limupp   = Utility.ox_element("limUpp", namespace: "m")
           limupppr = Utility.ox_element("limUppPr", namespace: "m")
           limupppr << Utility.pr_element("ctrl", true, namespace: "m")
@@ -27,8 +32,8 @@ module Plurimath
             limupp,
             [
               limupppr,
-              omml_parameter(parameter_one, tag_name: "e"),
-              omml_parameter(parameter_two, tag_name: "lim"),
+              omml_parameter(parameter_one, display_style, tag_name: "e"),
+              omml_parameter(parameter_two, display_style, tag_name: "lim"),
             ],
           )
           [limupp]

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

@@ -31,7 +31,7 @@ module Plurimath
           "#{first_value}#{second_value}"
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           ssup_element  = Utility.ox_element("sSup", namespace: "m")
           suppr_element = Utility.ox_element("sSupPr", namespace: "m")
           suppr_element << Utility.pr_element("ctrl", true, namespace: "m")
@@ -39,8 +39,8 @@ module Plurimath
             ssup_element,
             [
               suppr_element,
-              omml_parameter(parameter_one, tag_name: "e"),
-              omml_parameter(parameter_two, tag_name: "sup"),
+              omml_parameter(parameter_one, display_style, tag_name: "e"),
+              omml_parameter(parameter_two, display_style, tag_name: "sup"),
             ],
           )
           [ssup_element]

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

@@ -29,24 +29,26 @@ module Plurimath
           "#{first_value}#{second_value}#{third_value}"
         end
 
-        def omml_nary_tag
+        def omml_nary_tag(display_style)
           narypr = Utility.ox_element("naryPr", namespace: "m")
           chr_value(narypr)
           narypr << Utility.ox_element(
             "limLoc",
             namespace: "m",
-            attributes: { "m:val": "subSup" },
+            attributes: { "m:val": parameter_one.omml_tag_name },
           )
           hide_tags(narypr)
           narypr << Utility.pr_element("ctrl", true, namespace: "m")
           [
             narypr,
-            omml_parameter(parameter_two, tag_name: "sub"),
-            omml_parameter(parameter_three, tag_name: "sup"),
+            omml_parameter(parameter_two, display_style, tag_name: "sub"),
+            omml_parameter(parameter_three, display_style, tag_name: "sup"),
           ]
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
+          return underover(display_style) if parameter_one.omml_tag_name == "undOvr"
+
           ssubsup   = Utility.ox_element("sSubSup", namespace: "m")
           ssubsuppr = Utility.ox_element("sSubSupPr", namespace: "m")
           ssubsuppr << hide_tags(
@@ -56,9 +58,9 @@ module Plurimath
             ssubsup,
             [
               ssubsuppr,
-              omml_parameter(parameter_one, tag_name: "e"),
-              omml_parameter(parameter_two, tag_name: "sub"),
-              omml_parameter(parameter_three, tag_name: "sup"),
+              omml_parameter(parameter_one, display_style, tag_name: "e"),
+              omml_parameter(parameter_two, display_style, tag_name: "sub"),
+              omml_parameter(parameter_three, display_style, tag_name: "sup"),
             ],
           )
           [ssubsup]

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

@@ -54,16 +54,16 @@ module Plurimath
           "<i>&prod;</i>#{first_value}#{second_value}"
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           if all_values_exist?
             nary = Utility.ox_element("nary", namespace: "m")
             Utility.update_nodes(
               nary,
               [
                 narypr("∏"),
-                omml_parameter(parameter_one, tag_name: "sub"),
-                omml_parameter(parameter_two, tag_name: "sup"),
-                omml_parameter(parameter_three, tag_name: "e"),
+                omml_parameter(parameter_one, display_style, tag_name: "sub"),
+                omml_parameter(parameter_two, display_style, tag_name: "sup"),
+                omml_parameter(parameter_three, display_style, tag_name: "e"),
               ],
             )
             [nary]
@@ -74,6 +74,10 @@ module Plurimath
             [r_tag]
           end
         end
+
+        def nary_attr_value
+          "∏"
+        end
       end
     end
   end

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

@@ -16,7 +16,7 @@ module Plurimath
           mo
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           mr = Utility.ox_element("m:r")
           if parameter_one
             mt = Utility.ox_element("m:t")

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

@@ -24,15 +24,15 @@ module Plurimath
           "\\sqrt[#{first_value}]{#{second_value}}"
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           rad_element = Utility.ox_element("rad", namespace: "m")
           pr_element  = Utility.ox_element("radPr", namespace: "m")
           Utility.update_nodes(
             rad_element,
             [
               (pr_element << Utility.pr_element("ctrl", true, namespace: "m")),
-              omml_parameter(parameter_two, tag_name: "deg"),
-              omml_parameter(parameter_one, tag_name: "e"),
+              omml_parameter(parameter_two, display_style, tag_name: "deg"),
+              omml_parameter(parameter_one, display_style, tag_name: "e"),
             ],
           )
           [rad_element]

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

@@ -20,7 +20,7 @@ module Plurimath
           Utility.ox_element("mi")
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           [Utility.ox_element("m:r") << Utility.ox_element("m:t")]
         end
 

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

@@ -6,8 +6,8 @@ module Plurimath
   module Math
     module Function
       class Scarries < UnaryFunction
-        def to_omml_without_math_tag
-          omml_value
+        def to_omml_without_math_tag(display_style)
+          omml_value(display_style)
         end
       end
     end

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

@@ -23,8 +23,8 @@ module Plurimath
           parameter_one&.to_asciimath
         end
 
-        def to_omml_without_math_tag
-          Array(parameter_one.insert_t_tag)
+        def to_omml_without_math_tag(display_style)
+          Array(parameter_one.insert_t_tag(display_style))
         end
 
         protected

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

@@ -13,7 +13,7 @@ module Plurimath
           sqrt_tag
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           rad_element = Utility.ox_element("rad", namespace: "m")
           pr_element = Utility.ox_element("radPr", namespace: "m")
           pr_element << Utility.ox_element(
@@ -26,7 +26,7 @@ module Plurimath
             [
               (pr_element << Utility.pr_element("ctrl", true, namespace: "m")),
               Utility.ox_element("deg", namespace: "m"),
-              omml_parameter(parameter_one, tag_name: "e"),
+              omml_parameter(parameter_one, display_style, tag_name: "e"),
             ],
           )
           [rad_element]

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

@@ -27,7 +27,7 @@ module Plurimath
           "#{first_value}#{second_value}"
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           limupp   = Utility.ox_element("limUpp", namespace: "m")
           limupppr = Utility.ox_element("limUppPr", namespace: "m")
           limupppr << Utility.pr_element("ctrl", true, namespace: "m")
@@ -35,8 +35,8 @@ module Plurimath
             limupp,
             [
               limupppr,
-              omml_parameter(parameter_two, tag_name: "e"),
-              omml_parameter(parameter_one, tag_name: "lim"),
+              omml_parameter(parameter_two, display_style, tag_name: "e"),
+              omml_parameter(parameter_one, display_style, tag_name: "lim"),
             ],
           )
           [limupp]

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

@@ -19,13 +19,13 @@ module Plurimath
           Utility.update_nodes(Utility.ox_element("mtable"), value_array)
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           Array(
             Utility.update_nodes(
               mm_element,
               [
-                omml_parameter(parameter_one, tag_name: "mr"),
-                omml_parameter(parameter_two, tag_name: "mr"),
+                omml_parameter(parameter_one, display_style, tag_name: "mr"),
+                omml_parameter(parameter_two, display_style, tag_name: "mr"),
               ],
             ),
           )

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

@@ -54,25 +54,28 @@ module Plurimath
           "<i>&sum;</i>#{first_value}#{second_value}"
         end
 
-        def to_omml_without_math_tag
-          if all_values_exist?
-            nary = Utility.ox_element("nary", namespace: "m")
-            Utility.update_nodes(
-              nary,
-              [
-                narypr("∑"),
-                omml_parameter(parameter_one, tag_name: "sub"),
-                omml_parameter(parameter_two, tag_name: "sup"),
-                omml_parameter(parameter_three, tag_name: "e"),
-              ],
-            )
-            [nary]
-          else
-            r_tag = Utility.ox_element("r", namespace: "m")
-            t_tag = Utility.ox_element("t", namespace: "m")
-            r_tag << (t_tag << "&#x2211;")
-            [r_tag]
-          end
+        def to_omml_without_math_tag(display_style)
+          return r_element("&#x2211;", rpr_tag: false) unless all_values_exist?
+
+          nary = Utility.ox_element("nary", namespace: "m")
+          Utility.update_nodes(
+            nary,
+            [
+              narypr("∑"),
+              omml_parameter(parameter_one, display_style, tag_name: "sub"),
+              omml_parameter(parameter_two, display_style, tag_name: "sup"),
+              omml_parameter(parameter_three, display_style, tag_name: "e"),
+            ],
+          )
+          [nary]
+        end
+
+        def omml_tag_name
+          "undOvr"
+        end
+
+        def nary_attr_value
+          "∑"
         end
       end
     end

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

@@ -10,8 +10,8 @@ module Plurimath
           Utility.ox_element("mo") << "sup"
         end
 
-        def to_omml_without_math_tag
-          [r_element("sup"), omml_value]
+        def to_omml_without_math_tag(display_style)
+          [r_element("sup", rpr_tag: false), omml_value(display_style)]
         end
       end
     end

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

@@ -69,18 +69,14 @@ module Plurimath
           "<table>#{first_value}</table>"
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           if value.map { |d| d.parameter_one.length == 1 }.all?
-            single_td_table
+            single_td_table(display_style)
           else
-            fenced_table(multiple_td_table)
+            fenced_table(multiple_td_table(display_style))
           end
         end
 
-        def class_name
-          self.class.name.split("::").last.downcase
-        end
-
         protected
 
         def present?(field)
@@ -164,17 +160,17 @@ module Plurimath
           matrices_hash.invert[open_paren].to_s if matric_value
         end
 
-        def single_td_table
+        def single_td_table(display_style)
           eqarr    = Utility.ox_element("eqArr", namespace: "m")
           eqarrpr  = Utility.ox_element("eqArrPr", namespace: "m")
           eqarrpr  << Utility.pr_element("ctrl", true, namespace: "m")
           eqarr    << eqarrpr
-          tr_value = value.map(&:to_omml_without_math_tag).flatten
+          tr_value = value.map { |obj| obj.to_omml_without_math_tag(display_style) }.flatten
           Utility.update_nodes(eqarr, tr_value.compact)
           [eqarr]
         end
 
-        def multiple_td_table
+        def multiple_td_table(display_style)
           count  = { "m:val": value&.first&.parameter_one&.count }
           mcjc   = { "m:val": "center" }
           mm     = Utility.ox_element("m", namespace: "m")
@@ -198,7 +194,7 @@ module Plurimath
           mcs << mc
           mpr << mcs
           mpr << ctrlpr
-          mm_value = value&.map(&:to_omml_without_math_tag)
+          mm_value = value&.map { |obj| obj.to_omml_without_math_tag(display_style) }
           Utility.update_nodes(
             mm,
             mm_value.insert(0, mpr).flatten,

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

@@ -32,13 +32,13 @@ module Plurimath
           "<td>#{first_value}</td>"
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           me = Utility.ox_element("e", namespace: "m")
           return [me] if parameter_one&.empty?
 
           Utility.update_nodes(
             me,
-            Formula.new(parameter_one).omml_content,
+            Formula.new(parameter_one).omml_content(display_style),
           )
           [me]
         end

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

@@ -51,6 +51,10 @@ module Plurimath
           "#{first_value}#{second_value}#{third_value}"
         end
 
+        def any_value_exist?
+          !(parameter_one.nil? || parameter_two.nil? || parameter_three.nil?)
+        end
+
         protected
 
         def latex_wrapped(field)
@@ -131,6 +135,13 @@ module Plurimath
 
           Array(parameter.to_mathml_without_math_tag)
         end
+
+        def underover(display_style)
+          overset = Overset.new(parameter_one, parameter_three)
+          return overset.to_omml_without_math_tag(display_style) unless parameter_two
+
+          Underset.new(overset, parameter_two)&.to_omml_without_math_tag(display_style)
+        end
       end
     end
   end

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

@@ -27,15 +27,15 @@ module Plurimath
           parse_text("html") || parameter_one
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(_display_style)
           text = Utility.ox_element("t", namespace: "m")
           text << (parse_text("omml") || parameter_one)
           [text]
         end
 
-        def insert_t_tag
+        def insert_t_tag(display_style)
           r_tag = Utility.ox_element("r", namespace: "m")
-          Utility.update_nodes(r_tag, to_omml_without_math_tag)
+          Utility.update_nodes(r_tag, to_omml_without_math_tag(display_style))
           [r_tag]
         end
 
@@ -54,7 +54,8 @@ module Plurimath
           html_value = first_value(lang).dup
           html_value&.gsub!(PARSER_REGEX) do |_text|
             last_match = Regexp.last_match
-            if ["mathml", "html"].include?(lang)
+            case lang
+            when "mathml", "html"
               symbol_value(last_match[:unicode])
             else
               last_match[:unicode]
@@ -67,7 +68,7 @@ module Plurimath
           if lang == "omml"
             entities = HTMLEntities.new
             entities.encode(
-              entities.decode(parameter_one),
+              entities.decode(parameter_one.gsub(/ /, "&nbsp;")),
               :named,
             )
           else