plurimath 0.2.1 → 0.2.2

data/lib/plurimath/latex/parse.rb

@@ -4,48 +4,32 @@ require "parslet"
 module Plurimath
   class Latex
     class Parse < Parslet::Parser
-      rule(:base)   { str("_") }
-      rule(:power)  { str("^") }
-      rule(:slash)  { str("\\") }
-      rule(:unary)  { slash >> unary_classes }
-      rule(:ending) { (slash >> str("end") >> intermediate_exp).as(:ending) }
-      rule(:binary) { slash >> binary_classes }
-
-      rule(:array_args) { (str("{") >> expression >> str("}")).as(:args) }
+      rule(:base)       { str("_") }
+      rule(:power)      { str("^") }
+      rule(:slash)      { str("\\") }
       rule(:under_over) { slash >> underover_classes }
+      rule(:array_args) { (str("{") >> expression.as(:args) >> str("}")) }
 
-      rule(:begining) do
-        (slash >> str("begin") >> intermediate_exp).as(:begining)
+      rule(:optional_args) do
+        (str("[") >> intermediate_exp.maybe.as(:options) >> str("]")).maybe
       end
 
-      rule(:symbols) do
-        arr_to_expression(Constants::SYMBOLS.keys, :symbols)
+      rule(:begining) do
+        (slash >> str("begin") >> (str("{") >> symbol_text_or_integer >> str("*").as(:asterisk).maybe >> str("}")) >> optional_args)
       end
 
-      rule(:operators) do
-        arr_to_expression(Constants::OPERATORS, :operant)
+      rule(:ending) do
+        (slash >> str("end") >> (str("{") >> symbol_text_or_integer >> str("*").maybe >> str("}"))).as(:ending)
       end
 
       rule(:numeric_values) do
         arr_to_expression(Constants::NUMERIC_VALUES, :numeric_values)
       end
 
-      rule(:unary_classes) do
-        arr_to_expression(Constants::UNARY_CLASSES, :unary)
-      end
-
-      rule(:binary_classes) do
-        arr_to_expression(Constants::BINARY_CLASSES, :binary)
-      end
-
       rule(:underover_classes) do
         arr_to_expression(Constants::UNDEROVER_CLASSES, :binary)
       end
 
-      rule(:power_base_classes) do
-        arr_to_expression(Constants::POWER_BASE_CLASSES, :binary)
-      end
-
       rule(:math_operators_classes) do
         arr_to_expression(Constants::MATH_OPERATORS, :unary_functions)
       end
@@ -58,6 +42,10 @@ module Plurimath
         arr_to_expression(Constants::PARENTHESIS.values, :rparen)
       end
 
+      rule(:environment) do
+        arr_to_expression(Constants::MATRICES.keys, :environment)
+      end
+
       rule(:subscript) do
         intermediate_exp >> base >> intermediate_exp.as(:subscript)
       end
@@ -66,24 +54,13 @@ module Plurimath
         intermediate_exp >> power >> intermediate_exp.as(:supscript)
       end
 
-      rule(:environment) do
-        arr_to_expression(Constants::MATRICES.keys, :environment)
-      end
-
-      rule(:fonts) do
-        arr_to_expression(Constants::FONT_STYLES, :fonts)
-      end
-
       rule(:math_operators) do
-        slash >> math_operators_classes >> str("\\limits")
-      end
-
-      rule(:left_right) do
-        (str("\\left").as(:left) >> lparen >> expression.as(:expression) >> str("\\right").as(:right) >> rparen)
+        symbol_text_or_integer.as(:first_value) >> str("\\limits")
       end
 
       rule(:sqrt_arg) do
-        str("[").as(:lparen) >> (expression | str("")) >> str("]").as(:rparen)
+        (str("[").as(:lparen) >> intermediate_exp.repeat(1).as(:expression) >> str("]").as(:rparen)) |
+          (str("[").as(:lparen) >> str("]").as(:rparen))
       end
 
       rule(:limits) do
@@ -92,29 +69,27 @@ module Plurimath
       end
 
       rule(:symbol_class_commands) do
-        (slash >> symbols) |
-          (unary >> intermediate_exp.as(:first_value)).as(:unary_functions) |
-          unary.as(:unary_functions) |
-          binary |
+        (str("&#x") >> match["0-9a-fA-F"].repeat >> str(";")).as(:unicode_symbols) |
+          hash_to_expression(Constants::SYMBOLS) |
           under_over |
           environment |
-          operators |
-          numeric_values |
-          (slash >> power_base_classes) |
-          (slash >> fonts >> (binary_functions | intermediate_exp).as(:intermediate_exp))
+          numeric_values
       end
 
       rule(:symbol_text_or_integer) do
         symbol_class_commands |
-          match["a-zA-Z"].repeat(1).as(:text) |
+          (slash >> math_operators_classes) |
+          match["a-zA-Z"].as(:symbols) |
           (str('"') >> match("[^\"]").repeat >> str('"')).as(:text) |
           match(/\d+(\.[0-9]+)|\d/).repeat(1).as(:number) |
-          str("\\\\").as("\\\\")
+          str("\\\\").as("\\\\") |
+          (slash >> (lparen | rparen).as(:symbols)) |
+          lparen |
+          str("\\ ").as(:space)
       end
 
       rule(:intermediate_exp) do
-        (lparen >> expression.as(:expression) >> rparen) |
-          (lparen >> str("") >> rparen) |
+        (str("{") >> expression.maybe.as(:expression) >> str("}")) |
           symbol_text_or_integer
       end
 
@@ -126,73 +101,121 @@ module Plurimath
       end
 
       rule(:binary_functions) do
-        (slash >> str("sqrt").as(:root) >> sqrt_arg.as(:first_value) >> intermediate_exp.as(:second_value)).as(:binary) |
-          (slash >> str("sqrt").as(:sqrt) >> intermediate_exp.as(:intermediate_exp)).as(:binary) |
-          (intermediate_exp.as(:first_value) >> under_over >> intermediate_exp.as(:second_value)).as(:under_over) |
-          (binary >> intermediate_exp.as(:first_value) >> intermediate_exp.as(:second_value)).as(:binary)
+        (intermediate_exp.as(:first_value) >> under_over >> intermediate_exp.as(:second_value)).as(:under_over) |
+          (slash >> str("sqrt").as(:root) >> sqrt_arg.as(:first_value) >> intermediate_exp.as(:second_value)).as(:binary) |
+          (slash >> str("sqrt").as(:sqrt) >> intermediate_exp.as(:intermediate_exp)).as(:binary)
       end
 
       rule(:sequence) do
         limits.as(:limits) |
-          (left_right.as(:left_right) >> power >> intermediate_exp.as(:supscript)) |
-          (left_right.as(:left_right) >> base >> intermediate_exp.as(:subscript)) |
-          left_right.as(:left_right) |
+          (binary_functions.as(:binary_functions) >> power >> sequence.as(:supscript)).as(:power) |
+          (binary_functions.as(:binary_functions) >> base >> sequence.as(:subscript)).as(:base) |
+          binary_functions |
+          (slash >> str("rule").as(:rule) >> sqrt_arg.maybe.as(:first_value) >> intermediate_exp.maybe.as(:second_value) >> intermediate_exp.maybe.as(:third_value)).as(:binary) |
           (over_class >> power >> intermediate_exp.as(:supscript)) |
           (over_class >> base >> intermediate_exp.as(:subscript)) |
           over_class |
-          (slash >> str("mbox") >> lparen.capture(:paren) >> read_text >> rparen).as(:unary_functions) |
-          (slash >> str("substack").as(:substack) >> lparen >> expression.as(:substack_value) >> rparen) |
+          (left_right.as(:left_right) >> power >> intermediate_exp.as(:supscript)) |
+          (left_right.as(:left_right) >> base >> intermediate_exp.as(:subscript)) |
+          left_right.as(:left_right) |
+          (slash >> str("substack").as(:substack) >> intermediate_exp) |
           (begining >> array_args >> expression.as(:table_data) >> ending).as(:environment) |
           (begining >> expression.as(:table_data) >> ending).as(:environment) |
           (slash >> environment >> intermediate_exp).as(:table_data) |
           power_base |
-          binary_functions |
+          (rparen >> (base >> sequence.as(:subscript)).maybe >> power >> sequence.as(:supscript)).as(:power_base) |
+          (rparen >> (power >> sequence.as(:supscript)) >> base >> sequence.as(:subscript)).as(:power_base) |
+          rparen |
           intermediate_exp
       end
 
-      rule(:left_right_over) do
-        (str("\\left").as(:left) >>
-          lparen >>
-          expression.repeat.as(:dividend) >>
-          str("\\over") >>
-          expression.repeat.as(:divisor) >>
-          str("\\right").as(:right) >>
-          rparen)
+      rule(:left_right) do
+        (
+         str("\\left").as(:left) >> lparen.maybe >>
+         (
+           (expression.repeat.as(:dividend) >> str("\\over") >> expression.repeat.as(:divisor)) |
+           expression.as(:expression).maybe
+         ) >>
+         str("\\right").as(:right).maybe >> (rparen | str(".").maybe)
+       )
       end
 
       rule(:over_class) do
         (
           (str("{") >> expression.repeat.as(:dividend) >> str("\\over") >> expression.repeat.as(:divisor) >> str("}")) |
-          (left_right_over.as(:left_right).as(:power) >> power >> intermediate_exp) |
-          (left_right_over.as(:left_right).as(:base) >> base >> intermediate_exp) |
-          left_right_over.as(:left_right)
+          (left_right.as(:left_right).as(:power) >> power >> intermediate_exp) |
+          (left_right.as(:left_right).as(:base) >> base >> intermediate_exp)
         ).as(:over)
       end
 
       rule(:iteration) do
-        (sequence.as(:sequence) >> expression.as(:expression)) | sequence
+        (sequence.as(:sequence) >> expression.as(:expression)) |
+          sequence
       end
 
-      rule(:expression) { (iteration >> expression) | iteration }
+      rule(:expression) do
+        (iteration >> expression) |
+          iteration |
+          ((iteration.as(:dividend) >> str("\\over") >> iteration.as(:divisor)) >> expression.repeat)
+      end
 
       root :expression
 
-      def arr_to_expression(array, name = nil)
+      def arr_to_expression(array, name)
+        @@new_hash ||= {}
         type = array.first.class
-        array.reduce do |expression, expr_string|
-          name = name || expr_string.to_sym || expression.to_sym
+        @@new_hash[name] ||= array.reduce do |expression, expr_string|
           expression = str(expression).as(name) if expression.is_a?(type)
           expression | str(expr_string).as(name)
         end
       end
 
-      def read_text
-        dynamic do |_sour, context|
-          lparen = context.captures[:paren][:lparen].to_s
-          rparen = Constants::PARENTHESIS[lparen]
-          match("[^#{rparen}]").repeat.as(:mbox)
+      def hash_to_expression(hash)
+        @@expression ||= hash.reduce do |expression, (key, value)|
+          expression = dynamic_rules(expression.first, expression.last) if expression.is_a?(Array)
+          expression | dynamic_rules(key, value)
         end
       end
+
+      def dynamic_rules(expr, name)
+        first_value = str(expr.to_s)
+        case name
+        when :operant
+          (first_value.as(:operant) | (slashed_value(first_value, :symbols)))
+        when :symbols
+          slashed_value(first_value, :symbols)
+        when :unary
+          unary_rules(first_value)
+        when :fonts
+          (slashed_value(first_value, :fonts) >> (binary_functions | intermediate_exp).as(:intermediate_exp))
+        when :power_base
+          (slashed_value(first_value, :binary) >> dynamic_power_base).as(:power_base) |
+            (slashed_value(first_value, :binary))
+        when :underover
+          (slashed_value(first_value, :underover) >> dynamic_power_base) |
+            (slashed_value(first_value, :underover) >> intermediate_exp.maybe.as(:first_value) >> dynamic_power_base) |
+            (slashed_value(first_value, :underover))
+        when :binary
+          (slashed_value(first_value, :binary) >> intermediate_exp.as(:first_value) >> intermediate_exp.as(:second_value)).as(:binary)
+        end
+      end
+
+      def slashed_value(first_value, name = nil)
+        (slash >> first_value.as(name))
+      end
+
+      def unary_rules(first_value)
+        (slashed_value(first_value, :unary_functions) >> dynamic_power_base) |
+          (slashed_value(first_value, :unary) >> intermediate_exp.as(:first_value)).as(:unary_functions) |
+          (slashed_value(first_value, :unary))
+      end
+
+      def dynamic_power_base
+        (base >> intermediate_exp.as(:subscript) >> power >> intermediate_exp.as(:supscript)) |
+          (power >> intermediate_exp.as(:supscript) >> base >> intermediate_exp.as(:subscript)) |
+          (power >> intermediate_exp.as(:supscript)) |
+          (base >> intermediate_exp.as(:subscript))
+      end
     end
   end
 end

data/lib/plurimath/latex/parser.rb

@@ -9,13 +9,20 @@ module Plurimath
       attr_accessor :text
 
       def initialize(text)
-        @text = text.gsub(/\s/, "")
+        enti = HTMLEntities.new
+        text = enti.encode(enti.decode(text), :hexadecimal)
+        text = text
+          .gsub(/((?<!\\) )|\n+/, "")
+          .gsub(/\\\\ /, "\\\\\\\\")
+          .gsub(/&#x26;/, "&")
+          .gsub(/&#x22;/, "\"")
+          .gsub(/&#xa;/, "")
+        @text = text
       end
 
       def parse
-        tree_t = Latex::Parse.new.parse(text)
-        tree_t = JSON.parse(tree_t.to_json, symbolize_names: true)
-        formula = Latex::Transform.new.apply(tree_t)
+        tree_t = Parse.new.parse(text)
+        formula = Transform.new.apply(tree_t)
         formula = [formula] unless formula.is_a?(Array)
 
         Math::Formula.new(formula)