srl_ruby 0.4.5 → 0.4.9

data/lib/srl_ruby/grammar.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 # Grammar for SRL (Simple Regex Language)
 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')
 
@@ -29,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/regex_repr.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../regex/character'
 require_relative '../regex/char_range'
 require_relative '../regex/concatenation'

data/lib/srl_ruby/tokenizer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # File: srl_tokenizer.rb
 # Tokenizer for SRL (Simple Regex Language)
 require 'strscan'
@@ -15,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',
@@ -84,7 +90,7 @@ module SrlRuby
       WHITESPACE
       WITH
       WORD
-    ].map { |x| [x, x] } .to_h
+    ].map { |x| [x, x] }.to_h
 
     class ScanError < StandardError; end
 
@@ -151,9 +157,9 @@ module SrlRuby
         col = scanner.pos - aLexeme.size - @line_start + 1
         pos = Rley::Lexical::Position.new(@lineno, col)
         token = Rley::Lexical::Token.new(aLexeme, aSymbolName, pos)
-      rescue StandardError => exc
+      rescue StandardError => e
         puts "Failing with '#{aSymbolName}' and '#{aLexeme}'"
-        raise exc
+        raise e
       end
 
       return token

data/lib/srl_ruby/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SrlRuby
-  VERSION = '0.4.5'.freeze
+  VERSION = '0.4.9'
 end

data/lib/srl_ruby.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative './srl_ruby/version'
 require_relative './srl_ruby/tokenizer'
 require_relative './srl_ruby/grammar'

data/spec/acceptance/srl_test_suite_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../spec_helper'
 require_relative './support/rule_file_parser'
 require_relative '../../lib/srl_ruby'

data/spec/acceptance/support/rule_file_ast_builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'rule_file_nodes'
 
 module Acceptance

data/spec/acceptance/support/rule_file_grammar.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # File: rule_file_grammar.rb
 require 'rley' # Load the Rley gem
 
@@ -5,20 +7,20 @@ require 'rley' # Load the Rley gem
 # [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_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'
@@ -26,8 +28,8 @@ builder = Rley::Syntax::GrammarBuilder.new do
   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('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'

data/spec/acceptance/support/rule_file_nodes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Classes that implement nodes of Abstract Syntax Trees (AST) representing
 # rule file contents.
 

data/spec/acceptance/support/rule_file_parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'rule_file_tokenizer'
 require_relative 'rule_file_grammar'
 require_relative 'rule_file_ast_builder'

data/spec/acceptance/support/rule_file_tokenizer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # File: rule_tokenizer.rb
 # Tokenizer for SimpleRegex Test-Rule files
 # [File format](https://github.com/SimpleRegex/Test-Rules/blob/master/README.md)
@@ -14,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
@@ -80,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]
@@ -111,9 +118,9 @@ module Acceptance
         col = scanner.pos - aLexeme.size - @line_start + 1
         pos = Rley::Lexical::Position.new(@lineno, col)
         token = Rley::Lexical::Token.new(aLexeme, aSymbolName, pos)
-      rescue StandardError => exc
+      rescue StandardError => e
         puts "Failing with '#{aSymbolName}' and '#{aLexeme}'"
-        raise exc
+        raise e
       end
 
       return token

data/spec/regex/atomic_expression_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # File: atomic_expression_spec.rb
 require_relative '../spec_helper' # Use the RSpec test framework
 require_relative '../../lib/regex/atomic_expression'

data/spec/regex/character_spec.rb

@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 # File: character_spec.rb
 require_relative '../spec_helper' # Use the RSpec test framework
 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
 
@@ -85,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
@@ -109,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)
 
@@ -145,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)
@@ -164,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/match_option_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # File: match_option_spec.rb
 
 require_relative '../spec_helper' # Use the RSpec test framework

data/spec/regex/monadic_expression_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # File: monadic_expression_spec.rb
 require_relative '../spec_helper' # Use the RSpec test framework
 require_relative '../../lib/regex/monadic_expression'

data/spec/regex/multiplicity_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # File: multiplicity_spec.rb
 
 require_relative '../spec_helper' # Use the RSpec test framework
@@ -21,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: '+' }
 
@@ -71,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/regex/repetition_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # File: repetition_spec.rb
 require_relative '../spec_helper' # Use the RSpec test framework
 require_relative '../../lib/regex/repetition'

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bundler/setup'
 require 'rspec' # Use the RSpec framework
 require_relative '../lib/srl_ruby'

data/spec/srl_ruby/srl_ruby_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../spec_helper'
 
 RSpec.describe SrlRuby do

data/spec/srl_ruby/tokenizer_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../spec_helper' # Use the RSpec framework
 require_relative '../../lib/srl_ruby/tokenizer' # Load the class under test
 

data/spec/srl_ruby_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'spec_helper' # Use the RSpec framework
 require_relative '../lib/srl_ruby'
 
@@ -224,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
 
@@ -244,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'srl_ruby/version'
@@ -63,14 +65,14 @@ SUMMARY
   spec.require_paths = ['lib']
   PkgExtending.pkg_files(spec)
   PkgExtending.pkg_documentation(spec)
-  spec.required_ruby_version = '>= 2.1.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', '~> 1.16'
+  spec.add_development_dependency 'bundler', '~> 2.2.0'
   spec.add_development_dependency 'cucumber', '>= 2.2.0'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake', '~> 12.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
 end