srl_ruby 0.4.7 → 0.4.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0ad4df7433bb3c5e88e03e5670c306d1a70b6ec43f831c3d6d376e1776856e5
-  data.tar.gz: 57d9791c96e46524e08d21606d17d4757bea2d9d9cd4e1322276733e5cf1642c
+  metadata.gz: 4142454106f1b3b0a0e1e9b7c382ba6c5088f34a7b4d2e4c9437164537bb766a
+  data.tar.gz: 2ded972212dc2db8b037aba56aec6f79917a90a945f56c8f9f72b1bd88cd8b69
 SHA512:
-  metadata.gz: 151d3cdfd98bc907c2c4c3b63e317852fec743dc12b27f509b32285a8bd100242cc745c422a3c81641f4152453d3acc713246d8b907b532f635db5f99e83d2f2
-  data.tar.gz: 00b946261c11af9e9b64b460664a33498d1cd57685f3a6fc884c238c67c163b1c7a26efce508c3a9bd6e830bae82c1420697923e8889783b432c00333fffb2c7
+  metadata.gz: d7da9074cd772c28dc7eeaa8072d39fb5a91a08dba1665982fbf08303582c84742cf72ca6785ed18f1944cb11fcfd25fb011a37f93055c552011543235799669
+  data.tar.gz: '070724971995e366a27232732d5accf62c3e2141807ae80a7548d0ae98a28004bf811c50119001e581648c3e262cba7295ee6117bab5f1bddea3110e692d9c94'

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [0.4.8] - 2021-08-27
+- Updated dependencies (Bundler >~ 2.2), (Rley >~ 0.8.03)
+- Grammar refactoring to take profit of new Rley rule syntax.
+
+### Changed
+- File `srl_ruby.gemspec` Updated the dependencies
+- File `grammar.rb` Grammar refactored (use  ? * + modifiers in production rules)
+- class `ASTBuilder` updated `reduce_` to reflect new refactored production rules.
+
 ## [0.4.7] - 2021-08-24
 - Updated dependencies (Ruby >= 2.5), (Rley >= 0.8.02)
 - Code restyling to please rubocop 1.19.1. 

data/LICENSE.txt

@@ -5,7 +5,7 @@ the 'srl_test' directory, which is subject to its own license.
 
 The MIT License (MIT)
 
-Copyright (c) 2018-2019 Dimitri Geshef
+Copyright (c) 2018-2021 Dimitri Geshef
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/lib/srl_ruby/ast_builder.rb

@@ -118,70 +118,52 @@ module SrlRuby
       Regex::Anchor.new('^')
     end
 
-    # rule('expression' => %w[pattern flags]).as 'flagged_expr'
+    # rule('expression' => 'pattern (flags)?').tag 'flagged_expr'
     def reduce_flagged_expr(_production, aRange, theTokens, theChildren)
       @options = theChildren[1] if theChildren[1]
       return_first_child(aRange, theTokens, theChildren)
     end
 
-    # rule('pattern' => %w[pattern separator sub_pattern]).as 'pattern_sequence'
+    # rule('pattern' => 'subpattern (separator sub_pattern)*').tag 'pattern_sequence'
     def reduce_pattern_sequence(_production, _range, _tokens, theChildren)
-      third_member = theChildren[2]
-      if third_member.kind_of?(Regex::Lookaround) && third_member.dir == :behind
-        Regex::Concatenation.new(theChildren[2], theChildren[0])
+      return theChildren[0] if theChildren[1].empty?
+
+      successors = theChildren[1].map { |pair| pair[1] }
+      if successors[0].kind_of?(Regex::Lookaround) && successors[0].dir == :behind
+        Regex::Concatenation.new(successors.shift, theChildren[0], *successors)
       else
-        Regex::Concatenation.new(theChildren[0], theChildren[2])
+        Regex::Concatenation.new(theChildren[0], *successors)
       end
     end
 
-    # rule('pattern' => 'sub_pattern').as 'basic_pattern'
-    def reduce_basic_pattern(_production, aRange, theTokens, theChildren)
-      return_first_child(aRange, theTokens, theChildren)
-    end
-
-    # rule('sub_pattern' => 'assertion').as 'assertion_sub_pattern'
+    # rule('sub_pattern' => 'assertion').tag 'assertion_sub_pattern'
     def reduce_assertion_sub_pattern(_production, aRange, theTokens, theChildren)
       return_first_child(aRange, theTokens, theChildren)
     end
 
-    # rule('flags' => %[flags separator single_flag]).as 'flag_sequence'
+    # rule('flags' => '(separator single_flag)+').tag 'flag_sequence'
     def reduce_flag_sequence(_production, _range, _tokens, theChildren)
-      theChildren[0] << theChildren[2]
-    end
-
-    # rule('flags' => %w[separator single_flag]).as 'flag_simple'
-    def reduce_flag_simple(_production, _range, _tokens, theChildren)
-      [theChildren.last]
+      theChildren[0].map { |(_, flag)| flag }
     end
 
-    # rule('single_flag' => %w[CASE INSENSITIVE]).as 'case_insensitive'
+    # rule('single_flag' => %w[CASE INSENSITIVE]).tag 'case_insensitive'
     def reduce_case_insensitive(_production, _range, _tokens, _children)
       Regexp::IGNORECASE
     end
 
-    # rule('single_flag' => %w[MULTI LINE]).as 'multi_line'
+    # rule('single_flag' => %w[MULTI LINE]).tag 'multi_line'
     def reduce_multi_line(_production, _range, _tokens, _children)
       Regexp::MULTILINE
     end
 
-    # rule('single_flag' => %w[ALL LAZY]).as 'all_lazy'
+    # rule('single_flag' => %w[ALL LAZY]).tag 'all_lazy'
     def reduce_all_lazy(_production, _range, _tokens, _children)
       :ALL_LAZY
     end
 
-    # rule 'quantifiable' => %w[begin_anchor anchorable end_anchor]
-    def reduce_pinned_quantifiable(_production, _range, _tokens, theChildren)
-      Regex::Concatenation.new(*theChildren)
-    end
-
-    # rule 'quantifiable' => %w[begin_anchor anchorable]
-    def reduce_begin_anchor_quantifiable(_production, _range, _tokens, theChildren)
-      Regex::Concatenation.new(*theChildren)
-    end
-
-    # rule 'quantifiable' => %w[anchorable end_anchor]
-    def reduce_end_anchor_quantifiable(_production, _range, _tokens, theChildren)
-      return Regex::Concatenation.new(*theChildren)
+    # rule('quantifiable' => 'begin_anchor? anchorable end_anchor?')
+    def reduce_quantifiable(_production, _range, _tokens, theChildren)
+      Regex::Concatenation.new(*theChildren.compact)
     end
 
     # rule 'begin_anchor' => %w[STARTS WITH]
@@ -194,39 +176,30 @@ module SrlRuby
       begin_anchor
     end
 
-    # rule('end_anchor' => %w[separator MUST END]).as 'end_anchor'
+    # rule('end_anchor' => %w[separator MUST END]).tag 'end_anchor'
     def reduce_end_anchor(_production, _range, _tokens, _children)
       Regex::Anchor.new('$')
     end
 
-    # rule('assertion' => %w[IF FOLLOWED BY assertable]).as 'if_followed'
+    # rule('assertion' => 'IF NOT? FOLLOWED BY assertable')
     def reduce_if_followed(_production, _range, _tokens, theChildren)
-      Regex::Lookaround.new(theChildren.last, :ahead, :positive)
+      polarity = theChildren[1] ? :negative : :positive
+      Regex::Lookaround.new(theChildren.last, :ahead, polarity)
     end
 
-    # rule('assertion' => %w[IF NOT FOLLOWED BY assertable]).as 'if_not_followed'
-    def reduce_if_not_followed(_production, _range, _tokens, theChildren)
-      Regex::Lookaround.new(theChildren.last, :ahead, :negative)
-    end
-
-    # rule('assertion' => %w[IF ALREADY HAD assertable]).as 'if_had'
+    # rule('assertion' => 'IF NOT? ALREADY HAD assertable')
     def reduce_if_had(_production, _range, _tokens, theChildren)
-      Regex::Lookaround.new(theChildren.last, :behind, :positive)
+      polarity = theChildren[1] ? :negative : :positive
+      Regex::Lookaround.new(theChildren.last, :behind, polarity)
     end
 
-    # rule('assertion' => %w[IF NOT ALREADY HAD assertable]).as 'if_not_had'
-    def reduce_if_not_had(_production, _range, _tokens, theChildren)
-      Regex::Lookaround.new(theChildren.last, :behind, :negative)
+    # rule('assertable' => 'term quantifier?').tag 'assertable'
+    def reduce_assertable(_production, _range, _tokens, theChildren)
+      (term, quantifier) = theChildren
+      quantifier ? repetition(term, quantifier) : term
     end
 
-    # rule('assertable' => %w[term quantifier]).as 'quantified_assertable'
-    def reduce_quantified_assertable(_production, _range, _tokens, theChildren)
-      quantifier = theChildren[1]
-      term = theChildren[0]
-      repetition(term, quantifier)
-    end
-
-    # rule('letter_range' => %w[LETTER FROM LETTER_LIT TO LETTER_LIT]).as 'lowercase_from_to'
+    # rule('letter_range' => %w[LETTER FROM LETTER_LIT TO LETTER_LIT]).tag 'lowercase_from_to'
     def reduce_lowercase_from_to(_production, _range, _tokens, theChildren)
       raw_range = [theChildren[2].token.lexeme, theChildren[4].token.lexeme]
       range_sorted = raw_range.sort
@@ -234,7 +207,7 @@ module SrlRuby
       char_class(false, ch_range)
     end
 
-    # rule('letter_range' => %w[UPPERCASE LETTER FROM LETTER_LIT TO LETTER_LIT]).as 'uppercase_from_to'
+    # rule('letter_range' => %w[UPPERCASE LETTER FROM LETTER_LIT TO LETTER_LIT]).tag 'uppercase_from_to'
     def reduce_uppercase_from_to(_production, _range, _tokens, theChildren)
       raw_range = [theChildren[3].token.lexeme, theChildren[5].token.lexeme]
       range_sorted = raw_range.sort
@@ -242,19 +215,19 @@ module SrlRuby
       char_class(false, ch_range)
     end
 
-    # rule('letter_range' => 'LETTER').as 'any_lowercase'
+    # rule('letter_range' => 'LETTER').tag 'any_lowercase'
     def reduce_any_lowercase(_production, _range, _tokens, _children)
       ch_range = char_range('a', 'z')
       char_class(false, ch_range)
     end
 
-    # rule('letter_range' => %w[UPPERCASE LETTER]).as 'any_uppercase'
+    # rule('letter_range' => %w[UPPERCASE LETTER]).tag 'any_uppercase'
     def reduce_any_uppercase(_production, _range, _tokens, _children)
       ch_range = char_range('A', 'Z')
       char_class(false, ch_range)
     end
 
-    # rule('digit_range' => %w[digit_or_number FROM DIGIT_LIT TO DIGIT_LIT]).as 'digits_from_to'
+    # rule('digit_range' => %w[digit_or_number FROM DIGIT_LIT TO DIGIT_LIT]).tag 'digits_from_to'
     def reduce_digits_from_to(_production, _range, _tokens, theChildren)
       raw_range = [theChildren[2].token.lexeme, theChildren[4].token.lexeme]
       range_sorted = raw_range.map(&:to_i).sort
@@ -262,42 +235,42 @@ module SrlRuby
       char_class(false, ch_range)
     end
 
-    # rule('character_class' => %w[ANY CHARACTER]).as 'any_character'
+    # rule('character_class' => %w[ANY CHARACTER]).tag 'any_character'
     def reduce_any_character(_production, _range, _tokens, _children)
       char_shorthand('w')
     end
 
-    # rule('character_class' => %w[NO CHARACTER]).as 'no_character'
+    # rule('character_class' => %w[NO CHARACTER]).tag 'no_character'
     def reduce_no_character(_production, _range, _tokens, _children)
       char_shorthand('W')
     end
 
-    # rule('character_class' => 'digit_or_number').as 'digit'
+    # rule('character_class' => 'digit_or_number').tag 'digit'
     def reduce_digit(_production, _range, _tokens, _children)
       char_shorthand('d')
     end
 
-    # rule('character_class' => %w[NO DIGIT]).as 'non_digit'
+    # rule('character_class' => %w[NO DIGIT]).tag 'non_digit'
     def reduce_non_digit(_production, _range, _tokens, _children)
       char_shorthand('D')
     end
 
-    # rule('character_class' => 'WHITESPACE').as 'whitespace'
+    # rule('character_class' => 'WHITESPACE').tag 'whitespace'
     def reduce_whitespace(_production, _range, _tokens, _children)
       char_shorthand('s')
     end
 
-    # rule('character_class' => %w[NO WHITESPACE]).as 'no_whitespace'
+    # rule('character_class' => %w[NO WHITESPACE]).tag 'no_whitespace'
     def reduce_no_whitespace(_production, _range, _tokens, _children)
       char_shorthand('S')
     end
 
-    # rule('character_class' => 'ANYTHING').as 'anything'
+    # rule('character_class' => 'ANYTHING').tag 'anything'
     def reduce_anything(_production, _range, _tokens, _children)
       wildcard
     end
 
-    # rule('character_class' => %w[ONE OF STRING_LIT]).as 'one_of'
+    # rule('character_class' => %w[ONE OF STRING_LIT]).tag 'one_of'
     def reduce_one_of(_production, _range, _tokens, theChildren)
       raw_literal = theChildren[-1].token.lexeme.dup
       alternatives = raw_literal.chars.map do |ch|
@@ -313,7 +286,7 @@ module SrlRuby
       return Regex::CharClass.new(false, *alternatives)
     end
 
-    # rule('character_class' => %w[NONE OF STRING_LIT]).as 'none_of'
+    # rule('character_class' => %w[NONE OF STRING_LIT]).tag 'none_of'
     def reduce_none_of(_production, _range, _tokens, theChildren)
       raw_literal = theChildren[-1].token.lexeme.dup
       chars = raw_literal.chars.map do |ch|
@@ -322,44 +295,44 @@ module SrlRuby
       Regex::CharClass.new(true, *chars)
     end
 
-    # rule('special_char' => 'TAB').as 'tab'
+    # rule('special_char' => 'TAB').tag 'tab'
     def reduce_tab(_production, _range, _tokens, _children)
       Regex::Character.new('\t')
     end
 
-    # rule('special_char' => ' VERTICAL TAB').as 'vtab'
+    # rule('special_char' => ' VERTICAL TAB').tag 'vtab'
     def reduce_vtab(_production, _range, _tokens, _children)
       Regex::Character.new('\v')
     end
 
-    # rule('special_char' => 'BACKSLASH').as 'backslash'
+    # rule('special_char' => 'BACKSLASH').tag 'backslash'
     def reduce_backslash(_production, _range, _tokens, _children)
       # Double the backslash (because of escaping)
       string_literal('\\', true)
     end
 
-    # rule('special_char' => %w[NEW LINE]).as 'new_line'
+    # rule('special_char' => %w[NEW LINE]).tag 'new_line'
     def reduce_new_line(_production, _range, _tokens, _children)
       # TODO: control portability
       Regex::Character.new('\n')
     end
 
-    # rule('special_char' => %w[CARRIAGE RETURN]).as 'carriage_return'
+    # rule('special_char' => %w[CARRIAGE RETURN]).tag 'carriage_return'
     def reduce_carriage_return(_production, _range, _tokens, _children)
       Regex::Character.new('\r')
     end
 
-    # rule('special_char' => %w[WORD]).as 'word'
+    # rule('special_char' => %w[WORD]).tag 'word'
     def reduce_word(_production, _range, _tokens, _children)
       Regex::Anchor.new('\b')
     end
 
-    # rule('special_char' => %w[NO WORD]).as 'no word'
+    # rule('special_char' => %w[NO WORD]).tag 'no word'
     def reduce_no_word(_production, _range, _tokens, _children)
       Regex::Anchor.new('\B')
     end
 
-    # rule('literal' => %w[LITERALLY STRING_LIT]).as 'literally'
+    # rule('literal' => %w[LITERALLY STRING_LIT]).tag 'literally'
     def reduce_literally(_production, _range, _tokens, theChildren)
       # What if literal is empty?...
 
@@ -367,13 +340,13 @@ module SrlRuby
       return string_literal(raw_literal)
     end
 
-    # rule('raw' => %w[RAW STRING_LIT]).as 'raw_literal'
+    # rule('raw' => %w[RAW STRING_LIT]).tag 'raw_literal'
     def reduce_raw_literal(_production, _range, _tokens, theChildren)
       raw_literal = theChildren[-1].token.lexeme.dup
       return Regex::RawExpression.new(raw_literal)
     end
 
-    # rule('alternation' => %w[ANY OF LPAREN alternatives RPAREN]).as 'any_of'
+    # rule('alternation' => %w[ANY OF LPAREN alternatives RPAREN]).tag 'any_of'
     def reduce_any_of(_production, _range, _tokens, theChildren)
       first_alternative = theChildren[3].first
       result = nil
@@ -388,26 +361,21 @@ module SrlRuby
       return result
     end
 
-    # rule('alternatives' => %w[alternatives separator quantifiable]).as 'alternative_list'
+    # rule('alternatives' => %w[alternatives separator quantifiable]).tag 'alternative_list'
     def reduce_alternative_list(_production, _range, _tokens, theChildren)
       return theChildren[0] << theChildren[-1]
     end
 
-    # rule('alternatives' => 'quantifiable').as 'simple_alternative'
+    # rule('alternatives' => 'quantifiable').tag 'simple_alternative'
     def reduce_simple_alternative(_production, _range, _tokens, theChildren)
       [theChildren.last]
     end
 
-    # rule('grouping' => %w[LPAREN pattern RPAREN]).as 'grouping_parenthenses'
+    # rule('grouping' => %w[LPAREN pattern RPAREN]).tag 'grouping_parenthenses'
     def reduce_grouping_parenthenses(_production, _range, _tokens, theChildren)
       Regex::NonCapturingGroup.new(theChildren[1])
     end
 
-    # rule('capturing_group' => %w[CAPTURE assertable]).as 'capture'
-    def reduce_capture(_production, _range, _tokens, theChildren)
-      Regex::CapturingGroup.new(theChildren[1])
-    end
-
     # If the rightmost (sub)expression is a repetition, then make it lazy
     def make_last_repetition_lazy(anExpr)
       sub_expr = anExpr
@@ -427,51 +395,49 @@ module SrlRuby
       end
     end
 
-    # rule('capturing_group' => %w[CAPTURE assertable UNTIL assertable]).as
-    #   'capture_until'
-    def reduce_capture_until(_production, _range, _tokens, theChildren)
+    # rule('capturing_group' => 'CAPTURE assertable (UNTIL assertable)?').tag
+    # 'capture'
+    def reduce_capture(_production, _range, _tokens, theChildren)
+      return Regex::CapturingGroup.new(theChildren[1]) unless theChildren[2]
+
       # Until semantic requires that the last pattern in capture to be lazy
       make_last_repetition_lazy(theChildren[1])
 
       group = Regex::CapturingGroup.new(theChildren[1])
-      return Regex::Concatenation.new(group, theChildren[3])
+      (_, until_expr) = theChildren[2]
+      Regex::Concatenation.new(group, until_expr)
     end
 
-    # rule('capturing_group' => %w[CAPTURE assertable AS var_name]).as
-    #   'named_capture'
+    # rule('capturing_group' => 'CAPTURE assertable AS var_name (UNTIL assertable)?').tag
+    # 'named_capture'
     def reduce_named_capture(_production, _range, _tokens, theChildren)
       name = theChildren[3].token.lexeme.dup
-      return Regex::CapturingGroup.new(theChildren[1], name)
-    end
+      return Regex::CapturingGroup.new(theChildren[1], name) unless theChildren[4]
 
-    # rule('capturing_group' => %w[CAPTURE assertable AS var_name
-    #   UNTIL assertable]).as 'named_capture_until'
-    def reduce_named_capture_until(_production, _range, _tokens, theChildren)
       # Until semantic requires that the last pattern in capture to be lazy
       make_last_repetition_lazy(theChildren[1])
-
-      name = theChildren[3].token.lexeme.dup
       group = Regex::CapturingGroup.new(theChildren[1], name)
-      return Regex::Concatenation.new(group, theChildren[5])
+      (_, until_expr) = theChildren[4]
+      return Regex::Concatenation.new(group, until_expr)
     end
 
-    # rule('quantifier' => 'ONCE').as 'once'
+    # rule('quantifier' => 'ONCE').tag 'once'
     def reduce_once(_production, _range, _tokens, _children)
       multiplicity(1, 1)
     end
 
-    # rule('quantifier' => 'TWICE').as 'twice'
+    # rule('quantifier' => 'TWICE').tag 'twice'
     def reduce_twice(_production, _range, _tokens, _children)
       multiplicity(2, 2)
     end
 
-    # rule('quantifier' => %w[EXACTLY count TIMES]).as 'exactly'
+    # rule('quantifier' => %w[EXACTLY count TIMES]).tag 'exactly'
     def reduce_exactly(_production, _range, _tokens, theChildren)
       count = theChildren[1].token.lexeme.to_i
       multiplicity(count, count)
     end
 
-    # rule('quantifier' => %w[BETWEEN count AND count times_suffix]).as
+    # rule('quantifier' => 'BETWEEN count AND count times_suffix').tag
     #   'between_and'
     def reduce_between_and(_production, _range, _tokens, theChildren)
       lower = theChildren[1].token.lexeme.to_i
@@ -479,36 +445,26 @@ module SrlRuby
       multiplicity(lower, upper)
     end
 
-    # rule('quantifier' => 'OPTIONAL').as 'optional'
+    # rule('quantifier' => 'OPTIONAL').tag 'optional'
     def reduce_optional(_production, _range, _tokens, _children)
       multiplicity(0, 1)
     end
 
-    # rule('quantifier' => %w[ONCE OR MORE]).as 'once_or_more'
+    # rule('quantifier' => %w[ONCE OR MORE]).tag 'once_or_more'
     def reduce_once_or_more(_production, _range, _tokens, _children)
       multiplicity(1, :more)
     end
 
-    # rule('quantifier' => %w[NEVER OR MORE]).as 'never_or_more'
+    # rule('quantifier' => %w[NEVER OR MORE]).tag 'never_or_more'
     def reduce_never_or_more(_production, _range, _tokens, _children)
       multiplicity(0, :more)
     end
 
-    # rule('quantifier' => %w[AT LEAST count TIMES]).as 'at_least'
+    # rule('quantifier' => %w[AT LEAST count TIMES]).tag 'at_least'
     def reduce_at_least(_production, _range, _tokens, theChildren)
       count = theChildren[2].token.lexeme.to_i
       multiplicity(count, :more)
     end
-
-    # rule('times_suffix' => 'TIMES').as 'times_keyword'
-    def reduce_times_keyword(_production, _range, _tokens, _children)
-      nil
-    end
-
-    # rule('times_suffix' => []).as 'times_dropped'
-    def reduce_times_dropped(_production, _range, _tokens, _children)
-      nil
-    end
   end # class
 end # module
 # End of file

data/lib/srl_ruby/grammar.rb

@@ -31,97 +31,83 @@ module SrlRuby
     add_terminals('LAZY')
 
     # Grammar rules...
-    rule('srl' => 'expression').as 'start_rule'
-    rule('expression' => 'pattern flags').as 'flagged_expr'
-    rule('expression' => 'pattern').as 'simple_expr'
-    rule('pattern' => 'pattern separator sub_pattern').as 'pattern_sequence'
-    rule('pattern' => 'sub_pattern').as 'basic_pattern'
-    rule('sub_pattern' => 'quantifiable').as 'quantifiable_sub_pattern'
-    rule('sub_pattern' => 'assertion').as 'assertion_sub_pattern'
-    rule('separator' => 'COMMA').as 'comma_separator'
-    rule('separator' => []).as 'void_separator'
-    rule('flags' => 'flags separator single_flag').as 'flag_sequence'
-    rule('flags' => 'separator single_flag').as 'flag_simple'
-    rule('single_flag' => 'CASE INSENSITIVE').as 'case_insensitive'
-    rule('single_flag' => 'MULTI LINE').as 'multi_line'
-    rule('single_flag' => 'ALL LAZY').as 'all_lazy'
-    rule('quantifiable' => 'begin_anchor anchorable end_anchor').as 'pinned_quantifiable'
-    rule('quantifiable' => 'begin_anchor anchorable').as 'begin_anchor_quantifiable'
-    rule('quantifiable' => 'anchorable end_anchor').as 'end_anchor_quantifiable'
-    rule('quantifiable' => 'anchorable').as 'simple_quantifiable'
-    rule('begin_anchor' => 'STARTS WITH').as 'starts_with'
-    rule('begin_anchor' => 'BEGIN WITH').as 'begin_with'
-    rule('end_anchor' => 'separator MUST END').as 'end_anchor'
-    rule('anchorable' => 'assertable').as 'simple_anchorable'
-    rule('assertion' => 'IF FOLLOWED BY assertable').as 'if_followed'
-    rule('assertion' => 'IF NOT FOLLOWED BY assertable').as 'if_not_followed'
-    rule('assertion' => 'IF ALREADY HAD assertable').as 'if_had'
-    rule('assertion' => 'IF NOT ALREADY HAD assertable').as 'if_not_had'
-    rule('assertable' => 'term').as 'simple_assertable'
-    rule('assertable' => 'term quantifier').as 'quantified_assertable'
-    rule('term' => 'atom').as 'atom_term'
-    rule('term' => 'alternation').as 'alternation_term'
-    rule('term' => 'grouping').as 'grouping_term'
-    rule('term' => 'capturing_group').as 'capturing_group_atom'
-    rule('atom' => 'letter_range').as 'letter_range_atom'
-    rule('atom' => 'digit_range').as 'digit_range_atom'
-    rule('atom' => 'character_class').as 'character_class_atom'
-    rule('atom' => 'special_char').as 'special_char_atom'
-    rule('atom' => 'literal').as 'literal_atom'
-    rule('atom' => 'raw').as 'raw_atom'
-    rule('letter_range' => 'LETTER FROM LETTER_LIT TO LETTER_LIT').as 'lowercase_from_to'
-    rule('letter_range' => 'UPPERCASE LETTER FROM LETTER_LIT TO LETTER_LIT').as 'uppercase_from_to'
-    rule('letter_range' => 'LETTER').as 'any_lowercase'
-    rule('letter_range' => 'UPPERCASE LETTER').as 'any_uppercase'
-    rule('digit_range' => 'digit_or_number FROM DIGIT_LIT TO DIGIT_LIT').as 'digits_from_to'
-    rule('character_class' => 'ANY CHARACTER').as 'any_character'
-    rule('character_class' => 'NO CHARACTER').as 'no_character'
-    rule('character_class' => 'digit_or_number').as 'digit'
-    rule('character_class' => 'NO DIGIT').as 'non_digit'
-    rule('character_class' => 'WHITESPACE').as 'whitespace'
-    rule('character_class' => 'NO WHITESPACE').as 'no_whitespace'
-    rule('character_class' => 'ANYTHING').as 'anything'
-    rule('character_class' => 'ONE OF cclass').as 'one_of'
-    rule('character_class' => 'NONE OF cclass').as 'none_of'
-    rule('cclass' => 'STRING_LIT').as 'quoted_cclass' # Preferred syntax
-    rule('cclass' => 'INTEGER').as 'digits_cclass'
-    rule('cclass' => 'IDENTIFIER').as 'identifier_cclass'
-    rule('cclass' => 'CHAR_CLASS').as 'unquoted_cclass'
-    rule('special_char' => 'TAB').as 'tab'
-    rule('special_char' => 'VERTICAL TAB').as 'vtab'
-    rule('special_char' => 'BACKSLASH').as 'backslash'
-    rule('special_char' => 'NEW LINE').as 'new_line'
-    rule('special_char' => 'CARRIAGE RETURN').as 'carriage_return'
-    rule('special_char' => 'WORD').as 'word'
-    rule('special_char' => 'NO WORD').as 'no_word'
-    rule('literal' => 'LITERALLY STRING_LIT').as 'literally'
-    rule('raw' => 'RAW STRING_LIT').as 'raw_literal'
-    rule('alternation' => 'any_or_either OF LPAREN alternatives RPAREN').as 'any_of'
-    rule('alternatives' => 'alternatives separator quantifiable').as 'alternative_list'
-    rule('alternatives' => 'quantifiable').as 'simple_alternative'
-    rule('any_or_either' => 'ANY').as 'any_keyword'
-    rule('any_or_either' => 'EITHER').as 'either_keyword'
-    rule('grouping' => 'LPAREN pattern RPAREN').as 'grouping_parenthenses'
-    rule('capturing_group' => 'CAPTURE assertable').as 'capture'
-    rule('capturing_group' => 'CAPTURE assertable UNTIL assertable').as 'capture_until'
-    rule('capturing_group' => 'CAPTURE assertable AS var_name').as 'named_capture'
-    rule('capturing_group' => 'CAPTURE assertable AS var_name UNTIL assertable').as 'named_capture_until'
-    rule('var_name' => 'STRING_LIT').as 'var_name'
-    rule('var_name' => 'IDENTIFIER').as 'var_ident' # capture name not enclosed between quotes
-    rule('quantifier' => 'ONCE').as 'once'
-    rule('quantifier' => 'TWICE').as 'twice'
-    rule('quantifier' => 'EXACTLY count TIMES').as 'exactly'
-    rule('quantifier' => 'BETWEEN count AND count times_suffix').as 'between_and'
-    rule('quantifier' => 'OPTIONAL').as 'optional'
-    rule('quantifier' => 'ONCE OR MORE').as 'once_or_more'
-    rule('quantifier' => 'NEVER OR MORE').as 'never_or_more'
-    rule('quantifier' => 'AT LEAST count TIMES').as 'at_least'
-    rule('digit_or_number' => 'DIGIT').as 'digit_keyword'
-    rule('digit_or_number' => 'NUMBER').as 'number_keyword'
-    rule('count' => 'DIGIT_LIT').as 'single_digit'
-    rule('count' => 'INTEGER').as 'integer_count'
-    rule('times_suffix' => 'TIMES').as 'times_keyword'
-    rule('times_suffix' => []).as 'times_dropped'
+    rule('srl' => 'expression').tag 'start_rule'
+    rule('expression' => 'pattern flags?').tag 'flagged_expr'
+    rule('pattern' => 'sub_pattern (separator sub_pattern)*').tag 'pattern_sequence'
+    rule('sub_pattern' => 'quantifiable').tag 'quantifiable_sub_pattern'
+    rule('sub_pattern' => 'assertion').tag 'assertion_sub_pattern'
+    rule('separator' => 'COMMA?')
+    rule('flags' => '(separator single_flag)+').tag 'flag_sequence'
+    rule('single_flag' => 'CASE INSENSITIVE').tag 'case_insensitive'
+    rule('single_flag' => 'MULTI LINE').tag 'multi_line'
+    rule('single_flag' => 'ALL LAZY').tag 'all_lazy'
+    rule('quantifiable' => 'begin_anchor? anchorable end_anchor?').tag 'quantifiable'
+    rule('begin_anchor' => 'STARTS WITH').tag 'starts_with'
+    rule('begin_anchor' => 'BEGIN WITH').tag 'begin_with'
+    rule('end_anchor' => 'separator MUST END').tag 'end_anchor'
+    rule('anchorable' => 'assertable').tag 'simple_anchorable'
+    rule('assertion' => 'IF NOT? FOLLOWED BY assertable').tag 'if_followed'
+    rule('assertion' => 'IF NOT? ALREADY HAD assertable').tag 'if_had'
+    rule('assertable' => 'term quantifier?').tag 'assertable'
+    rule('term' => 'atom').tag 'atom_term'
+    rule('term' => 'alternation').tag 'alternation_term'
+    rule('term' => 'grouping').tag 'grouping_term'
+    rule('term' => 'capturing_group').tag 'capturing_group_atom'
+    rule('atom' => 'letter_range').tag 'letter_range_atom'
+    rule('atom' => 'digit_range').tag 'digit_range_atom'
+    rule('atom' => 'character_class').tag 'character_class_atom'
+    rule('atom' => 'special_char').tag 'special_char_atom'
+    rule('atom' => 'literal').tag 'literal_atom'
+    rule('atom' => 'raw').tag 'raw_atom'
+    rule('letter_range' => 'LETTER FROM LETTER_LIT TO LETTER_LIT').tag 'lowercase_from_to'
+    rule('letter_range' => 'UPPERCASE LETTER FROM LETTER_LIT TO LETTER_LIT').tag 'uppercase_from_to'
+    rule('letter_range' => 'LETTER').tag 'any_lowercase'
+    rule('letter_range' => 'UPPERCASE LETTER').tag 'any_uppercase'
+    rule('digit_range' => 'digit_or_number FROM DIGIT_LIT TO DIGIT_LIT').tag 'digits_from_to'
+    rule('character_class' => 'ANY CHARACTER').tag 'any_character'
+    rule('character_class' => 'NO CHARACTER').tag 'no_character'
+    rule('character_class' => 'digit_or_number').tag 'digit'
+    rule('character_class' => 'NO DIGIT').tag 'non_digit'
+    rule('character_class' => 'WHITESPACE').tag 'whitespace'
+    rule('character_class' => 'NO WHITESPACE').tag 'no_whitespace'
+    rule('character_class' => 'ANYTHING').tag 'anything'
+    rule('character_class' => 'ONE OF cclass').tag 'one_of'
+    rule('character_class' => 'NONE OF cclass').tag 'none_of'
+    rule('cclass' => 'STRING_LIT').tag 'quoted_cclass' # Preferred syntax
+    rule('cclass' => 'INTEGER').tag 'digits_cclass'
+    rule('cclass' => 'IDENTIFIER').tag 'identifier_cclass'
+    rule('cclass' => 'CHAR_CLASS').tag 'unquoted_cclass'
+    rule('special_char' => 'TAB').tag 'tab'
+    rule('special_char' => 'VERTICAL TAB').tag 'vtab'
+    rule('special_char' => 'BACKSLASH').tag 'backslash'
+    rule('special_char' => 'NEW LINE').tag 'new_line'
+    rule('special_char' => 'CARRIAGE RETURN').tag 'carriage_return'
+    rule('special_char' => 'WORD').tag 'word'
+    rule('special_char' => 'NO WORD').tag 'no_word'
+    rule('literal' => 'LITERALLY STRING_LIT').tag 'literally'
+    rule('raw' => 'RAW STRING_LIT').tag 'raw_literal'
+    rule('alternation' => 'any_or_either OF LPAREN alternatives RPAREN').tag 'any_of'
+    rule('alternatives' => 'alternatives separator quantifiable').tag 'alternative_list'
+    rule('alternatives' => 'quantifiable').tag 'simple_alternative'
+    rule('any_or_either' => 'ANY').tag 'any_keyword'
+    rule('any_or_either' => 'EITHER').tag 'either_keyword'
+    rule('grouping' => 'LPAREN pattern RPAREN').tag 'grouping_parenthenses'
+    rule('capturing_group' => 'CAPTURE assertable (UNTIL assertable)?').tag 'capture'
+    rule('capturing_group' => 'CAPTURE assertable AS var_name (UNTIL assertable)?').tag 'named_capture'
+    rule('var_name' => 'STRING_LIT').tag 'var_name'
+    rule('var_name' => 'IDENTIFIER').tag 'var_ident' # capture name not enclosed between quotes
+    rule('quantifier' => 'ONCE').tag 'once'
+    rule('quantifier' => 'TWICE').tag 'twice'
+    rule('quantifier' => 'EXACTLY count TIMES').tag 'exactly'
+    rule('quantifier' => 'BETWEEN count AND count TIMES?').tag 'between_and'
+    rule('quantifier' => 'OPTIONAL').tag 'optional'
+    rule('quantifier' => 'ONCE OR MORE').tag 'once_or_more'
+    rule('quantifier' => 'NEVER OR MORE').tag 'never_or_more'
+    rule('quantifier' => 'AT LEAST count TIMES').tag 'at_least'
+    rule('digit_or_number' => 'DIGIT').tag 'digit_keyword'
+    rule('digit_or_number' => 'NUMBER').tag 'number_keyword'
+    rule('count' => 'DIGIT_LIT').tag 'single_digit'
+    rule('count' => 'INTEGER').tag 'integer_count'
   end
 
   # And now build the grammar and make it accessible via a global constant

data/lib/srl_ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SrlRuby
-  VERSION = '0.4.7'
+  VERSION = '0.4.8'
 end

data/srl_ruby.gemspec

@@ -71,7 +71,7 @@ SUMMARY
   spec.add_dependency 'rley', '~> 0.8.02'
 
   # Development dependencies
-  spec.add_development_dependency 'bundler', '~> 2.1.0'
+  spec.add_development_dependency 'bundler', '~> 2.2.0'
   spec.add_development_dependency 'cucumber', '>= 2.2.0'
   spec.add_development_dependency 'rake', '~> 12.0'
   spec.add_development_dependency 'rspec', '~> 3.0'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: srl_ruby
 version: !ruby/object:Gem::Version
-  version: 0.4.7
+  version: 0.4.8
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-08-24 00:00:00.000000000 Z
+date: 2021-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: 2.2.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: 2.2.0
 - !ruby/object:Gem::Dependency
   name: cucumber
   requirement: !ruby/object:Gem::Requirement