plurimath 0.2.0 → 0.2.2

data/lib/plurimath/asciimath.rb

@@ -10,7 +10,7 @@ module Plurimath
     end
 
     def to_formula
-      @text = Plurimath::Asciimath::Parser.new(text).parse
+      Parser.new(text).parse
     end
   end
 end

data/lib/plurimath/html/constants.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Plurimath
+  class Html
+    class Constants
+      PARENTHESIS = {
+        "(": :")",
+        "{": :"}",
+        "[": :"]",
+      }.freeze
+      UNARY_CLASSES = %w[
+        arcsin
+        arccos
+        arctan
+        coth
+        tanh
+        sech
+        csch
+        sqrt
+        ceil
+        sinh
+        cosh
+        sin
+        cos
+        gcd
+        csc
+        abs
+        vec
+        exp
+        sec
+        tan
+        cot
+        lcm
+        det
+        ln
+        lg
+        g
+        f
+      ].freeze
+      SUB_SUP_CLASSES = {
+        "∏": :prod,
+        "∑": :sum,
+        log: :log,
+        lim: :lim,
+        "∏": :prod,
+        "∑": :sum,
+      }.freeze
+    end
+  end
+end

data/lib/plurimath/html/parse.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "parslet"
+module Plurimath
+  class Html
+    class Parse < Parslet::Parser
+      rule(:unary)   { array_to_expression(Constants::UNARY_CLASSES, :unary) }
+      rule(:binary)  { str("lim").as(:binary) }
+      rule(:sub_tag) { parse_sub_sup_tags("sub") }
+      rule(:sup_tag) { parse_sub_sup_tags("sup") }
+
+      rule(:mod) do
+        (parse_tag(:open) >> str("mod").as(:binary) >> parse_tag(:close)) |
+          str("mod").as(:binary)
+      end
+
+      rule(:lparen) do
+        array_to_expression(Constants::PARENTHESIS.keys, :lparen)
+      end
+
+      rule(:rparen) do
+        array_to_expression(Constants::PARENTHESIS.values, :rparen)
+      end
+
+      rule(:sub_sup) do
+        array_to_expression(Constants::SUB_SUP_CLASSES.keys, :sum_prod)
+      end
+
+      rule(:open_paren) do
+        (parse_tag(:open) >> lparen >> parse_tag(:close)) |
+          lparen
+      end
+
+      rule(:close_paren) do
+        (parse_tag(:open) >> rparen >> parse_tag(:close)) |
+          rparen
+      end
+
+      rule(:sub_sup_tags) do
+        (sub_tag >> sup_tag) |
+          (sup_tag >> sub_tag) |
+          sup_tag |
+          sub_tag
+      end
+
+      rule(:unary_args) do
+        (unary_functions >> parse_parenthesis.as(:first_value)).as(:unary_function) |
+          (unary_functions >> intermediate_exp.as(:first_value)).as(:unary_function) |
+          (unary_functions >> sequence.as(:first_value)).as(:unary_function)
+      end
+
+      rule(:binary_args) do
+        (binary_functions >> parse_parenthesis.as(:first_value) >> parse_parenthesis.as(:second_value)) |
+          (binary_functions >> parse_parenthesis.as(:first_value)) |
+          (binary_functions >> intermediate_exp.as(:first_value) >> intermediate_exp.as(:second_value)) |
+          (binary_functions >> intermediate_exp.as(:first_value))
+      end
+
+      rule(:unary_functions) do
+        (parse_tag(:open) >> unary >> parse_tag(:close)) |
+          unary
+      end
+
+      rule(:binary_functions) do
+        (parse_tag(:open) >> binary >> parse_tag(:close)) |
+          binary
+      end
+
+      rule(:parse_classes) do
+        unary_functions |
+          binary_functions
+      end
+
+      rule(:symbol_text_or_tag) do
+        tag_parse |
+          (str("&") >> match["a-zA-Z0-9"].repeat(2) >> str(";")).as(:symbol) |
+          match["0-9"].as(:number) |
+          match["a-zA-Z"].as(:text) |
+          match["^0-9a-zA-Z<>/(){}\\[\\]"].as(:symbol)
+      end
+
+      rule(:intermediate_exp) do
+        (sub_sup.as(:sub_sup) >> sub_sup_tags) |
+          (symbol_text_or_tag.as(:sub_sup) >> sub_sup_tags) |
+          sub_sup |
+          parse_classes |
+          symbol_text_or_tag
+      end
+
+      rule(:parse_parenthesis) do
+        (open_paren >> symbol_text_or_tag >> close_paren) |
+          (open_paren >> intermediate_exp >> close_paren) |
+          (open_paren >> expression >> close_paren)
+      end
+
+      rule(:sequence) do
+        parse_parenthesis.as(:parse_parenthesis) |
+          (unary_args >> sequence.as(:sequence)) |
+          (binary_args >> sequence.as(:sequence)) |
+          unary_args |
+          binary_args |
+          (symbol_text_or_tag >> parse_parenthesis.as(:parse_parenthesis)) |
+          (intermediate_exp >> expression.as(:expression)) |
+          intermediate_exp
+      end
+
+      rule(:tag_parse) do
+        parse_sub_sup_tags("table") |
+          parse_sub_sup_tags("tr") |
+          parse_sub_sup_tags("td") |
+          (parse_tag(:open) >> sequence.as(:sequence) >> parse_tag(:close))
+      end
+
+      rule(:expression) do
+        (intermediate_exp.as(:first_value) >> mod >> intermediate_exp.as(:second_value)) |
+          (parse_classes.as(:sub_sup) >> sub_sup_tags) |
+          (sequence.as(:sequence) >> sequence.as(:expression)) |
+          sequence
+      end
+
+      root :expression
+
+      def array_to_expression(array, name = nil)
+        initial_type = array.first.class
+        array.reduce do |expr, tag|
+          expr = str_to_expression(expr, name) if expr.is_a?(initial_type)
+          expr | str_to_expression(tag, name)
+        end
+      end
+
+      def str_to_expression(string, name)
+        return str(string) if name.nil?
+
+        str(string).as(name)
+      end
+
+      def parse_tag(opts)
+        tag = str("<")
+        tag = tag >> str("/") if opts == :close
+        tag = tag >> match(/\w+/).repeat
+        tag >> str(">")
+      end
+
+      def parse_sub_sup_tags(tag)
+        str("<#{tag}>") >> sequence.as(:"#{tag}_value") >> str("</#{tag}>")
+      end
+    end
+  end
+end

data/lib/plurimath/html/parser.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "parse"
+require_relative "constants"
+require_relative "transform"
+module Plurimath
+  class Html
+    class Parser
+      attr_accessor :text
+
+      def initialize(text)
+        @text = CGI.unescapeHTML(text)
+      end
+
+      def parse
+        nodes = Parse.new.parse(text)
+        nodes = JSON.parse(nodes.to_json, symbolize_names: true)
+        transformed_tree = Transform.new.apply(nodes)
+        return transformed_tree if transformed_tree.is_a?(Math::Formula)
+
+        Math::Formula.new(transformed_tree)
+      end
+    end
+  end
+end

data/lib/plurimath/html/transform.rb

@@ -0,0 +1,363 @@
+# frozen_string_literal: true
+
+module Plurimath
+  class Html
+    class Transform < Parslet::Transform
+      rule(text: simple(:text))     { Math::Function::Text.new(text) }
+      rule(unary: simple(:unary))   { Utility.get_class(unary).new }
+      rule(symbol: simple(:symbol)) { Math::Symbol.new(symbol) }
+      rule(number: simple(:number)) { Math::Number.new(number) }
+
+      rule(sequence: simple(:sequence))   { sequence }
+      rule(tr_value: simple(:tr_value))   { Math::Function::Tr.new([tr_value]) }
+      rule(td_value: simple(:td_value))   { Math::Function::Td.new([td_value]) }
+      rule(sequence: sequence(:sequence)) { Math::Formula.new(sequence) }
+      rule(td_value: sequence(:td_value)) { Math::Function::Td.new(td_value) }
+
+      rule(parse_parenthesis: simple(:parse_paren)) { parse_paren }
+      rule(unary_function: simple(:unary_function)) { unary_function }
+
+      rule(table_value: simple(:table_value)) do
+        Math::Function::Table.new([table_value])
+      end
+
+      rule(table_value: sequence(:table_value)) do
+        Math::Function::Table.new(table_value)
+      end
+
+      rule(sum_prod: simple(:sum_prod)) do
+        Utility.get_class(
+          Constants::SUB_SUP_CLASSES[sum_prod.to_sym],
+        ).new
+      end
+
+      rule(sequence: simple(:sequence),
+           expression: simple(:expr)) do
+        [sequence, expr]
+      end
+
+      rule(sequence: simple(:sequence),
+           expression: sequence(:expr)) do
+        expr.insert(0, sequence)
+      end
+
+      rule(sequence: sequence(:sequence),
+           expression: simple(:expr)) do
+        sequence << expr
+      end
+
+      rule(tr_value: simple(:tr_value),
+           expression: simple(:expr)) do
+        [
+          Math::Function::Tr.new([tr_value]),
+          expr,
+        ]
+      end
+
+      rule(tr_value: simple(:tr_value),
+           expression: sequence(:expr)) do
+        expr.insert(
+          0,
+          Math::Function::Tr.new([tr_value]),
+        )
+      end
+
+      rule(unary_function: simple(:unary_function),
+           sequence: simple(:sequence)) do
+        Math::Formula.new(
+          [
+            unary_function,
+            sequence,
+          ],
+        )
+      end
+
+      rule(text: simple(:text),
+           expression: simple(:expr)) do
+        [
+          Math::Function::Text.new(text),
+          expr,
+        ]
+      end
+
+      rule(text: simple(:text),
+           expression: sequence(:expr)) do
+        [Math::Function::Text.new(text)] + expr
+      end
+
+      rule(symbol: simple(:symbol),
+           expression: simple(:expr)) do
+        [
+          Math::Symbol.new(symbol),
+          expr,
+        ]
+      end
+
+      rule(symbol: simple(:symbol),
+           expression: sequence(:expr)) do
+        [Math::Symbol.new(symbol)] + expr
+      end
+
+      rule(number: simple(:number),
+           expression: sequence(:expr)) do
+        [Math::Number.new(number)] + expr
+      end
+
+      rule(number: simple(:number),
+           expression: simple(:expr)) do
+        [
+          Math::Number.new(number),
+          expr,
+        ]
+      end
+
+      rule(text: simple(:text),
+           parse_parenthesis: simple(:parse_paren)) do
+        Math::Formula.new(
+          [
+            Math::Function::Text.new(text),
+            parse_paren,
+          ],
+        )
+      end
+
+      rule(unary: simple(:unary),
+           first_value: simple(:first_value)) do
+        Utility.get_class(unary).new(first_value)
+      end
+
+      rule(symbol: simple(:symbol),
+           parse_parenthesis: simple(:parse_paren)) do
+        [
+          Math::Symbol.new(symbol),
+          parse_paren,
+        ]
+      end
+
+      rule(sub_sup: simple(:sub_sup),
+           sub_value: simple(:sub_value)) do
+        if Utility.sub_sup_method?(sub_sup)
+          sub_sup.parameter_one = sub_value
+          sub_sup
+        else
+          Math::Function::Base.new(
+            sub_sup,
+            sub_value,
+          )
+        end
+      end
+
+      rule(sub_sup: simple(:sub_sup),
+           sub_value: sequence(:sub_value)) do
+        if Utility.sub_sup_method?(sub_sup)
+          sub_sup.parameter_one = Math::Formula.new(sub_value)
+          sub_sup
+        else
+          Math::Function::Base.new(
+            sub_sup,
+            Math::Formula.new(sub_value),
+          )
+        end
+      end
+
+      rule(sub_sup: simple(:sub_sup),
+           sup_value: simple(:sup_value)) do
+        if Utility.sub_sup_method?(sub_sup)
+          sub_sup.parameter_two = sup_value
+          sub_sup
+        else
+          Math::Function::Power.new(
+            sub_sup,
+            sup_value,
+          )
+        end
+      end
+
+      rule(sub_sup: simple(:sub_sup),
+           sup_value: sequence(:sup_value)) do
+        if Utility.sub_sup_method?(sub_sup)
+          sub_sup.parameter_two = Math::Formula.new(sup_value)
+          sub_sup
+        else
+          Math::Function::Power.new(
+            sub_sup,
+            Math::Formula.new(sup_value),
+          )
+        end
+      end
+
+      rule(sub_sup: simple(:sub_sup),
+           sub_value: simple(:sub_value),
+           sup_value: simple(:sup_value)) do
+        if Utility.sub_sup_method?(sub_sup)
+          sub_sup.parameter_one = sub_value
+          sub_sup.parameter_two = sup_value
+          sub_sup
+        else
+          Math::Function::PowerBase.new(
+            sub_sup,
+            sub_value,
+            sup_value,
+          )
+        end
+      end
+
+      rule(sub_sup: simple(:sub_sup),
+           sub_value: simple(:sub_value),
+           sup_value: sequence(:sup_value)) do
+        if Utility.sub_sup_method?(sub_sup)
+          sub_sup.parameter_one = sub_value
+          sub_sup.parameter_two = Math::Formula.new(sup_value)
+          sub_sup
+        else
+          Math::Function::PowerBase.new(
+            sub_sup,
+            sub_value,
+            Math::Formula.new(sup_value),
+          )
+        end
+      end
+
+      rule(sub_sup: simple(:sub_sup),
+           sub_value: sequence(:sub_value),
+           sup_value: simple(:sup_value)) do
+        if Utility.sub_sup_method?(sub_sup)
+          sub_sup.parameter_one = Math::Formula.new(sub_value)
+          sub_sup.parameter_two = sup_value
+          sub_sup
+        else
+          Math::Function::PowerBase.new(
+            sub_sup,
+            Math::Formula.new(sub_value),
+            sup_value,
+          )
+        end
+      end
+
+      rule(sub_sup: simple(:sub_sup),
+           sub_value: sequence(:sub_value),
+           sup_value: sequence(:sup_value)) do
+        if Utility.sub_sup_method?(sub_sup)
+          sub_sup.parameter_one = Math::Formula.new(sub_value)
+          sub_sup.parameter_two = Math::Formula.new(sup_value)
+          sub_sup
+        else
+          Math::Function::PowerBase.new(
+            sub_sup,
+            Math::Formula.new(sub_value),
+            Math::Formula.new(sup_value),
+          )
+        end
+      end
+
+      rule(lparen: simple(:lparen),
+           text: simple(:text),
+           rparen: simple(:rparen)) do
+        Math::Formula.new([
+                            Math::Symbol.new(lparen),
+                            Math::Function::Text.new(text),
+                            Math::Symbol.new(rparen),
+                          ])
+      end
+
+      rule(lparen: simple(:lparen),
+           sequence: simple(:sequence),
+           rparen: simple(:rparen)) do
+        Math::Formula.new([
+                            Math::Symbol.new(lparen),
+                            sequence,
+                            Math::Symbol.new(rparen),
+                          ])
+      end
+
+      rule(lparen: simple(:lparen),
+           sequence: sequence(:sequence),
+           rparen: simple(:rparen)) do
+        Math::Formula.new([
+                            Math::Symbol.new(lparen),
+                            Math::Formula.new(sequence),
+                            Math::Symbol.new(rparen),
+                          ])
+      end
+
+      rule(lparen: simple(:lparen),
+           number: simple(:number),
+           rparen: simple(:rparen)) do
+        Math::Formula.new([
+                            Math::Symbol.new(lparen),
+                            Math::Number.new(number),
+                            Math::Symbol.new(rparen),
+                          ])
+      end
+
+      rule(lparen: simple(:lparen),
+           unary_function: simple(:unary_function),
+           rparen: simple(:rparen)) do
+        Math::Formula.new([
+                            Math::Symbol.new(lparen),
+                            unary_function,
+                            Math::Symbol.new(rparen),
+                          ])
+      end
+
+      rule(binary: simple(:binary),
+           first_value: simple(:first_value),
+           second_value: simple(:second_value)) do
+        Utility.get_class(binary).new(first_value, second_value)
+      end
+
+      rule(lparen: simple(:lparen),
+           text: simple(:text),
+           expression: sequence(:expression),
+           rparen: simple(:rparen)) do
+        Math::Formula.new(
+          (
+            [
+              Math::Symbol.new(lparen),
+              Math::Function::Text.new(text),
+            ] + expression
+          ) << Math::Symbol.new(rparen),
+        )
+      end
+
+      rule(lparen: simple(:lparen),
+           text: simple(:text),
+           expression: simple(:expression),
+           rparen: simple(:rparen)) do
+        Math::Formula.new([
+                            Math::Symbol.new(lparen),
+                            Math::Function::Text.new(text),
+                            expression,
+                            Math::Symbol.new(rparen),
+                          ])
+      end
+
+      rule(lparen: simple(:lparen),
+           number: simple(:number),
+           expression: simple(:expression),
+           rparen: simple(:rparen)) do
+        Math::Formula.new([
+                            Math::Symbol.new(lparen),
+                            Math::Number.new(number),
+                            expression,
+                            Math::Symbol.new(rparen),
+                          ])
+      end
+
+      rule(lparen: simple(:lparen),
+           number: simple(:number),
+           expression: sequence(:expression),
+           rparen: simple(:rparen)) do
+        Math::Formula.new(
+          (
+            [
+              Math::Symbol.new(lparen),
+              Math::Number.new(number),
+            ] +
+            expression
+          ) << Math::Symbol.new(rparen),
+        )
+      end
+    end
+  end
+end

data/lib/plurimath/html.rb

@@ -9,7 +9,7 @@ module Plurimath
     end
 
     def to_formula
-      # TODO: Will be implemented soon
+      Parser.new(text).parse
     end
   end
 end