srl_ruby 0.4.6 → 0.4.10

data/lib/srl_ruby/grammar.rb

@@ -5,7 +5,7 @@ require 'rley' # Load the gem
 module SrlRuby
   ########################################
   # SRL grammar
-  builder = Rley::Syntax::GrammarBuilder.new do
+  builder = Rley::grammar_builder do
     # Separators...
     add_terminals('LPAREN', 'RPAREN', 'COMMA')
 
@@ -31,97 +31,83 @@ module SrlRuby
     add_terminals('LAZY')
 
     # Grammar rules...
-    rule('srl' => 'expression').as 'start_rule'
-    rule('expression' => %w[pattern flags]).as 'flagged_expr'
-    rule('expression' => 'pattern').as 'simple_expr'
-    rule('pattern' => %w[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' => %w[flags separator single_flag]).as 'flag_sequence'
-    rule('flags' => %w[separator single_flag]).as 'flag_simple'
-    rule('single_flag' => %w[CASE INSENSITIVE]).as 'case_insensitive'
-    rule('single_flag' => %w[MULTI LINE]).as 'multi_line'
-    rule('single_flag' => %w[ALL LAZY]).as 'all_lazy'
-    rule('quantifiable' => %w[begin_anchor anchorable end_anchor]).as 'pinned_quantifiable'
-    rule('quantifiable' => %w[begin_anchor anchorable]).as 'begin_anchor_quantifiable'
-    rule('quantifiable' => %w[anchorable end_anchor]).as 'end_anchor_quantifiable'
-    rule('quantifiable' => 'anchorable').as 'simple_quantifiable'
-    rule('begin_anchor' => %w[STARTS WITH]).as 'starts_with'
-    rule('begin_anchor' => %w[BEGIN WITH]).as 'begin_with'
-    rule('end_anchor' => %w[separator MUST END]).as 'end_anchor'
-    rule('anchorable' => 'assertable').as 'simple_anchorable'
-    rule('assertion' => %w[IF FOLLOWED BY assertable]).as 'if_followed'
-    rule('assertion' => %w[IF NOT FOLLOWED BY assertable]).as 'if_not_followed'
-    rule('assertion' => %w[IF ALREADY HAD assertable]).as 'if_had'
-    rule('assertion' => %w[IF NOT ALREADY HAD assertable]).as 'if_not_had'
-    rule('assertable' => 'term').as 'simple_assertable'
-    rule('assertable' => %w[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' => %w[LETTER FROM LETTER_LIT TO LETTER_LIT]).as 'lowercase_from_to'
-    rule('letter_range' => %w[UPPERCASE LETTER FROM LETTER_LIT TO LETTER_LIT]).as 'uppercase_from_to'
-    rule('letter_range' => 'LETTER').as 'any_lowercase'
-    rule('letter_range' => %w[UPPERCASE LETTER]).as 'any_uppercase'
-    rule('digit_range' => %w[digit_or_number FROM DIGIT_LIT TO DIGIT_LIT]).as 'digits_from_to'
-    rule('character_class' => %w[ANY CHARACTER]).as 'any_character'
-    rule('character_class' => %w[NO CHARACTER]).as 'no_character'
-    rule('character_class' => 'digit_or_number').as 'digit'
-    rule('character_class' => %w[NO DIGIT]).as 'non_digit'
-    rule('character_class' => 'WHITESPACE').as 'whitespace'
-    rule('character_class' => %w[NO WHITESPACE]).as 'no_whitespace'
-    rule('character_class' => 'ANYTHING').as 'anything'
-    rule('character_class' => %w[ONE OF cclass]).as 'one_of'
-    rule('character_class' => %w[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' => %w[NEW LINE]).as 'new_line'
-    rule('special_char' => %w[CARRIAGE RETURN]).as 'carriage_return'
-    rule('special_char' => %w[WORD]).as 'word'
-    rule('special_char' => %w[NO WORD]).as 'no_word'
-    rule('literal' => %w[LITERALLY STRING_LIT]).as 'literally'
-    rule('raw' => 'RAW STRING_LIT').as 'raw_literal'
-    rule('alternation' => %w[any_or_either OF LPAREN alternatives RPAREN]).as 'any_of'
-    rule('alternatives' => %w[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' => %w[LPAREN pattern RPAREN]).as 'grouping_parenthenses'
-    rule('capturing_group' => %w[CAPTURE assertable]).as 'capture'
-    rule('capturing_group' => %w[CAPTURE assertable UNTIL assertable]).as 'capture_until'
-    rule('capturing_group' => %w[CAPTURE assertable AS var_name]).as 'named_capture'
-    rule('capturing_group' => %w[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' => %w[EXACTLY count TIMES]).as 'exactly'
-    rule('quantifier' => %w[BETWEEN count AND count times_suffix]).as 'between_and'
-    rule('quantifier' => 'OPTIONAL').as 'optional'
-    rule('quantifier' => %w[ONCE OR MORE]).as 'once_or_more'
-    rule('quantifier' => %w[NEVER OR MORE]).as 'never_or_more'
-    rule('quantifier' => %w[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/tokenizer.rb

@@ -17,10 +17,14 @@ module SrlRuby
   # Delimiters: parentheses '(' and ')'
   # Separators: comma (optional)
   class Tokenizer
+    # @return [StringScanner]
     attr_reader(:scanner)
+
+    # @return [Integer] current line number
     attr_reader(:lineno)
+
+    # @return [Integer] offset of start of current line within input
     attr_reader(:line_start)
-    # attr_reader(:column)
 
     @@lexeme2name = {
       '(' => 'LPAREN',
@@ -86,7 +90,7 @@ module SrlRuby
       WHITESPACE
       WITH
       WORD
-    ].map { |x| [x, x] } .to_h
+    ].map { |x| [x, x] }.to_h
 
     class ScanError < StandardError; end
 

data/lib/srl_ruby/version.rb

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

data/spec/acceptance/support/rule_file_ast_builder.rb

@@ -32,7 +32,7 @@ module Acceptance
       Terminal2NodeClass
     end
 
-    # rule('rule_file' => %w[srl_heading srl_tests]).as 'start_rule'
+    # rule('rule_file' => 'srl_heading tests').as 'start_rule'
     def reduce_start_rule(_production, _range, _tokens, theChildren)
       rule_file = RuleFileTests.new(theChildren[0])
       tests = theChildren.last.flatten
@@ -54,16 +54,6 @@ module Acceptance
       theChildren.last
     end
 
-    # rule('srl_tests' => %w[srl_tests single_test]).as 'test_list'
-    def reduce_test_list(_production, _range, _tokens, theChildren)
-      theChildren[0] << theChildren[1]
-    end
-
-    # rule('srl_tests' => 'single_test').as 'one_test'
-    def reduce_one_test(_production, _range, _tokens, theChildren)
-      [theChildren.last]
-    end
-
     # rule('match_test' => %w[MATCH: STRING_LIT]).as 'match_string'
     def reduce_match_string(_production, _range, _tokens, theChildren)
       MatchTest.new(theChildren.last)
@@ -85,17 +75,6 @@ module Acceptance
       theChildren[2]
     end
 
-    # rule('capture_expectations' => %w[capture_expectations
-    #   single_expectation]).as 'assertion_list'
-    def reduce_assertion_list(_production, _range, _tokens, theChildren)
-      theChildren[0] << theChildren[1]
-    end
-
-    # rule('capture_expectations' => 'single_expectation').as 'one_expectation'
-    def reduce_one_expectation(_production, _range, _tokens, theChildren)
-      [theChildren.last]
-    end
-
     # rule('single_expectation' => %w[DASH INTEGER COLON capture_variable
     #   COLON STRING_LIT]).as 'capture_expectation'
     def reduce_capture_expectation(_production, _range, _tokens, theChildren)

data/spec/acceptance/support/rule_file_grammar.rb

@@ -6,37 +6,32 @@ require 'rley' # Load the Rley gem
 # Grammar for Test-Rule files
 # [File format](https://github.com/SimpleRegex/Test-Rules/blob/master/README.md)
 ########################################
-# Define a grammar for basic arithmetical expressions
-builder = Rley::Syntax::GrammarBuilder.new do
+builder = Rley::grammar_builder do
   # Punctuation
   add_terminals('COLON', 'DASH')
 
   # Keywords
   add_terminals('CAPTURE', 'FOR')
-  add_terminals('MATCH:', 'NO', 'SRL:')
+  add_terminals('MATCH', 'NO', 'SRL')
 
   # Literals
   add_terminals('INTEGER', 'STRING_LIT')
   add_terminals('IDENTIFIER', 'SRL_SOURCE')
 
-  rule('rule_file' => 'srl_heading srl_tests').as 'start_rule'
-  rule('srl_heading' => 'SRL: SRL_SOURCE').as 'srl_source'
-  rule('srl_tests' => 'srl_tests single_test').as 'test_list'
-  rule('srl_tests' => 'single_test').as 'one_test'
-  rule('single_test' => 'atomic_test').as 'single_atomic_test'
-  rule('single_test' => 'compound_test').as 'single_compound_test'
-  rule('atomic_test' => 'match_test').as 'atomic_match'
-  rule('atomic_test' => 'no_match_test').as 'atomic_no_match'
-  rule('compound_test' => 'capture_test').as 'compound_capture'
-  rule('match_test' => 'MATCH: STRING_LIT').as 'match_string'
-  rule('no_match_test' => 'NO MATCH: STRING_LIT').as 'no_match_string'
-  rule('capture_test' => 'capture_heading capture_expectations').as 'capture_test'
-  rule('capture_heading' => 'CAPTURE FOR STRING_LIT COLON').as 'capture_string'
-  rule('capture_expectations' => 'capture_expectations single_expectation').as 'assertion_list'
-  rule('capture_expectations' => 'single_expectation').as 'one_expectation'
-  rule('single_expectation' => 'DASH INTEGER COLON capture_variable COLON STRING_LIT').as 'capture_expectation'
-  rule('capture_variable' => 'INTEGER').as 'var_integer'
-  rule('capture_variable' => 'IDENTIFIER').as 'var_identifier'
+  rule('rule_file' => 'srl_heading srl_test+').tag 'start_rule'
+  rule('srl_heading' => 'SRL SRL_SOURCE').tag 'srl_source'
+  rule('srl_test' => 'atomic_test').tag 'single_atomic_test'
+  rule('srl_test' => 'compound_test').tag 'single_compound_test'
+  rule('atomic_test' => 'match_test').tag 'atomic_match'
+  rule('atomic_test' => 'no_match_test').tag 'atomic_no_match'
+  rule('compound_test' => 'capture_test').tag 'compound_capture'
+  rule('match_test' => 'MATCH STRING_LIT').tag 'match_string'
+  rule('no_match_test' => 'NO MATCH STRING_LIT').tag 'no_match_string'
+  rule('capture_test' => 'capture_heading capture_expectation+').tag 'capture_test'
+  rule('capture_heading' => 'CAPTURE FOR STRING_LIT COLON').tag 'capture_string'
+  rule('capture_expectation' => 'DASH INTEGER COLON capture_variable COLON STRING_LIT').tag 'capture_expectation'
+  rule('capture_variable' => 'INTEGER').tag 'var_integer'
+  rule('capture_variable' => 'IDENTIFIER').tag 'var_identifier'
 end
 
 # And now build the grammar...

data/spec/acceptance/support/rule_file_tokenizer.rb

@@ -16,8 +16,13 @@ module Acceptance
   # Delimiters: parentheses '(' and ')'
   # Separators: comma (optional)
   class RuleFileTokenizer
+    # @return [StringScanner]
     attr_reader(:scanner)
+
+    # @return [Integer] current line number
     attr_reader(:lineno)
+
+    # @return [Integer] offset of start of current line within input
     attr_reader(:line_start)
 
     # Can be :default, :expecting_srl
@@ -82,7 +87,7 @@ module Acceptance
       elsif (lexeme = scanner.scan(/[0-9]+/))
         token = build_token('INTEGER', lexeme)
       elsif (lexeme = scanner.scan(/srl:|match:/))
-        token = build_token(@@keywords[lexeme], lexeme)
+        token = build_token(@@keywords[lexeme].chop, lexeme.chop)
         @state = :expecting_srl if lexeme == 'srl:'
       elsif (lexeme = scanner.scan(/[a-zA-Z_][a-zA-Z0-9_]*/))
         keyw = @@keywords[lexeme]

data/spec/regex/character_spec.rb

@@ -6,6 +6,8 @@ require_relative '../../lib/regex/character'
 
 module Regex # Open this namespace, to get rid of scope qualifiers
   describe Character do
+  # rubocop: disable Lint/ConstantDefinitionInBlock
+
     # This constant holds an arbitrary selection of characters
     SampleChars = [?a, ?\0, ?\u0107].freeze
 
@@ -87,6 +89,8 @@ module Regex # Open this namespace, to get rid of scope qualifiers
 
         # Try with our escape sequence samples
         (SampleDigrams + SampleNumEscs).each do |escape_seq|
+          
+          # Build a string from escape sequence literal
           expectation = String.class_eval(%Q|"#{escape_seq}"|, __FILE__, __LINE__)
           new_ch = Character.new(escape_seq).to_str
           new_ch == expectation
@@ -111,11 +115,20 @@ module Regex # Open this namespace, to get rid of scope qualifiers
 
         # Try with our escape sequence samples
         (SampleDigrams + SampleNumEscs).each do |escape_seq|
+
+          # Get ordinal value of given escape sequence
           expectation = String.class_eval(%Q|"#{escape_seq}".ord()|, __FILE__, __LINE__)
           expect(Character.new(escape_seq).codepoint).to eq(expectation)
         end
       end
 
+      # Create a module that re-defines the existing to_s method
+      module Tweak_to_s
+        def to_s # Overwrite the existing to_s method
+          ?\u03a3
+        end
+      end # module
+
       it 'should known whether it is equal to another Object' do
         newOne = Character.new(?\u03a3)
 
@@ -147,12 +160,6 @@ module Regex # Open this namespace, to get rid of scope qualifiers
         expect(simulator).to receive(:to_s).and_return(?\u03a3)
         expect(newOne).to eq(simulator)
 
-        # Create a module that re-defines the existing to_s method
-        module Tweak_to_s
-          def to_s # Overwrite the existing to_s method
-            ?\u03a3
-          end
-        end # module
         weird = Object.new
         weird.extend(Tweak_to_s)
         expect(newOne).to eq(weird)
@@ -166,6 +173,7 @@ module Regex # Open this namespace, to get rid of scope qualifiers
         expect(ch2.explain).to eq("the character '\u03a3'")
       end
     end # context
+    # rubocop: enable Lint/ConstantDefinitionInBlock
   end # describe
 end # module
 

data/spec/regex/multiplicity_spec.rb

@@ -23,6 +23,7 @@ module Regex # This module is used as a namespace
     end
 
     context 'Provided services' do
+      # rubocop: disable Style/CombinableLoops
       it 'should know its text representation' do
         policy2text = { greedy: '', lazy: '?', possessive: '+' }
 
@@ -73,6 +74,7 @@ module Regex # This module is used as a namespace
           end
         end
       end
+      # rubocop: enable Style/CombinableLoops
     end
   end
 end # module

data/spec/srl_ruby_spec.rb

@@ -226,7 +226,7 @@ SRL
     let(:prefix) { 'letter from p to t ' }
 
     it "should parse 'once' syntax" do
-      regexp = SrlRuby.parse(prefix + 'once')
+      regexp = SrlRuby.parse("#{prefix}once")
       expect(regexp.source).to eq('[p-t]{1}')
     end
 
@@ -246,26 +246,26 @@ SRL
     end
 
     it "should parse 'between ... and ... times' syntax" do
-      regexp = SrlRuby.parse(prefix + 'between 2 and 4 times')
+      regexp = SrlRuby.parse("#{prefix}between 2 and 4 times")
       expect(regexp.source).to eq('[p-t]{2,4}')
 
       # Dropping 'times' keyword is a shorter alternative syntax
-      regexp = SrlRuby.parse(prefix + 'between 2 and 4')
+      regexp = SrlRuby.parse("#{prefix}between 2 and 4")
       expect(regexp.source).to eq('[p-t]{2,4}')
     end
 
     it "should parse 'once or more' syntax" do
-      regexp = SrlRuby.parse(prefix + 'once or more')
+      regexp = SrlRuby.parse("#{prefix}once or more")
       expect(regexp.source).to eq('[p-t]+')
     end
 
     it "should parse 'never or more' syntax" do
-      regexp = SrlRuby.parse(prefix + 'never or more')
+      regexp = SrlRuby.parse("#{prefix}never or more")
       expect(regexp.source).to eq('[p-t]*')
     end
 
     it "should parse 'at least  ... times' syntax" do
-      regexp = SrlRuby.parse(prefix + 'at least 10 times')
+      regexp = SrlRuby.parse("#{prefix}at least 10 times")
       expect(regexp.source).to eq('[p-t]{10,}')
     end
   end # context

data/srl_ruby.gemspec

@@ -65,13 +65,13 @@ SUMMARY
   spec.require_paths = ['lib']
   PkgExtending.pkg_files(spec)
   PkgExtending.pkg_documentation(spec)
-  spec.required_ruby_version = '>= 2.3.0'
+  spec.required_ruby_version = '>= 2.5.0'
 
   # Runtime dependencies
-  spec.add_dependency 'rley', '~> 0.7.00'
+  spec.add_dependency 'rley', '~> 0.8.08'
 
   # Development dependencies
-  spec.add_development_dependency 'bundler', '~> 2.0.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.6
+  version: 0.4.10
 platform: ruby
 authors:
 - Dimitri Geshef
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-08-17 00:00:00.000000000 Z
+date: 2021-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.00
+        version: 0.8.08
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.00
+        version: 0.8.08
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 2.2.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 2.2.0
 - !ruby/object:Gem::Dependency
   name: cucumber
   requirement: !ruby/object:Gem::Requirement
@@ -190,7 +190,7 @@ homepage: https://github.com/famished-tiger/SRL-Ruby
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
 - --charset=UTF-8 --exclude="examples|spec"
 require_paths:
@@ -199,15 +199,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: A parser for the [Simple Regex Language](https://simple-regex.com/). It translates
   patterns expressed in SRL into plain Ruby Regexp objects or in regex literals. Use