plurimath 0.7.1 → 0.8.0

data/lib/plurimath/mathml/transform.rb

@@ -8,34 +8,28 @@ module Plurimath
       rule(mo: sequence(:mo))       { Utility.mathml_unary_classes(mo) }
       rule(mtd: sequence(:mtd))     { Math::Function::Td.new(mtd) }
       rule(mtr: sequence(:mtr))     { Math::Function::Tr.new(mtr) }
+      rule(math: subtree(:math))    { math.flatten.compact }
+      rule(mfrac: simple(:mfrac))   { mfrac }
       rule(none: sequence(:none))   { nil }
-      rule(mspace: simple(:space))  { nil }
-      rule(notation: simple(:att))  { Math::Function::Menclose.new(att) }
+      rule(mspace: simple(:space))  { space.is_a?(Math::Function::Mpadded) ? nil : space }
       rule(mtable: simple(:table))  { table }
-      rule(msqrt: sequence(:sqrt))  { Math::Function::Sqrt.new(sqrt.first) }
+      rule(mglyph: simple(:glyph))  { glyph }
       rule(mstyle: simple(:mstyle)) { mstyle }
       rule(msline: sequence(:line)) { Math::Function::Msline.new }
       rule(value: sequence(:value)) { Utility.filter_values(value) }
 
+      rule(mpadded: simple(:padded))    { padded }
       rule(mspace: sequence(:space))    { nil }
-      rule(mstyle: sequence(:mstyle))   { Utility.filter_values(mstyle) }
       rule(mfenced: simple(:mfenced))   { mfenced }
       rule(mtable: sequence(:mtable))   { Math::Function::Table.new(mtable) }
       rule(mscarry: sequence(:scarry))  { nil }
       rule(menclose: simple(:enclose))  { enclose }
       rule(mlabeledtr: sequence(:mtr))  { Math::Function::Tr.new(mtr) }
-      rule(mpadded: sequence(:padded))  { Utility.filter_values(padded) }
       rule(malignmark: sequence(:mark)) { nil }
       rule(maligngroup: sequence(:att)) { nil }
       rule(mprescripts: sequence(:att)) { "mprescripts" }
       rule(columnlines: simple(:lines)) { lines }
 
-      rule(math: subtree(:math)) do
-        Utility.filter_values(
-          math.flatten.compact,
-        )
-      end
-
       rule(mphantom: sequence(:phantom)) do
         Math::Function::Phantom.new(
           Utility.filter_values(phantom),
@@ -75,9 +69,10 @@ module Plurimath
         Math::Function::Longdiv.new(long.flatten.compact)
       end
 
-      rule(menclose: sequence(:close)) do
+      rule(menclose: subtree(:close)) do
+        options = close.find { |obj| obj.is_a?(Hash) and close.delete(obj) }
         Math::Function::Menclose.new(
-          nil,
+          (options[:notation] if options),
           Utility.filter_values(close),
         )
       end
@@ -95,6 +90,15 @@ module Plurimath
         )
       end
 
+      rule(msqrt: subtree(:sqrt)) do
+        options = sqrt.find { |sqr| sqr.is_a?(Hash) and sqrt.delete(sqr) }
+        sqrt_obj = Math::Function::Sqrt.new(
+          Utility.filter_values(sqrt),
+        )
+        sqrt_obj.options = options
+        sqrt_obj
+      end
+
       rule(mfrac: sequence(:mfrac)) do
         Math::Function::Frac.new(
           mfrac[0],
@@ -184,6 +188,20 @@ module Plurimath
         Utility.fenceable_classes(flatten_mrow)
         if flatten_mrow.length == 1
           flatten_mrow.first
+        elsif flatten_mrow&.first&.is_nary_function? && flatten_mrow.length == 2
+          nary_function = flatten_mrow.first
+          if nary_function.is_ternary_function? && nary_function.all_values_exist?
+            flatten_mrow[0] = nary_function.new_nary_function(flatten_mrow.delete_at(1))
+            flatten_mrow
+          elsif nary_function.is_binary_function? && nary_function.any_value_exist?
+            flatten_mrow[0] = nary_function.new_nary_function(flatten_mrow.delete_at(1))
+            flatten_mrow
+          else
+            Math::Formula.new(
+              flatten_mrow,
+              Utility.mrow_left_right(flatten_mrow),
+            )
+          end
         else
           Math::Formula.new(
             flatten_mrow,
@@ -192,6 +210,18 @@ module Plurimath
         end
       end
 
+      rule(mstyle: sequence(:mstyle)) do
+        nary_function = mstyle.first
+        if nary_function&.is_nary_function?
+          if nary_function.is_ternary_function? && nary_function.parameter_three.nil?
+            nary_function.parameter_three = mstyle.delete_at(1)
+          elsif nary_function.is_binary_function?
+            mstyle[0] = nary_function.new_nary_function(mstyle.delete_at(1))
+          end
+        end
+        Utility.filter_values(mstyle)
+      end
+
       rule(msrow: sequence(:msrow)) do
         Math::Formula.new(msrow.flatten.compact)
       end
@@ -210,10 +240,7 @@ module Plurimath
           mover.last.parameter_one = mover.shift if mover.length > 1
           mover.last
         else
-          Math::Function::Overset.new(
-            mover[1],
-            mover[0],
-          )
+          Math::Function::Overset.new(mover[1], mover[0])
         end
       end
 
@@ -230,6 +257,9 @@ module Plurimath
         elsif ["ubrace", "obrace", "underline"].any?(munder.last.class_name)
           munder.last.parameter_one = munder.shift if munder.length > 1
           munder.last
+        elsif Constants::CLASSES.include?(munder.first.class_name)
+          munder.first.parameter_one = munder.delete_at(1)
+          munder.first
         else
           Math::Function::Underset.new(
             munder[1],
@@ -244,6 +274,12 @@ module Plurimath
         )
       end
 
+      rule(mpadded: sequence(:padded)) do
+        Math::Function::Mpadded.new(
+          Utility.filter_values(padded),
+        )
+      end
+
       rule(mtext: subtree(:mtext)) do
         entities = HTMLEntities.new
         symbols  = Constants::UNICODE_SYMBOLS.transform_keys(&:to_s)
@@ -255,13 +291,9 @@ module Plurimath
       end
 
       rule(ms: sequence(:ms)) do
-        entities = HTMLEntities.new
-        symbols  = Constants::UNICODE_SYMBOLS.transform_keys(&:to_s)
-        text     = entities.encode(ms.first, :hexadecimal)
-        symbols.each do |code, string|
-          text = text.gsub(code.downcase, "unicode[:#{string}]")
-        end
-        Math::Function::Text.new(text)
+        Math::Function::Ms.new(
+          ms.flatten.compact.join(" "),
+        )
       end
 
       rule(mfenced: sequence(:fenced)) do
@@ -273,7 +305,7 @@ module Plurimath
       end
 
       rule(mmultiscripts: subtree(:script)) do
-        multi = Utility.multiscript(script.compact)
+        multi = Utility.multiscript(script)
         prescripts = multi[1]
         Math::Function::Multiscript.new(
           multi[0],
@@ -334,11 +366,30 @@ module Plurimath
       rule(attributes: subtree(:attrs),
            value: sequence(:value)) do
         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
+                     supported_attrs = %w[
+                       linethickness
+                       accentunder
+                       columnlines
+                       separators
+                       rowlines
+                       bevelled
+                       notation
+                       height
+                       accent
+                       height
+                       width
+                       index
+                       depth
+                       width
+                       frame
+                       alt
+                       src
+                     ]
+                     attrs if attrs.keys.any? do |k|
+                       supported_attrs.include?(k.to_s)
                      end
+                     unicode_only = true if attrs.key?(:linebreak)
+                     attrs
                    else
                      attrs
                    end

data/lib/plurimath/omml/parser.rb

@@ -8,6 +8,7 @@ module Plurimath
 
       CUSTOMIZABLE_TAGS = %w[
         eqArr
+        sPre
         mr
         r
       ].freeze
@@ -67,6 +68,8 @@ module Plurimath
           organize_fonts(node)
         when "mr", "eqArr"
           organize_table_td(node)
+        when "sPre"
+          organize_spre(node)
         end
       end
 
@@ -83,6 +86,11 @@ module Plurimath
         end
         node.attributes.merge! attrs_arr
       end
+
+      def organize_spre(node)
+        node.locate("sub").first.name = "sPreSub"
+        node.locate("sup").first.name = "sPreSup"
+      end
     end
   end
 end

data/lib/plurimath/omml/transform.rb

@@ -32,10 +32,10 @@ module Plurimath
       rule(barPr: subtree(:barpr))  { barpr }
       rule(oMath: subtree(:omath))  { omath.flatten.compact }
       rule(fName: subtree(:fname))  { fname }
+      rule(sPreSub: sequence(:sub)) { { sub: Utility.nil_to_none_object(sub) } }
+      rule(sPreSup: sequence(:sup)) { { sup: Utility.nil_to_none_object(sup) } }
       rule(oMath: sequence(:omath)) { omath }
       rule(limLoc: simple(:limLoc)) { limLoc }
-      rule(begChr: simple(:begChr)) { Math::Symbol.new(begChr) }
-      rule(endChr: simple(:endChr)) { Math::Symbol.new(endChr) }
 
       rule(rFonts: subtree(:rFonts))   { nil }
       rule(sSupPr: subtree(:ssuppr))   { nil }
@@ -95,26 +95,32 @@ module Plurimath
       end
 
       rule(d: subtree(:data)) do
-        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
-        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
+        fenced = data.shift
+        fenced_value = data.flatten.compact
+        if data.length == 1 && data.flatten.compact.first.is_a?(Math::Function::Table)
+          fenced_value.first.open_paren = fenced&.parameter_one&.value
+          fenced_value.first.close_paren = fenced&.parameter_three&.value
+          data
         else
-          Math::Function::Fenced.new(
-            open_paren,
-            fenced_value,
-            close_paren,
-          )
+          fenced.parameter_two = data.flatten.compact
+          fenced
         end
       end
 
       rule(dPr: subtree(:dpr)) do
-        dpr.reject! { |d| d.is_a?(Hash) }
-        dpr
+        flatten_dpr = dpr.flatten.compact
+        open_paren  = flatten_dpr.find { |hash| hash[:begChr] }&.values&.first
+        close_paren = flatten_dpr.find { |hash| hash[:endChr] }&.values&.first
+        sep_chr     = flatten_dpr.find { |hash| hash[:sepChr] }
+        open_paren_object = Utility.symbol_object(open_paren) if open_paren
+        close_paren_object = Utility.symbol_object(close_paren) if close_paren
+        fenced = Math::Function::Fenced.new(
+          open_paren_object,
+          nil,
+          close_paren_object,
+        )
+        fenced.options = sep_chr
+        fenced
       end
 
       rule(mtd: sequence(:mtd)) do
@@ -149,11 +155,7 @@ module Plurimath
       end
 
       rule(lim: sequence(:lim)) do
-        if lim.any?(String)
-          Utility.text_classes(lim)
-        else
-          Utility.filter_values(lim)
-        end
+        lim.any?(String) ? Utility.text_classes(lim) : Utility.filter_values(lim)
       end
 
       rule(acc: subtree(:acc)) do
@@ -298,11 +300,12 @@ module Plurimath
       end
 
       rule(sPre: subtree(:spre)) do
-        pre = spre.flatten.compact
+        sub_value = spre.find { |pre| pre.is_a?(Hash) && pre[:sub] }[:sub]
+        sup_value = spre.find { |pre| pre.is_a?(Hash) && pre[:sup] }[:sup]
         Math::Function::Multiscript.new(
-          pre[2],
-          pre[0],
-          pre[1],
+          Utility.filter_values(spre[0]),
+          sub_value,
+          sup_value,
         )
       end