plurimath 0.10.7 → 0.11.0

data/lib/plurimath/html/parse.rb

@@ -6,11 +6,12 @@ module Plurimath
       rule(:space)   { match["\s"].repeat(1) }
       rule(:unary)   { array_to_expression(Constants::UNARY_CLASSES, :unary) }
       rule(:binary)  { str("lim").as(:binary) }
+      rule(:linebreak) { parse_void_tag("br").as(:linebreak) }
       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)) |
+        wrapped_tag(str("mod").as(:binary)) |
           str("mod").as(:binary)
       end
 
@@ -27,12 +28,12 @@ module Plurimath
       end
 
       rule(:open_paren) do
-        (parse_tag(:open) >> lparen >> parse_tag(:close)) |
+        wrapped_tag(lparen) |
           lparen
       end
 
       rule(:close_paren) do
-        (parse_tag(:open) >> rparen >> parse_tag(:close)) |
+        wrapped_tag(rparen) |
           rparen
       end
 
@@ -57,12 +58,12 @@ module Plurimath
       end
 
       rule(:unary_functions) do
-        (parse_tag(:open) >> unary >> parse_tag(:close)) |
+        wrapped_tag(unary) |
           unary
       end
 
       rule(:binary_functions) do
-        (parse_tag(:open) >> binary >> parse_tag(:close)) |
+        wrapped_tag(binary) |
           binary
       end
 
@@ -73,11 +74,11 @@ module Plurimath
 
       rule(:symbol_text_or_tag) do
         tag_parse |
-          (str("&") >> match["a-zA-Z0-9"].repeat(2) >> str(";")).as(:symbol) |
-          (match["0-9"].repeat(1) >> str(".") >> match["0-9"].repeat(1)).as(:number) |
+          html_entity.as(:symbol) |
+          (match["0-9"].repeat(1) >> decimal_marker >> match["0-9"].repeat(1)).as(:number) |
           match["0-9"].repeat(1).as(:number) |
           match["a-zA-Z"].as(:text) |
-          match["^0-9a-zA-Z<>/(){}\\[\\]\s"].as(:symbol)
+          match["^0-9a-zA-Z<>(){}\\[\\]\s"].as(:symbol)
       end
 
       rule(:intermediate_exp) do
@@ -85,6 +86,7 @@ module Plurimath
           (symbol_text_or_tag.as(:sub_sup) >> sub_sup_tags) |
           sub_sup |
           parse_classes |
+          linebreak |
           symbol_text_or_tag |
           space
       end
@@ -109,8 +111,9 @@ module Plurimath
       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))
+          # Formula has no header-cell node; HTML <th> is parsed as Td.
+          parse_sub_sup_tags(%w[td th], "td") |
+          wrapped_tag(sequence.as(:sequence))
       end
 
       rule(:expression) do
@@ -136,15 +139,75 @@ module Plurimath
         str(string).as(name)
       end
 
-      def parse_tag(opts)
+      def decimal_marker
+        str(Plurimath.configuration.decimal)
+      end
+
+      def parse_tag(opts, tag_name = nil, capture_name: nil)
         tag = str("<")
         tag = tag >> str("/") if opts == :close
-        tag = tag >> match(/\w+/).repeat
+        name_expression = html_tag_name(tag_name)
+        name_expression = name_expression.capture(capture_name) if capture_name
+        tag = tag >> name_expression
+        tag = tag >> tag_attributes if opts == :open
         tag >> str(">")
       end
 
-      def parse_sub_sup_tags(tag)
-        str("<#{tag}>") >> sequence.as(:"#{tag}_value") >> str("</#{tag}>")
+      def parse_void_tag(tag_name)
+        str("<") >> html_tag_name(tag_name) >> tag_attributes >> str(">")
+      end
+
+      def html_entity
+        (str("&#x") >> match["0-9a-fA-F"].repeat(1) >> str(";")) |
+          (str("&#") >> match["0-9"].repeat(1) >> str(";")) |
+          (str("&") >> match["a-zA-Z"] >> match["a-zA-Z0-9"].repeat >> str(";"))
+      end
+
+      def parse_sub_sup_tags(tag_names, transform_name = tag_names)
+        Array(tag_names).map do |tag_name|
+          parse_tag(:open, tag_name) >>
+            sequence.as(:"#{transform_name}_value") >>
+            parse_tag(:close, tag_name)
+        end.reduce(:|)
+      end
+
+      def wrapped_tag(expression)
+        scope do
+          parse_tag(:open, capture_name: :html_tag_name) >>
+            expression >>
+            matching_close_tag
+        end
+      end
+
+      def matching_close_tag
+        dynamic do |_source, context|
+          parse_tag(:close, context.captures[:html_tag_name].to_s)
+        end
+      end
+
+      def html_tag_name(tag_name)
+        return match["a-zA-Z"] >> match["a-zA-Z0-9:._-"].repeat unless tag_name
+
+        case_insensitive_string(tag_name) >> tag_name_boundary
+      end
+
+      def tag_name_boundary
+        match["\\s/>"].present?
+      end
+
+      def tag_attributes
+        (quoted_attribute_value | match["^<>"]).repeat
+      end
+
+      def quoted_attribute_value
+        (str('"') >> match['^"'].repeat >> str('"')) |
+          (str("'") >> match["^'"].repeat >> str("'"))
+      end
+
+      def case_insensitive_string(value)
+        value.chars
+          .map { |char| char.match?(/[A-Za-z]/) ? match["#{char.downcase}#{char.upcase}"] : str(char) }
+          .reduce(:>>)
       end
     end
   end

data/lib/plurimath/html/parser.rb

@@ -1,24 +1,36 @@
 # frozen_string_literal: true
 
 require "json"
-require "cgi"
+
 module Plurimath
   class Html
     class Parser
+      HTML_ENTITY = /&(?:#x[0-9a-f]+|#\d+|[a-z][a-z0-9]+);/i
+
       attr_accessor :text
 
       def initialize(text)
-        @text = ::CGI.unescapeHTML(text)
+        @text = text.to_s
       end
 
       def parse
-        nodes = Parse.new.parse(text)
+        nodes = Parse.new.parse(normalized_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
+
+      private
+
+      def normalized_text
+        text.gsub(HTML_ENTITY) do |entity|
+          decoded_entity = Utility.html_entity_to_unicode(entity)
+
+          Utility.string_to_html_entity(decoded_entity)
+        end
+      end
     end
   end
 end

data/lib/plurimath/html/transform.rb

@@ -5,15 +5,28 @@ module Plurimath
     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))  do
-        Utility.symbols_class(symbol, lang: :html)
-      end
-      rule(number: simple(:number))  { Math::Number.new(number) }
+      rule(symbol: simple(:symbol)) { TransformUtility.symbol(symbol) }
+      rule(number: simple(:number)) { Math::Number.new(number) }
+      rule(linebreak: simple(:_linebreak)) { Math::Function::Linebreak.new }
       rule(expression: simple(:exp)) { exp }
 
+      rule(linebreak: simple(:_linebreak),
+           expression: simple(:expr)) do
+        [
+          Math::Function::Linebreak.new,
+          expr,
+        ]
+      end
+
+      rule(linebreak: simple(:_linebreak),
+           expression: sequence(:expr)) do
+        [Math::Function::Linebreak.new] + expr
+      end
+
       rule(expression: sequence(:exp))    { exp }
       rule(sequence: simple(:sequence))   { sequence }
       rule(tr_value: simple(:tr_value))   { Math::Function::Tr.new([tr_value]) }
+      rule(tr_value: sequence(:tr_value)) { Math::Function::Tr.new(tr_value) }
       rule(td_value: simple(:td_value))   { Math::Function::Td.new([td_value]) }
       rule(sequence: sequence(:sequence)) { sequence }
       rule(td_value: sequence(:td_value)) { Math::Function::Td.new(td_value) }
@@ -71,6 +84,22 @@ module Plurimath
         )
       end
 
+      rule(td_value: simple(:td_value),
+           expression: simple(:expr)) do
+        [
+          Math::Function::Td.new([td_value]),
+          expr,
+        ]
+      end
+
+      rule(td_value: simple(:td_value),
+           expression: sequence(:expr)) do
+        expr.insert(
+          0,
+          Math::Function::Td.new([td_value]),
+        )
+      end
+
       rule(unary_function: simple(:unary_function),
            sequence: simple(:sequence)) do
         Math::Formula.new(
@@ -104,14 +133,14 @@ module Plurimath
       rule(symbol: simple(:symbol),
            expression: simple(:expr)) do
         [
-          Utility.symbols_class(symbol, lang: :html),
+          TransformUtility.symbol(symbol),
           expr,
         ]
       end
 
       rule(symbol: simple(:symbol),
            expression: sequence(:expr)) do
-        [Utility.symbols_class(symbol, lang: :html)] + expr
+        [TransformUtility.symbol(symbol)] + expr
       end
 
       rule(number: simple(:number),
@@ -145,135 +174,208 @@ module Plurimath
       rule(symbol: simple(:symbol),
            parse_parenthesis: simple(:parse_paren)) do
         [
-          Utility.symbols_class(symbol, lang: :html),
+          TransformUtility.symbol(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
+        TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value)
       end
 
       rule(sub_sup: simple(:sub_sup),
            sub_value: sequence(:sub_value)) do
-        if Utility.sub_sup_method?(sub_sup)
-          sub_sup.parameter_one = Utility.filter_values(sub_value)
-          sub_sup
-        else
-          Math::Function::Base.new(
-            sub_sup,
-            Utility.filter_values(sub_value),
-          )
-        end
+        TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value)
       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
+        TransformUtility.sub_sup_value(sub_sup, sup_value: sup_value)
       end
 
       rule(sub_sup: simple(:sub_sup),
            sup_value: sequence(:sup_value)) do
-        if Utility.sub_sup_method?(sub_sup)
-          sub_sup.parameter_two = Utility.filter_values(sup_value)
-          sub_sup
-        else
-          Math::Function::Power.new(
-            sub_sup,
-            Utility.filter_values(sup_value),
-          )
-        end
+        TransformUtility.sub_sup_value(sub_sup, sup_value: sup_value)
       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
+        TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value)
       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 = Utility.filter_values(sup_value)
-          sub_sup
-        else
-          Math::Function::PowerBase.new(
-            sub_sup,
-            sub_value,
-            Utility.filter_values(sup_value),
-          )
-        end
+        TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value)
       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 = Utility.filter_values(sub_value)
-          sub_sup.parameter_two = sup_value
-          sub_sup
-        else
-          Math::Function::PowerBase.new(
-            sub_sup,
-            Utility.filter_values(sub_value),
-            sup_value,
-          )
-        end
+        TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value)
       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 = Utility.filter_values(sub_value)
-          sub_sup.parameter_two = Utility.filter_values(sup_value)
-          sub_sup
-        else
-          Math::Function::PowerBase.new(
-            sub_sup,
-            Utility.filter_values(sub_value),
-            Utility.filter_values(sup_value),
-          )
-        end
+        TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value)
+      end
+
+      # Parslet emits separate shapes for each sub/sup value combination and
+      # trailing expression form. Keep this cluster mechanical: build the
+      # sub/sup node, then append the remaining expression in input order.
+      rule(sub_sup: simple(:sub_sup),
+           sup_value: sequence(:sup_value),
+           expression: simple(:expression)) do
+        TransformUtility.append_expression(
+          TransformUtility.sub_sup_value(sub_sup, sup_value: sup_value),
+          expression,
+        )
+      end
+
+      rule(sub_sup: simple(:sub_sup),
+           sub_value: simple(:sub_value),
+           expression: simple(:expression)) do
+        TransformUtility.append_expression(
+          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value),
+          expression,
+        )
+      end
+
+      rule(sub_sup: simple(:sub_sup),
+           sub_value: simple(:sub_value),
+           expression: sequence(:expression)) do
+        TransformUtility.append_expression(
+          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value),
+          expression,
+        )
+      end
+
+      rule(sub_sup: simple(:sub_sup),
+           sub_value: sequence(:sub_value),
+           expression: simple(:expression)) do
+        TransformUtility.append_expression(
+          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value),
+          expression,
+        )
+      end
+
+      rule(sub_sup: simple(:sub_sup),
+           sub_value: sequence(:sub_value),
+           expression: sequence(:expression)) do
+        TransformUtility.append_expression(
+          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value),
+          expression,
+        )
+      end
+
+      rule(sub_sup: simple(:sub_sup),
+           sup_value: simple(:sup_value),
+           expression: simple(:expression)) do
+        TransformUtility.append_expression(
+          TransformUtility.sub_sup_value(sub_sup, sup_value: sup_value),
+          expression,
+        )
+      end
+
+      rule(sub_sup: simple(:sub_sup),
+           sup_value: simple(:sup_value),
+           expression: sequence(:expression)) do
+        TransformUtility.append_expression(
+          TransformUtility.sub_sup_value(sub_sup, sup_value: sup_value),
+          expression,
+        )
       end
 
       rule(sub_sup: simple(:sub_sup),
            sup_value: sequence(:sup_value),
+           expression: sequence(:expression)) do
+        TransformUtility.append_expression(
+          TransformUtility.sub_sup_value(sub_sup, sup_value: sup_value),
+          expression,
+        )
+      end
+
+      rule(sub_sup: simple(:sub_sup),
+           sub_value: simple(:sub_value),
+           sup_value: simple(:sup_value),
            expression: simple(:expression)) do
-        power = Math::Function::Power.new(
-          sub_sup,
-          Utility.filter_values(sup_value),
+        TransformUtility.append_expression(
+          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value),
+          expression,
+        )
+      end
+
+      rule(sub_sup: simple(:sub_sup),
+           sub_value: simple(:sub_value),
+           sup_value: simple(:sup_value),
+           expression: sequence(:expression)) do
+        TransformUtility.append_expression(
+          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value),
+          expression,
+        )
+      end
+
+      rule(sub_sup: simple(:sub_sup),
+           sub_value: simple(:sub_value),
+           sup_value: sequence(:sup_value),
+           expression: simple(:expression)) do
+        TransformUtility.append_expression(
+          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value),
+          expression,
+        )
+      end
+
+      rule(sub_sup: simple(:sub_sup),
+           sub_value: simple(:sub_value),
+           sup_value: sequence(:sup_value),
+           expression: sequence(:expression)) do
+        TransformUtility.append_expression(
+          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value),
+          expression,
+        )
+      end
+
+      rule(sub_sup: simple(:sub_sup),
+           sub_value: sequence(:sub_value),
+           sup_value: simple(:sup_value),
+           expression: simple(:expression)) do
+        TransformUtility.append_expression(
+          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value),
+          expression,
+        )
+      end
+
+      rule(sub_sup: simple(:sub_sup),
+           sub_value: sequence(:sub_value),
+           sup_value: simple(:sup_value),
+           expression: sequence(:expression)) do
+        TransformUtility.append_expression(
+          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value),
+          expression,
+        )
+      end
+
+      rule(sub_sup: simple(:sub_sup),
+           sub_value: sequence(:sub_value),
+           sup_value: sequence(:sup_value),
+           expression: simple(:expression)) do
+        TransformUtility.append_expression(
+          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value),
+          expression,
+        )
+      end
+
+      rule(sub_sup: simple(:sub_sup),
+           sub_value: sequence(:sub_value),
+           sup_value: sequence(:sup_value),
+           expression: sequence(:expression)) do
+        TransformUtility.append_expression(
+          TransformUtility.sub_sup_value(sub_sup, sub_value: sub_value, sup_value: sup_value),
+          expression,
         )
-        [power, expression]
       end
 
       rule(lparen: simple(:lparen),

data/lib/plurimath/html/transform_utility.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Plurimath
+  class Html
+    module TransformUtility
+      module_function
+
+      HTML_ENTITY = /\A&(?:#x[0-9a-f]+|#\d+|[a-z][a-z0-9]+);\z/i
+
+      def symbol(symbol)
+        Utility.symbols_class(normalize_symbol(symbol), lang: :html)
+      end
+
+      def append_expression(value, expression)
+        return [value] + expression if expression.is_a?(Array)
+
+        [value, expression]
+      end
+
+      def sub_sup_value(sub_sup, sub_value: nil, sup_value: nil)
+        normalized_sub_value = normalize_sub_sup_value(sub_value)
+        normalized_sup_value = normalize_sub_sup_value(sup_value)
+
+        if Utility.sub_sup_method?(sub_sup)
+          sub_sup.parameter_one = normalized_sub_value if normalized_sub_value
+          sub_sup.parameter_two = normalized_sup_value if normalized_sup_value
+          sub_sup
+        elsif normalized_sub_value && normalized_sup_value
+          Math::Function::PowerBase.new(
+            sub_sup,
+            normalized_sub_value,
+            normalized_sup_value,
+          )
+        elsif normalized_sup_value
+          Math::Function::Power.new(
+            sub_sup,
+            normalized_sup_value,
+          )
+        else
+          Math::Function::Base.new(
+            sub_sup,
+            normalized_sub_value,
+          )
+        end
+      end
+
+      def normalize_sub_sup_value(value)
+        return Utility.filter_values(value) if value.is_a?(Array)
+
+        value
+      end
+
+      def normalize_symbol(symbol)
+        symbol = symbol.to_s
+        return symbol if symbol.match?(HTML_ENTITY)
+
+        Utility.string_to_html_entity(symbol)
+      end
+    end
+  end
+end

data/lib/plurimath/html.rb

@@ -6,6 +6,7 @@ module Plurimath
     autoload :Parse, "#{__dir__}/html/parse"
     autoload :Parser, "#{__dir__}/html/parser"
     autoload :Transform, "#{__dir__}/html/transform"
+    autoload :TransformUtility, "#{__dir__}/html/transform_utility"
 
     attr_accessor :text
 

data/lib/plurimath/latex/parse.rb

@@ -101,7 +101,7 @@ module Plurimath
           (rparen.absent? >> symbol_class_commands) |
           (slash >> math_operators_classes) |
           match["a-zA-Z"].as(:symbols) |
-          (match["0-9"].repeat(0) >> str(".").maybe >> match["0-9"].repeat(1)).as(:number) |
+          (match["0-9"].repeat(0) >> decimal_marker.maybe >> match["0-9"].repeat(1)).as(:number) |
           match["0-9"].repeat(1).as(:number) |
           (str("\\\\").as("\\\\") >> match(/\s/).repeat) |
           str("\\ ").as(:space) |
@@ -197,6 +197,12 @@ module Plurimath
         end
       end
 
+      def decimal_marker
+        # Latex::Parser entity-encodes input before Parslet sees it, so
+        # non-ASCII locale markers must match that encoded parser input.
+        str(Utility.string_to_html_entity(Plurimath.configuration.decimal))
+      end
+
       def hash_to_expression(hash)
         @@expression ||= hash.reduce do |expression, (key, value)|
           if expression.is_a?(Array)