plurimath 0.2.0 → 0.2.2

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

@@ -5,36 +5,206 @@ require_relative "ternary_function"
 module Plurimath
   module Math
     module Function
-      class Table < TernaryFunction
+      class Table
+        attr_accessor :value, :open_paren, :close_paren, :options
+
+        def initialize(value = nil,
+                       open_paren = nil,
+                       close_paren = nil,
+                       options = {})
+          @value = value
+          @open_paren = open_paren
+          @close_paren = close_paren
+          @options = options
+        end
+
+        def ==(object)
+          object.class == self.class &&
+            object.value == value &&
+            object.options == options &&
+            object.open_paren == open_paren &&
+            object.close_paren == close_paren
+        end
+
         def to_asciimath
-          first_value  = parameter_one.map(&:to_asciimath).join(",")
-          second_value = parameter_two.nil? ? "[" : parameter_two
-          third_value  = parameter_three.nil? ? "]" : parameter_three
-          "#{second_value}#{first_value}#{third_value}"
+          parenthesis = Asciimath::Constants::TABLE_PARENTHESIS
+          first_value = value.map(&:to_asciimath).join(", ")
+          third_value = close_paren.is_a?(::Array) || close_paren.nil?
+          lparen = open_paren.nil? ? "[" : open_paren
+          rparen = third_value ? parenthesis[lparen.to_sym] : close_paren
+          "#{lparen}#{first_value}#{rparen}"
         end
 
         def to_mathml_without_math_tag
-          table_value = parameter_one.map(&:to_mathml_without_math_tag).join
-          if Latex::Constants::PARENTHESIS.key?(parameter_two) || parameter_two == "|"
-            "<mfenced open='#{parameter_two}' close='#{parameter_three}'>"\
-              "<mtable>#{table_value}</mtable></mfenced>"
-          elsif parameter_two == "norm["
-            "<mo>&#x2225;</mo>#{table_value}<mo>&#x2225;</mo>"
-          else
-            "<mtable>#{table_value}</mtable>"
+          table_tag = Utility.ox_element("mtable", attributes: table_attribute)
+          Utility.update_nodes(
+            table_tag,
+            value&.map(&:to_mathml_without_math_tag),
+          )
+          return norm_table(table_tag) if open_paren == "norm["
+
+          if present?(open_paren) || present?(close_paren)
+            first_paren = Utility.ox_element("mo") << mathml_parenthesis(open_paren)
+            second_paren = Utility.ox_element("mo") << mathml_parenthesis(close_paren)
+            mrow_tag = Utility.ox_element("mrow")
+            return Utility.update_nodes(mrow_tag, [first_paren, table_tag, second_paren])
           end
+
+          table_tag
         end
 
         def to_latex
-          first_value = parameter_one&.map(&:to_latex)&.join("\\\\")
-          environment = latex_environment
-          divider     = "{#{parameter_three&.map(&:to_latex).join}}" if environment == "array"
-          "\\begin{#{environment}}#{divider}#{first_value}\\end{#{environment}}"
+          if open_paren == "norm["
+            return "\\begin{Vmatrix}#{latex_content}\\end{Vmatrix}"
+          end
+
+          separator = "{#{table_attribute(:latex)}}" if environment&.include?("array")
+          left_paren = latex_parenthesis(open_paren) || "."
+          right_paren = latex_parenthesis(close_paren) || "."
+          left = "\\left #{left_paren}\\begin{matrix}"
+          right = "\\end{matrix}\\right #{right_paren}"
+          "#{left}#{separator}#{latex_content}#{right}"
+        end
+
+        def to_html
+          first_value = value.map(&:to_html).join
+          "<table>#{first_value}</table>"
+        end
+
+        def to_omml_without_math_tag
+          if value.map { |d| d.parameter_one.length == 1 }.all?
+            single_td_table
+          else
+            multiple_td_table
+          end
+        end
+
+        def class_name
+          self.class.name.split("::").last.downcase
+        end
+
+        protected
+
+        def present?(field)
+          !(field.nil? || field.empty?)
+        end
+
+        def mathml_parenthesis(field)
+          return "" if field&.include?(":")
+
+          present?(field) ? field : ""
+        end
+
+        def latex_parenthesis(field)
+          return " ." if field&.include?(":")
+
+          return "\\#{field}" if ["{", "}"].include?(field)
+
+          field
+        end
+
+        def table_attribute(type = :mathml)
+          column_string = column_lines
+          case type
+          when :mathml
+            mathml_attrs(column_string)
+          when :latex
+            column_string.insert(0, "none") if column_string.include?("solid")
+            column_string&.map { |d| d == "solid" ? "|" : "a" }&.join
+          end
+        end
+
+        def column_lines
+          columns_array = []
+          value.first.parameter_one.each_with_index do |td, i|
+            if td.parameter_one.find { |obj| Utility.symbol_value(obj, "|") }
+              columns_array.empty? ? columns_array = ["solid"] : columns_array[i - 1] = "solid"
+            else
+              columns_array << "none"
+            end
+          end
+          columns_array
+        end
+
+        def mathml_attrs(column_strings)
+          args = options&.dup&.reject { |arg| arg.to_s == "asterisk" }
+          args[:columnlines] = column_strings.join(" ") if column_strings.include?("solid")
+          args
+        end
+
+        def latex_content
+          value&.map(&:to_latex)&.join(" \\\\ ")
+        end
+
+        def matrix_class
+          matrix = if open_paren
+                     Latex::Constants::MATRICES.invert[open_paren]
+                   else
+                     class_name
+                   end
+          options&.key?(:asterisk) ? "{#{matrix}*}" : "{#{matrix}}"
+        end
+
+        def opening
+          "#{matrix_class}#{latex_columnalign}"
+        end
+
+        def latex_columnalign
+          return "" unless Hash(options)[:asterisk]
+
+          columnalign = Hash(value&.first&.parameter_one&.first&.parameter_two)[:columnalign]
+          "[#{Utility::ALIGNMENT_LETTERS.invert[columnalign]}]"
+        end
+
+        def environment
+          matrices_hash = Latex::Constants::MATRICES
+          matric_value  = matrices_hash.value?(open_paren)
+          matrices_hash.invert[open_paren].to_s if matric_value
+        end
+
+        def single_td_table
+          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
+          Utility.update_nodes(eqarr, tr_value.compact)
+        end
+
+        def multiple_td_table
+          count  = { "m:val": value&.first&.parameter_one&.count }
+          mcjc   = { "m:val": "center" }
+          mm     = Utility.ox_element("m", namespace: "m")
+          mpr    = Utility.ox_element("mpr", namespace: "m")
+          mcs    = Utility.ox_element("mcs", namespace: "m")
+          mc     = Utility.ox_element("mc", namespace: "m")
+          mcpr   = Utility.ox_element("mcPr", namespace: "m")
+          mcount = Utility.ox_element(
+            "count",
+            namespace: "m",
+            attributes: count,
+          )
+          mcjc = Utility.ox_element(
+            "mcJc",
+            namespace: "m",
+            attributes: mcjc,
+          )
+          ctrlpr = Utility.pr_element("ctrl", true, namespace: "m")
+          Utility.update_nodes(mcpr, [mcount, mcjc])
+          mc  << mcpr
+          mcs << mc
+          mpr << mcs
+          mpr << ctrlpr
+          mm_value = value&.map(&:to_omml_without_math_tag)
+          Utility.update_nodes(mm, mm_value.insert(0, mpr).flatten)
         end
 
-        def latex_environment
-          matrices_hash = Latex::Constants::ENVIRONMENTS
-          matrices_hash.invert[parameter_two] if matrices_hash.value?(parameter_two)
+        def norm_table(table_tag)
+          mo_tag = Utility.ox_element("mo") << "&#x2225;"
+          Utility.update_nodes(
+            Utility.ox_element("mrow"),
+            [mo_tag, table_tag, mo_tag],
+          )
         end
       end
     end

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

@@ -1,25 +1,43 @@
 # frozen_string_literal: true
 
-require_relative "unary_function"
+require_relative "binary_function"
 
 module Plurimath
   module Math
     module Function
-      class Td < UnaryFunction
+      class Td < BinaryFunction
         def to_asciimath
-          if parameter_one.length > 1
-            "[#{parameter_one.map(&:to_asciimath).join(',')}]"
-          else
-            "#{parameter_one.map(&:to_asciimath).join(',')}"
-          end
+          parameter_one.map(&:to_asciimath).join(" ")
         end
 
         def to_mathml_without_math_tag
-          "<mtd>#{parameter_one.map(&:to_mathml_without_math_tag).join}</mtd>"
+          return "" if Utility.symbol_value(parameter_one.first, "|")
+
+          td_attribute = parameter_two if parameter_two&.any?
+
+          Utility.update_nodes(
+            Utility.ox_element("mtd", attributes: td_attribute),
+            parameter_one.map(&:to_mathml_without_math_tag),
+          )
         end
 
         def to_latex
-          parameter_one.map(&:to_latex).join
+          return "" if Utility.symbol_value(parameter_one.first, "|")
+
+          parameter_one.map(&:to_latex).join(" ")
+        end
+
+        def to_html
+          first_value = parameter_one.map(&:to_html).join
+          "<td>#{first_value}</td>"
+        end
+
+        def to_omml_without_math_tag
+          me = Utility.ox_element("e", namespace: "m")
+          Utility.update_nodes(
+            me,
+            parameter_one&.map(&:to_omml_without_math_tag),
+          )
         end
       end
     end

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

@@ -6,16 +6,18 @@ module Plurimath
       class TernaryFunction
         attr_accessor :parameter_one, :parameter_two, :parameter_three
 
-        def initialize(parameter_one = nil, parameter_two = nil, parameter_three = nil)
+        def initialize(parameter_one = nil,
+                       parameter_two = nil,
+                       parameter_three = nil)
           @parameter_one = parameter_one
           @parameter_two = parameter_two
           @parameter_three = parameter_three
         end
 
         def to_asciimath
-          first_value = parameter_one.to_asciimath if parameter_one
-          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
 
@@ -27,15 +29,88 @@ 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  = parameter_three.to_mathml_without_math_tag if parameter_three
-          "<m#{class_name}>#{first_value}#{second_value}#{third_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}"
+        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,30 +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
-          "\"#{parameter_one}\""
+          "\"#{parse_text('asciimath') || parameter_one}\""
         end
 
         def to_mathml_without_math_tag
-          regex_exp = %r{unicode\[:(?<unicode>\w{1,})\]}
-          parameter_one.gsub!(regex_exp) do |_text|
-            symbol_value(Regexp.last_match[:unicode]).to_s
-          end
-          "<mtext>#{parameter_one}</mtext>"
+          text = Utility.ox_element("mtext")
+          text << (parse_text("mathml") || parameter_one) if parameter_one
+        end
+
+        def to_latex
+          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 to_latex
-          parameter_one
+        def parse_text(lang)
+          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])
+            else
+              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,17 +7,41 @@ 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?(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

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