srl_ruby 0.4.3 → 0.4.7

data/lib/regex/lookaround.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # File: Lookaround.rb
 
 ########################
@@ -40,7 +42,7 @@ module Regex # This module is used as a namespace
     def to_str
       dir_syntax = (dir == :ahead) ? '' : '<'
       kind_syntax = (kind == :positive) ? '=' : '!'
-      result = '(?' + dir_syntax + kind_syntax + child.to_str + ')'
+      result = "(?#{dir_syntax}#{kind_syntax}#{child.to_str})"
       return result
     end
   end # class

data/lib/regex/match_option.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # File: MatchOption.rb
 require_relative 'monadic_expression'
 

data/lib/regex/monadic_expression.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # File: monadic_expression.rb
 
 require_relative 'compound_expression' # Access the superclass

data/lib/regex/multiplicity.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # File: Multiplicity.rb
 
 module Regex # This module is used as a namespace
@@ -48,16 +50,13 @@ module Regex # This module is used as a namespace
           end
       end
 
-      suffix = case policy
-        when :greedy
-          ''
-        when :lazy
-          '?'
-        when :possessive
-          '+'
-      end
+      policy2suffix = {
+        greedy: '',
+        lazy: '?',
+        possessive: '+'
+      }
 
-      return subresult + suffix
+      return subresult + policy2suffix[policy]
     end
 
     private
@@ -66,6 +65,7 @@ module Regex # This module is used as a namespace
     def valid_lower_bound(aLowerBound)
       err_msg = "Invalid lower bound of repetition count #{aLowerBound}"
       raise StandardError, err_msg unless aLowerBound.kind_of?(Integer)
+
       return aLowerBound
     end
 

data/lib/regex/non_capturing_group.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # File: non_capturing_group.rb
 
 require_relative 'monadic_expression' # Access the superclass
@@ -20,7 +22,7 @@ module Regex # This module is used as a namespace
     # Conversion method re-definition.
     # Purpose: Return the String representation of the captured expression.
     def text_repr
-      result = '(?:' + all_child_text + ')'
+      result = "(?:#{all_child_text})"
       return result
     end
   end # class

data/lib/regex/polyadic_expression.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # File: polyadic_expression.rb
 
 require_relative 'compound_expression' # Access the superclass
@@ -30,6 +32,7 @@ module Regex # This module is used as a namespace
       children.each(&:done!)
       children.each_with_index do |child, index|
         break if index == children.size - 1
+
         next_child = children[index + 1]
         if next_child.kind_of?(Lookaround) && next_child.dir == :behind
           # Swap children: lookbehind regex must precede pattern
@@ -57,6 +60,7 @@ module Regex # This module is used as a namespace
           top = visit_stack.pop
           if top.kind_of?(Array)
             next if top.empty?
+
             currChild = top.pop
             visit_stack.push top
           else

data/lib/regex/quantifiable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # File: quantifiable.rb
 
 require_relative 'multiplicity'
@@ -6,7 +8,7 @@ module Regex # This module is used as a namespace
   module Quantifiable
     # Redefined method. Return true since it may not have any child.
     def quantified?
-      return @quantifier.nil? ? false : true
+      return !@quantifier.nil?
     end
 
     def quantifier

data/lib/regex/raw_expression.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'atomic_expression' # Access the superclass
 
 module Regex # This module is used as a namespace

data/lib/regex/repetition.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # File: repetition.rb
 
 require_relative 'monadic_expression' # Access the superclass

data/lib/regex/wildcard.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # File: wildcard.rb
 
 require_relative 'atomic_expression' # Access the superclass
@@ -5,11 +7,6 @@ require_relative 'atomic_expression' # Access the superclass
 module Regex # This module is used as a namespace
   # A wildcard matches any character (except for the newline).
   class Wildcard < AtomicExpression
-    # Constructor
-    def initialize
-      super
-    end
-
     protected
 
     # Conversion method re-definition.

data/lib/srl_ruby/ast_builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'stringio'
 require_relative 'regex_repr'
 
@@ -44,6 +46,7 @@ module SrlRuby
         end
       end
       return if regexp_opts.empty?
+
       new_root = Regex::MatchOption.new(tree_root, regexp_opts)
       result.instance_variable_set(:@root, new_root)
     end
@@ -65,6 +68,8 @@ module SrlRuby
       return Regex::Multiplicity.new(lowerBound, upperBound, :greedy)
     end
 
+    # rubocop: disable Style/OptionalBooleanParameter
+
     def string_literal(aString, to_escape = true)
       if aString.size > 1
         chars = []
@@ -85,6 +90,7 @@ module SrlRuby
 
       return result
     end
+    # rubocop: enable Style/OptionalBooleanParameter
 
     def char_range(lowerBound, upperBound)
       lower = Regex::Character.new(lowerBound)
@@ -120,7 +126,12 @@ module SrlRuby
 
     # rule('pattern' => %w[pattern separator sub_pattern]).as 'pattern_sequence'
     def reduce_pattern_sequence(_production, _range, _tokens, theChildren)
-      Regex::Concatenation.new(theChildren[0], theChildren[2])
+      third_member = theChildren[2]
+      if third_member.kind_of?(Regex::Lookaround) && third_member.dir == :behind
+        Regex::Concatenation.new(theChildren[2], theChildren[0])
+      else
+        Regex::Concatenation.new(theChildren[0], theChildren[2])
+      end
     end
 
     # rule('pattern' => 'sub_pattern').as 'basic_pattern'

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::Notation::GrammarBuilder.new do
     # Separators...
     add_terminals('LPAREN', 'RPAREN', 'COMMA')
 
@@ -30,33 +32,33 @@ module SrlRuby
 
     # Grammar rules...
     rule('srl' => 'expression').as 'start_rule'
-    rule('expression' => %w[pattern flags]).as 'flagged_expr'
+    rule('expression' => 'pattern flags').as 'flagged_expr'
     rule('expression' => 'pattern').as 'simple_expr'
-    rule('pattern' => %w[pattern separator sub_pattern]).as 'pattern_sequence'
+    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' => %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('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' => %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('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' => %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('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' => %w[term quantifier]).as 'quantified_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'
@@ -67,20 +69,20 @@ module SrlRuby
     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 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' => %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('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' => %w[NO DIGIT]).as 'non_digit'
+    rule('character_class' => 'NO DIGIT').as 'non_digit'
     rule('character_class' => 'WHITESPACE').as 'whitespace'
-    rule('character_class' => %w[NO WHITESPACE]).as 'no_whitespace'
+    rule('character_class' => '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('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'
@@ -88,32 +90,32 @@ module SrlRuby
     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('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' => %w[any_or_either OF LPAREN alternatives RPAREN]).as 'any_of'
-    rule('alternatives' => %w[alternatives separator quantifiable]).as 'alternative_list'
+    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' => %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('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' => %w[EXACTLY count TIMES]).as 'exactly'
-    rule('quantifier' => %w[BETWEEN count AND count times_suffix]).as 'between_and'
+    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' => %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('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'

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,7 +1,9 @@
+# frozen_string_literal: true
+
 # File: srl_tokenizer.rb
 # Tokenizer for SRL (Simple Regex Language)
 require 'strscan'
-require_relative 'srl_token'
+require 'rley'
 
 
 module SrlRuby
@@ -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
 
@@ -132,7 +138,7 @@ module SrlRuby
         token = build_token('LETTER_LIT', lexeme)
       elsif (lexeme = scanner.scan(/[a-zA-Z_][a-zA-Z0-9_]+/))
         keyw = @@keywords[lexeme.upcase]
-        tok_type = keyw ? keyw : 'IDENTIFIER'
+        tok_type = keyw || 'IDENTIFIER'
         token = build_token(tok_type, lexeme)
       elsif (lexeme = scanner.scan(/[^,"\s]{2,}/))
         token = build_token('CHAR_CLASS', lexeme)
@@ -149,11 +155,11 @@ module SrlRuby
     def build_token(aSymbolName, aLexeme)
       begin
         col = scanner.pos - aLexeme.size - @line_start + 1
-        pos = Position.new(@lineno, col)
-        token = SrlToken.new(aLexeme, aSymbolName, pos)
-      rescue StandardError => exc
+        pos = Rley::Lexical::Position.new(@lineno, col)
+        token = Rley::Lexical::Token.new(aLexeme, aSymbolName, pos)
+      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.3'.freeze
+  VERSION = '0.4.7'
 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::Notation::GrammarBuilder.new 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'