plurimath 0.5.0 → 0.7.0

data/lib/plurimath/math/symbol.rb

@@ -5,12 +5,12 @@ module Plurimath
     class Symbol < Core
       attr_accessor :value
 
-      def initialize(sym)
+      def initialize(sym = nil)
         @value = sym.is_a?(Parslet::Slice) ? sym.to_s : sym
       end
 
       def ==(object)
-        object.value == value
+        object.respond_to?(:value) && object.value == value
       end
 
       def to_asciimath
@@ -29,11 +29,9 @@ module Plurimath
         mi_tag = Utility.ox_element("mi")
         return mi_tag if ["{:", ":}"].include?(value)
 
-        unicodes = Mathml::Constants::UNICODE_SYMBOLS
-        unicode = unicodes.invert[value]
+        unicode = Mathml::Constants::UNICODE_SYMBOLS.invert[value]
         if operator?(unicode) || unicode || explicit_checks(unicode)
-          mo_value = (unicodes[value] || unicode || value).to_s
-          return Utility.ox_element("mo") << mo_value
+          return Utility.ox_element("mo") << (unicode || value).to_s
         end
 
         mi_tag << value
@@ -58,14 +56,12 @@ module Plurimath
         value
       end
 
-      def to_omml_without_math_tag(_display_style)
+      def to_omml_without_math_tag(_, _)
         value
       end
 
-      def insert_t_tag(_display_style)
-        r_tag = Utility.ox_element("r", namespace: "m")
-        r_tag << (Utility.ox_element("t", namespace: "m") << value)
-        [r_tag]
+      def insert_t_tag(_)
+        [(Utility.ox_element("r", namespace: "m") << t_tag)]
       end
 
       def tag_name
@@ -80,8 +76,8 @@ module Plurimath
         "subSup"
       end
 
-      def font_style_t_tag(_display_style)
-        Utility.ox_element("t", namespace: "m") << value
+      def font_style_t_tag(_)
+        t_tag
       end
 
       def nary_attr_value
@@ -92,6 +88,22 @@ module Plurimath
         false
       end
 
+      def omml_nodes(_)
+        Array(t_tag)
+      end
+
+      def t_tag
+        Utility.ox_element("t", namespace: "m") << value
+      end
+
+      def separate_table
+        ["&", "\\\\"].include?(value)
+      end
+
+      def linebreak
+        value == "\\\\"
+      end
+
       private
 
       def operator?(unicode)

data/lib/plurimath/math.rb

@@ -19,9 +19,7 @@ require_relative "latex/parser"
 require_relative "html/parser"
 require_relative "omml/parser"
 require_relative "utility"
-require "ox"
 require "yaml"
-Ox.default_options = { encoding: "UTF-8" }
 
 module Plurimath
   module Math
@@ -72,7 +70,7 @@ module Plurimath
 
     def type_error!
       raise InvalidTypeError.new(
-        "`type` must be one of: `#{VALID_TYPES.keys.join('`, `')}`"
+        "`type` must be one of: `#{VALID_TYPES.keys.join('`, `')}`",
       )
     end
 

data/lib/plurimath/mathml/parser.rb

@@ -8,9 +8,11 @@ module Plurimath
       attr_accessor :text
 
       SUPPORTED_ATTRS = %w[
+        linebreakstyle
         columnlines
         mathvariant
         accentunder
+        linebreak
         mathcolor
         notation
         accent
@@ -23,8 +25,8 @@ module Plurimath
       end
 
       def parse
-        ox_nodes = Ox.load(text, strip_namespace: true)
-        display_style = ox_nodes&.locate("*/mstyle/@displaystyle")&.first
+        ox_nodes = Plurimath.xml_engine.load(text)
+        display_style = ox_nodes&.locate("mstyle/@displaystyle")&.first
         nodes = parse_nodes(ox_nodes.nodes)
         Math::Formula.new(
           Transform.new.apply(nodes).flatten.compact,
@@ -34,7 +36,7 @@ module Plurimath
 
       def parse_nodes(nodes)
         nodes.map do |node|
-          next if node.is_a?(Ox::Comment)
+          next if Plurimath.xml_engine.is_xml_comment?(node)
 
           if node.is_a?(String)
             node
@@ -47,7 +49,7 @@ module Plurimath
       end
 
       def validate_attributes(attributes)
-        attributes&.select! { |key, _| SUPPORTED_ATTRS.include?(key&.to_s) }
+        attributes&.select! { |key, _| SUPPORTED_ATTRS.include?(key.to_s) }
         attributes&.transform_keys(&:to_sym) if attributes&.any?
       end
 

data/lib/plurimath/mathml/transform.rb

@@ -9,6 +9,7 @@ module Plurimath
       rule(mtd: sequence(:mtd))     { Math::Function::Td.new(mtd) }
       rule(mtr: sequence(:mtr))     { Math::Function::Tr.new(mtr) }
       rule(none: sequence(:none))   { nil }
+      rule(mspace: simple(:space))  { nil }
       rule(notation: simple(:att))  { Math::Function::Menclose.new(att) }
       rule(mtable: simple(:table))  { table }
       rule(msqrt: sequence(:sqrt))  { Math::Function::Sqrt.new(sqrt.first) }
@@ -36,7 +37,9 @@ module Plurimath
       end
 
       rule(mphantom: sequence(:phantom)) do
-        Math::Function::Phantom.new(phantom)
+        Math::Function::Phantom.new(
+          Utility.filter_values(phantom),
+        )
       end
 
       rule(mn: sequence(:mn)) do
@@ -88,8 +91,7 @@ module Plurimath
 
       rule(merror: sequence(:merror)) do
         Math::Function::Merror.new(
-          merror[0],
-          merror[1],
+          Utility.filter_values(merror),
         )
       end
 
@@ -247,7 +249,7 @@ module Plurimath
         symbols  = Constants::UNICODE_SYMBOLS.transform_keys(&:to_s)
         text     = entities.encode(mtext.flatten.join, :hexadecimal)
         symbols.each do |code, string|
-          text.gsub!(code.downcase, "unicode[:#{string}]")
+          text = text.gsub(code.downcase, "unicode[:#{string}]")
         end
         Math::Function::Text.new(text)
       end
@@ -257,7 +259,7 @@ module Plurimath
         symbols  = Constants::UNICODE_SYMBOLS.transform_keys(&:to_s)
         text     = entities.encode(ms.first, :hexadecimal)
         symbols.each do |code, string|
-          text.gsub!(code.downcase, "unicode[:#{string}]")
+          text = text.gsub(code.downcase, "unicode[:#{string}]")
         end
         Math::Function::Text.new(text)
       end
@@ -317,11 +319,6 @@ module Plurimath
         end
       end
 
-      rule(attributes: simple(:attrs),
-           value: subtree(:value)) do
-        Utility.join_attr_value(attrs, value&.flatten&.compact)
-      end
-
       rule(semantics: subtree(:value)) do
         Math::Function::Semantics.new(
           value.shift,
@@ -329,17 +326,27 @@ module Plurimath
         )
       end
 
+      rule(attributes: simple(:attrs),
+           value: subtree(:value)) do
+        Utility.join_attr_value(attrs, value&.flatten&.compact)
+      end
+
       rule(attributes: subtree(:attrs),
            value: sequence(:value)) do
-        approved_attrs = if attrs.is_a?(Hash)
-                           supported_attrs = %w[accentunder accent]
-                           attrs if attrs.keys.any? do |k|
-                             supported_attrs.include?(k.to_s)
-                           end
-                         else
-                           attrs
-                         end
-        Utility.join_attr_value(approved_attrs, value&.flatten&.compact)
+        approved = if attrs.is_a?(Hash)
+                     supported = %w[accentunder accent linebreak]
+                     if attrs.keys.any? { |k| supported.include?(k.to_s) }
+                       unicode_only = true if attrs.key?(:linebreak)
+                       attrs
+                     end
+                   else
+                     attrs
+                   end
+        Utility.join_attr_value(
+          approved,
+          value&.flatten&.compact,
+          unicode_only: unicode_only,
+        )
       end
     end
   end

data/lib/plurimath/omml/parser.rb

@@ -33,7 +33,7 @@ module Plurimath
       end
 
       def parse
-        nodes = Ox.load(text, strip_namespace: true)
+        nodes = Plurimath.xml_engine.load(text)
         @hash = { sequence: parse_nodes(nodes.nodes) }
         nodes = JSON.parse(@hash.to_json, symbolize_names: true)
         Math::Formula.new(
@@ -71,14 +71,14 @@ module Plurimath
       end
 
       def organize_table_td(node)
-        node.locate("e/?").each do |child_node|
+        node.locate("e/*").each do |child_node|
           child_node.name = "mtd" if child_node.name == "r"
         end
       end
 
       def organize_fonts(node)
         attrs_arr = { val: [] }
-        node.locate("rPr/?").each do |child|
+        node.locate("rPr/*").each do |child|
           attrs_arr[:val] << child.attributes["val"]
         end
         node.attributes.merge! attrs_arr

data/lib/plurimath/omml/transform.rb

@@ -9,6 +9,7 @@ module Plurimath
       rule(i: sequence(:i)) { i }
       rule(e: sequence(:e)) { e.flatten.compact }
 
+      rule(br: sequence(:br))    { Math::Function::Linebreak.new }
       rule(val: simple(:val))    { val }
       rule(scr: simple(:scr))    { scr }
       rule(sty: simple(:sty))    { sty }
@@ -98,11 +99,17 @@ module Plurimath
         open_paren   = fenced.shift if fenced&.first&.class_name == "symbol"
         close_paren  = fenced.shift if fenced&.first&.class_name == "symbol"
         fenced_value = fenced.compact
-        Math::Function::Fenced.new(
-          open_paren,
-          fenced_value,
-          close_paren,
-        )
+        if fenced_value.length == 1 && fenced_value.first.is_a?(Math::Function::Table)
+          fenced_value.first.open_paren = open_paren&.value
+          fenced_value.first.close_paren = close_paren&.value
+          fenced_value
+        else
+          Math::Function::Fenced.new(
+            open_paren,
+            fenced_value,
+            close_paren,
+          )
+        end
       end
 
       rule(dPr: subtree(:dpr)) do
@@ -176,12 +183,7 @@ module Plurimath
           ternary_class.parameter_three = Utility.filter_values(nary[3])
           ternary_class
         else
-          Math::Formula.new(
-            [
-              Utility.nary_fonts(nary),
-              Utility.filter_values(nary[3]),
-            ],
-          )
+          Utility.nary_fonts(nary)
         end
       end
 
@@ -209,7 +211,7 @@ module Plurimath
         end
         if Utility.valid_class(subsup[0])
           Utility.get_class(
-            subsup[0].extract_class_from_text,
+            subsup[0].extract_class_name_from_text,
           ).new(
             subsup[1],
             subsup[2],
@@ -255,20 +257,31 @@ module Plurimath
       rule(limUpp: subtree(:lim)) do
         lim_values = lim.flatten.compact
         first_value = lim_values[0]
-        Math::Function::Overset.new(
-          first_value,
-          lim_values[1],
-        )
+        if lim.last.is_unary? && lim.last.value_nil?
+          function_class = lim.pop
+          function_class.parameter_one = Utility.filter_values(lim.flatten.compact)
+          function_class
+        else
+          Math::Function::Overset.new(
+            first_value,
+            lim_values[1],
+          )
+        end
       end
 
       rule(limLow: subtree(:lim)) do
         second_value = Utility.filter_values(lim[2])
-        unicode = Mathml::Constants::UNICODE_SYMBOLS.invert[second_value.class_name]
+        unicode = Mathml::Constants::UNICODE_SYMBOLS.invert[second_value&.class_name]
         second_value = unicode ? Math::Symbol.new(unicode.to_s) : second_value
-        Math::Function::Underset.new(
-          Utility.filter_values(lim[1]),
-          second_value,
-        )
+        if second_value.is_unary? && second_value.value_nil?
+          second_value.parameter_one = Utility.filter_values(lim[1])
+          second_value
+        else
+          Math::Function::Underset.new(
+            Utility.filter_values(lim[1]),
+            second_value,
+          )
+        end
       end
 
       rule(borderBox: subtree(:box)) do

data/lib/plurimath/setup/oga.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "plurimath/xml_engine/oga"
+
+Plurimath.xml_engine = Plurimath::XMLEngine::Oga

data/lib/plurimath/setup/opal.rb.erb

@@ -0,0 +1,8 @@
+require 'plurimath/math/core'
+require 'plurimath/math/function'
+<% (
+     Dir[File.dirname(__dir__)+"/math/function/*.rb"] +
+     Dir[File.dirname(__dir__)+"/math/function/**/*.rb"]
+   ).each do |f| %>
+  require 'plurimath/<%= f.split("lib/plurimath").last.gsub(/.rb$/,'') %>'
+<% end %>

data/lib/plurimath/setup/ox.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "plurimath/xml_engine/ox"
+
+Plurimath.xml_engine = Plurimath::XMLEngine::Ox

data/lib/plurimath/unitsml.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "unitsml"
 module Plurimath
   class Unitsml
     attr_accessor :text
@@ -9,7 +10,7 @@ module Plurimath
     end
 
     def to_formula
-      # TODO: Will be implemented soon
+      ::Unitsml.parse(text).to_plurimath
     end
   end
 end

data/lib/plurimath/utility.rb

@@ -21,6 +21,7 @@ module Plurimath
       mathrm: Math::Function::FontStyle::Normal,
       textrm: Math::Function::FontStyle::Normal,
       italic: Math::Function::FontStyle::Italic,
+      mathit: Math::Function::FontStyle::Italic,
       mathbf: Math::Function::FontStyle::Bold,
       textbf: Math::Function::FontStyle::Bold,
       script: Math::Function::FontStyle::Script,
@@ -46,6 +47,8 @@ module Plurimath
       arccos
       arcsin
       arctan
+      liminf
+      limsup
       right
       sech
       sinh
@@ -58,6 +61,7 @@ module Plurimath
       min
       sec
       sin
+      sup
       deg
       det
       dim
@@ -65,6 +69,8 @@ module Plurimath
       gcd
       glb
       lub
+      lcm
+      ker
       tan
       cos
       cot
@@ -91,20 +97,25 @@ module Plurimath
       "{": "}",
       "[": "]",
     }.freeze
+    TEXT_CLASSES = %w[
+      unicode
+      symbol
+      number
+      text
+    ].freeze
 
     class << self
       def organize_table(array, column_align: nil, options: nil)
         table = []
         table_data = []
         table_row = []
-        table_separators = ["&", "\\\\"].freeze
         organize_options(array, column_align) if options
         string_columns = column_align&.map(&:value)
         array.each do |data|
-          if data.is_a?(Math::Symbol) && table_separators.include?(data.value)
+          if data&.separate_table
             table_row << Math::Function::Td.new(filter_table_data(table_data).compact)
             table_data = []
-            if data.value == "\\\\"
+            if data.linebreak
               organize_tds(table_row.flatten, string_columns.dup, options)
               table << Math::Function::Tr.new(table_row)
               table_row = []
@@ -187,7 +198,7 @@ module Plurimath
       def ox_element(node, attributes: [], namespace: "")
         namespace = "#{namespace}:" unless namespace.empty?
 
-        element = Ox::Element.new("#{namespace}#{node}")
+        element = Plurimath.xml_engine.new_element("#{namespace}#{node}")
         attributes&.each do |attr_key, attr_value|
           element[attr_key] = attr_value
         end
@@ -224,12 +235,10 @@ module Plurimath
       end
 
       def filter_values(array)
-        return array unless array.is_a?(Array)
+        return array unless array.is_a?(Array) || array.is_a?(Math::Formula)
 
-        array = array.flatten.compact
-        if array.length > 1
-          return Math::Formula.new(array)
-        end
+        array = array.is_a?(Math::Formula) ? array.value : array.flatten.compact
+        return Math::Formula.new(array) if array.length > 1
 
         array.first
       end
@@ -249,20 +258,17 @@ module Plurimath
 
       def nary_fonts(nary)
         narypr  = nary.first.flatten.compact
-        subsup  = narypr.any?("undOvr") ? "underover" : "power_base"
+        subsup  = narypr.any?("undOvr") ? "undOvr" : "subSup"
         unicode = narypr.any?(Hash) ? narypr.first[:chr] : "∫"
-        get_class(subsup).new(
+        Math::Function::Nary.new(
           Math::Symbol.new(string_to_html_entity(unicode)),
-          nary[1],
-          nary[2],
+          filter_values(nary[1]),
+          filter_values(nary[2]),
+          filter_values(nary[3]),
+          { type: subsup }
         )
       end
 
-      def find_class_name(object)
-        new_object = object.value.first.parameter_one if object.is_a?(Math::Formula)
-        get_class(new_object) unless new_object.nil?
-      end
-
       def find_pos_chr(fonts_array, key)
         fonts_array.find { |d| d.is_a?(Hash) && d[key] }
       end
@@ -279,31 +285,31 @@ module Plurimath
       end
 
       def symbol_value(object, value)
-        object.is_a?(Math::Symbol) && object.value.include?(value)
+        (object.is_a?(Math::Symbol) && object.value.include?(value)) ||
+          (value == "\\\\" && object.is_a?(Math::Function::Linebreak))
       end
 
       def td_value(td_object)
-        if td_object.is_a?(String) && td_object.empty?
+        str_classes = [String, Parslet::Slice]
+        if str_classes.include?(td_object.class) && td_object.to_s.empty?
           return Math::Function::Text.new(nil)
         end
 
         td_object
       end
 
-      def mathml_unary_classes(text_array, omml: false)
+      def mathml_unary_classes(text_array, omml: false, unicode_only: false)
         return [] if text_array.empty?
 
         compacted = text_array.compact
-        string = if compacted.count == 1
-                   compacted.first
-                 else
-                   compacted.join
-                 end
-        return string unless string.is_a?(String)
+        return filter_values(compacted) unless compacted.any?(String)
 
+        string  = compacted.join
         classes = Mathml::Constants::CLASSES
         unicode = string_to_html_entity(string)
-        symbol  = Mathml::Constants::UNICODE_SYMBOLS[unicode.strip.to_sym]
+        return Math::Symbol.new(unicode) if unicode_only && unicode
+
+        symbol = Mathml::Constants::UNICODE_SYMBOLS[unicode.strip.to_sym]
         if classes.include?(symbol&.strip)
           get_class(symbol.strip).new
         elsif classes.any?(string&.strip)
@@ -338,17 +344,21 @@ module Plurimath
         value
       end
 
-      def join_attr_value(attrs, value)
+      def join_attr_value(attrs, value, unicode_only: false)
         if value.any?(String)
-          new_value = mathml_unary_classes(value)
+          new_value = mathml_unary_classes(value, unicode_only: unicode_only)
           array_value = Array(new_value)
-          attrs.nil? ? array_value : join_attr_value(attrs, array_value)
+          attrs.nil? ? array_value : join_attr_value(attrs, array_value, unicode_only: unicode_only)
         elsif attrs.nil?
           value
         elsif attrs.is_a?(String) && ["solid", "none"].include?(attrs.split.first.downcase)
           table_separator(attrs.split, value)
-        elsif attrs.is_a?(Hash) && (attrs.key?(:accent) || attrs.key?(:accentunder))
-          attr_is_accent(attrs, value)
+        elsif attrs.is_a?(Hash)
+          if (attrs.key?(:accent) || attrs.key?(:accentunder))
+            attr_is_accent(attrs, value)
+          elsif attrs.key?(:linebreak)
+            Math::Function::Linebreak.new(value.first, attrs)
+          end
         elsif attrs.is_a?(Math::Core)
           attr_is_function(attrs, value)
         end
@@ -452,7 +462,7 @@ module Plurimath
       end
 
       def left_right_objects(paren, function)
-        paren = if paren.to_s.match?(/\\{|\\}/)
+        paren = if paren.to_s.match?(/\\\{|\\\}/)
                   paren.to_s.gsub(/\\/, "")
                 else
                   Latex::Constants::LEFT_RIGHT_PARENTHESIS[paren.to_sym]
@@ -461,7 +471,7 @@ module Plurimath
       end
 
       def valid_class(object)
-        text = object.extract_class_from_text
+        text = object.extract_class_name_from_text
         (object.extractable? && Asciimath::Constants::SUB_SUP_CLASSES.include?(text)) ||
           Latex::Constants::SYMBOLS[text.to_sym] == :power_base
       end
@@ -469,12 +479,7 @@ module Plurimath
       def mrow_left_right(mrow = [])
         object = mrow.first
         !(
-          (
-            (
-              object.is_a?(Math::Function::TernaryFunction) && object.any_value_exist?
-            ) &&
-            (mrow.length <= 2)
-          ) ||
+          ((object.is_a?(Math::Function::TernaryFunction) && object.any_value_exist?) && (mrow.length <= 2)) ||
           (object.is_a?(Math::Function::UnaryFunction) && mrow.length == 1)
         )
       end
@@ -564,6 +569,37 @@ module Plurimath
           end
         end
       end
+
+      def validate_math_zone(object)
+        return false unless object
+
+        if object.is_a?(Math::Formula)
+          filter_math_zone_values(object.value).find do |d|
+            !d.is_a?(Math::Function::Text)
+          end
+        else
+          !TEXT_CLASSES.include?(object.class_name)
+        end
+      end
+
+      def filter_math_zone_values(value)
+        return [] if value&.empty?
+
+        new_arr = []
+        temp_array = []
+        skip_index = nil
+        value.each_with_index do |obj, index|
+          object = obj.dup
+          next if index == skip_index
+          next temp_array << object.value if TEXT_CLASSES.include?(object.class_name)
+
+          new_arr << Math::Function::Text.new(temp_array.join(" ")) if temp_array.any?
+          temp_array = []
+          new_arr << object
+        end
+        new_arr << Math::Function::Text.new(temp_array.join(" ")) if temp_array.any?
+        new_arr
+      end
     end
   end
 end

data/lib/plurimath/version.rb

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