lib/plurimath/latex/transform.rb in plurimath-0.3.1.2 vs lib/plurimath/latex/transform.rb in plurimath-0.3.2

@@ -22,10 +22,12 @@
       rule(left_right: simple(:left_right)) { left_right }
       rule(under_over: simple(:under_over)) { under_over }
       rule(power_base: simple(:power_base)) { power_base }
       rule(table_data: simple(:table_data)) { table_data }
 
+      rule(intermediate_exp: simple(:int_exp)) { int_exp }
+
       rule(numeric_values: simple(:value)) do
         Math::Symbol.new(value)
       end
 
       rule(text: simple(:text)) do
@@ -70,65 +72,115 @@
           supscript,
         )
       end
 
       rule(left: simple(:left),
-           lparen: simple(:lparen),
+           left_paren: simple(:lparen),
            expression: sequence(:expr),
            right: simple(:right),
-           rparen: simple(:rparen)) do
+           right_paren: simple(:rparen)) do
         Math::Formula.new(
           [
-            Math::Function::Left.new(lparen),
+            Utility.left_right_objects(lparen, "left"),
             Math::Formula.new(expr),
-            Math::Function::Right.new(rparen),
+            Utility.left_right_objects(rparen, "right"),
           ],
         )
       end
 
       rule(left: simple(:left),
-           lparen: simple(:lparen),
+           left_paren: simple(:lparen),
+           expression: sequence(:expr),
            right: simple(:right)) do
         Math::Formula.new(
           [
-            Math::Function::Left.new(lparen),
+            Utility.left_right_objects(lparen, "left"),
+            Math::Formula.new(expr),
             Math::Function::Right.new,
           ],
         )
       end
 
       rule(left: simple(:left),
-           lparen: simple(:lparen),
+           left_paren: simple(:lparen),
+           expression: simple(:expr),
+           right: simple(:right)) do
+        Math::Formula.new(
+          [
+            Utility.left_right_objects(lparen, "left"),
+            expr,
+            Math::Function::Right.new,
+          ],
+        )
+      end
+
+      rule(left: simple(:left),
+           left_paren: simple(:lparen),
+           right: simple(:right)) do
+        Math::Formula.new(
+          [
+            Utility.left_right_objects(lparen, "left"),
+            Math::Function::Right.new,
+          ],
+        )
+      end
+
+      rule(left: simple(:left),
+           left_paren: simple(:lparen),
            right: simple(:right),
-           rparen: simple(:rparen)) do
+           right_paren: simple(:rparen)) do
         Math::Formula.new(
           [
-            Math::Function::Left.new(lparen),
-            Math::Function::Right.new(rparen),
+            Utility.left_right_objects(lparen, "left"),
+            Utility.left_right_objects(rparen, "right"),
           ],
         )
       end
 
       rule(left: simple(:left),
-           lparen: simple(:lparen)) do
-        Math::Function::Left.new(lparen)
+           left_paren: simple(:lparen)) do
+        Utility.left_right_objects(lparen, "left")
       end
 
       rule(left: simple(:left),
-           lparen: simple(:lparen),
+           left_paren: simple(:lparen),
            expression: simple(:expr),
            right: simple(:right),
-           rparen: simple(:rparen)) do
+           right_paren: simple(:rparen)) do
         Math::Formula.new(
           [
-            Math::Function::Left.new(lparen),
+            Utility.left_right_objects(lparen, "left"),
             expr,
-            Math::Function::Right.new(rparen),
+            Utility.left_right_objects(rparen, "right"),
           ],
         )
       end
 
+      rule(left: simple(:left),
+           expression: simple(:expr),
+           right: simple(:right)) do
+        Math::Formula.new(
+          [
+            Math::Function::Left.new,
+            expr,
+            Math::Function::Right.new,
+          ],
+        )
+      end
+
+      rule(left: simple(:left),
+           expression: sequence(:expr),
+           right: simple(:right)) do
+        Math::Formula.new(
+          [
+            Math::Function::Left.new,
+            Math::Formula.new(expr),
+            Math::Function::Right.new,
+          ],
+        )
+      end
+
       rule(power: simple(:power),
            number: simple(:number)) do
         Math::Function::Power.new(
           power,
           Math::Number.new(number),
@@ -166,27 +218,27 @@
           Utility.filter_values(expr),
         )
       end
 
       rule(left: simple(:left),
-           lparen: simple(:lparen),
+           left_paren: simple(:lparen),
            dividend: subtree(:dividend),
            divisor: subtree(:divisor),
            right: simple(:right),
-           rparen: simple(:rparen)) do
+           right_paren: simple(:rparen)) do
         Math::Formula.new(
           [
-            Math::Function::Left.new(lparen),
+            Utility.left_right_objects(lparen, "left"),
             Math::Function::Over.new(
               Math::Formula.new(
                 Array(dividend).flatten,
               ),
               Math::Formula.new(
                 Array(divisor).flatten,
               ),
             ),
-            Math::Function::Right.new(rparen),
+            Utility.left_right_objects(rparen, "right"),
           ],
         )
       end
 
       rule(dividend: subtree(:dividend),
@@ -331,10 +383,18 @@
           ),
           supscript,
         )
       end
 
+      rule(intermediate_exp: simple(:int_exp),
+           supscript: simple(:supscript)) do
+        Math::Function::Power.new(
+          int_exp,
+          supscript,
+        )
+      end
+
       rule(unicode_symbols: simple(:sym),
            subscript: simple(:subscript)) do
         Math::Function::Base.new(
           Math::Unicode.new(sym),
           subscript,
@@ -447,9 +507,29 @@
 
       rule(lparen: simple(:lparen),
            expression: sequence(:expr),
            rparen: simple(:rparen)) do
         Math::Formula.new(expr)
+      end
+
+      rule(left_paren: simple(:lparen),
+           expression: simple(:expr),
+           right_paren: simple(:rparen)) do
+        Math::Function::Fenced.new(
+          lparen,
+          [expr],
+          rparen,
+        )
+      end
+
+      rule(left_paren: simple(:lparen),
+           expression: sequence(:expr),
+           right_paren: simple(:rparen)) do
+        Math::Function::Fenced.new(
+          lparen,
+          expr,
+          rparen,
+        )
       end
 
       rule(expression: sequence(:expr)) do
         Math::Formula.new(expr)
       end