plurimath 0.11.12 → 0.11.13

data/lib/plurimath/asciimath/parse.rb

@@ -2,232 +2,49 @@
 
 module Plurimath
   class Asciimath
-    class Parse < Parslet::Parser
-      include Plurimath::BaseNumberPrefix::Parser
-
-      rule(:td)     { expression.as(:td) }
-      rule(:base)   { str("__|").absent? >> str("_") }
-      rule(:power)  { str("^") }
-      rule(:space)  { match(/\s+/) }
-      rule(:comma)  { str(",") >> space? }
-      rule(:space?) { space.maybe }
-      rule(:number) do
-        hex_number |
-          binary_number |
-          octal_number |
-          decimal_number.as(:number) |
-          str(".").as(:symbol)
-      end
-
-      rule(:decimal_number) do
-        (match("[0-9]").repeat(1) >> decimal_marker >> match("[0-9]").repeat(1)) |
-          match("[0-9]").repeat(1)
-      end
-
-      rule(:decimal_operand) do
-        (hex_number | binary_number | octal_number).absent? >> decimal_number
-      end
-
-      rule(:signed_number) { (str("-") >> decimal_operand).as(:number) }
-      rule(:script_operand) { signed_number | sequence }
-      rule(:mod_operand) do
-        (str("-") >> decimal_operand.present? >> iteration).as(:negative_mod_operand) |
-          iteration
-      end
-
-      rule(:controversial_symbols)   { power_base | expression }
-      rule(:left_right_open_paren)   { str("(") | str("[") }
-      rule(:left_right_close_paren)  { str(")") | str("]") }
-      rule(:color_left_parenthesis)  { str("(") | str("[") | str("{") }
-      rule(:color_right_parenthesis) { str(")") | str("]") | str("}") }
-
-      rule(:ternary_classes_rules) do
-        (str("left") >> space? >> left_right_open_paren.as(:left) >> space? >> (ternary_classes >> power_base >> space? >> iteration.as(:third_value).maybe).as(:ternary) >> space? >> str("right") >> space? >> left_right_close_paren.as(:right)) |
-          (ternary_classes >> power_base >> space? >> iteration.as(:third_value).maybe).as(:ternary) |
-          ternary_classes
-      end
-
-      rule(:ternary_classes) do
-        arr_to_expression(Constants::TERNARY_CLASSES, :ternary_class)
-      end
-
-      rule(:binary_classes) do
-        arr_to_expression(Constants::BINARY_CLASSES, :binary_class)
-      end
-
-      rule(:sub_sup_classes) do
-        arr_to_expression(Constants::SUB_SUP_CLASSES, :binary_class)
-      end
-
-      rule(:open_table) do
-        arr_to_expression(Constants::TABLE_PARENTHESIS.keys, :table_left)
-      end
-
-      rule(:close_table) do
-        arr_to_expression(Constants::TABLE_PARENTHESIS.values, :table_right)
-      end
-
-      rule(:lparen) do
-        Constants::PARENTHESIS.keys.reduce do |expression, parenthesis|
-          expression = str(expression) if expression.is_a?(Symbol)
-          expression | str(parenthesis)
-        end
-      end
-
-      rule(:rparen) do
-        Constants::PARENTHESIS.values.reduce do |expression, parenthesis|
-          expression = str(expression) if expression.is_a?(String)
-          expression | str(parenthesis)
-        end
-      end
-
-      rule(:left_right) do
-        (str("left") >> space? >> left_right_open_paren.as(:left) >> space? >> (iteration.maybe >> sequence.maybe).as(:left_right_value) >> space? >> str("right") >> space? >> left_right_close_paren.as(:right)) |
-          ((table.as(:numerator) >> space? >> match(/(?<!\/)\/(?!\/)/) >> space? >> iteration.as(:denominator)).as(:frac) >> expression) |
-          (table.as(:table) >> power_base.maybe >> expression.maybe)
-      end
-
-      rule(:quoted_text) do
-        (str('"') >> str("unitsml(") >> (str(')"').absent? >> any).repeat.as(:unitsml) >> str(')"')) |
-          (str('"') >> match("[^\"]").repeat.as(:text) >> str('"')) |
-          (str('"') >> str("").as(:text))
-      end
-
-      rule(:symbol_text_or_integer) do
-        sub_sup_classes |
-          binary_classes |
-          ternary_classes |
-          hash_to_expression(Constants.precompile_constants) |
-          (match(/[0-9]/).as(:number) >> (decimal_marker >> match("[0-9]")).absent? >> str(",").as(:comma)).repeat(1).as(:comma_separated) |
-          quoted_text |
-          (str("d").as(:d) >> str("x").as(:x)).as(:intermediate_exp) |
-          ((str("left").absent? >> str("right").absent?) >> match["a-zA-Z"].as(:symbol)) |
-          match(/[^\[{(\\\/@;:.,'"|\]})0-9a-zA-Z\-><$%^&*_=+!`~\s?ℒℛᑕᑐ]/).as(:symbol) |
-          number
-      end
-
-      rule(:power_base) do
-        (base >> space? >> script_operand.as(:base_value) >> power >> (power >> power.maybe).absent? >> space? >> script_operand.as(:power_value)) |
-          (space? >> base >> space? >> script_operand.as(:base_value)).as(:base) |
-          (space? >> power >> (power >> power.maybe).absent? >> space? >> script_operand.as(:power_value)).as(:power) |
-          (space? >> base >> space? >> power.as(:symbol).as(:base_value)).as(:base) |
-          (space? >> power >> (power >> power.maybe).absent? >> space? >> base.as(:symbol).as(:power_value)).as(:power)
-      end
-
-      rule(:power_base_rules) do
-        (sub_sup_classes >> power_base).as(:power_base) |
-          (binary_classes >> space? >> sequence.as(:base_value).maybe >> space? >> sequence.as(:power_value).maybe).as(:power_base) |
-          (sequence.as(:power_base) >> power_base).as(:power_base)
-      end
-
-      rule(:table) do
-        (str("{").as(:table_left) >> space? >> tr >> space? >> close_table.as(:table_right)) |
-          (open_table.as(:table_left) >> space? >> tr >> space? >> close_table.as(:table_right)) |
-          (str("norm").as(:norm) >> open_table.as(:table_left) >> space? >> tr >> space? >> close_table.as(:table_right)) |
-          (str("|").as(:table_left) >> space? >> tr >> space? >> str("|").as(:table_right)) |
-          (str("left") >> space? >> left_right_open_paren.as(:left) >> space? >> tr >> space? >> str("right") >> space? >> left_right_close_paren.as(:right))
-      end
-
-      rule(:tr) do
-        ((left_right_open_paren.as(:open_tr) >> td.as(:tds_list) >> left_right_close_paren).as(:table_row) >> space? >> comma >> space? >> tr.as(:expr)) |
-          (left_right_open_paren.as(:open_tr) >> td.as(:tds_list) >> left_right_close_paren).as(:table_row)
-      end
-
-      rule(:color_value) do
-        (color_left_parenthesis.capture(:paren).as(:lparen) >> expression.as(:rgb_color) >> color_right_parenthesis.maybe.as(:rparen)).as(:intermediate_exp) |
-          iteration
-      end
-
-      rule(:sequence) do
-        (lparen.as(:lparen) >> space? >> expression.maybe.as(:expr) >> space? >> rparen.maybe.as(:rparen)).as(:intermediate_exp) |
-          (str("text") >> lparen.capture(:paren) >> read_text.as(:text) >> rparen.maybe).as(:intermediate_exp) |
-          symbol_text_or_integer
-      end
-
-      rule(:frac) do
-        (sequence.as(:numerator) >> space? >> match(/(?<!\/)\/(?!\/)/) >> space? >> iteration.as(:denominator)).as(:frac) |
-          ((power_base_rules | power_base).as(:numerator) >> space? >> match(/(?<!\/)\/(?!\/)/) >> space? >> iteration.as(:denominator)).as(:frac)
-      end
-
-      rule(:mod) do
-        (sequence.as(:dividend) >> space? >> str("mod").as(:mod) >> space? >> mod_operand.as(:divisor)).as(:mod) |
-          ((power_base_rules >> power_base).as(:dividend) >> space? >> str("mod").as(:mod) >> space? >> mod_operand.as(:divisor)).as(:mod) |
-          (power_base_rules.as(:dividend) >> space? >> str("mod").as(:mod) >> space? >> mod_operand.as(:divisor)).as(:mod)
-      end
-
-      rule(:iteration) do
-        ternary_classes_rules |
-          (table.as(:table) >> power_base.maybe) |
-          comma.as(:comma) |
-          mod |
-          (sequence.as(:sequence) >> space? >> str("//").as(:symbol)) |
-          (str("color") >> color_value.as(:color) >> sequence.as(:color_value)) |
-          frac |
-          (power_base_rules >> power_base) |
-          power_base_rules |
-          sequence.as(:sequence) |
-          space
-      end
-
-      rule(:expression) do
-        left_right.as(:left_right) |
-          (iteration >> space? >> expression).as(:expr) |
-          (base.as(:symbol) >> expression.maybe).as(:expr) |
-          (power.as(:symbol) >> expression.maybe).as(:expr) |
-          str("") |
-          (rparen.as(:rparen) >> space? >> controversial_symbols >> comma.as(:comma).maybe >> expression).repeat(1).as(:expr) |
-          (power.as(:symbol) >> space? >> expression).as(:expr) |
-          (table.as(:table) >> space? >> rparen.as(:rparen) >> space? >> expression.as(:expr).maybe) |
-          comma.as(:comma).maybe
-      end
-
-      root :expression
-
-      def arr_to_expression(arr, name = nil)
-        type = arr.first.class
-        arr.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|
-          rparen = Constants::PARENTHESIS[context.captures[:paren].to_sym]
-          match("[^#{rparen}]").repeat
-        end
-      end
-
-      def hash_to_expression(arr)
-        type = arr.first.class
-        @@expression ||= arr.reduce do |expression, expr_string|
-          expression = dynamic_parser_rules(expression) if expression.is_a?(type)
-          expression | dynamic_parser_rules(expr_string)
-        end
-      end
-
-      def dynamic_parser_rules(expr)
-        first_value = str(expr.first.to_s)
-        case expr.last
-        when :symbol then (str("\\").as(:slash) >> match("\s").repeat >> str("\n")) | first_value.as(:symbol)
-        when :unary_class then unary_functions(first_value)
-        when :fonts then first_value.as(:fonts_class) >> space? >> sequence.as(:fonts_value)
-        when :special_fonts then first_value.as(:bold_fonts)
-        end
-      end
-
-      def decimal_marker
-        str(Plurimath.configuration.decimal)
-      end
-
-      def unary_functions(first_value)
-        if ["'underbrace'", "'ubrace'"].include?(first_value.to_s)
-          (first_value.as(:unary_class) >> space? >> str("_").as(:symbol)).as(:unary) |
-            (first_value.as(:unary_class) >> space? >> sequence.maybe).as(:unary)
-        else
-          (first_value.as(:unary_class).as(:power_base) >> space? >> power_base).as(:unary) |
-            (first_value.as(:unary_class) >> space? >> sequence.maybe).as(:unary)
-        end
+    # The AsciiMath grammar lives in the amath gem. This class keeps the
+    # tree-level entry point for callers that parse without transforming
+    # (plurimath-testsuite's corpus generator calls Parse.new.parse): it
+    # returns the Parslet-shaped tree Asciimath::Transform expects, and
+    # raises Parslet::ParseFailed with a cause at amath's rejection position.
+    class Parse
+      # amath is not released yet, so the Gemfile line points at GitHub.
+      AMATH_GEMFILE_LINE = 'gem "amath", github: "plurimath/amath"'
+
+      def parse(text)
+        load_amath
+        parse_with_amath(text)
+      end
+
+      private
+
+      # Loaded here, outside parse_with_amath, so its `rescue ::Amath::...`
+      # clause is never evaluated while Amath is undefined.
+      def load_amath
+        require "amath"
+      rescue LoadError => e
+        raise unless e.path == "amath" || e.message.end_with?("-- amath")
+
+        raise Math::MissingDependencyError.new(
+          :asciimath,
+          format_name: "AsciiMath",
+          gem_name: "amath",
+          gemfile_line: AMATH_GEMFILE_LINE,
+        ), cause: nil
+      end
+
+      def parse_with_amath(text)
+        tree = ::Amath.parse(text, decimal: Plurimath.configuration.decimal)
+        SliceAdapter.convert(tree, text)
+      rescue ::Amath::ParseError => e
+        raise parse_failed(e, text)
+      end
+
+      def parse_failed(error, text)
+        position = Parslet::Position.new(text, error.byte_offset)
+        cause = Parslet::Cause.new(error.message, Parslet::Source.new(text),
+                                   position, [])
+        Parslet::ParseFailed.new(error.message, cause)
       end
     end
   end

data/lib/plurimath/asciimath/parser.rb

@@ -3,6 +3,10 @@
 module Plurimath
   class Asciimath
     class Parser
+      # An uncertainty call. amath splits letters, so xustd(1,5) is x
+      # followed by ustd(1,5): a preceding letter does not exempt it.
+      UNCERTAINTY_CALL = /u(?:std|exp|cov)\(/
+
       attr_accessor :text
 
       def initialize(text)
@@ -15,12 +19,65 @@ module Plurimath
       end
 
       def parse
-        nodes = Parse.new.parse(text)
+        ambiguous_uncertainty_comma!
+        nodes = parse_tree
         transformed_tree = Transform.new.apply(nodes)
         return transformed_tree if transformed_tree.is_a?(Math::Formula)
 
         Math::Formula.new(transformed_tree)
       end
+
+      private
+
+      def parse_tree
+        Parse.new.parse(text)
+      end
+
+      # Uncertainty arguments use "." as the decimal mark and "," between
+      # arguments. Under a locale whose decimal mark is not ".", a separator
+      # comma directly followed by a digit (ustd(1,5), uexp(10,0, 0,3, 2))
+      # most likely is a decimal comma: amath would read it as a separator,
+      # or give up on the call and read letters (ustd(1,230, 0,004) under fr).
+      # Raise instead of guessing; other input is not checked.
+      def ambiguous_uncertainty_comma!
+        decimal = Plurimath.configuration.decimal
+        return if decimal == "." || text.nil?
+
+        text.to_enum(:scan, UNCERTAINTY_CALL).each do
+          start = Regexp.last_match.begin(0)
+          next if text[0...start].count('"').odd?
+
+          call = uncertainty_call(start, Regexp.last_match.end(0))
+          next unless call
+
+          raise Math::AmbiguousDecimalError.new(
+            "uncertainty forms use '.' as the decimal mark; the comma " \
+            "before a digit in #{call} is ambiguous with decimal " \
+            "'#{decimal}' (locale #{Plurimath.configuration.locale}), " \
+            "write the value with '.' and separate arguments with ', '",
+          )
+        end
+      end
+
+      # The call text from start to its closing parenthesis if a top-level
+      # argument separator in it is directly followed by a digit, else nil.
+      def uncertainty_call(start, index)
+        depth = 1
+        quoted = false
+        ambiguous = false
+        while index < text.length && depth.positive?
+          char = text[index]
+          quoted = !quoted if char == '"'
+          unless quoted
+            depth += 1 if char == "("
+            depth -= 1 if char == ")"
+            ambiguous ||= depth == 1 && char == "," &&
+              text[index + 1].to_s.match?(/\A[0-9]\z/)
+          end
+          index += 1
+        end
+        text[start...index] if ambiguous
+      end
     end
   end
 end

data/lib/plurimath/asciimath/slice_adapter.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Plurimath
+  class Asciimath
+    # Turns a parse tree produced by amath (Parsanol) into a Parslet-shaped
+    # tree (Symbol keys, Parslet::Slice leaves), so Asciimath::Transform and
+    # the other Parslet::Slice consumers keep working unchanged.
+    #
+    # - Every leaf becomes a real Parslet::Slice. Parsanol slices carry a byte
+    #   offset into the parsed string; Parslet::Position also stores a byte
+    #   offset and derives the character offset (Slice#offset) from it, so the
+    #   byte offset is kept and #offset answers in characters, as Parslet does.
+    # - Plain String leaves (Parsanol returns a bare "" for an empty match)
+    #   become Parslet::Slice at the end of the last leaf seen so far, in tree
+    #   order; for empty input that is ""@0, as Parslet gives.
+    # - Hashes keep their key order (String keys become Symbols, as Parslet
+    #   always uses Symbols), arrays keep their order, [] stays [], nil stays
+    #   nil.
+    module SliceAdapter
+      class OffsetError < StandardError; end
+
+      module_function
+
+      def convert(tree, input)
+        input = input.to_s
+        line_cache = Parslet::Source::LineCache.new
+        line_cache.scan_for_line_endings(0, input)
+        Walker.new(input, line_cache).walk(tree)
+      end
+
+      class Walker
+        def initialize(input, line_cache)
+          @input = input
+          @line_cache = line_cache
+          @cursor = 0
+        end
+
+        # Depth-first with an explicit stack instead of recursion: a long
+        # AsciiMath sum is a tree about two levels deep per term, which would
+        # overflow a small (1 MiB, as on Windows) stack. Children are visited
+        # in the same order as a recursive walk, so the cursor that places
+        # empty-string leaves sees the leaves in the same order.
+        def walk(root)
+          return leaf(root) unless container?(root)
+
+          result = empty_copy(root)
+          stack = [[entries(root), result, 0]]
+          until stack.empty?
+            frame = stack.last
+            items, out, index = frame
+            next stack.pop if index == items.size
+
+            frame[2] = index + 1
+            key, value = items[index]
+            if container?(value)
+              child = empty_copy(value)
+              store(out, key, child)
+              stack.push([entries(value), child, 0])
+            else
+              store(out, key, leaf(value))
+            end
+          end
+          result
+        end
+
+        private
+
+        def container?(node)
+          node.is_a?(Hash) || node.is_a?(Array)
+        end
+
+        def empty_copy(node)
+          node.is_a?(Hash) ? {} : []
+        end
+
+        def entries(node)
+          node.is_a?(Hash) ? node.to_a : node.each_with_index.map { |v, i| [i, v] }
+        end
+
+        def store(out, key, value)
+          if out.is_a?(Hash)
+            out[symbol_key(key)] = value
+          else
+            out << value
+          end
+        end
+
+        def leaf(node)
+          case node
+          when ::Parslet::Slice then keep(node)
+          when String then slice(@cursor, node)
+          when nil then nil
+          else
+            return slice_from(node) if foreign_slice?(node)
+
+            node
+          end
+        end
+
+        def keep(node)
+          advance(node.position.bytepos, node.to_s)
+          node
+        end
+
+        def symbol_key(key)
+          key.is_a?(String) ? key.to_sym : key
+        end
+
+        def foreign_slice?(node)
+          node.respond_to?(:offset) && node.respond_to?(:to_str)
+        end
+
+        def slice_from(node)
+          content = node.to_str
+          bytepos = node.offset
+          unless @input.byteslice(bytepos, content.bytesize) == content
+            raise OffsetError,
+                  "slice #{content.inspect} does not match the input at " \
+                  "byte #{bytepos}"
+          end
+
+          slice(bytepos, content)
+        end
+
+        def slice(bytepos, content)
+          advance(bytepos, content)
+          position = ::Parslet::Position.new(@input, bytepos)
+          ::Parslet::Slice.new(position, content.to_s.dup, @line_cache)
+        end
+
+        def advance(bytepos, content)
+          finish = bytepos + content.to_s.bytesize
+          @cursor = finish if finish > @cursor
+        end
+      end
+    end
+  end
+end