plurimath 0.2.1 → 0.2.2

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

@@ -15,9 +15,9 @@ module Plurimath
         end
 
         def to_asciimath
-          first_value = parameter_one&.to_asciimath
-          second_value = "_(#{parameter_two.to_asciimath})" if parameter_two
-          third_value = "^(#{parameter_three.to_asciimath})" if parameter_three
+          first_value = first_field_wrap(parameter_one) if parameter_one
+          second_value = "_#{wrapped(parameter_two)}" if parameter_two
+          third_value = "^#{wrapped(parameter_three)}" if parameter_three
           "#{first_value}#{second_value}#{third_value}"
         end
 
@@ -29,23 +29,88 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag
-          first_value  = parameter_one&.to_mathml_without_math_tag
-          second_value = parameter_two&.to_mathml_without_math_tag
-          third_value  = parameter_three&.to_mathml_without_math_tag
-          body_value   = "#{first_value}#{second_value}#{third_value}"
-          "<m#{class_name}>#{body_value}</m#{class_name}>"
+          value_arr = [parameter_one&.to_mathml_without_math_tag]
+          value_arr << parameter_two&.to_mathml_without_math_tag
+          value_arr << parameter_three&.to_mathml_without_math_tag
+          class_tag = Utility.ox_element("m#{class_name}")
+          Utility.update_nodes(class_tag, value_arr)
+        end
+
+        def to_latex
+          first_value  = parameter_one&.to_latex
+          second_value = parameter_two&.to_latex
+          third_value  = parameter_three&.to_latex
+          "#{first_value}#{second_value}#{third_value}"
         end
 
         def to_html
           first_value  = "<i>#{parameter_one.to_html}</i>" if parameter_one
           second_value = "<i>#{parameter_two.to_html}</i>" if parameter_two
           third_value = "<i>#{parameter_three.to_html}</i>" if parameter_three
-          first_value + second_value + third_value
+          "#{first_value}#{second_value}#{third_value}"
+        end
+
+        def to_omml_without_math_tag
+          r_tag = Utility.ox_element("r", namespace: "m")
+          r_tag << omml_value(parameter_one) if parameter_one
+          r_tag << omml_value(parameter_two) if parameter_two
+          r_tag << omml_value(parameter_three) if parameter_three
+          r_tag
         end
 
         def class_name
           self.class.name.split("::").last.downcase
         end
+
+        protected
+
+        def omml_value(field)
+          case field
+          when Array
+            field.compact.map(&:to_omml_without_math_tag)
+          else
+            t_tag = Utility.ox_element("t", namespace: "m")
+            first_value = field.to_omml_without_math_tag
+            first_value = (t_tag << first_value) if field.is_a?(Symbol)
+            first_value
+          end
+        end
+
+        def wrapped(field, type: "ascii")
+          return "" unless field
+
+          type == "ascii" ? "(#{field.to_asciimath})" : "{#{field.to_latex}}"
+        end
+
+        def first_field_wrap(field, type: "ascii")
+          return "" unless field
+
+          type == "ascii" ? ascii_wrap(field) : latex_wrap(field)
+        end
+
+        def ascii_wrap(field)
+          asciimath = field.to_asciimath
+          return latex if ["obrace", "ubrace"].include?(field.class_name)
+
+          case field
+          when Formula || field.class.name.include?("Function")
+            "(#{asciimath})"
+          else
+            asciimath
+          end
+        end
+
+        def latex_wrap(field)
+          latex = field.to_latex
+          return latex if ["obrace", "ubrace"].include?(field.class_name)
+
+          case field
+          when Formula || field.class.name.include?("Function")
+            "{#{latex}}"
+          else
+            latex
+          end
+        end
       end
     end
   end

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

@@ -1,42 +1,67 @@
 # frozen_string_literal: true
 
+require "htmlentities"
 require_relative "unary_function"
 
 module Plurimath
   module Math
     module Function
       class Text < UnaryFunction
+        PARSER_REGEX = %r{unicode\[:(?<unicode>\w{1,})\]}.freeze
+
         def to_asciimath
           "\"#{parse_text('asciimath') || parameter_one}\""
         end
 
         def to_mathml_without_math_tag
-          "<mtext>#{parse_text('mathml') || parameter_one}</mtext>"
-        end
-
-        def symbol_value(unicode)
-          Mathml::Constants::UNICODE_SYMBOLS.invert[unicode] ||
-            Mathml::Constants::SYMBOLS.invert[unicode]
+          text = Utility.ox_element("mtext")
+          text << (parse_text("mathml") || parameter_one) if parameter_one
         end
 
         def to_latex
-          parse_text("latex") || parameter_one
+          text_value = parse_text("latex") || parameter_one
+          "\\text{#{text_value}}"
         end
 
         def to_html
           parse_text("html") || parameter_one
         end
 
+        def to_omml_without_math_tag
+          text = Utility.ox_element("t", namespace: "m")
+          text << (parse_text("omml") || parameter_one)
+        end
+
+        protected
+
+        def symbol_value(unicode)
+          Mathml::Constants::UNICODE_SYMBOLS.invert[unicode] ||
+            Mathml::Constants::SYMBOLS.invert[unicode]
+        end
+
         def parse_text(lang)
-          regex = %r{\\mbox\{(?<mbox>.{1,})\}|unicode\[:(?<unicode>\w{1,})\]}
-          parameter_one.gsub!(regex) do |_text|
+          html_value = first_value(lang).dup
+          html_value&.gsub!(PARSER_REGEX) do |_text|
             last_match = Regexp.last_match
             if ["mathml", "html"].include?(lang)
-              symbol_value(last_match[:unicode]) || last_match[:mbox]
+              symbol_value(last_match[:unicode])
             else
-              last_match[:unicode] || last_match[:mbox]
+              last_match[:unicode]
             end
           end
+          html_value
+        end
+
+        def first_value(lang)
+          if lang == "omml"
+            entities = HTMLEntities.new
+            entities.encode(
+              entities.decode(parameter_one),
+              :named,
+            )
+          else
+            parameter_one
+          end
         end
       end
     end

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

@@ -7,23 +7,42 @@ module Plurimath
     module Function
       class Tr < UnaryFunction
         def to_asciimath
-          "[#{parameter_one.map(&:to_asciimath).join(',')}]"
+          "[#{parameter_one.map(&:to_asciimath).join(', ')}]"
         end
 
         def to_mathml_without_math_tag
-          "<mtr>#{parameter_one.map(&:to_mathml_without_math_tag).join}</mtr>"
+          first_value = parameter_one.dup
+          row_lines = first_value.first.parameter_one
+          row_lines.shift if Utility.symbol_value(row_lines.first, "&#x23af;")
+          Utility.update_nodes(
+            Utility.ox_element("mtr"),
+            first_value.map(&:to_mathml_without_math_tag).compact,
+          )
         end
 
         def to_latex
           parameter_one.reject do |td|
-            td if td.is_a?(Math::Symbol) && td.value == "|"
-          end.map(&:to_latex).join("&")
+            td if Utility.symbol_value(td, "|") || Utility.symbol_value(td.parameter_one.first, "|")
+          end.map(&:to_latex).join(" & ")
         end
 
         def to_html
           first_value = parameter_one.map(&:to_html).join
           "<tr>#{first_value}</tr>"
         end
+
+        def to_omml_without_math_tag
+          omml_content = parameter_one&.map(&:to_omml_without_math_tag)
+          if parameter_one.count.eql?(1)
+            omml_content
+          else
+            mr = Utility.ox_element("mr", namespace: "m")
+            Utility.update_nodes(
+              mr,
+              omml_content,
+            )
+          end
+        end
       end
     end
   end

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

@@ -6,7 +6,24 @@ module Plurimath
   module Math
     module Function
       class Ubrace < UnaryFunction
+        def to_latex
+          first_value = "{#{parameter_one.to_latex}}" if parameter_one
+          "\\underbrace#{first_value}"
+        end
+
+        def to_mathml_without_math_tag
+          mo_tag = (Utility.ox_element("mo") << "&#x23df;")
+          if parameter_one
+            over_tag = Utility.ox_element("munder")
+            arr_value = mathml_value
+            Utility.update_nodes(over_tag, (arr_value << mo_tag))
+          else
+            mo_tag
+          end
+        end
       end
+
+      Underbrace = Ubrace
     end
   end
 end

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

@@ -6,6 +6,35 @@ module Plurimath
   module Math
     module Function
       class Ul < UnaryFunction
+        def to_mathml_without_math_tag
+          first_value = parameter_one&.to_mathml_without_math_tag
+          Utility.update_nodes(
+            Utility.ox_element("munder"),
+            [
+              first_value,
+              Utility.ox_element("mo") << "&#xaf;",
+            ],
+          )
+        end
+
+        def to_omml_without_math_tag
+          bar    = Utility.ox_element("bar", namespace: "m")
+          barpr  = Utility.ox_element("barPr", namespace: "m")
+          barpr << Utility.pr_element("ctrl", true, namespace: "m")
+          me = Utility.ox_element("e", namespace: "m")
+          me << parameter_one.to_omml_without_math_tag
+          Utility.update_nodes(
+            bar,
+            [
+              barpr,
+              me,
+            ],
+          )
+        end
+
+        def class_name
+          "underline"
+        end
       end
     end
   end

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

@@ -7,6 +7,7 @@ module Plurimath
         attr_accessor :parameter_one
 
         def initialize(parameter_one = nil)
+          parameter_one  = parameter_one.to_s if parameter_one.is_a?(Parslet::Slice)
           @parameter_one = parameter_one
         end
 
@@ -16,30 +17,102 @@ module Plurimath
         end
 
         def to_asciimath
-          "#{class_name}#{value_to_asciimath}"
-        end
-
-        def value_to_asciimath
-          "(#{parameter_one.to_asciimath})" unless parameter_one.nil?
+          value = if Utility::UNARY_CLASSES.any?(class_name)
+                    asciimath_value
+                  elsif parameter_one
+                    "(#{asciimath_value})"
+                  end
+          "#{class_name}#{value}"
         end
 
         def to_mathml_without_math_tag
-          "<mi>#{class_name}</mi>"
+          row_tag = Utility.ox_element("mrow")
+          tag_name = Utility::UNARY_CLASSES.include?(class_name) ? "mi" : "mo"
+          new_arr = [Utility.ox_element(tag_name) << class_name]
+          new_arr += mathml_value if parameter_one
+          Utility.update_nodes(row_tag, new_arr)
         end
 
         def to_latex
-          first_value = "{#{parameter_one.to_latex}}" if parameter_one
+          first_value = "{#{latex_value}}" if parameter_one
           "\\#{class_name}#{first_value}"
         end
 
         def to_html
-          first_value = "<i>#{parameter_one.to_html}</i>" if parameter_one
+          first_value = if parameter_one.is_a?(Array)
+                          "<i>#{parameter_one.map(&:to_html).join}</i>"
+                        elsif parameter_one
+                          "<i>#{parameter_one.to_html}</i>"
+                        end
           "<i>#{class_name}</i>#{first_value}"
         end
 
+        def to_omml_without_math_tag
+          func   = Utility.ox_element("func", namespace: "m")
+          funcpr = Utility.ox_element("funcPr", namespace: "m")
+          funcpr << Utility.pr_element("ctrl", true, namespace: "m")
+          fname  = Utility.ox_element("fName", namespace: "m")
+          mr  = Utility.ox_element("r", namespace: "m")
+          rpr = Utility.rpr_element
+          mt  = Utility.ox_element("t", namespace: "m") << class_name
+          fname << Utility.update_nodes(mr, [rpr, mt])
+          me = Utility.ox_element("e", namespace: "m")
+          Utility.update_nodes(me, omml_value) if parameter_one
+          Utility.update_nodes(
+            func,
+            [
+              funcpr,
+              fname,
+              me,
+            ],
+          )
+        end
+
         def class_name
           self.class.name.split("::").last.downcase
         end
+
+        protected
+
+        def asciimath_value
+          return "" unless parameter_one
+
+          case parameter_one
+          when Array
+            parameter_one.compact.map(&:to_asciimath).join
+          else
+            parameter_one.to_asciimath
+          end
+        end
+
+        def mathml_value
+          case parameter_one
+          when Array
+            parameter_one.compact.map(&:to_mathml_without_math_tag)
+          else
+            Array(parameter_one&.to_mathml_without_math_tag)
+          end
+        end
+
+        def latex_value
+          if parameter_one.is_a?(Array)
+            return parameter_one&.compact&.map(&:to_latex)&.join(" ")
+          end
+
+          parameter_one&.to_latex
+        end
+
+        def omml_value
+          if parameter_one.is_a?(Array)
+            return parameter_one.compact.map(&:to_omml_without_math_tag)
+          end
+
+          first_value = parameter_one.to_omml_without_math_tag
+          if parameter_one.is_a?(Symbol)
+            first_value = Utility.ox_element("t", namespace: "m") << first_value
+          end
+          Array(first_value)
+        end
       end
     end
   end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "unary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Underline < UnaryFunction
+      end
+    end
+  end
+end

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

@@ -6,6 +6,113 @@ module Plurimath
   module Math
     module Function
       class Underover < TernaryFunction
+        def to_asciimath
+          first_value = first_field_wrap(parameter_one) if parameter_one
+          second_value = "_#{wrapped(parameter_two)}" if parameter_two
+          third_value = "^#{wrapped(parameter_three)}" if parameter_three
+          "#{first_value}#{second_value}#{third_value}"
+        end
+
+        def to_latex
+          first_value = first_field_wrap(parameter_one, type: "latex") if parameter_one
+          second_value = "_#{wrapped(parameter_two, type: 'latex')}" if parameter_two
+          third_value = "^#{wrapped(parameter_three, type: 'latex')}" if parameter_three
+          "#{first_value}#{second_value}#{third_value}"
+        end
+
+        def to_mathml_without_math_tag
+          first_value  = parameter_one&.to_mathml_without_math_tag
+          second_value = parameter_two&.to_mathml_without_math_tag
+          third_value  = parameter_three&.to_mathml_without_math_tag
+          class_tag = Utility.ox_element("m#{class_name}")
+          Utility.update_nodes(
+            class_tag,
+            [
+              first_value,
+              second_value,
+              third_value,
+            ],
+          )
+        end
+
+        def to_omml_without_math_tag
+          limupp = Utility.ox_element("limUpp", namespace: "m")
+          limpr = Utility.ox_element("limUppPr", namespace: "m")
+          limpr << Utility.pr_element("ctrl", namespace: "m")
+          e_tag = Utility.ox_element("e", namespace: "m")
+          e_tag << parameter_one&.to_omml_without_math_tag
+          lim = Utility.ox_element("lim", namespace: "m")
+          lim << parameter_two&.to_omml_without_math_tag if parameter_two
+          Utility.update_nodes(
+            limupp,
+            [
+              e_tag,
+              lim,
+            ],
+          )
+        end
+
+        def omml_nary_tag
+          pr = Utility.ox_element("naryPr", namespace: "m")
+          [pr_element_value(pr), sub_value, sup_value]
+        end
+
+        protected
+
+        def hidden_sub_tag(pr_element)
+          return true unless parameter_two.nil?
+
+          pr_element << Utility.ox_element(
+            "subHide",
+            namespace: "m",
+            attributes: { "m:val": 1 },
+          )
+        end
+
+        def hidden_sup_tag(pr_element)
+          return true unless parameter_three.nil?
+
+          pr_element << Utility.ox_element(
+            "supHide",
+            namespace: "m",
+            attributes: { "m:val": 1 },
+          )
+        end
+
+        def pr_element_value(pr_element)
+          first_value(pr_element)
+          pr_element << Utility.ox_element(
+            "limLoc",
+            namespace: "m",
+            attributes: { "m:val": "undOvr" },
+          )
+          hidden_sub_tag(pr_element)
+          hidden_sup_tag(pr_element)
+          pr_element << Utility.pr_element("ctrl", true, namespace: "m")
+        end
+
+        def sub_value
+          sub = Utility.ox_element("sub", namespace: "m")
+          sub << omml_value(parameter_two) if parameter_two
+          sub
+        end
+
+        def sup_value
+          sup = Utility.ox_element("sup", namespace: "m")
+          sup << omml_value(parameter_three) if parameter_three
+          sup
+        end
+
+        def first_value(pr_element)
+          first_value = parameter_one.is_a?(Number) ? parameter_one.value : parameter_one.to_omml_without_math_tag
+          unless first_value == "∫"
+            pr_element << Utility.ox_element(
+              "chr",
+              namespace: "m",
+              attributes: { "m:val": first_value },
+            )
+          end
+        end
       end
     end
   end

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

@@ -6,6 +6,45 @@ module Plurimath
   module Math
     module Function
       class Underset < BinaryFunction
+        def to_mathml_without_math_tag
+          first_value = parameter_one&.to_mathml_without_math_tag
+          second_value = parameter_two&.to_mathml_without_math_tag
+          Utility.update_nodes(
+            Utility.ox_element("munder"),
+            [
+              second_value,
+              first_value,
+            ],
+          )
+        end
+
+        def to_omml_without_math_tag
+          first_value  = if parameter_one.is_a?(Math::Symbol)
+                           mt = Utility.ox_element("t", namespace: "m")
+                           mt << parameter_one.to_omml_without_math_tag
+                         else
+                           parameter_one.to_omml_without_math_tag
+                         end
+          second_value = if parameter_two.is_a?(Math::Symbol)
+                           mt = Utility.ox_element("t", namespace: "m")
+                           mt << parameter_two.to_omml_without_math_tag
+                         else
+                           parameter_two.to_omml_without_math_tag
+                         end
+          limlow   = Utility.ox_element("limLow", namespace: "m")
+          limlowpr = Utility.ox_element("limLowPr", namespace: "m")
+          limlowpr << Utility.pr_element("ctrl", true, namespace: "m")
+          me = Utility.ox_element("e", namespace: "m") << first_value
+          lim = Utility.ox_element("lim", namespace: "m") << second_value if second_value
+          Utility.update_nodes(
+            limlow,
+            [
+              limlowpr,
+              me,
+              lim,
+            ],
+          )
+        end
       end
     end
   end

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

@@ -8,7 +8,13 @@ module Plurimath
       class Vec < UnaryFunction
         def to_mathml_without_math_tag
           first_value = parameter_one&.to_mathml_without_math_tag
-          "<mover>#{first_value}<mo>&#x20D1;</mo></mover>"
+          Utility.update_nodes(
+            Utility.ox_element("mover"),
+            [
+              first_value,
+              Utility.ox_element("mo") << "&#x2192;",
+            ],
+          )
         end
       end
     end

data/lib/plurimath/math/number.rb

@@ -2,11 +2,11 @@
 
 module Plurimath
   module Math
-    class Number
+    class Number < Base
       attr_accessor :value
 
       def initialize(value)
-        @value = value
+        @value = super
       end
 
       def ==(object)
@@ -18,7 +18,7 @@ module Plurimath
       end
 
       def to_mathml_without_math_tag
-        "<mn>#{value}</mn>"
+        Utility.ox_element("mn") << value
       end
 
       def to_latex
@@ -29,8 +29,8 @@ module Plurimath
         value
       end
 
-      def class_name
-        self.class.name.split("::").last.downcase
+      def to_omml_without_math_tag
+        Utility.ox_element("t", namespace: "m") << value
       end
     end
   end