plurimath 0.3.4 → 0.3.6

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

@@ -34,10 +34,13 @@ module Plurimath
 
         def to_omml_without_math_tag
           me = Utility.ox_element("e", namespace: "m")
+          return [me] if parameter_one&.empty?
+
           Utility.update_nodes(
             me,
-            parameter_one&.map(&:to_omml_without_math_tag),
+            Formula.new(parameter_one).omml_content,
           )
+          [me]
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module Plurimath
   module Math
     module Function
-      class TernaryFunction
+      class TernaryFunction < Core
         attr_accessor :parameter_one, :parameter_two, :parameter_three
 
         def initialize(parameter_one = nil,
@@ -51,32 +51,24 @@ module Plurimath
           "#{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)
+        def latex_wrapped(field)
+          if field.validate_function_formula
+            "{ \\left ( #{field.to_latex} \\right ) }"
           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
+            "{#{field.to_latex}}"
           end
         end
 
+        def invert_unicode_symbols
+          Mathml::Constants::UNICODE_SYMBOLS.invert[class_name] || class_name
+        end
+
         def wrapped(field, type: "ascii")
           return "" unless field
 
@@ -112,6 +104,31 @@ module Plurimath
             latex
           end
         end
+
+        def narypr(function_symbol, function_type: "undOvr")
+          chr_arg     = { "m:val": function_symbol }
+          limloc_arg  = { "m:val": function_type }
+          subhide_arg = { "m:val": "0" }
+          suphide_arg = { "m:val": "0" }
+          chr_tag     = Utility.ox_element("chr", attributes: chr_arg, namespace: "m")
+          limloc_tag  = Utility.ox_element("limLoc", attributes: limloc_arg, namespace: "m")
+          subhide_tag = Utility.ox_element("subHide", attributes: subhide_arg, namespace: "m")
+          suphide_tag = Utility.ox_element("supHide", attributes: suphide_arg, namespace: "m")
+          nary_pr_tag = Utility.ox_element("naryPr", namespace: "m")
+          Utility.update_nodes(
+            nary_pr_tag,
+            [
+              chr_tag,
+              limloc_tag,
+              subhide_tag,
+              suphide_tag,
+            ],
+          )
+        end
+
+        def all_values_exist?
+          !(parameter_one.nil? && parameter_two.nil? && parameter_three.nil?)
+        end
       end
     end
   end

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

@@ -30,6 +30,17 @@ module Plurimath
         def to_omml_without_math_tag
           text = Utility.ox_element("t", namespace: "m")
           text << (parse_text("omml") || parameter_one)
+          [text]
+        end
+
+        def insert_t_tag
+          r_tag = Utility.ox_element("r", namespace: "m")
+          Utility.update_nodes(r_tag, to_omml_without_math_tag)
+          [r_tag]
+        end
+
+        def validate_function_formula
+          false
         end
 
         protected

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

@@ -41,6 +41,7 @@ module Plurimath
               mr,
               omml_content,
             )
+            [mr]
           end
         end
       end

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

@@ -21,6 +21,14 @@ module Plurimath
             mo_tag
           end
         end
+
+        def tag_name
+          "underover"
+        end
+
+        def validate_function_formula
+          false
+        end
       end
 
       Underbrace = Ubrace

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

@@ -22,7 +22,7 @@ module Plurimath
           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(me, omml_value)
           Utility.update_nodes(
             bar,
             [
@@ -30,6 +30,7 @@ module Plurimath
               me,
             ],
           )
+          [bar]
         end
 
         def class_name

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

@@ -3,7 +3,7 @@
 module Plurimath
   module Math
     module Function
-      class UnaryFunction
+      class UnaryFunction < Core
         attr_accessor :parameter_one
 
         def initialize(parameter_one = nil)
@@ -30,8 +30,12 @@ module Plurimath
           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)
+          if parameter_one
+            new_arr += mathml_value
+            Utility.update_nodes(row_tag, new_arr)
+          else
+            new_arr.first
+          end
         end
 
         def to_latex
@@ -67,6 +71,7 @@ module Plurimath
               me,
             ],
           )
+          [func]
         end
 
         def class_name
@@ -105,14 +110,10 @@ module Plurimath
 
         def omml_value
           if parameter_one.is_a?(Array)
-            return parameter_one&.compact&.map(&:to_omml_without_math_tag)
+            return parameter_one&.compact&.map(&:insert_t_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)
+          Array(parameter_one&.insert_t_tag)
         end
       end
     end

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

@@ -36,25 +36,19 @@ module Plurimath
         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,
-            ],
-          )
+          overset = Overset.new(parameter_one, parameter_three)
+          return overset unless parameter_two
+
+          Underset.new(overset, parameter_two)&.to_omml_without_math_tag
         end
 
         def omml_nary_tag
           pr = Utility.ox_element("naryPr", namespace: "m")
-          [pr_element_value(pr), sub_value, sup_value]
+          [
+            pr_element_value(pr),
+            omml_parameter(parameter_two, tag_name: "sub"),
+            omml_parameter(parameter_three, tag_name: "sup"),
+          ]
         end
 
         protected
@@ -91,20 +85,9 @@ module Plurimath
           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
+          first_value = Utility.html_entity_to_unicode(first_value)
           unless first_value == "∫"
             pr_element << Utility.ox_element(
               "chr",

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

@@ -19,31 +19,18 @@ module Plurimath
         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,
+              omml_parameter(parameter_one, tag_name: "e"),
+              omml_parameter(parameter_two, tag_name: "lim"),
             ],
           )
+          [limlow]
         end
       end
     end

data/lib/plurimath/math/number.rb

@@ -2,11 +2,11 @@
 
 module Plurimath
   module Math
-    class Number < Base
+    class Number < Core
       attr_accessor :value
 
       def initialize(value)
-        @value = super
+        @value = value.is_a?(Parslet::Slice) ? value.to_s : value
       end
 
       def ==(object)
@@ -30,7 +30,21 @@ module Plurimath
       end
 
       def to_omml_without_math_tag
-        Utility.ox_element("t", namespace: "m") << value
+        [(Utility.ox_element("t", namespace: "m") << value)]
+      end
+
+      def insert_t_tag
+        r_tag = Utility.ox_element("r", namespace: "m")
+        r_tag << (Utility.ox_element("t", namespace: "m") << value)
+        [r_tag]
+      end
+
+      def nary_attr_value
+        value
+      end
+
+      def validate_function_formula
+        false
       end
     end
   end

data/lib/plurimath/math/symbol.rb

@@ -2,11 +2,11 @@
 
 module Plurimath
   module Math
-    class Symbol < Base
+    class Symbol < Core
       attr_accessor :value
 
       def initialize(sym)
-        @value = super
+        @value = sym.is_a?(Parslet::Slice) ? sym.to_s : sym
       end
 
       def ==(object)
@@ -62,6 +62,24 @@ module Plurimath
         value
       end
 
+      def insert_t_tag
+        r_tag = Utility.ox_element("r", namespace: "m")
+        r_tag << (Utility.ox_element("t", namespace: "m") << value)
+        [r_tag]
+      end
+
+      def tag_name
+        ["&#x22c0;", "&#x22c1;", "&#x22c2;", "&#x22c3;"].include?(value) ? "underover" : "subsup"
+      end
+
+      def nary_attr_value
+        value
+      end
+
+      def validate_function_formula
+        false
+      end
+
       private
 
       def operator?(unicode)

data/lib/plurimath/math.rb

@@ -7,7 +7,7 @@ require_relative "mathml"
 require_relative "html"
 require_relative "latex"
 require_relative "unitsml"
-require_relative "math/base"
+require_relative "math/core"
 require_relative "math/number"
 require_relative "math/symbol"
 require_relative "math/unicode"

data/lib/plurimath/mathml/constants.rb

@@ -91,8 +91,6 @@ module Plurimath
         "⊤": "TT",
         "⊢": "|--",
         "⊨": "|==",
-        "〈": "(:",
-        "〉": ":)",
         "&#x2329;": "<<",
         "&#x232a;": ">>",
         "&#x222b;": "int",

data/lib/plurimath/mathml/parser.rb

@@ -6,7 +6,15 @@ module Plurimath
   class Mathml
     class Parser
       attr_accessor :text
-      SUPPORTED_ATTRIBUTES = %w[columnlines mathvariant mathcolor notation close open].freeze
+
+      SUPPORTED_ATTRIBUTES = %w[
+        columnlines
+        mathvariant
+        mathcolor
+        notation
+        close
+        open
+      ].freeze
 
       def initialize(text)
         @text = text

data/lib/plurimath/mathml/transform.rb

@@ -114,6 +114,20 @@ module Plurimath
         )
       end
 
+      rule(msub: subtree(:msub)) do
+        Math::Function::Base.new(
+          Utility.filter_values(msub[0]),
+          Utility.filter_values(msub[1]),
+        )
+      end
+
+      rule(msup: subtree(:msup)) do
+        Math::Function::Power.new(
+          Utility.filter_values(msup[0]),
+          Utility.filter_values(msup[1]),
+        )
+      end
+
       rule(msup: sequence(:msup)) do
         Math::Function::Power.new(
           msup[0],
@@ -131,11 +145,17 @@ module Plurimath
 
       rule(munderover: sequence(:function)) do
         binary_function = Plurimath::Math::Function::BinaryFunction
+        ternary_function = Plurimath::Math::Function::TernaryFunction
         base_class = function[0]&.value&.first if function[0].is_a?(Math::Formula)
         if base_class&.class&.ancestors&.include?(binary_function)
           base_class.parameter_one = function[1]
           base_class.parameter_two = function[2]
           base_class
+        elsif base_class&.class&.ancestors&.include?(ternary_function)
+          base_class.parameter_one = function[1]
+          base_class.parameter_two = function[2]
+          base_class.parameter_three = function[3]
+          base_class
         else
           Math::Function::Underover.new(
             function[0],
@@ -290,7 +310,7 @@ module Plurimath
            value: sequence(:value)) do
         Utility.join_attr_value(
           attrs.is_a?(Hash) ? nil : attrs,
-          value&.flatten.compact,
+          value&.flatten&.compact,
         )
       end
     end

data/lib/plurimath/omml/parser.rb

@@ -24,7 +24,7 @@ module Plurimath
       def parse_nodes(nodes)
         nodes.map do |node|
           if node.is_a?(String)
-            node
+            node == "​" ? nil : node
           elsif !node.attributes.empty?
             {
               node.name => {
@@ -33,10 +33,17 @@ module Plurimath
               },
             }
           else
+            organize_table_td(node) if %w[mr eqArr].include?(node.name)
             { node.name => parse_nodes(node.nodes) }
           end
         end
       end
+
+      def organize_table_td(node)
+        node.locate("e/?").each do |child_node|
+          child_node.name = "mtd" if child_node.name == "r"
+        end
+      end
     end
   end
 end

data/lib/plurimath/omml/transform.rb

@@ -21,6 +21,7 @@ module Plurimath
       rule(deg: sequence(:deg))  { Utility.filter_values(deg) }
       rule(sub: sequence(:sub))  { Utility.filter_values(sub) }
       rule(sup: sequence(:sup))  { Utility.filter_values(sup) }
+      rule(mtd: sequence(:mtd))  { mtd.flatten.compact }
       rule(boxPr: subtree(:box)) { nil }
       rule(argPr: subtree(:arg)) { nil }
       rule(accPr: subtree(:acc)) { acc.flatten.compact }
@@ -64,10 +65,14 @@ module Plurimath
         )
       end
 
-      rule(r: sequence(:r)) do
-        Math::Formula.new(
-          r.flatten.compact,
-        )
+      rule(r: subtree(:r)) do
+        if r.flatten.compact.empty?
+          nil
+        else
+          Math::Formula.new(
+            r.flatten.compact,
+          )
+        end
       end
 
       rule(m: sequence(:m)) do
@@ -80,7 +85,7 @@ module Plurimath
         if t.empty?
           Math::Function::Text.new
         else
-          Utility.text_classes(t)
+          t&.compact&.empty? ? [nil] : Utility.text_classes(t)
         end
       end
 
@@ -100,7 +105,7 @@ module Plurimath
         row = []
         mr.each do |td|
           row << Math::Function::Td.new(
-            td.is_a?(Array) ? td : [td],
+            Array(td),
           )
         end
         Math::Function::Tr.new(row)
@@ -167,11 +172,20 @@ module Plurimath
         subsup.each_with_index do |object, ind|
           subsup[ind] = Utility.mathml_unary_classes([object]) if object.is_a?(String)
         end
-        Math::Function::PowerBase.new(
-          subsup[0],
-          subsup[1],
-          subsup[2],
-        )
+        if subsup[0].is_a?(Math::Formula) && Utility.valid_class(subsup[0])
+          Utility.get_class(
+            subsup[0].extract_class_from_text,
+          ).new(
+            subsup[1],
+            subsup[2],
+          )
+        else
+          Math::Function::PowerBase.new(
+            subsup[0],
+            subsup[1],
+            subsup[2],
+          )
+        end
       end
 
       rule(sSup: subtree(:ssup)) do
@@ -197,7 +211,7 @@ module Plurimath
 
       rule(sSub: subtree(:ssub)) do
         sub = ssub.flatten.compact
-        Plurimath::Math::Function::Base.new(
+        Math::Function::Base.new(
           sub[0],
           sub[1],
         )
@@ -253,7 +267,7 @@ module Plurimath
           table_value << Math::Function::Tr.new(
             [
               Math::Function::Td.new(
-                value.is_a?(Array) ? value : [value],
+                Array(value),
               ),
             ],
           )

data/lib/plurimath/utility.rb

@@ -64,8 +64,6 @@ module Plurimath
       csc
       ln
       lg
-      f
-      g
     ].freeze
     MUNDER_CLASSES = %w[
       ubrace
@@ -192,6 +190,7 @@ module Plurimath
       def update_nodes(element, nodes)
         nodes&.each do |node|
           next update_nodes(element, node) if node.is_a?(Array)
+
           element << node unless node.nil?
         end
         element
@@ -217,12 +216,12 @@ module Plurimath
       end
 
       def text_classes(text)
-        return nil if text.empty?
+        return nil if text&.empty?
 
         text = filter_values(text) unless text.is_a?(String)
-        if text.scan(/[[:digit:]]/).length == text.length
+        if text&.scan(/[[:digit:]]/)&.length == text&.length
           Math::Number.new(text)
-        elsif text.match?(/[a-zA-Z]/)
+        elsif text&.match?(/[a-zA-Z]/)
           Math::Function::Text.new(text)
         else
           Math::Symbol.new(text)
@@ -230,10 +229,11 @@ module Plurimath
       end
 
       def nary_fonts(nary)
-        narypr = nary.first.flatten.compact
-        subsup = narypr.any?("undOvr") ? "underover" : "power_base"
+        narypr  = nary.first.flatten.compact
+        subsup  = narypr.any?("undOvr") ? "underover" : "power_base"
+        unicode = narypr.any?(Hash) ? narypr.first[:chr] : "∫"
         get_class(subsup).new(
-          Math::Symbol.new(narypr.any?(Hash) ? narypr.first[:chr] : "∫"),
+          Math::Symbol.new(string_to_html_entity(unicode)),
           nary[1],
           nary[2],
         )
@@ -299,6 +299,11 @@ module Plurimath
         entities.encode(string, :hexadecimal)
       end
 
+      def html_entity_to_unicode(string)
+        entities = HTMLEntities.new
+        entities.decode(string)
+      end
+
       def table_separator(separator, value, symbol: "solid")
         sep_symbol = Math::Function::Td.new([Math::Symbol.new("|")])
         separator&.each_with_index do |sep, ind|
@@ -395,6 +400,8 @@ module Plurimath
         value = case value
                 when "ℒ" then "{:"
                 when "ℛ" then ":}"
+                when "ᑕ" then "&#x2329;"
+                when "ᑐ" then "&#x232a;"
                 else value
                 end
         Math::Symbol.new(value)
@@ -416,6 +423,11 @@ module Plurimath
                 end
         get_class(function).new(paren)
       end
+
+      def valid_class(object)
+        text = object.extract_class_from_text
+        Asciimath::Constants::SUB_SUP_CLASSES.include?(text)
+      end
     end
   end
 end

data/lib/plurimath/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Plurimath
-  VERSION = "0.3.4"
+  VERSION = "0.3.6"
 end