plurimath 0.2.0 → 0.2.2

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,25 +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 = 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

@@ -6,6 +6,16 @@ module Plurimath
   module Math
     module Function
       class Vec < UnaryFunction
+        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") << "&#x2192;",
+            ],
+          )
+        end
       end
     end
   end

data/lib/plurimath/math/function.rb

@@ -1,3 +1,14 @@
-Dir[File.join(__dir__, "function/*.rb")].each do |file|
-  require_relative file.gsub(".rb", "")
+module Plurimath
+  module Math
+    module Function
+    end
+  end
+end
+
+# Include the first level files before the next
+(
+  Dir.glob(File.join(__dir__, "function", "*.rb")) +
+  Dir.glob(File.join(__dir__, "function", "*", "*.rb"))
+).each do |file|
+  require file
 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,12 +18,20 @@ module Plurimath
       end
 
       def to_mathml_without_math_tag
-        "<mn>#{value}</mn>"
+        Utility.ox_element("mn") << value
       end
 
       def to_latex
         value
       end
+
+      def to_html
+        value
+      end
+
+      def to_omml_without_math_tag
+        Utility.ox_element("t", namespace: "m") << value
+      end
     end
   end
 end

data/lib/plurimath/math/symbol.rb

@@ -2,11 +2,11 @@
 
 module Plurimath
   module Math
-    class Symbol
+    class Symbol < Base
       attr_accessor :value
 
       def initialize(sym)
-        @value = sym
+        @value = super
       end
 
       def ==(object)
@@ -14,20 +14,68 @@ module Plurimath
       end
 
       def to_asciimath
-        value
+        return "" if value.nil?
+
+        symbol = Asciimath::Constants::SYMBOLS.invert[value.strip.to_sym]
+        unicodes = Latex::Constants::UNICODE_SYMBOLS.invert
+        if value.match?(/&#x[0-9\w]+;/) && symbol.nil? && unicodes[value]
+          return unicodes[value].to_s
+        end
+
+        symbol ? symbol.to_s : value
       end
 
       def to_mathml_without_math_tag
-        "<mo>#{mathml_symbol_value}</mo>"
-      end
+        mi_tag = Utility.ox_element("mi")
+        return mi_tag if ["{:", ":}"].include?(value)
+
+        unicodes = Mathml::Constants::UNICODE_SYMBOLS
+        unicode = unicodes.invert[value]
+        if operator?(unicode) || unicode
+          mo_value = (unicodes[value] || unicode || value).to_s
+          return Utility.ox_element("mo") << mo_value
+        end
 
-      def mathml_symbol_value
-        Mathml::Constants::UNICODE_SYMBOLS.invert[value] || value
+        mi_tag << value
       end
 
       def to_latex
-        symbols = Latex::Constants::SYMBOLS
-        symbols.include?(value) ? "\\#{value}" : value
+        returned = specific_values
+        return returned if returned
+
+        special_char = %w[&#x26; &#x23;]
+        symbols = Latex::Constants::UNICODE_SYMBOLS.invert
+
+        symbol = symbols[value]
+        if Latex::Constants::SYMBOLS[symbol] == :operant
+          special_char.include?(value) ? "\\#{symbol}" : symbol
+        else
+          symbols.key?(value) ? "\\#{symbol}" : value
+        end
+      end
+
+      def to_html
+        value
+      end
+
+      def to_omml_without_math_tag
+        value
+      end
+
+      private
+
+      def operator?(unicode)
+        Mathml::Constants::OPERATORS.any? do |d|
+          [unicode.to_s, value.strip].include?(d)
+        end
+      end
+
+      def specific_values
+        return "" if ["{:", ":}"].include?(value)
+
+        return "\\#{value}" if ["{", "}"].include?(value) || value == "_"
+
+        return "\\operatorname{if}" if value == "if"
       end
     end
   end

data/lib/plurimath/math/unicode.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Math
+    class Unicode < Symbol
+      def to_mathml_without_math_tag
+        Utility.ox_element("mo") << value
+      end
+    end
+  end
+end

data/lib/plurimath/math.rb

@@ -7,24 +7,33 @@ require_relative "mathml"
 require_relative "html"
 require_relative "latex"
 require_relative "unitsml"
-require_relative "math/formula"
-require_relative "math/function"
+require_relative "math/base"
 require_relative "math/number"
 require_relative "math/symbol"
+require_relative "math/unicode"
+require_relative "math/formula"
+require_relative "math/function"
 require_relative "asciimath/parser"
 require_relative "mathml/parser"
 require_relative "latex/parser"
+require_relative "html/parser"
+require_relative "omml/parser"
+require_relative "utility"
+require "ox"
+Ox.default_options = { encoding: "UTF-8" }
+
 module Plurimath
   module Math
     class Error < StandardError; end
 
     VALID_TYPES = {
-      unicode: Unicode,
-      asciimath: Asciimath,
       omml: Omml,
-      mathml: Mathml,
       html: Html,
       latex: Latex,
+      mathml: Mathml,
+      unitsml: Unitsml,
+      unicode: Unicode,
+      asciimath: Asciimath,
     }.freeze
 
     def parse(text, type)
@@ -42,7 +51,7 @@ module Plurimath
     end
 
     def valid_type?(type)
-      (type.is_a?(Symbol) || type.is_a?(String)) &&
+      (type.is_a?(::Symbol) || type.is_a?(String)) &&
         VALID_TYPES.key?(type.to_sym)
     end