plurimath 0.2.0 → 0.2.1

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "../table"
+
+module Plurimath
+  module Math
+    module Function
+      class Table
+        class Pmatrix < Table
+          def initialize(parameter_one,
+                         parameter_two = "(",
+                         parameter_three = ")")
+            super
+          end
+
+          def to_latex
+            first_value = parameter_one&.map(&:to_latex)&.join("\\\\")
+            "\\begin{pmatrix}#{first_value}\\end{pmatrix}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "../table"
+
+module Plurimath
+  module Math
+    module Function
+      class Table
+        class Split < Table
+          def initialize(parameter_one,
+                         parameter_two = "[",
+                         parameter_three = "]")
+            super
+          end
+
+          def to_latex
+            first_value = parameter_one&.map(&:to_latex)&.join("\\\\")
+            "\\begin{split}#{first_value}\\end{split}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "../table"
+
+module Plurimath
+  module Math
+    module Function
+      class Table
+        class Vmatrix < Table
+          def initialize(parameter_one,
+                         parameter_two = "|",
+                         parameter_three = "|")
+            parameter_three = nil if parameter_two == "norm["
+            super
+          end
+
+          def to_latex
+            first_value = parameter_one&.map(&:to_latex)&.join("\\\\")
+            "\\begin{vmatrix}#{first_value}\\end{vmatrix}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,12 @@ module Plurimath
   module Math
     module Function
       class Table < TernaryFunction
+        def initialize(parameter_one = nil,
+                       parameter_two = nil,
+                       parameter_three = nil)
+          super
+        end
+
         def to_asciimath
           first_value  = parameter_one.map(&:to_asciimath).join(",")
           second_value = parameter_two.nil? ? "[" : parameter_two
@@ -15,7 +21,8 @@ module Plurimath
 
         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 == "|"
+          parenthesis = Latex::Constants::PARENTHESIS
+          if parenthesis.key?(parameter_two) || parameter_two == "|"
             "<mfenced open='#{parameter_two}' close='#{parameter_three}'>"\
               "<mtable>#{table_value}</mtable></mfenced>"
           elsif parameter_two == "norm["
@@ -28,13 +35,18 @@ module Plurimath
         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}}"
+          "\\begin{#{environment}}#{first_value}\\end{#{environment}}"
         end
 
         def latex_environment
-          matrices_hash = Latex::Constants::ENVIRONMENTS
-          matrices_hash.invert[parameter_two] if matrices_hash.value?(parameter_two)
+          matrices_hash = Latex::Constants::MATRICES
+          matric_value  = matrices_hash.value?(parameter_two)
+          matrices_hash.invert[parameter_two] if matric_value
+        end
+
+        def to_html
+          first_value = parameter_one.map(&:to_html).join
+          "<table>#{first_value}</table>"
         end
       end
     end

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

@@ -10,7 +10,7 @@ module Plurimath
           if parameter_one.length > 1
             "[#{parameter_one.map(&:to_asciimath).join(',')}]"
           else
-            "#{parameter_one.map(&:to_asciimath).join(',')}"
+            parameter_one.map(&:to_asciimath).join(",")
           end
         end
 
@@ -21,6 +21,11 @@ module Plurimath
         def to_latex
           parameter_one.map(&:to_latex).join
         end
+
+        def to_html
+          first_value = parameter_one.map(&:to_html).join
+          "<td>#{first_value}</td>"
+        end
       end
     end
   end

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

@@ -6,14 +6,16 @@ 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
+          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}#{second_value}#{third_value}"
@@ -27,10 +29,18 @@ 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}>"
+          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}>"
+        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 class_name

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

@@ -7,15 +7,11 @@ module Plurimath
     module Function
       class Text < UnaryFunction
         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>"
+          "<mtext>#{parse_text('mathml') || parameter_one}</mtext>"
         end
 
         def symbol_value(unicode)
@@ -24,7 +20,23 @@ module Plurimath
         end
 
         def to_latex
-          parameter_one
+          parse_text("latex") || parameter_one
+        end
+
+        def to_html
+          parse_text("html") || parameter_one
+        end
+
+        def parse_text(lang)
+          regex = %r{\\mbox\{(?<mbox>.{1,})\}|unicode\[:(?<unicode>\w{1,})\]}
+          parameter_one.gsub!(regex) do |_text|
+            last_match = Regexp.last_match
+            if ["mathml", "html"].include?(lang)
+              symbol_value(last_match[:unicode]) || last_match[:mbox]
+            else
+              last_match[:unicode] || last_match[:mbox]
+            end
+          end
         end
       end
     end

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

@@ -16,9 +16,14 @@ module Plurimath
 
         def to_latex
           parameter_one.reject do |td|
-            td if td.is_a?(Symbol) && td.value == "|"
+            td if td.is_a?(Math::Symbol) && td.value == "|"
           end.map(&:to_latex).join("&")
         end
+
+        def to_html
+          first_value = parameter_one.map(&:to_html).join
+          "<tr>#{first_value}</tr>"
+        end
       end
     end
   end

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

@@ -32,6 +32,11 @@ module Plurimath
           "\\#{class_name}#{first_value}"
         end
 
+        def to_html
+          first_value = "<i>#{parameter_one.to_html}</i>" if parameter_one
+          "<i>#{class_name}</i>#{first_value}"
+        end
+
         def class_name
           self.class.name.split("::").last.downcase
         end

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

@@ -6,6 +6,10 @@ module Plurimath
   module Math
     module Function
       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>"
+        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

@@ -24,6 +24,14 @@ module Plurimath
       def to_latex
         value
       end
+
+      def to_html
+        value
+      end
+
+      def class_name
+        self.class.name.split("::").last.downcase
+      end
     end
   end
 end

data/lib/plurimath/math/symbol.rb

@@ -14,7 +14,8 @@ module Plurimath
       end
 
       def to_asciimath
-        value
+        symbol = Asciimath::Constants::SYMBOLS.invert[value.to_sym].to_s
+        symbol.empty? ? value : symbol
       end
 
       def to_mathml_without_math_tag
@@ -26,8 +27,16 @@ module Plurimath
       end
 
       def to_latex
-        symbols = Latex::Constants::SYMBOLS
-        symbols.include?(value) ? "\\#{value}" : value
+        symbols = Latex::Constants::SYMBOLS.invert
+        symbols.key?(value) ? "\\#{symbols[value]}" : value
+      end
+
+      def to_html
+        value
+      end
+
+      def class_name
+        self.class.name.split("::").last.downcase
       end
     end
   end

data/lib/plurimath/math.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "ox"
 require_relative "unicode"
 require_relative "asciimath"
 require_relative "omml"
@@ -14,17 +15,21 @@ require_relative "math/symbol"
 require_relative "asciimath/parser"
 require_relative "mathml/parser"
 require_relative "latex/parser"
+require_relative "html/parser"
+require_relative "omml/parser"
+require_relative "utility"
 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 +47,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
 

data/lib/plurimath/mathml/constants.rb

@@ -283,45 +283,13 @@ module Plurimath
         log
       ].freeze
       FONT_CLASSES = %i[
-        fraktur
+        double-struck
         sans-serif
         monospace
+        fraktur
         script
-        double-struck
         bold
       ].freeze
-      FONT_TYPES = {
-        :bb=>"bold",
-        :fr=>"fraktur",
-        :cc=>"script",
-        :sf=>"sans-serif",
-        :tt=>"monospace",
-        :mbf=>"bold",
-        :mit=>"italic",
-        :mtt=>"monospace",
-        :Bbb=>"double-struck",
-        :bbb=>"double-struck",
-        :mscr=>"mathbb",
-        :mfrak=>"fraktur",
-        :msans=>"sans-serif",
-        :mbfit=>"bold italic",
-        :mathbf=>"bold",
-        :mathit=>"italic",
-        :mathds=>"mathbb",
-        :mathrm=>"mathrm",
-        :mathtt=>"monospace",
-        :mathsf=>"sans-serif",
-        :mathbb=>"double-struck",
-        :mbfsans=>"bold sans-serif",
-        :mathcal=>"script",
-        :mathbold=>"bold",
-        :mathfrak=>"fraktur",
-        :mathbfit=>"bold italic",
-        :mathsfbf=>"sans-serif bold",
-        :mathsfit=>"sans-serif italic",
-        :mbfitsans=>"bold italic sans-serif",
-        :mathsfbfit=>"sans-serif bold italic",
-      }.freeze
     end
   end
 end

data/lib/plurimath/mathml/parse.rb

@@ -13,13 +13,18 @@ module Plurimath
           str("")
       end
 
-      rule(:tag) { (parse_tag(:open) >> iteration.as(:iteration) >> parse_tag(:close)).as(:tag) | parse_text_tag.as(:tag) }
+      rule(:tag) do
+        (parse_tag(:open) >> iteration.as(:iteration) >> parse_tag(:close)).as(:tag) |
+          parse_text_tag.as(:tag)
+      end
 
       rule(:sequence) { (tag >> sequence.as(:sequence)) | tag }
 
       rule(:iteration) { (sequence >> iteration.as(:iteration)) | parse_record }
 
-      rule(:expression) { parse_tag(:open) >> iteration.as(:iteration) >> parse_tag(:close) }
+      rule(:expression) do
+        parse_tag(:open) >> iteration.as(:iteration) >> parse_tag(:close)
+      end
 
       root :expression
 

data/lib/plurimath/mathml/parser.rb

@@ -9,11 +9,12 @@ module Plurimath
       attr_accessor :text
 
       def initialize(text)
-        @text = text.gsub("\n", "").gsub(" ", "")
+        @text = text.gsub(/\s/, "")
       end
 
       def parse
         tree_t = Plurimath::Mathml::Parse.new.parse(text)
+        tree_t = JSON.parse(tree_t.to_json, symbolize_names: true)
         formula = Plurimath::Mathml::Transform.new.apply(tree_t)
         formula = [formula] unless formula.is_a?(Array) || formula.nil?
         return if formula.nil?