plurimath 0.3.9 → 0.4.2

data/lib/plurimath/mathml/transform.rb

@@ -135,27 +135,39 @@ module Plurimath
         )
       end
 
-      rule(msubsup: sequence(:msubsup)) do
-        Math::Function::PowerBase.new(
-          msubsup[0],
-          msubsup[1],
-          msubsup[2],
-        )
+      rule(msubsup: sequence(:function)) do
+        base = function[0].is_a?(Math::Formula) ? function[0].value : function
+        base_object = base.first
+        if base_object.is_a?(Math::Function::BinaryFunction) && !base_object.any_value_exist?
+          base_object.parameter_one = function[1]
+          base_object.parameter_two = function[2]
+          base_object
+        elsif base_object.is_a?(Math::Function::TernaryFunction) && !base_object.any_value_exist?
+          base_object.parameter_one = function[1]
+          base_object.parameter_two = function[2]
+          base_object.parameter_three = function[3]
+          base_object
+        else
+          Math::Function::PowerBase.new(
+            function[0],
+            function[1],
+            function[2],
+          )
+        end
       end
 
       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
+        base = function[0].is_a?(Math::Formula) ? function[0].value : function
+        base_object = base.first
+        if base_object.is_a?(Math::Function::BinaryFunction) && !base_object.any_value_exist?
+          base_object.parameter_one = function[1]
+          base_object.parameter_two = function[2]
+          base_object
+        elsif base_object.is_a?(Math::Function::TernaryFunction) && !base_object.any_value_exist?
+          base_object.parameter_one = function[1]
+          base_object.parameter_two = function[2]
+          base_object.parameter_three = function[3]
+          base_object
         else
           Math::Function::Underover.new(
             function[0],
@@ -166,12 +178,16 @@ module Plurimath
       end
 
       rule(mrow: subtree(:mrow)) do
-        if mrow.any?(String)
-          mrow.each_with_index do |object, ind|
-            mrow[ind] = Utility.mathml_unary_classes([object]) if object.is_a?(String)
-          end
+        flatten_mrow = Utility.populate_function_classes(mrow)
+        Utility.fenceable_classes(flatten_mrow)
+        if flatten_mrow.length == 1
+          flatten_mrow.first
+        else
+          Math::Formula.new(
+            flatten_mrow,
+            Utility.mrow_left_right(flatten_mrow),
+          )
         end
-        Math::Formula.new(mrow.flatten.compact)
       end
 
       rule(msrow: sequence(:msrow)) do
@@ -184,8 +200,11 @@ module Plurimath
         )
       end
 
-      rule(mover: sequence(:mover)) do
-        if ["ubrace", "obrace"].any?(mover.last.class_name)
+      rule(mover: subtree(:mover)) do
+        if mover&.length == 1
+          base_object = mover.first
+          base_object.class_name == "underline" ? base_object.swap_class : base_object
+        elsif Constants::CLASSES.any?(mover&.last&.class_name)
           mover.last.parameter_one = mover.shift if mover.length > 1
           mover.last
         else
@@ -199,10 +218,14 @@ module Plurimath
       rule(munder: sequence(:munder)) do
         if munder.any?(String)
           munder.each_with_index do |object, ind|
-            munder[ind] = Utility.mathml_unary_classes([object]) if object.is_a?(String)
+            next unless object.is_a?(String)
+
+            munder[ind] = Utility.mathml_unary_classes([object])
           end
         end
-        if ["ubrace", "obrace"].any?(munder.last.class_name)
+        if munder.length == 1
+          munder.first.class_name == "bar" ? munder.first.swap_class : munder.last
+        elsif ["ubrace", "obrace", "underline"].any?(munder.last.class_name)
           munder.last.parameter_one = munder.shift if munder.length > 1
           munder.last
         else
@@ -308,10 +331,15 @@ module Plurimath
 
       rule(attributes: subtree(:attrs),
            value: sequence(:value)) do
-        Utility.join_attr_value(
-          attrs.is_a?(Hash) ? nil : attrs,
-          value&.flatten&.compact,
-        )
+        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)
       end
     end
   end

data/lib/plurimath/omml/parser.rb

@@ -6,6 +6,12 @@ module Plurimath
     class Parser
       attr_accessor :text
 
+      CUSTOMIZABLE_TAGS = %w[
+        eqArr
+        mr
+        r
+      ].freeze
+
       def initialize(text)
         @text = text
       end
@@ -33,17 +39,34 @@ module Plurimath
               },
             }
           else
-            organize_table_td(node) if %w[mr eqArr].include?(node.name)
+            customize_tags(node) if CUSTOMIZABLE_TAGS.include?(node.name)
             { node.name => parse_nodes(node.nodes) }
           end
         end
       end
 
+      def customize_tags(node)
+        case node.name
+        when "r"
+          organize_fonts(node)
+        when "mr", "eqArr"
+          organize_table_td(node)
+        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
+
+      def organize_fonts(node)
+        attrs_arr = { val: [] }
+        node.locate("rPr/?").each do |child|
+          attrs_arr[:val] << child.attributes["val"]
+        end
+        node.attributes.merge! attrs_arr
+      end
     end
   end
 end

data/lib/plurimath/omml/transform.rb

@@ -10,10 +10,11 @@ module Plurimath
       rule(e: sequence(:e)) { e.flatten.compact }
 
       rule(val: simple(:val))    { val }
+      rule(scr: simple(:scr))    { scr }
+      rule(sty: simple(:sty))    { sty }
       rule(dPr: subtree(:dpr))   { dpr }
       rule(num: subtree(:num))   { num }
       rule(den: subtree(:den))   { den }
-      rule(rPr: subtree(:rPr))   { nil }
       rule(fPr: subtree(:fPr))   { nil }
       rule(mpr: subtree(:mpr))   { nil }
       rule(mPr: subtree(:mPr))   { nil }
@@ -66,12 +67,17 @@ module Plurimath
       end
 
       rule(r: subtree(:r)) do
-        if r.flatten.compact.empty?
+        flatten_row = r&.flatten&.compact
+        if flatten_row.empty?
           nil
-        else
-          Math::Formula.new(
-            r.flatten.compact,
+        elsif flatten_row.length > 1 && !flatten_row.first.is_a?(Math::Core)
+          font = flatten_row.shift
+          font.new(
+            Utility.filter_values(flatten_row),
+            Utility::OMML_FONTS.invert[font].to_s,
           )
+        else
+          Utility.filter_values(flatten_row)
         end
       end
 
@@ -85,15 +91,15 @@ module Plurimath
         if t.empty?
           Math::Function::Text.new
         else
-          t&.compact&.empty? ? [nil] : Utility.text_classes(t)
+          t&.compact&.empty? ? [nil] : Utility.mathml_unary_classes(t, omml: true)
         end
       end
 
       rule(d: subtree(:data)) do
-        fenced       = data.flatten.compact
-        open_paren   = fenced.shift if fenced.first.class_name == "symbol"
-        close_paren  = fenced.shift if fenced.first.class_name == "symbol"
-        fenced_value = fenced
+        fenced       = data.flatten
+        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,
@@ -111,6 +117,12 @@ module Plurimath
         Math::Function::Tr.new(row)
       end
 
+      rule(rPr: subtree(:rpr)) do
+        if rpr.is_a?(Array)
+          Utility::OMML_FONTS[rpr.join("-").to_sym]
+        end
+      end
+
       rule(lim: sequence(:lim)) do
         if lim.any?(String)
           Utility.text_classes(lim)
@@ -122,34 +134,39 @@ module Plurimath
       rule(acc: subtree(:acc)) do
         acc_value = acc.flatten.compact
         chr = Utility.find_pos_chr(acc_value, :chr)
-        chr_value = chr ? chr[:chr] : "^"
-        Math::Function::Overset.new(
-          Math::Symbol.new(chr_value),
-          Utility.filter_values(acc.last),
-        )
+        chr_value = chr ? chr[:chr] : Math::Function::Hat.new
+        index = acc_value.index { |d| d[:chr] }
+        acc_value[index] = chr_value
+        Utility.unary_function_classes(acc_value)
+        acc_value.first.attributes = { accent: true }
+        acc_value.first
       end
 
       rule(func: subtree(:func)) do
-        func_name = func.flatten.compact
-        class_object = Utility.find_class_name(func_name.first)
-        if class_object
-          class_object.new(func_name.last)
+        Utility.filter_values(
+          Utility.populate_function_classes(func),
+        )
+      end
+
+      rule(nary: subtree(:nary)) do
+        flatten_nary = nary.flatten.compact
+        chr = Utility.find_pos_chr(flatten_nary, :chr)
+        ternary_class = Utility.mathml_unary_classes(chr.values) if chr
+        if ternary_class.is_a?(Math::Function::TernaryFunction)
+          ternary_class.parameter_one = Utility.filter_values(nary[1])
+          ternary_class.parameter_two = Utility.filter_values(nary[2])
+          ternary_class.parameter_three = Utility.filter_values(nary[3])
+          ternary_class
         else
           Math::Formula.new(
-            func_name,
+            [
+              Utility.nary_fonts(nary),
+              Utility.filter_values(nary[3]),
+            ],
           )
         end
       end
 
-      rule(nary: subtree(:nary)) do
-        Math::Formula.new(
-          [
-            Utility.nary_fonts(nary),
-            Utility.filter_values(nary[3]),
-          ],
-        )
-      end
-
       rule(groupChr: subtree(:groupchr)) do
         chr_pos = groupchr.first
         pos = Utility.find_pos_chr(chr_pos, :pos)
@@ -172,7 +189,7 @@ module Plurimath
         subsup.each_with_index do |object, ind|
           subsup[ind] = Utility.mathml_unary_classes([object]) if object.is_a?(String)
         end
-        if subsup[0].is_a?(Math::Formula) && Utility.valid_class(subsup[0])
+        if Utility.valid_class(subsup[0])
           Utility.get_class(
             subsup[0].extract_class_from_text,
           ).new(
@@ -217,8 +234,8 @@ module Plurimath
         )
       end
 
-      rule(limUpp: subtree(:limUpp)) do
-        lim_values = limUpp.flatten.compact
+      rule(limUpp: subtree(:lim)) do
+        lim_values = lim.flatten.compact
         first_value = lim_values[0]
         Math::Function::Overset.new(
           first_value,
@@ -227,9 +244,12 @@ module Plurimath
       end
 
       rule(limLow: subtree(:lim)) do
+        second_value = Utility.filter_values(lim[2])
+        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]),
-          Utility.filter_values(lim[2]),
+          second_value,
         )
       end
 
@@ -241,14 +261,9 @@ module Plurimath
       end
 
       rule(bar: subtree(:bar)) do
-        barpr = bar&.flatten&.compact
-        pospr = Utility.find_pos_chr(bar.first, :pos)
-        class_name = if pospr&.value?("top")
-                       Math::Function::Bar
-                     else
-                       Math::Function::Ul
-                     end
-        class_name.new(barpr.last)
+        flatten_bar = bar.flatten.compact
+        attrs = { accent: false }
+        Math::Function::Bar.new(flatten_bar.last, attrs)
       end
 
       rule(sPre: subtree(:spre)) do

data/lib/plurimath/utility.rb

@@ -72,6 +72,34 @@ module Plurimath
       max
       min
     ].freeze
+    OMML_FONTS = {
+      "sans-serif-bi": Math::Function::FontStyle::SansSerifBoldItalic,
+      "sans-serif-i": Math::Function::FontStyle::SansSerifItalic,
+      "sans-serif-b": Math::Function::FontStyle::BoldSansSerif,
+      "double-struck": Math::Function::FontStyle::DoubleStruck,
+      "sans-serif-p": Math::Function::FontStyle::SansSerif,
+      "fraktur-p": Math::Function::FontStyle::Fraktur,
+      "fraktur-b": Math::Function::FontStyle::BoldFraktur,
+      "script-b": Math::Function::FontStyle::BoldScript,
+      "script-p": Math::Function::FontStyle::Script,
+      monospace: Math::Function::FontStyle::Monospace,
+      bi: Math::Function::FontStyle::BoldItalic,
+      p: Math::Function::FontStyle::Normal,
+      i: Math::Function::FontStyle::Italic,
+      b: Math::Function::FontStyle::Bold,
+    }.freeze
+    PARENTHESIS = {
+      "〈": "〉",
+      "⌊": "⌋",
+      "⌈": "⌉",
+      "‖": "‖",
+      "{": "}",
+      "[": "]",
+      "|": "|",
+      "(": ")",
+      "{": "}",
+      "[": "]",
+    }.freeze
 
     class << self
       def organize_table(array, column_align: nil, options: nil)
@@ -271,7 +299,7 @@ module Plurimath
         td_object
       end
 
-      def mathml_unary_classes(text_array)
+      def mathml_unary_classes(text_array, omml: false)
         return [] if text_array.empty?
 
         compacted = text_array.compact
@@ -290,7 +318,7 @@ module Plurimath
         elsif classes.any?(string&.strip)
           get_class(string.strip).new
         else
-          Math::Symbol.new(unicode)
+          omml ? text_classes(string) : Math::Symbol.new(unicode)
         end
       end
 
@@ -326,16 +354,35 @@ module Plurimath
           attrs.nil? ? array_value : join_attr_value(attrs, array_value)
         elsif attrs.nil?
           value
-        elsif attrs.is_a?(Math::Function::Menclose)
+        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?(Math::Core)
+          attr_is_function(attrs, value)
+        end
+      end
+
+      def attr_is_accent(attrs, value)
+        if value.last.is_a?(Math::Function::UnaryFunction)
+          value.last.parameter_one = value.shift if value.length > 1
+          value.last.attributes = attrs.transform_values { |v| YAML.safe_load(v) }
+        end
+        value
+      end
+
+      def attr_is_function(attrs, value)
+        case attrs
+        when Math::Function::Menclose
           attrs.parameter_two = filter_values(value)
           attrs
-        elsif attrs.is_a?(Math::Function::Fenced)
+        when Math::Function::Fenced
           attrs.parameter_two = value.compact
           attrs
-        elsif attrs.is_a?(Math::Function::FontStyle)
+        when Math::Function::FontStyle
           attrs.parameter_one = filter_values(value)
           attrs
-        elsif attrs.is_a?(Math::Function::Color)
+        when Math::Function::Color
           color_value = filter_values(value)
           if attrs.parameter_two
             attrs.parameter_two.parameter_one = color_value
@@ -343,8 +390,6 @@ module Plurimath
             attrs.parameter_two = color_value
           end
           attrs
-        elsif ["solid", "none"].include?(attrs.split.first.downcase)
-          table_separator(attrs.split, value)
         end
       end
 
@@ -426,7 +471,107 @@ module Plurimath
 
       def valid_class(object)
         text = object.extract_class_from_text
-        Asciimath::Constants::SUB_SUP_CLASSES.include?(text)
+        (object.extractable? && Asciimath::Constants::SUB_SUP_CLASSES.include?(text)) ||
+          Latex::Constants::SYMBOLS[text.to_sym] == :power_base
+      end
+
+      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::UnaryFunction) && mrow.length == 1)
+        )
+      end
+
+      def populate_function_classes(mrow = [])
+        flatten_mrow = mrow.flatten.compact
+        unary_function_classes(flatten_mrow)
+        binary_function_classes(flatten_mrow)
+        ternary_function_classes(flatten_mrow)
+        flatten_mrow
+      end
+
+      def binary_function_classes(mrow, under: false)
+        binary_class = Math::Function::BinaryFunction
+        mrow.each_with_index do |object, ind|
+          mrow[ind] = mathml_unary_classes([object]) if object.is_a?(String)
+          object = mrow[ind]
+          next unless object.is_a?(binary_class)
+
+          if object.is_a?(Math::Function::Mod)
+            next unless mrow.length >= 1
+
+            object.parameter_one = mrow.delete_at(ind - 1) unless ind.zero?
+            object.parameter_two = mrow.delete_at(ind)
+          elsif Mathml::Constants::UNICODE_SYMBOLS.invert[object.class_name] && mrow.length > 1
+            next if object.parameter_one || mrow.length > 2
+            next object.parameter_one = mrow.delete_at(ind - 1) if under && ind <= 1
+
+            object.parameter_one = mrow.delete_at(ind + 1)
+          end
+        end
+      end
+
+      def unary_function_classes(mrow)
+        unary_class = Math::Function::UnaryFunction
+        if mrow.any?(String) || mrow.any?(unary_class)
+          mrow.each_with_index do |object, ind|
+            mrow[ind] = mathml_unary_classes([object]) if object.is_a?(String)
+            object = mrow[ind] if object.is_a?(String)
+            next unless object.is_a?(unary_class)
+            next if object.is_a?(Math::Function::Text)
+            next if object.parameter_one || mrow[ind + 1].nil?
+            next unless ind.zero?
+
+            object.parameter_one = mrow.delete_at(ind + 1)
+          end
+        end
+      end
+
+      def ternary_function_classes(mrow)
+        ternary_class = Math::Function::TernaryFunction
+        if mrow.any?(ternary_class) && mrow.length > 1
+          mrow.each_with_index do |object, ind|
+            if object.is_a?(ternary_class)
+              next if [Math::Function::Fenced, Math::Function::Multiscript].include?(object.class)
+              next unless object.parameter_one || object.parameter_two
+              next if object.parameter_three
+
+              object.parameter_three = filter_values(mrow.delete_at(ind + 1))
+            end
+          end
+        end
+      end
+
+      def paren_able?(arr = [], mrow = [])
+        arr.any? do |opening, closing|
+          symbol_value(mrow.first, opening.to_s) && symbol_value(mrow.last, closing.to_s)
+        end
+      end
+
+      def fenceable_classes(mrow = [])
+        return false unless mrow.length > 1
+
+        if paren_able?(PARENTHESIS, mrow)
+          open_paren = mrow.shift
+          close_paren = mrow.pop
+          if mrow.length == 1 && mrow.first.is_a?(Math::Function::Table)
+            table = mrow.first
+            table.open_paren = open_paren
+            table.close_paren = close_paren
+          else
+            mrow.replace(
+              [
+                Math::Function::Fenced.new(open_paren, mrow.dup, close_paren),
+              ],
+            )
+          end
+        end
       end
     end
   end

data/lib/plurimath/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plurimath
 version: !ruby/object:Gem::Version
-  version: 0.3.9
+  version: 0.4.2
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-08-10 00:00:00.000000000 Z
+date: 2023-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -104,12 +104,18 @@ files:
 - lib/plurimath/math/function/fenced.rb
 - lib/plurimath/math/function/floor.rb
 - lib/plurimath/math/function/font_style.rb
+- lib/plurimath/math/function/font_style/bold-fraktur.rb
+- lib/plurimath/math/function/font_style/bold-italic.rb
+- lib/plurimath/math/function/font_style/bold-sans-serif.rb
+- lib/plurimath/math/function/font_style/bold-script.rb
 - lib/plurimath/math/function/font_style/bold.rb
 - lib/plurimath/math/function/font_style/double_struck.rb
 - lib/plurimath/math/function/font_style/fraktur.rb
 - lib/plurimath/math/function/font_style/italic.rb
 - lib/plurimath/math/function/font_style/monospace.rb
 - lib/plurimath/math/function/font_style/normal.rb
+- lib/plurimath/math/function/font_style/sans-serif-bold-italic.rb
+- lib/plurimath/math/function/font_style/sans-serif-italic.rb
 - lib/plurimath/math/function/font_style/sans-serif.rb
 - lib/plurimath/math/function/font_style/script.rb
 - lib/plurimath/math/function/frac.rb