plurimath 0.11.0 → 0.11.1

data/lib/plurimath/unicode_math/parse.rb

@@ -12,8 +12,10 @@ module Plurimath
       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(:char) { absent_chars >> unicode.as(:unicode_symbols) }
+      rule(:rows) do
+        (str("@").as(:tr) >> space? >> rows.as(:trs).maybe) | (row.as(:tr) >> space? >> str("@") >> space? >> rows.as(:trs).maybe) | row.as(:tr)
+      end
 
       rule(:space) { match(/\s/).repeat(1) | invisible_times }
       rule(:other) { other_absent >> alphanumeric.as(:symbol) }
@@ -25,43 +27,81 @@ module Plurimath
       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(:an_math) do
+        space.absent? >> match("[\u{1D400}-\u{1D7FF}\u{2102}-\u{2134}]")
+      end
 
-      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("") | str("\\array") }
+      rule(:td_value) do
+        expression.as(:exp) >> space? >> td_value.as(:expr).maybe
+      end
+      rule(:an_other) do
+        (an_math | n_ascii).absent? >> alphanumeric.as(:alphanumeric)
+      end
+      rule(:function) do
+        root_functions | box | hbrack | arg_function | intent_function
+      end
+      rule(:op_array) do
+        op_matrixs | op_prefixed_matrixs | str("&") | str("") | str("\\array")
+      end
 
-      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_opener) do
+        open_paren | op_open_unicode | op_open_paren | op_open
+      end
+      rule(:op_closer) do
+        op_close_unicode | close_paren | op_close_paren | op_close
+      end
 
       rule(:op_decimal) { decimal_marker | 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(:diacritics) do
+        (char.as(:char) >> diacritics.as(:diacritics)) | char.as(:char)
+      end
+      rule(:open_paren) do
+        (op_masked_open >> (op_closer | op_opener)).as(:open_paren) | op_masked_open
+      end
 
-      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(:matrix_only) do
+        non_matrixs_absence? >> (op_matrixs | op_prefixed_matrixs)
+      end
+      rule(:close_paren) do
+        (op_masked_close >> (op_opener | op_closer)).as(:close_paren) | op_masked_close
+      end
 
       rule(:diacriticbase) { an | n_ascii }
       rule(:forward_slash) { str("/") | str("/") | str("⁄") }
 
       rule(:root_functions) { qdrt | cbrt | sqrt | binary_root | nthrt }
       rule(:op_over_choose) { (str("\\choose") | str("⒞")).as(:choose) }
-      rule(:op_masked_open) { (str("\\left") | str("\\open") | str("├")).as(:paren_open_prefix) >> digits.as(:open_paren_mask).maybe }
+      rule(:op_masked_open) do
+        (str("\\left") | str("\\open") | str("├")).as(:paren_open_prefix) >> digits.as(:open_paren_mask).maybe
+      end
 
-      rule(:invisible_times) { (str("⁢") | str("⁡") | str(" ") | str("\\itimes") >> space?) }
+      rule(:invisible_times) do
+        str("⁢") | str("⁡") | str(" ") | (str("\\itimes") >> space?)
+      end
 
-      rule(:ordinary_symbols) { op_ordinary_symbols | op_prefixed_ordinary_symbols }
+      rule(:ordinary_symbols) do
+        op_ordinary_symbols | op_prefixed_ordinary_symbols
+      end
       rule(:interval_a_ascii) { match["A-Za-z"].as(:symbol).repeat(1) }
 
-      rule(:negatable_symbols) { forward_slash >> negated | negated >> str("̸") }
-      rule(:invisible_unicode) { str("▒") | (str("\\naryand") | str("\\of") >> space?) }
+      rule(:negatable_symbols) do
+        (forward_slash >> negated) | (negated >> str("̸"))
+      end
+      rule(:invisible_unicode) do
+        str("▒") | (str("\\naryand") | (str("\\of") >> space?))
+      end
 
       rule(:invisible_unicode?) { invisible_unicode.maybe }
-      rule(:relational_symbols) { op_relational_unicode | op_relational_symbols }
+      rule(:relational_symbols) do
+        op_relational_unicode | op_relational_symbols
+      end
 
-      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_power_base_check) do
+        (sub_sup_operand >> (power_symbol | base_symbol)).present?
+      end
+      rule(:spaced_bracketed_operand) do
+        operand >> space? >> spaced_bracketed_operand.as(:expr).maybe
+      end
 
       rule(:hbrack) do
         (op_h_brackets >> str("(").present? >> exp_bracket.as(:first_value)) |
@@ -76,15 +116,15 @@ module Plurimath
           op_prefixed_ordinary_negated |
           op_ordinary_negated |
           binary_negated |
-          absent_negated_unicodes >> unicode.as(:negated_operator)
+          (absent_negated_unicodes >> unicode.as(:negated_operator))
         )
       end
 
       rule(:op_over) do
         str("⁄").as(:bevelled) |
-          slash >> (str("sdiv") | str("sdivide") | str("sfrac")).as(:bevelled) |
+          (slash >> (str("sdiv") | str("sdivide") | str("sfrac")).as(:bevelled)) |
           str("⊘").as(:no_display_style) |
-          slash >> (str("ndiv") | str("oslash")).as(:no_display_style) |
+          (slash >> (str("ndiv") | str("oslash")).as(:no_display_style)) |
           (str("∕") | str("\\ldiv")).as(:ldiv) |
           forward_slash |
           str("\\over") |
@@ -95,14 +135,14 @@ module Plurimath
       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?)
+        ((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("−").as(:symbol) >> space? >> spaced_exp_bracket.as(:expr) |
-          expression >> space?
+        (expression >> space? >> spaced_exp_bracket.as(:exp)) |
+          (mid_symbols >> space? >> spaced_exp_bracket.as(:expr)) |
+          (str("−").as(:symbol) >> space? >> spaced_exp_bracket.as(:expr)) |
+          (expression >> space?)
       end
 
       rule(:row) do
@@ -117,8 +157,8 @@ module Plurimath
       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)
+        (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
@@ -128,10 +168,10 @@ module Plurimath
       end
 
       rule(:numerator) do
-        (relational_symbols.absent? | exp_script.present?) >>  (
+        (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 |
+          (((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 |
@@ -139,7 +179,7 @@ module Plurimath
           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 |
+          (operator.absent? >> operand >> frac_binary_absent.maybe) |
           frac_binary_absent
         )
       end
@@ -172,9 +212,9 @@ module Plurimath
       end
 
       rule(:interval_exp_bracket) do
-        str("(").as(:open_paren) >> interval_value.as(:left_value) >> str(",").as(:comma) >> interval_value.as(:right_value) >> str("]").as(:close_paren) |
-        str("[").as(:open_paren) >> interval_value.as(:left_value) >> str(",").as(:comma) >> interval_value.as(:right_value) >> str(")").as(:close_paren) |
-        (str("[") | str("]")).as(:open_paren) >> interval_value.as(:left_value) >> str(",").as(:comma) >> interval_value.as(:right_value) >> (str("[") | str("]")).as(:close_paren)
+        (str("(").as(:open_paren) >> interval_value.as(:left_value) >> str(",").as(:comma) >> interval_value.as(:right_value) >> str("]").as(:close_paren)) |
+          (str("[").as(:open_paren) >> interval_value.as(:left_value) >> str(",").as(:comma) >> interval_value.as(:right_value) >> str(")").as(:close_paren)) |
+          ((str("[") | str("]")).as(:open_paren) >> interval_value.as(:left_value) >> str(",").as(:comma) >> interval_value.as(:right_value) >> (str("[") | str("]")).as(:close_paren))
       end
 
       rule(:interval_value) do
@@ -191,15 +231,15 @@ module Plurimath
       end
 
       rule(:denominator) do
-        operator.absent? >> fraction.as(:frac) |
+        (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 >> 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
+          (operator.absent? >> operand)
       end
 
       rule(:op_masked_close) do
@@ -207,10 +247,10 @@ module Plurimath
       end
 
       rule(:element) do
-        accents.present? >> (accents.as(:base) >> accents_subsup).as(:accents_subsup) |
-          accents.present? >> fraction.as(:frac) |
+        (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) |
+          (mini_sub_sup_present? >> operator >> mini_fraction.as(:frac)) |
           accents |
           diacritics_accents |
           op_unicode_fractions |
@@ -218,7 +258,7 @@ module Plurimath
           monospace_fonts |
           array |
           exp_script |
-          element_exp_script_validation? >> space? >> exp_script |
+          (element_exp_script_validation? >> space? >> exp_script) |
           unary_arg_functions |
           combined_symbols |
           wrapper_symbols |
@@ -232,13 +272,13 @@ module Plurimath
       end
 
       rule(:expression) do
-        element >> other.as(:other) >> expression.as(:expr) |
-          element >> relational_symbols >> expression.as(:expr).maybe |
+        (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
+          (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

data/lib/plurimath/unicode_math/parser.rb

@@ -13,8 +13,11 @@ module Plurimath
         @text = @text.gsub("&", "&")
         @text = @text.gsub(""", "\"")
         @text = @text.gsub(/⫷.*⫸/, "")
-        @text = @text.gsub(/\\\\/, "\\")
-        @text = @text.gsub(/\\u([\da-fA-F]{1,5})\w{0,5}/) { "&#x#{$1};" } # Converting \u#{xxxx} encoding to &#x#{xxxx};
+        @text = @text.gsub("\\\\", "\\")
+        @text = # Converting \u#{xxxx} encoding to &#x#{xxxx};
+          @text.gsub(/\\u([\da-fA-F]{1,5})\w{0,5}/) do
+            "&#x#{$1};"
+          end
         @text = @text.strip
       end
 
@@ -33,7 +36,7 @@ module Plurimath
       def post_processing(tree)
         {
           labeled_tr_value: tree,
-          labeled_tr_id: @splitted
+          labeled_tr_id: @splitted,
         }
       end
 
@@ -41,7 +44,7 @@ module Plurimath
         text unless text.include?("#") && !text.match?(LABELED_TR_REGEX)
 
         text = text.gsub(/✎\(.*(\#).*\)/) do |str|
-          str = str.gsub("#", "\"replacement\"")
+          str.gsub("#", "\"replacement\"")
         end
         splitted = text.split("#")
         splitted[0] = splitted.first.gsub("\"replacement\"", "#")

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

@@ -6,19 +6,31 @@ module Plurimath
       module AbsenceRules
         include Helper
 
-        rule(:frac_binary_absent) { frac_binary_absent_symbols? >> binary_symbols }
+        rule(:frac_binary_absent) do
+          frac_binary_absent_symbols? >> binary_symbols
+        end
 
-        rule(:non_matrixs_absence?) { (str("eqarray") | str("█") | str("cases") | str("Ⓒ")).absent? }
+        rule(:non_matrixs_absence?) do
+          (str("eqarray") | str("█") | str("cases") | str("Ⓒ")).absent?
+        end
 
-        rule(:sub_sup_binary_absent) { ((slash >> str("times")) | str("×")).absent? >> binary_symbols }
+        rule(:sub_sup_binary_absent) do
+          ((slash >> str("times")) | str("×")).absent? >> binary_symbols
+        end
 
         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(:frac_binary_absent_symbols?) do
+          ((slash >> (str("times") | str("neq") | str("ne"))) | (str("×") | str("&#x2260"))).absent?
+        end
 
-        rule(:binary_negated_absent_symbols?) { ((slash >> str("dd")) | str("ⅆ")).absent? }
+        rule(:binary_negated_absent_symbols?) do
+          ((slash >> str("dd")) | str("ⅆ")).absent?
+        end
 
-        rule(:mini_fraction_exp_script_absent?) { (operator >> mini_fraction).absent? }
+        rule(:mini_fraction_exp_script_absent?) do
+          (operator >> mini_fraction).absent?
+        end
 
         rule(:absent_chars) do
           (
@@ -86,28 +98,28 @@ module Plurimath
             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") |
+            (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") |
+            (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") |
+            (slash >> str("mid")) |
             op_accent_prefixed |
             prefixed_primes |
             op_nary_text |

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

@@ -7,22 +7,34 @@ module Plurimath
         include Helper
 
         rule(:atom)   { (diacritics >> diacriticbase.maybe) | an }
-        rule(:atoms)  { (atom.as(:atom) >> atoms.as(:atoms).maybe) }
+        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(:op_unary) do
+          op_prefixed_unary_arg_functions | op_unary_arg_functions | op_prefixed_unary_symbols | op_unary_symbols
+        end
 
-        rule(:mid_symbols) { (slash >> str("mid").as(:mid_symbol)) | str("∣").as(:mid_symbol) }
+        rule(:mid_symbols) do
+          (slash >> str("mid").as(:mid_symbol)) | str("∣").as(:mid_symbol)
+        end
 
         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(:parsing_text) do
+          str("\"") >> match("[^\"]").repeat(1).as(:text) >> str("\"")
+        end
+        rule(:alphanumeric) do
+          match("[\u{0041}-\u{005A}\u{0061}-\u{007A}\u{0391}-\u{2207}\u{3B1}-\u{3DD}\u{30}-\u{39}]")
+        end
 
         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(:nary_functions) do
+          (op_unary >> unary_spaces.maybe) | (op_unary_functions >> unary_spaces)
+        end
+        rule(:exclamation_symbols) do
+          (str("!") | str("!!")).as(:exclamation_symbol)
+        end
         rule(:exclamation_symbols?) { exclamation_symbols.maybe }
 
         rule(:mini_fraction) do
@@ -36,15 +48,15 @@ module Plurimath
         rule(:fraction) do
           mini_fraction |
             binomial_fraction |
-            numerator.as(:numerator) >> space? >> (negatable_symbols.absent? >> op_over) >> space? >> denominator.as(:denominator)
+            (numerator.as(:numerator) >> space? >> (negatable_symbols.absent? >> op_over) >> space? >> denominator.as(:denominator))
         end
 
         rule(:fonts) do
           unicoded_fonts |
-            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))
+            (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
@@ -52,7 +64,7 @@ module Plurimath
             (nary_functions >> space? >> (exp_bracket | soperand).as(:first_value)).as(:unary_function)
         end
 
-        rule(:accents)  do
+        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
@@ -65,12 +77,12 @@ module Plurimath
         end
 
         rule(:repeated_accent_symbols) do
-          (op_accent | op_accent_prefixed).repeat(1) >> prime_symbols.maybe |
+          ((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))
+          ((slash >> prefixed_primes.as(:prefixed_prime)) | primes).repeat(1).as(:prime_accent_symbols)
         end
 
         rule(:operand) do
@@ -94,7 +106,7 @@ module Plurimath
             monospace_fonts |
             relational_symbols |
             unary_arg_functions |
-            op_unary_functions >> unary_spaces >> (operand | exp_bracket).absent? |
+            (op_unary_functions >> unary_spaces >> (operand | exp_bracket).absent?) |
             wrapper_symbols |
             ordinary_symbols |
             negatable_symbols |

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

@@ -8,7 +8,9 @@ module Plurimath
 
         rule(:slash)  { str("\\") }
         rule(:slash?) { slash.maybe }
-        rule(:primes) { str("⁗") | str("‴") | str("″") | str("′") | str("'") | str("'") }
+        rule(:primes) do
+          str("⁗") | str("‴") | str("″") | str("′") | str("'") | str("'")
+        end
 
         rule(:op_open) { slash >> arr_to_expression(Constants::OPEN_SYMBOLS.keys, :open_paren) }
 
@@ -33,13 +35,19 @@ module Plurimath
 
         rule(:binary_symbols) { op_binary_symbols | op_binary_symbols_prefixed }
         rule(:op_close_paren) { arr_to_expression(Constants::CLOSE_PARENTHESIS, :close_paren) }
-        rule(:binary_negated) { binary_negated_absent_symbols? >> (op_binary_negated | op_prefixed_binary_negated) }
+        rule(:binary_negated) do
+          binary_negated_absent_symbols? >> (op_binary_negated | op_prefixed_binary_negated)
+        end
         rule(:unicoded_fonts) { unicoded_fonts_to_expression(Constants::UNICODED_FONTS, :symbol) }
 
-        rule(:wrapper_symbols) { arr_to_expression(Constants.wrapper_symbols, :symbol) }
+        rule(:wrapper_symbols) do
+          arr_to_expression(Constants.wrapper_symbols, :symbol)
+        end
         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(:prefixed_primes) do
+          str("pppprime") | str("ppprime") | str("pprime") | str("prime")
+        end
 
         rule(:combined_symbols) { op_combined_symbols | op_combined_unicode }
         rule(:op_close_unicode) { arr_to_expression(Constants::CLOSE_SYMBOLS.values, :close_paren) }
@@ -76,7 +84,10 @@ module Plurimath
         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_size_overrides_symbols) do
+          str("Ⅎ") >> arr_to_expression(Constants::SIZE_OVERRIDES_SYMBOLS.keys,
+                                               :size_overrides)
+        end
 
         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) }
@@ -98,7 +109,7 @@ module Plurimath
           end
         end
 
-        def unicoded_fonts_to_expression(hash, name = nil)
+        def unicoded_fonts_to_expression(hash, _name = nil)
           type = hash.first.class
           hash.reduce do |expression, expr_hash|
             if expression.is_a?(type)
@@ -113,7 +124,7 @@ module Plurimath
             type = expr_hash.first.class
             expr_hash.reduce do |expression, (_, hex_code)|
               expression = str(name).absent?.as(name).as(:unicoded_font_class) >> str(expression.last).as(:symbol) if expression.is_a?(type)
-              expression | str(name).absent?.as(name).as(:unicoded_font_class) >> str(hex_code).as(:symbol)
+              expression | (str(name).absent?.as(name).as(:unicoded_font_class) >> str(hex_code).as(:symbol))
             end
           else
             str(expr_hash.values.last)

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

@@ -7,33 +7,53 @@ module Plurimath
         include Helper
 
         rule(:rect) { rect_symbols >> space? >> bracketed_masked_value(:rect) }
-        rule(:sqrt) { (sqrt_symbols.as(:root_symbol) >> (exp_script | operand).as(:first_value)).as(:root) }
-        rule(:qdrt) { (qdrt_symbols.as(:root_symbol) >> (exp_script | operand).as(:first_value)).as(:root) }
-        rule(:cbrt) { (cbrt_symbols.as(:root_symbol) >> (exp_script | operand).as(:first_value)).as(:root) }
+        rule(:sqrt) do
+          (sqrt_symbols.as(:root_symbol) >> (exp_script | operand).as(:first_value)).as(:root)
+        end
+        rule(:qdrt) do
+          (qdrt_symbols.as(:root_symbol) >> (exp_script | operand).as(:first_value)).as(:root)
+        end
+        rule(:cbrt) do
+          (cbrt_symbols.as(:root_symbol) >> (exp_script | operand).as(:first_value)).as(:root)
+        end
 
-        rule(:color) { color_symbols >> space? >>  bracketed_masked_value(:color) }
-        rule(:phant) { phantom_symbols >> space? >> bracketed_masked_value(:phantom) }
+        rule(:color) do
+          color_symbols >> space? >> bracketed_masked_value(:color)
+        end
+        rule(:phant) do
+          phantom_symbols >> space? >> bracketed_masked_value(:phantom)
+        end
 
-        rule(:backcolor)   { backcolor_symbols >> space? >> bracketed_masked_value(:backcolor) }
+        rule(:backcolor) do
+          backcolor_symbols >> space? >> bracketed_masked_value(:backcolor)
+        end
 
         rule(:cbrt_symbols) { str("∛") | str("\\cbrt") }
         rule(:qdrt_symbols) { str("∜") | str("\\cbrt") }
         rule(:rect_symbols) { str("▭") | str("\\rect") }
         rule(:sqrt_symbols) { str("√") | str("\\sqrt") | str("\\surd") }
-        rule(:root_symbols) { str("⒭") | str("√") | str("\\root") | str("\\surd") }
+        rule(:root_symbols) do
+          str("⒭") | str("√") | str("\\root") | str("\\surd")
+        end
         rule(:arg_function) do
-          str("ⓐ").as(:arg) >> str("(") >> a_ascii.as(:arg_arguments).maybe >> space? >> expression.as(:first_value).maybe >> str(")") |
-            str("ⓐ").as(:arg) >> a_ascii.as(:arg_arguments).maybe >> space? >> expression.as(:first_value).maybe
+          (str("ⓐ").as(:arg) >> str("(") >> a_ascii.as(:arg_arguments).maybe >> space? >> expression.as(:first_value).maybe >> str(")")) |
+            (str("ⓐ").as(:arg) >> a_ascii.as(:arg_arguments).maybe >> space? >> expression.as(:first_value).maybe)
         end
 
         rule(:color_symbols)   { str("✎") | str("\\color") }
         rule(:phantom_symbols) { str("⟡") | str("\\phantom") }
-        rule(:monospace_fonts) { (str("ￗ") >> str("(") >> space? >> expression.as(:monospace_value) >> space? >> str(")")).as(:monospace) }
+        rule(:monospace_fonts) do
+          (str("ￗ") >> str("(") >> space? >> expression.as(:monospace_value) >> space? >> str(")")).as(:monospace)
+        end
 
         rule(:backcolor_symbols) { str("☁") | str("\\backcolor") }
-        rule(:masked_recursive_value) { (space? >> expression | exp_bracket | exp_script).as(:expr) >> masked_recursive_value.as(:func_expr).maybe }
+        rule(:masked_recursive_value) do
+          ((space? >> expression) | exp_bracket | exp_script).as(:expr) >> masked_recursive_value.as(:func_expr).maybe
+        end
 
-        rule(:root_invisible_character?) { (str("\\naryand").absent? >> invisible_unicode).maybe }
+        rule(:root_invisible_character?) do
+          (str("\\naryand").absent? >> invisible_unicode).maybe
+        end
 
         rule(:nthrt) do
           (sqrt_symbols >> str("(") >> masked_recursive_value.as(:first_value) >> str("&") >> masked_recursive_value.as(:second_value) >> str(")")).as(:root)
@@ -44,8 +64,8 @@ module Plurimath
         end
 
         rule(:intent_function) do
-          str("ⓘ").as(:intent) >> str("(").as(:open_paren) >> parsing_text.as(:intent_arguments).maybe >> space? >> expression.as(:first_value).maybe >> str(")").as(:close_paren) |
-            str("ⓘ").as(:intent) >> expression.as(:intent_expr)
+          (str("ⓘ").as(:intent) >> str("(").as(:open_paren) >> parsing_text.as(:intent_arguments).maybe >> space? >> expression.as(:first_value).maybe >> str(")").as(:close_paren)) |
+            (str("ⓘ").as(:intent) >> expression.as(:intent_expr))
         end
 
         def masked_value(func_name)
@@ -53,7 +73,7 @@ module Plurimath
         end
 
         def bracketed_masked_value(func_name)
-          str("(") >> (masked_value(func_name).as(func_name)) >> str(")")
+          str("(") >> masked_value(func_name).as(func_name) >> str(")")
         end
       end
     end