plurimath 0.7.2 → 0.8.0

data/lib/plurimath/unicode_math/parse.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require_relative "parsing_rules/masked"
+require_relative "parsing_rules/sub_sup"
+require_relative "parsing_rules/common_rules"
+require_relative "parsing_rules/absence_rules"
+require_relative "parsing_rules/constants_rules"
+module Plurimath
+  class UnicodeMath
+    class Parse < Parslet::Parser
+      include ParsingRules::Masked
+      include ParsingRules::SubSup
+      include ParsingRules::CommonRules
+      include ParsingRules::ConstantsRules
+      include ParsingRules::AbsenceRules
+
+      rule(:an)  { an_math | an_other }
+      rule(:box) { str("□") >> operand }
+
+      rule(:char) { (absent_chars >> unicode.as(:unicode_symbols)) }
+      rule(:rows) { (str("@").as(:tr) >> space? >> rows.as(:trs).maybe) | (row.as(:tr) >> space? >> str("@") >> space? >> rows.as(:trs).maybe) | row.as(:tr) }
+
+      rule(:space) { match(/\s/).repeat(1) | invisible_times }
+      rule(:other) { other_absent >> alphanumeric.as(:symbol) }
+
+      rule(:space?) { space.maybe }
+      rule(:digits) { (n_ascii >> digits) | n_ascii }
+
+      rule(:op_nary) { op_nary_symbols | op_nary_text }
+      rule(:n_ascii) { match["0-9"].repeat(1).as(:number) }
+      rule(:a_ascii) { match["A-Za-z"].repeat(1).as(:symbol) }
+      rule(:unicode) { str("&#x") >> match["0-9a-fA-F"].repeat >> str(";") }
+      rule(:an_math) { space.absent? >> match("[\u{1D400}-\u{1D7FF}\u{2102}-\u{2134}]") }
+
+      rule(:td_value) { expression.as(:exp) >> space? >> td_value.as(:expr).maybe }
+      rule(:an_other) { (an_math | n_ascii).absent? >> alphanumeric.as(:alphanumeric) }
+      rule(:function) { root_functions | box | hbrack | arg_function | intent_function }
+      rule(:op_array) { op_matrixs | op_prefixed_matrixs | str("&") | str("&#xb;") | str("\\array") }
+
+      rule(:op_opener) { open_paren | op_open_unicode | op_open_paren | op_open }
+      rule(:op_closer) { op_close_unicode | close_paren | op_close_paren | op_close }
+
+      rule(:op_decimal) { str(",") | str(".") }
+      rule(:diacritics) { (char.as(:char) >> diacritics.as(:diacritics)) | char.as(:char) }
+      rule(:open_paren) { (op_masked_open >> (op_closer | op_opener)).as(:open_paren) | op_masked_open }
+
+      rule(:matrix_only) { non_matrixs_absence? >> (op_matrixs | op_prefixed_matrixs) }
+      rule(:close_paren) { (op_masked_close >> (op_opener | op_closer)).as(:close_paren) | op_masked_close }
+
+      rule(:diacriticbase) { an | n_ascii }
+      rule(:forward_slash) { str("/") | str("&#x2f;") | str("&#x2044;") }
+
+      rule(:root_functions) { qdrt | cbrt | sqrt | binary_root | nthrt }
+      rule(:op_masked_open) { (str("\\left") | str("\\open") | str("&#x251c;")).as(:paren_open_prefix) >> digits.as(:open_paren_mask).maybe }
+
+      rule(:invisible_times) { (str("&#x2062;") | str("&#x2061;") | str("&#x20;") | str("\\itimes") >> space?) }
+
+      rule(:ordinary_symbols)  { op_ordinary_symbols | op_prefixed_ordinary_symbols }
+      rule(:negatable_symbols) { forward_slash >> negated | negated >> str("&#x338;") }
+      rule(:invisible_unicode) { str("&#x2592;") | (str("\\naryand") | str("\\of") >> space?) }
+
+      rule(:invisible_unicode?) { invisible_unicode.maybe }
+      rule(:relational_symbols) { op_relational_unicode | op_relational_symbols }
+
+      rule(:hbrack_power_base_check)  { (sub_sup_operand >> (power_symbol | base_symbol)).present? }
+      rule(:spaced_bracketed_operand) { operand >> space? >> spaced_bracketed_operand.as(:expr).maybe }
+
+      rule(:hbrack) do
+        (op_h_brackets >> str("(").present? >> exp_bracket.as(:first_value)) |
+          (op_h_brackets >> (sub_sup_operand >> (power_symbol | base_symbol)).present? >> exp_script.as(:scripted_first_value)).as(:hbrack) |
+          (op_h_brackets >> operand.as(:first_value)).as(:hbrack)
+      end
+
+      rule(:negated) do
+        root_functions.absent? >> (
+          op_negated |
+          op_prefixed_negated |
+          op_prefixed_ordinary_negated |
+          op_ordinary_negated |
+          binary_negated |
+          absent_negated_unicodes >> unicode.as(:negated_operator)
+        )
+      end
+
+      rule(:op_over) do
+        str("&#x2044;").as(:bevelled) |
+          slash >> (str("sdiv") | str("sdivide") | str("sfrac")).as(:bevelled) |
+          str("&#x2298;").as(:no_display_style) |
+          slash >> (str("ndiv") | str("oslash")).as(:no_display_style) |
+          (str("&#x2215;") | str("\\ldiv")).as(:ldiv) |
+          forward_slash |
+          str("\\over") |
+          str("&#x2f;") |
+          str("\\not") |
+          (str("&#xa6;") | str("\\atop")).as(:atop) |
+          (str("\\choose") | str("&#x249e;")).as(:choose)
+      end
+
+      rule(:element_exp_script_validation?) do
+        (((op_unary_functions | unary_arg_functions).absent? >> atom.as(:factor).maybe) >> (mini_sub_sup_present? >> operator >> mini_fraction.present?).absent?)
+      end
+
+      rule(:spaced_exp_bracket) do
+        expression >> space? >> spaced_exp_bracket.as(:exp) |
+          mid_symbols >> space? >> spaced_exp_bracket.as(:expr) |
+          str("&#x2212;").as(:symbol) >> space? >> spaced_exp_bracket.as(:expr) |
+          expression >> space?
+      end
+
+      rule(:row) do
+        (td_value.as(:td) >> space? >> str("&") >> space? >> row.as(:tds).maybe) |
+          td_value.as(:td) |
+          (char.absent? >> space? >> str("&").as(:td) >> space? >> row.as(:tds).maybe)
+      end
+
+      rule(:array) do
+        (op_array >> str("(") >> rows.as(:array) >> str(")")).as(:table) |
+          (matrix_only >> match["0-9"].as(:identity_matrix_number)).as(:table)
+      end
+
+      rule(:slashed_operator) do
+        absent_slashed_values >> str("\\") >> (str("\\") | unicode | (n_ascii | a_ascii).repeat(1) | any).as(:slashed_value) |
+          absent_slashed_values >> str("\\").as(:slashed_value)
+      end
+
+      rule(:number) do
+        (digits.as(:whole) >> op_decimal.as(:decimal) >> digits.as(:fractional)).as(:decimal_number) |
+          (op_decimal.as(:decimal) >> digits.as(:whole) >> space?).as(:decimal_number) |
+          digits.as(:digit)
+      end
+
+      rule(:numerator) do
+        (relational_symbols.absent? | exp_script.present?) >>  (
+          (unary_arg_functions >> numerator.as(:recursive_numerator).maybe) |
+          ((absent_numerator_exp_script? >> op_nary.absent?) >> mini_fraction_exp_script_absent? >> exp_script >> space) >> numerator.as(:recursive_numerator).maybe |
+          (absent_numerator_exp_script? >> mini_fraction_exp_script_absent? >> exp_script) >> numerator.as(:recursive_numerator).maybe |
+          (accents.as(:base) >> accents_subsup).as(:accents_subsup) |
+          sub_paren |
+          sup_paren |
+          accents |
+          unary_arg_functions |
+          (frac_binary_absent >> numerator.as(:recursive_numerator)) |
+          (factor >> frac_binary_absent.maybe >> numerator.as(:recursive_numerator).maybe) |
+          operator.absent? >> operand >> frac_binary_absent.maybe |
+          frac_binary_absent
+        )
+      end
+
+      rule(:op_build_up) do
+        str("_") |
+          str("^") |
+          str("∛") |
+          str("∜") |
+          str("□") |
+          str("|") |
+          op_array |
+          op_open |
+          op_close |
+          op_nary |
+          op_over |
+          forward_slash |
+          op_h_brackets |
+          root_symbols |
+          op_decimal
+      end
+
+      rule(:exp_bracket) do
+        (str("||").as(:open_paren) >> space? >> spaced_exp_bracket >> space? >> str("||").as(:close_paren)) |
+          (str("|").as(:open_paren) >> space? >> spaced_exp_bracket >> space? >> str("|").as(:close_paren)) |
+          (op_opener >> space? >> spaced_exp_bracket.maybe >> space? >> op_closer) |
+          (mix_bracketed.as(:intermediate_exp) >> space? >> expression.as(:expr)) |
+          (mix_bracketed.as(:intermediate_exp) >> space)
+      end
+
+      rule(:mix_bracketed) do
+        (op_opener >> space? >> spaced_exp_bracket >> space? >> str("|").as(:close_paren)) |
+          (str("|").as(:open_paren) >> space? >> spaced_exp_bracket >> space? >> op_closer)
+      end
+
+      rule(:denominator) do
+        operator.absent? >> fraction.as(:frac) |
+          exp_script |
+          sub_paren |
+          sup_paren |
+          frac_binary_absent >> invisible_times.maybe >> relational_symbols.absent? >> denominator.as(:recursive_denominator) |
+          operator.absent? >> factor >> invisible_times.maybe >> relational_symbols.absent? >> denominator.as(:recursive_denominator) |
+          operator.absent? >> operand >> invisible_times.maybe >> relational_symbols.absent? >> denominator.as(:recursive_denominator) |
+          frac_binary_absent |
+          operator.absent? >> operand
+      end
+
+      rule(:op_masked_close) do
+        (str("\\right") | str("\\close") | str("&#x2524;")).as(:paren_close_prefix) >> digits.as(:close_paren_mask).maybe
+      end
+
+      rule(:element) do
+        accents.present? >> (accents.as(:base) >> accents_subsup).as(:accents_subsup) |
+          accents.present? >> fraction.as(:frac) |
+          ((op_unary_functions | unary_arg_functions).present? >> fraction.as(:frac)) |
+          mini_sub_sup_present? >> operator >> mini_fraction.as(:frac) |
+          accents |
+          diacritics_accents |
+          op_unicode_fractions |
+          fraction.as(:frac) |
+          monospace_fonts |
+          array |
+          exp_script |
+          element_exp_script_validation? >> space? >> exp_script |
+          unary_arg_functions |
+          combined_symbols |
+          operand |
+          char |
+          alphanumeric |
+          negatable_symbols |
+          operator |
+          binary_symbols |
+          slashed_operator
+      end
+
+      rule(:expression) do
+        element >> other.as(:other) >> expression.as(:expr) |
+          element >> relational_symbols >> expression.as(:expr).maybe |
+          element |
+          element >> space? >> expression.as(:expr) |
+          slashed_operator >> space? >> expression.as(:expr).maybe |
+          element >> space? >> expression.as(:expr) >> space? >> expression.as(:expression).maybe |
+          mini_values >> space? >> expression.as(:expr).maybe
+      end
+
+      root :expression
+    end
+  end
+end

data/lib/plurimath/unicode_math/parser.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "parslet"
+require "parslet/convenience"
+require_relative "parse"
+require_relative "transform"
+require_relative "constants"
+module Plurimath
+  class UnicodeMath
+    class Parser
+      attr_accessor :text
+
+      LABELED_TR_REGEX = /"([^"]*(#|#|\\\\eqno)[^"]*[^"]*|[^"]*(#|#|\\\\eqno)[^"]*[^"]*)"/
+
+      def initialize(text)
+        text = pre_processing(text)
+        @text = HTMLEntities.new.encode(text, :hexadecimal)
+        @text.gsub!("&", "&")
+        @text.gsub!(""", "\"")
+        @text.gsub!(/⫷.*⫸/, "")
+        @text.gsub!(/\\\\/, "\\")
+        @text.gsub!(/\\u([\da-fA-F]{1,5})\w{0,5}/) { "&#x#{$1};" } # Converting \u#{xxxx} encoding to &#x#{xxxx};
+        @text.strip!
+      end
+
+      def parse
+        tree = Parse.new.parse(text)
+        tree = post_processing(tree) if @splitted
+        Math::Formula.new(
+          Array(
+            Transform.new.apply(tree),
+          ),
+        )
+      end
+
+      private
+
+      def post_processing(tree)
+        {
+          labeled_tr_value: tree,
+          labeled_tr_id: @splitted
+        }
+      end
+
+      def pre_processing(text)
+        text unless text.include?("#") && !text.match?(LABELED_TR_REGEX)
+
+        text.gsub!(/✎\(.*(\#).*\)/) do |str|
+          str.gsub!("#", "\"replacement\"")
+        end
+        splitted = text.split("#")
+        splitted.first.gsub!("\"replacement\"", "#")
+        @splitted = splitted.last if splitted.count > 1
+        splitted.first
+      end
+    end
+  end
+end

data/lib/plurimath/unicode_math/parsing_rules/absence_rules.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+module Plurimath
+  class UnicodeMath
+    module ParsingRules
+      module AbsenceRules
+        include Helper
+
+        rule(:frac_binary_absent) { frac_binary_absent_symbols? >> binary_symbols }
+
+        rule(:non_matrixs_absence?) { (str("eqarray") | str("█") | str("cases") | str("Ⓒ")).absent? }
+
+        rule(:sub_sup_binary_absent) { ((slash >> str("times")) | str("×")).absent? >> binary_symbols }
+
+        rule(:absent_negated_unicodes) { sqrt_symbols | root_symbols }
+
+        rule(:frac_binary_absent_symbols?) { ((slash >> (str("times") | str("neq") | str("ne"))) | (str("×") | str("&#x2260"))).absent? }
+
+        rule(:binary_negated_absent_symbols?) { ((slash >> str("dd")) | str("ⅆ")).absent? }
+
+        rule(:mini_fraction_exp_script_absent?) { (operator >> mini_fraction).absent? }
+
+        rule(:absent_chars) do
+          (
+            op_unary_arg_functions |
+            op_diacritic_overlays |
+            op_unicode_fractions |
+            op_diacritic_belows |
+            op_ordinary_symbols |
+            relational_symbols |
+            op_sub_close_paren |
+            op_sup_close_paren |
+            op_sub_open_paren |
+            op_sup_open_paren |
+            op_binary_symbols |
+            invisible_unicode |
+            op_unary_symbols |
+            op_sub_operators |
+            op_sup_operators |
+            op_close_unicode |
+            str("┴") |
+            str("┬") |
+            str("┤") |
+            str("├") |
+            str("✎") |
+            str("⁢") |
+            str("⁄") |
+            str("⁡") |
+            str("☁") |
+            str("▒") |
+            str("⒞") |
+            str("⊘") |
+            op_open_unicode |
+            op_nary_symbols |
+            str("√") |
+            str("∛") |
+            str("∜") |
+            str("⒭") |
+            str("▭") |
+            str("ￗ") |
+            str("ⓐ") |
+            str("ⓘ") |
+            str("∣") |
+            str("∕") |
+            str(" ") |
+            str("'") |
+            str("/") |
+            str("¬") |
+            str("¦") |
+            op_sup_digits |
+            op_sub_digits |
+            op_sup_alpha |
+            op_sub_alpha |
+            op_h_bracket |
+            skip_symbols |
+            op_matrixs |
+            op_accent |
+            primes
+          ).absent?
+        end
+
+        rule(:absent_slashed_values) do
+          (
+            op_prefixed_unary_arg_functions |
+            op_prefixed_ordinary_symbols |
+            op_binary_symbols_prefixed |
+            op_prefixed_unary_symbols |
+            slash >> str("backcolor") |
+            slash >> str("naryand") |
+            slash >> str("sdivide") |
+            slash >> str("oslash") |
+            slash >> str("color") |
+            op_relational_symbols |
+            op_h_bracket_prefixed |
+            op_alphanumeric_fonts |
+            skip_symbols_prefixed |
+            slash >> str("sfrac") |
+            slash >> str("rect") |
+            slash >> str("sqrt") |
+            slash >> str("qdrt") |
+            slash >> str("cbrt") |
+            slash >> str("root") |
+            slash >> str("sdiv") |
+            slash >> str("ndiv") |
+            slash >> str("ldiv") |
+            op_prefixed_matrixs |
+            op_binary_symbols_prefixed |
+            op_prefixed_negated |
+            slash >> str("mid") |
+            op_accent_prefixed |
+            prefixed_primes |
+            op_nary_text |
+            str("\\of") |
+            op_close |
+            op_fonts |
+            op_open
+          ).absent?
+        end
+
+        rule(:other_absent) do
+          (
+            an.as(:other_exp) |
+            op_build_up |
+            match('\r') |
+            n_ascii |
+            char
+          ).absent?
+        end
+
+        rule(:absent_numerator_exp_script?) do
+          (power_base_script.as(:nary_sub_sup) >> invisible_space? >> naryand_recursion.as(:naryand)).absent? |
+            (op_nary >> invisible_space? >> naryand_recursion.as(:naryand).maybe).absent?
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/unicode_math/parsing_rules/common_rules.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+module Plurimath
+  class UnicodeMath
+    module ParsingRules
+      module CommonRules
+        include Helper
+
+        rule(:atom)   { (diacritics >> diacriticbase.maybe) | an }
+        rule(:atoms)  { (atom.as(:atom) >> atoms.as(:atoms).maybe) }
+        rule(:entity) { atoms | number }
+
+        rule(:operator) { match["-+*=.?:,`"].as(:operator) }
+        rule(:op_unary) { op_prefixed_unary_arg_functions | op_unary_arg_functions | op_prefixed_unary_symbols | op_unary_symbols }
+
+        rule(:mid_symbols) { (slash >> str("mid").as(:mid_symbol)) | str("∣").as(:mid_symbol) }
+
+        rule(:unary_spaces) { space | invisible_unicode }
+        rule(:custom_fonts) { str("double") | str("fraktur") | str("script") }
+        rule(:parsing_text) { str("\"") >> match("[^\"]").repeat(1).as(:text) >> str("\"") }
+        rule(:alphanumeric) { match("[\u{0041}-\u{005A}\u{0061}-\u{007A}\u{0391}-\u{2207}\u{3B1}-\u{3DD}\u{30}-\u{39}]") }
+
+        rule(:op_h_brackets)  { op_h_bracket | op_h_bracket_prefixed }
+        rule(:nary_functions) { (op_unary >> unary_spaces.maybe) | (op_unary_functions >> unary_spaces) }
+        rule(:exclamation_symbols) { (str("!") | str("!!")).as(:exclamation_symbol) }
+        rule(:exclamation_symbols?) { exclamation_symbols.maybe }
+
+        rule(:mini_fraction) do
+          sup_paren.as(:mini_numerator) >> (negatable_symbols.absent? >> op_over) >> sub_paren.as(:mini_denominator)
+        end
+
+        rule(:fraction) do
+          mini_fraction |
+            numerator.as(:numerator) >> space? >> (negatable_symbols.absent? >> op_over) >> space? >> denominator.as(:denominator)
+        end
+
+        rule(:fonts) do
+          str("\\") >> custom_fonts.as(:unicoded_font_class) >> str("H").as(:symbol) |
+            str("\\") >> str("mitBbb").as(:unicoded_font_class) >> match(/D|d|e|i|j/).as(:symbol)|
+            op_fonts >> match["A-Za-z"].as(:symbol) |
+            op_alphanumeric_fonts >> (match["A-Za-z"].as(:symbol) | match("[0-9]").as(:number))
+        end
+
+        rule(:unary_arg_functions) do
+          (op_unary_functions >> space? >> (soperand | exp_bracket).as(:first_value).maybe) |
+            (nary_functions >> space? >> (exp_bracket | soperand).as(:first_value)).as(:unary_function)
+        end
+
+        rule(:accents)  do
+          (exp_bracket.as(:intermediate_exp).as(:first_value) >> str(" ").maybe >> repeated_accent_symbols).as(:accents) |
+            (str(" ").absent? >> factor.as(:first_value) >> str(" ").maybe >> repeated_accent_symbols).as(:accents)
+        end
+
+        rule(:diacritics_accents) do
+          (operand.as(:first_value) >> op_diacritic_overlays.as(:overlay_after)).as(:diacritics_accents) |
+            (operand.as(:first_value) >> op_diacritic_belows.as(:below_after)).as(:diacritics_accents) |
+            (op_diacritic_belows.as(:below_before) >> operand.as(:first_value)).as(:diacritics_accents) |
+            (op_diacritic_overlays.as(:overlay_before) >> operand.as(:first_value)).as(:diacritics_accents)
+        end
+
+        rule(:repeated_accent_symbols) do
+          (op_accent | op_accent_prefixed).repeat(1) >> prime_symbols.maybe |
+            prime_symbols
+        end
+
+        rule(:prime_symbols) do
+          ((slash >> prefixed_primes.as(:prefixed_prime) | primes).repeat(1).as(:prime_accent_symbols))
+        end
+
+        rule(:operand) do
+          rect |
+            phant |
+            accents |
+            negatable_symbols |
+            fonts.as(:fonts) |
+            ((parsing_text | factor.as(:factor)) >> operand.as(:operand).maybe)
+        end
+
+        rule(:factor) do
+          combined_symbols |
+            ((str("−").absent? >> op_unary_functions.absent?) >> entity >> exclamation_symbols?) |
+            color |
+            (exp_bracket.as(:intermediate_exp) >> exclamation_symbols?) |
+            function |
+            backcolor |
+            op_spaces |
+            monospace_fonts |
+            relational_symbols |
+            unary_arg_functions |
+            op_unary_functions >> unary_spaces >> (operand | exp_bracket).absent? |
+            ordinary_symbols |
+            negatable_symbols |
+            str("...").as(:ldots).as(:symbol) |
+            exclamation_symbols
+        end
+
+        rule(:soperand) do
+          operand |
+            str("∞").as(:infty) |
+            str("-∞").as(:symbol) |
+            str("−").as(:symbol) |
+            str("-").as(:symbol) |
+            operator
+        end
+
+        rule(:bracketed_soperand) do
+          (op_opener.as(:opener) >> space? >> soperand.as(:operand) >> space? >> op_closer.as(:closer)).as(:int_exp) |
+            soperand.as(:operand)
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/unicode_math/parsing_rules/constants_rules.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+module Plurimath
+  class UnicodeMath
+    module ParsingRules
+      module ConstantsRules
+        include Helper
+
+        rule(:slash) { str("\\") }
+        rule(:slash?) { slash.maybe }
+        rule(:primes) { str("⁗") | str("‴") | str("″") | str("′") | str("'") | str("'") }
+
+        rule(:op_open) { slash >> arr_to_expression(Constants::OPEN_SYMBOLS.keys, :open_paren) }
+
+        rule(:op_fonts) { slash >> arr_to_expression(Constants::FONTS_CLASSES, :font_class) }
+        rule(:op_close) { slash >> arr_to_expression(Constants::CLOSE_SYMBOLS.keys, :close_paren) }
+
+        rule(:op_accent) { arr_to_expression(Constants::ACCENT_SYMBOLS.values, :accent_symbols) }
+        rule(:op_spaces) { skip_symbols | skip_symbols_prefixed }
+
+        rule(:op_matrixs) { arr_to_expression(Constants::MATRIXS.values, :matrixs) }
+        rule(:op_negated) { arr_to_expression(Constants::NEGATABLE_SYMBOLS, :negated_operator) }
+
+        rule(:op_nary_text) { slash >> arr_to_expression(Constants::NARY_SYMBOLS.keys, :nary_class) }
+        rule(:op_sub_alpha) { arr_to_expression(Constants::SUB_ALPHABETS.values, :sub_alpha) }
+        rule(:op_sup_alpha) { arr_to_expression(Constants::SUP_ALPHABETS.values, :sup_alpha) }
+        rule(:op_h_bracket) { arr_to_expression(Constants::HORIZONTAL_BRACKETS.values, :hbracket_class) }
+        rule(:skip_symbols) { arr_to_expression(Constants::SKIP_SYMBOLS.values, :spaces) }
+
+        rule(:op_open_paren) { arr_to_expression(Constants::OPEN_PARENTHESIS, :open_paren) }
+        rule(:op_sup_digits) { arr_to_expression(Constants::SUP_DIGITS.values, :sup_digits) }
+        rule(:op_sub_digits) { arr_to_expression(Constants::SUB_DIGITS.values, :sub_digits) }
+
+        rule(:binary_symbols) { op_binary_symbols | op_binary_symbols_prefixed }
+        rule(:binary_negated) { binary_negated_absent_symbols? >> (op_binary_negated | op_prefixed_binary_negated) }
+        rule(:op_close_paren) { arr_to_expression(Constants::CLOSE_PARENTHESIS, :close_paren) }
+
+        rule(:op_nary_symbols) { arr_to_expression(Constants::NARY_SYMBOLS.values, :nary_class) }
+        rule(:op_open_unicode) { arr_to_expression(Constants::OPEN_SYMBOLS.values, :open_paren) }
+        rule(:prefixed_primes) { str("pppprime") | str("ppprime") | str("pprime") | str("prime") }
+
+        rule(:combined_symbols) { op_combined_symbols | op_combined_unicode }
+        rule(:op_close_unicode) { arr_to_expression(Constants::CLOSE_SYMBOLS.values, :close_paren) }
+        rule(:op_unary_symbols) { arr_to_expression(Constants::UNARY_SYMBOLS.values, :unary_symbols) }
+        rule(:op_sub_operators) { arr_to_expression(Constants::SUB_OPERATORS.values, :sub_operators) }
+        rule(:op_sup_operators) { arr_to_expression(Constants::SUP_OPERATORS.values, :sup_operators) }
+
+        rule(:op_binary_symbols) { arr_to_expression(Constants::BINARY_SYMBOLS.values, :binary_symbols) }
+        rule(:op_binary_negated) { arr_to_expression(Constants::BINARY_SYMBOLS.values, :binary_negated_operator) }
+        rule(:op_sub_open_paren) { arr_to_expression(Constants::SUB_PARENTHESIS[:open].values, :sub_open_paren) }
+        rule(:op_sup_open_paren) { arr_to_expression(Constants::SUP_PARENTHESIS[:open].values, :sup_open_paren) }
+
+        rule(:op_accent_prefixed) { slash >> arr_to_expression(Constants::ACCENT_SYMBOLS.keys, :accent_symbols) }
+        rule(:op_unary_functions) { arr_to_expression(Constants::UNARY_FUNCTIONS, :unary_functions) }
+        rule(:op_sub_close_paren) { arr_to_expression(Constants::SUB_PARENTHESIS[:close].values, :sub_close_paren) }
+        rule(:op_sup_close_paren) { arr_to_expression(Constants::SUP_PARENTHESIS[:close].values, :sup_close_paren) }
+
+        rule(:op_prefixed_matrixs) { slash >> arr_to_expression(Constants::MATRIXS.keys, :matrixs) }
+        rule(:op_diacritic_belows) { arr_to_expression(Constants::DIACRITIC_BELOWS, :diacritic_belows) }
+        rule(:op_combined_symbols) { arr_to_expression(Constants::COMBINING_SYMBOLS.keys, :combined_symbols) }
+        rule(:op_ordinary_symbols) { arr_to_expression(Constants::ORDINARY_SYMBOLS.values, :ordinary_symbols) }
+        rule(:op_combined_unicode) { arr_to_expression(Constants::COMBINING_SYMBOLS.values, :combined_symbols) }
+        rule(:op_ordinary_negated) { arr_to_expression(Constants::ORDINARY_SYMBOLS.values, :ordinary_negated_operator) }
+        rule(:op_prefixed_negated) { slash >> arr_to_expression(Constants::PREFIXED_NEGATABLE_SYMBOLS, :negated_operator) }
+
+        rule(:op_unicode_fractions)  { arr_to_expression(Constants::UNICODE_FRACTIONS.keys, :unicode_fractions) }
+        rule(:skip_symbols_prefixed) { slash >> arr_to_expression(Constants::SKIP_SYMBOLS.keys, :spaces) }
+        rule(:op_alphanumeric_fonts) { slash >> arr_to_expression(Constants::ALPHANUMERIC_FONTS_CLASSES, :font_class) }
+        rule(:op_h_bracket_prefixed) { slash >> arr_to_expression(Constants::HORIZONTAL_BRACKETS.keys, :hbracket_class) }
+        rule(:op_relational_symbols) { slash >> arr_to_expression(Constants::RELATIONAL_SYMBOLS.keys, :relational_symbols) }
+        rule(:op_diacritic_overlays) { arr_to_expression(Constants::DIACRITIC_OVERLAYS, :diacritic_overlays) }
+        rule(:op_relational_unicode) { arr_to_expression(Constants::RELATIONAL_SYMBOLS.values, :relational_symbols) }
+
+        rule(:op_unary_arg_functions) { arr_to_expression(Constants::UNARY_ARG_FUNCTIONS.values, :unary_arg_functions) }
+
+        rule(:op_prefixed_unary_symbols) { slash >> arr_to_expression(Constants::UNARY_SYMBOLS.keys, :unary_symbols) }
+        rule(:op_size_overrides_symbols) { str("Ⅎ") >> arr_to_expression(Constants::SIZE_OVERRIDES_SYMBOLS.keys, :size_overrides) }
+
+        rule(:op_binary_symbols_prefixed) { slash >> arr_to_expression(Constants::BINARY_SYMBOLS.keys, :binary_symbols) }
+        rule(:op_prefixed_binary_negated) { slash >> arr_to_expression(Constants::BINARY_SYMBOLS.keys, :binary_negated_operator) }
+
+        rule(:op_prefixed_ordinary_symbols) { slash >> arr_to_expression(Constants::ORDINARY_SYMBOLS.keys, :ordinary_symbols) }
+        rule(:op_prefixed_ordinary_negated) { slash >> arr_to_expression(Constants::ORDINARY_SYMBOLS.keys, :ordinary_negated_operator) }
+
+        rule(:op_prefixed_unary_arg_functions) { slash >> arr_to_expression(Constants::UNARY_ARG_FUNCTIONS.keys, :unary_arg_functions) }
+
+        def arr_to_expression(arr, name = nil)
+          type = arr.first.class
+          if arr.length > 1
+            arr.reduce do |expression, expr_string|
+              expression = str(expression).as(name) if expression.is_a?(type)
+              expression | str(expr_string).as(name)
+            end
+          else
+            str(arr.first).as(name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/unicode_math/parsing_rules/helper.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Plurimath
+  class UnicodeMath
+    module ParsingRules
+      module Helper
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+      end
+
+      module ClassMethods
+        def rule(name, &block)
+          Parslet::Parser.rule(name, &block)
+        end
+      end
+    end
+  end
+end