plurimath 0.3.8 → 0.4.1

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,23 +134,18 @@ 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.binary_function_classes(acc_value)
+        acc_value.first.parameter_two = { 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)
-        else
-          Math::Formula.new(
-            func_name,
-          )
-        end
+        Utility.filter_values(
+          Utility.populate_function_classes(func),
+        )
       end
 
       rule(nary: subtree(:nary)) do
@@ -168,11 +175,12 @@ module Plurimath
       end
 
       rule(sSubSup: subtree(:sSubSup)) do
+        function_classes = [Math::Formula, Math::Function::FontStyle]
         subsup = sSubSup.flatten.compact
         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 +225,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 +235,13 @@ module Plurimath
       end
 
       rule(limLow: subtree(:lim)) do
+        flatten_lim = lim.flatten.compact
+        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 +253,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,22 @@ 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,
+      "monospace": Math::Function::FontStyle::Monospace,
+      "script-p": Math::Function::FontStyle::Script,
+      "bi": Math::Function::FontStyle::BoldItalic,
+      "p": Math::Function::FontStyle::Normal,
+      "i": Math::Function::FontStyle::Italic,
+      "b": Math::Function::FontStyle::Bold,
+    }.freeze
 
     class << self
       def organize_table(array, column_align: nil, options: nil)
@@ -271,7 +287,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 +306,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 +342,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)
+        value.last.parameter_one = value.shift if value.length > 1
+        if value.last.is_a?(Math::Function::BinaryFunction)
+          value.last.parameter_two = attrs.transform_values { |v| YAML.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 +378,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 +459,79 @@ 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 == 0
+            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)
+            next unless object.is_a?(unary_class)
+            next if object.is_a?(Math::Function::Text)
+            next if object.parameter_one || mrow[ind + 1].nil?
+
+            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
     end
   end

data/lib/plurimath/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plurimath
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.4.1
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-08-03 00:00:00.000000000 Z
+date: 2023-08-24 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