plurimath 0.7.2 → 0.8.1

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