plurimath 0.2.0 → 0.2.2

data/lib/plurimath/math/base.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Math
+    class Base
+      def initialize(field)
+        field.is_a?(Parslet::Slice) ? field.to_s : field
+      end
+
+      def class_name
+        self.class.name.split("::").last.downcase
+      end
+    end
+  end
+end

data/lib/plurimath/math/formula.rb

@@ -14,29 +14,114 @@ module Plurimath
       end
 
       def to_asciimath
-        value.map(&:to_asciimath).join
+        value.map(&:to_asciimath).join(" ")
       end
 
       def to_mathml
-        <<~MATHML
-          <math xmlns='http://www.w3.org/1998/Math/MathML'>
-            <mstyle displaystyle='true'>
-              #{mathml_content}
-            </mstyle>
-          </math>
-        MATHML
+        math_attrs = {
+          xmlns: "http://www.w3.org/1998/Math/MathML",
+          display: "block",
+        }
+        style_attrs = { displaystyle: "true" }
+        math  = Utility.ox_element("math", attributes: math_attrs)
+        style = Utility.ox_element("mstyle", attributes: style_attrs)
+        Utility.update_nodes(style, mathml_content)
+        Utility.update_nodes(math, [style])
+        Ox.dump(math, indent: 2).gsub("&amp;", "&")
       end
 
       def to_mathml_without_math_tag
-        "<mrow>#{mathml_content}</mrow>"
+        Utility.update_nodes(
+          Utility.ox_element("mrow"),
+          mathml_content,
+        )
       end
 
       def mathml_content
-        value.map(&:to_mathml_without_math_tag).join
+        value.map(&:to_mathml_without_math_tag)
       end
 
       def to_latex
-        value.map(&:to_latex).join
+        value.map(&:to_latex).join(" ")
+      end
+
+      def to_html
+        value.map(&:to_html).join(" ")
+      end
+
+      def omml_math_attrs
+        {
+          "xmlns:m": "http://schemas.openxmlformats.org/officeDocument/2006/math",
+          "xmlns:mc": "http://schemas.openxmlformats.org/markup-compatibility/2006",
+          "xmlns:mo": "http://schemas.microsoft.com/office/mac/office/2008/main",
+          "xmlns:mv": "urn:schemas-microsoft-com:mac:vml",
+          "xmlns:o": "urn:schemas-microsoft-com:office:office",
+          "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+          "xmlns:v": "urn:schemas-microsoft-com:vml",
+          "xmlns:w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+          "xmlns:w10": "urn:schemas-microsoft-com:office:word",
+          "xmlns:w14": "http://schemas.microsoft.com/office/word/2010/wordml",
+          "xmlns:w15": "http://schemas.microsoft.com/office/word/2012/wordml",
+          "xmlns:wne": "http://schemas.microsoft.com/office/word/2006/wordml",
+          "xmlns:wp": "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
+          "xmlns:wp14": "http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing",
+          "xmlns:wpc": "http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas",
+          "xmlns:wpg": "http://schemas.microsoft.com/office/word/2010/wordprocessingGroup",
+          "xmlns:wpi": "http://schemas.microsoft.com/office/word/2010/wordprocessingInk",
+          "xmlns:wps": "http://schemas.microsoft.com/office/word/2010/wordprocessingShape",
+        }
+      end
+
+      def to_omml
+        para_element = Utility.ox_element(
+          "oMathPara",
+          attributes: omml_math_attrs,
+          namespace: "m",
+        )
+        math_element = Utility.ox_element("oMath", namespace: "m")
+        Utility.update_nodes(math_element, omml_content)
+        para_element << math_element
+        Ox.dump(para_element, indent: 2).gsub("&amp;", "&")
+      end
+
+      def omml_content
+        value.map do |object|
+          if object.is_a?(Symbol)
+            mt = Utility.ox_element("t", namespace: "m")
+            mt << object.value
+          else
+            object.to_omml_without_math_tag
+          end
+        end
+      end
+
+      def to_omml_without_math_tag
+        if value.length == 2 && ["underover", "powerbase"].include?(
+          value&.first&.class_name,
+        )
+          nary_tag
+        else
+          r_element = Utility.ox_element("r", namespace: "m")
+          r_element << Utility.rpr_element if ["symbol", "number", "text"].include?(value&.first&.class_name)
+          Utility.update_nodes(r_element, omml_content)
+        end
+      end
+
+      def nary_tag
+        nary_tag = Utility.ox_element("nary", namespace: "m")
+        e_tag    = Utility.ox_element("e", namespace: "m")
+        e_tag   << value&.last&.to_omml_without_math_tag
+        Utility.update_nodes(
+          nary_tag,
+          [
+            value.first.omml_nary_tag,
+            e_tag,
+          ].flatten.compact,
+        )
+      end
+
+      def class_name
+        self.class.name.split("::").last.downcase
       end
     end
   end

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

@@ -10,6 +10,40 @@ module Plurimath
           first_value = "{#{parameter_one.to_latex}}" if parameter_one
           "\\overline#{first_value}"
         end
+
+        def to_mathml_without_math_tag
+          first_value = parameter_one&.to_mathml_without_math_tag
+          Utility.update_nodes(
+            Utility.ox_element("mover"),
+            [
+              first_value,
+              Utility.ox_element("mo") << "&#xaf;",
+            ],
+          )
+        end
+
+        def to_omml_without_math_tag
+          bar = Utility.ox_element("bar", namespace: "m")
+          me  = Utility.ox_element("e", namespace: "m")
+          me << parameter_one.to_omml_without_math_tag if parameter_one
+          Utility.update_nodes(
+            bar,
+            [
+              bar_pr,
+              me,
+            ],
+          )
+        end
+
+        protected
+
+        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])
+        end
       end
     end
   end

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

@@ -8,22 +8,49 @@ module Plurimath
       class Base < BinaryFunction
         def to_asciimath
           first_value = parameter_one.to_asciimath if parameter_one
-          second_value = "_#{parameter_two.to_asciimath}" if parameter_two
+          second_value = "_#{wrapped(parameter_two)}" if parameter_two
           "#{first_value}#{second_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
-          "<msub>#{first_value}#{second_value}</msub>"
+          under_classes = ["ubrace", "obrace"] + Utility::UNARY_CLASSES
+          tag_name = (under_classes.include?(parameter_one&.class_name) ? "under" : "sub")
+          sub_tag = Utility.ox_element("m#{tag_name}")
+          mathml_value = []
+          mathml_value << parameter_one&.to_mathml_without_math_tag
+          mathml_value << parameter_two&.to_mathml_without_math_tag if parameter_two
+          Utility.update_nodes(sub_tag, mathml_value)
         end
 
         def to_latex
           first_value  = parameter_one.to_latex if parameter_one
-          first_value  = "{#{first_value}}" if parameter_one.is_a?(Math::Formula)
+          first_value  = "{#{first_value}}" if parameter_one.is_a?(Formula)
           second_value = parameter_two.to_latex if parameter_two
           "#{first_value}_{#{second_value}}"
         end
+
+        def to_html
+          first_value  = "<i>#{parameter_one.to_html}</i>" if parameter_one
+          second_value = "<sub>#{parameter_two.to_html}</sub>" if parameter_two
+          "#{first_value}#{second_value}"
+        end
+
+        def to_omml_without_math_tag
+          ssub_element  = Utility.ox_element("sSub", namespace: "m")
+          subpr_element = Utility.ox_element("sSubPr", namespace: "m")
+          e_element     = Utility.ox_element("e", namespace: "m")
+          sub_element   = Utility.ox_element("sub", namespace: "m")
+          sub_element << parameter_two.to_omml_without_math_tag if parameter_two
+          Utility.update_nodes(
+            ssub_element,
+            [
+              subpr_element << Utility.pr_element("ctrl", true, namespace: "m"),
+              e_element << parameter_one.to_omml_without_math_tag,
+              sub_element,
+            ],
+          )
+          ssub_element
+        end
       end
     end
   end

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

@@ -12,13 +12,7 @@ module Plurimath
         end
 
         def to_asciimath
-          "#{class_name}#{value_to_asciimath}"
-        end
-
-        def value_to_asciimath
-          first_value = "(#{parameter_one.to_asciimath})" if parameter_one
-          second_value = "(#{parameter_two.to_asciimath})" if parameter_two
-          "#{first_value}#{second_value}"
+          "#{class_name}#{wrapped(parameter_one)}#{wrapped(parameter_two)}"
         end
 
         def ==(object)
@@ -28,25 +22,118 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag
-          first_value = parameter_one.to_mathml_without_math_tag if parameter_one
-          second_value = parameter_two.to_mathml_without_math_tag if parameter_two
-          third_value = invert_unicode_symbols.empty? ? class_name : invert_unicode_symbols
-          "<mo>#{third_value}</mo>#{first_value}#{second_value}"
-        end
-
-        def invert_unicode_symbols
-          Mathml::Constants::UNICODE_SYMBOLS.invert[class_name].to_s
+          mrow_tag = Utility.ox_element("mrow")
+          mo_tag = Utility.ox_element("mo") << invert_unicode_symbols.to_s
+          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(
+            mrow_tag,
+            [
+              first_value,
+              mo_tag,
+              second_value,
+            ],
+          )
         end
 
         def to_latex
-          first_value = "{#{parameter_one.to_latex}}" if parameter_one
-          second_value = "{#{parameter_two.to_latex}}" if parameter_two
+          first_value = latex_wrapped(parameter_one) if parameter_one
+          second_value = latex_wrapped(parameter_two) if parameter_two
           "\\#{class_name}#{first_value}#{second_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
+          "#{first_value}#{second_value}"
+        end
+
+        def to_omml_without_math_tag
+          r_tag = Utility.ox_element("r", namespace: "m")
+          update_row_tag(r_tag, parameter_one) if parameter_one
+          update_row_tag(r_tag, parameter_two) if parameter_two
+          r_tag
+        end
+
         def class_name
           self.class.name.split("::").last.downcase
         end
+
+        protected
+
+        def update_row_tag(tag, field)
+          first_value = field.to_omml_without_math_tag
+          first_value = if first_value.is_a?(String)
+                          Utility.ox_element("t", namespace: "m") << first_value
+                        end
+          Utility.update_nodes(
+            tag,
+            first_value.is_a?(Array) ? first_value : [first_value],
+          )
+        end
+
+        def latex_wrapped(field)
+          if validate_function_formula(field)
+            "{ \\left ( #{field.to_latex} \\right ) }"
+          else
+            "{#{field.to_latex}}"
+          end
+        end
+
+        def validate_function_formula(field)
+          unary_classes = (Utility::UNARY_CLASSES + ["obrace", "ubrace", "hat"])
+          if field.is_a?(Formula)
+            !(field.value.any?(Left) || field.value.any?(Right))
+          elsif unary_classes.include?(field.class_name)
+            false
+          elsif field.class.name.include?("Function") || field.is_a?(FontStyle)
+            !field.is_a?(Text)
+          end
+        end
+
+        def mathml_wrapped(field)
+          if validate_function_formula(field)
+            mrow_tag = Utility.ox_element("mrow")
+            open_paren = (Utility.ox_element("mo") << "(")
+            close_paren = (Utility.ox_element("mo") << ")")
+            Utility.update_nodes(
+              mrow_tag,
+              [
+                open_paren,
+                field.to_mathml_without_math_tag,
+                close_paren,
+              ],
+            )
+          else
+            field.to_mathml_without_math_tag
+          end
+        end
+
+        def wrapped(field)
+          return "" unless field
+
+          "(#{field.to_asciimath})"
+        end
+
+        def asciimath_base_value(field)
+          if validate_function_formula(field)
+            "(#{field.to_asciimath})"
+          else
+            field.to_asciimath
+          end
+        end
+
+        def latex_base_value(field)
+          if validate_function_formula(field)
+            "{ \\left ( #{field.to_latex} \\right ) }"
+          else
+            field.to_latex
+          end
+        end
+
+        def invert_unicode_symbols
+          Mathml::Constants::UNICODE_SYMBOLS.invert[class_name] || class_name
+        end
       end
     end
   end

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

@@ -6,6 +6,14 @@ module Plurimath
   module Math
     module Function
       class Cancel < UnaryFunction
+        def to_mathml_without_math_tag
+          cancel_tag = Utility.ox_element(
+            "menclose",
+            attributes: { notation: "updiagonalstrike" },
+          )
+          first_value = parameter_one&.to_mathml_without_math_tag
+          Utility.update_nodes(cancel_tag, [first_value])
+        end
       end
     end
   end

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

@@ -6,6 +6,9 @@ module Plurimath
   module Math
     module Function
       class Ceil < UnaryFunction
+        def to_latex
+          "{\\lceil #{latex_value} \\rceil}"
+        end
       end
     end
   end

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

@@ -6,16 +6,26 @@ module Plurimath
   module Math
     module Function
       class Color < BinaryFunction
+        def to_asciimath
+          first_value = "(#{parameter_one&.to_asciimath&.gsub(/\s/, '')})"
+          second_value = "(#{parameter_two&.to_asciimath})"
+          "color#{first_value}#{second_value}"
+        end
+
         def to_mathml_without_math_tag
-          first_value = parameter_one.value if parameter_one
-          second_value = parameter_two.to_mathml_without_math_tag if parameter_two
-          "<mstyle mathcolor='#{first_value}'>#{second_value}</mstyle>"
+          Utility.update_nodes(
+            Utility.ox_element(
+              "mstyle",
+              attributes: { mathcolor: parameter_one&.to_asciimath&.gsub(/\s/, "")&.gsub(/"/, "") },
+            ),
+            [parameter_two&.to_mathml_without_math_tag],
+          )
         end
 
         def to_latex
-          first_value = parameter_one.to_latex if parameter_one
-          second_value = parameter_two.to_latex if parameter_two
-          "\\#{class_name}{#{first_value}}#{second_value}"
+          first_value = parameter_one&.to_asciimath&.gsub(/\s/, "")
+          second_value = parameter_two&.to_latex
+          "{\\#{class_name}{#{first_value}} #{second_value}}"
         end
       end
     end

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

@@ -6,6 +6,14 @@ module Plurimath
   module Math
     module Function
       class F < UnaryFunction
+        def to_asciimath
+          "f#{parameter_one&.to_asciimath}"
+        end
+
+        def to_latex
+          first_value = latex_value if parameter_one
+          "f#{first_value}"
+        end
       end
     end
   end

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

@@ -8,13 +8,105 @@ module Plurimath
       class Fenced < TernaryFunction
         def to_asciimath
           first_value  = parameter_one ? parameter_one.to_asciimath : "("
-          second_value = parameter_two.map(&:to_asciimath).join(",") if parameter_two
           third_value  = parameter_three ? parameter_three.to_asciimath : ")"
-          "#{first_value}#{second_value}#{third_value}"
+          "#{first_value}#{parameter_two&.map(&:to_asciimath)&.join(' ')}#{third_value}"
         end
 
         def to_mathml_without_math_tag
-          "<mfenced open='#{parameter_one.value}' close='#{parameter_three.value}'>#{parameter_two.map(&:to_mathml_without_math_tag).join}</mfenced>"
+          first_value = Utility.ox_element("mo") << (mathml_paren(parameter_one) || "")
+          second_value = parameter_two&.map(&:to_mathml_without_math_tag) || []
+          third_value = Utility.ox_element("mo") << (mathml_paren(parameter_three) || "")
+          Utility.update_nodes(
+            Utility.ox_element("mrow"),
+            (second_value.insert(0, first_value) << third_value),
+          )
+        end
+
+        def to_html
+          first_value  = "<i>#{parameter_one.value}</i>" if parameter_one
+          second_value = parameter_two.map(&:to_html).join if parameter_two
+          third_value  = "<i>#{parameter_three.value}</i>" if parameter_three
+          "#{first_value}#{second_value}#{third_value}"
+        end
+
+        def to_latex
+          open_paren   = parameter_one ? parameter_one.value : "("
+          fenced_value = parameter_two&.map(&:to_latex)&.join(" ")
+          close_paren  = parameter_three ? parameter_three.value : ")"
+          first_value  = latex_paren(open_paren, false)
+          second_value = latex_paren(close_paren, true)
+          "#{first_value}#{fenced_value}#{second_value}"
+        end
+
+        def to_omml_without_math_tag
+          d = Utility.ox_element("d", namespace: "m")
+          dpr = Utility.ox_element("dPr", namespace: "m")
+          first_value(dpr)
+          third_value(dpr)
+          dpr << Utility.pr_element("ctrl", true, namespace: "m")
+          Utility.update_nodes(
+            d,
+            [dpr] + second_value,
+          )
+        end
+
+        protected
+
+        def second_value
+          class_names = ["number", "symbol"].freeze
+          parameter_two.map do |object|
+            e_tag = Utility.ox_element("e", namespace: "m")
+            e_tag << if class_names.include?(object.class_name)
+                       fenced_omml_value(object)
+                     else
+                       object.to_omml_without_math_tag
+                     end
+          end
+        end
+
+        def fenced_omml_value(object)
+          r_tag = Utility.ox_element("r", namespace: "m")
+          t_tag = Utility.ox_element("t", namespace: "m")
+          t_tag << object.value
+          r_tag << t_tag
+        end
+
+        def first_value(dpr)
+          first_value = parameter_one&.value
+          return dpr if first_value.nil? || first_value.empty?
+
+          attributes = { "m:val": first_value }
+          dpr << Utility.ox_element(
+            "begChr",
+            namespace: "m",
+            attributes: attributes,
+          )
+        end
+
+        def third_value(dpr)
+          third_value = parameter_three&.value
+          return dpr if third_value.nil? || third_value.empty?
+
+          attributes = { "m:val": third_value }
+          dpr << Utility.ox_element(
+            "endChr",
+            namespace: "m",
+            attributes: attributes,
+          )
+        end
+
+        def latex_paren(paren, right)
+          paren_side = right ? "\\right" : "\\left"
+          return "#{paren_side} ." if paren.include?(":")
+
+          paren = %w[{ }].include?(paren) ? "\\#{paren}" : paren
+          " #{paren_side} #{paren} "
+        end
+
+        def mathml_paren(field)
+          return "" if field.value.include?(":")
+
+          field.value
         end
       end
     end

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

@@ -6,6 +6,21 @@ module Plurimath
   module Math
     module Function
       class Floor < UnaryFunction
+        def to_latex
+          "\\lfloor #{parameter_one.to_latex} \\rfloor"
+        end
+
+        def to_mathml_without_math_tag
+          first_value = parameter_one&.to_mathml_without_math_tag
+          Utility.update_nodes(
+            Utility.ox_element("mrow"),
+            [
+              Utility.ox_element("mo") << "&#x230a;",
+              first_value,
+              Utility.ox_element("mo") << "&#x230b;",
+            ],
+          )
+        end
       end
     end
   end

data/lib/plurimath/math/function/font_style/bold.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../font_style"
+
+module Plurimath
+  module Math
+    module Function
+      class FontStyle
+        class Bold < FontStyle
+          def initialize(parameter_one,
+                         parameter_two = "bold")
+            super
+          end
+
+          def to_asciimath
+            "mathbf(#{parameter_one.to_asciimath})"
+          end
+
+          def to_latex
+            first_value = parameter_one.to_latex if parameter_one
+            "\\mathbf{#{first_value}}"
+          end
+
+          def to_mathml_without_math_tag
+            Utility.update_nodes(
+              Utility.ox_element(
+                "mstyle",
+                attributes: { mathvariant: "bold" },
+              ),
+              [parameter_one.to_mathml_without_math_tag],
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/math/function/font_style/double_struck.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../font_style"
+
+module Plurimath
+  module Math
+    module Function
+      class FontStyle
+        class DoubleStruck < FontStyle
+          def initialize(parameter_one,
+                         parameter_two = "double-struck")
+            super
+          end
+
+          def to_asciimath
+            "mathbb(#{parameter_one.to_asciimath})"
+          end
+
+          def to_latex
+            first_value = parameter_one.to_latex if parameter_one
+            "\\mathbb{#{first_value}}"
+          end
+
+          def to_mathml_without_math_tag
+            Utility.update_nodes(
+              Utility.ox_element(
+                "mstyle",
+                attributes: { mathvariant: "double-struck" },
+              ),
+              [parameter_one.to_mathml_without_math_tag],
+            )
+          end
+        end
+      end
+    end
+  end
+end