srl_ruby 0.2.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d5c1623523fb8a959a54590b407208b61b0019ef
-  data.tar.gz: 96d647c8fc0b91dc4e02aad405c870e14d3dce39
+  metadata.gz: 3642f7f1361cb920e2a9e42dcd8969d5ec75c7fe
+  data.tar.gz: 480c7561fd6972a8872e472166d07d0905c4612d
 SHA512:
-  metadata.gz: f8d99780790b039088b4bc320d21dfa3d8e33866d34b203b95b650034ca8c2d29a79d953969bbf89eac45b1a2dd862af3e8f2e3aae156f5e62aef1ba3b62a0b3
-  data.tar.gz: 188f144c3bad7eae1f6a21c9f30b674326bc596aa943ee087c3f6c0c5bcbf3837f16af5f387f6c8e39fb78e0a9f9b581834c4a2645dae59b0c557b763f04f9e5
+  metadata.gz: d60a8e33fbf0b2fafdacf03127fe1502efd60bc5fc69de9d97fa9ddd07d0505d3c6577f0fb078277980b6a024f76f88887fcd01e0798f02f6b55c41ebef65bbe
+  data.tar.gz: 838e7c67fa30ac58d2fefffd701394db75a632087c2440aaaac0d2fb3b349857c79eefd446089b6ccb6878232ed56c987dcd669847b1b4aff2cf40025e0df20e

data/CHANGELOG.md

@@ -6,6 +6,21 @@
 ### Fixed
 ### Security
 
+## [0.2.4] - 2018-04-02
+SrlRuby passes 10 tests out of 15 standard SRL tests in total. 
+### Changed
+- File `lib/srl_ruby/grammar.rb` grammar refactoring. Added support for new 'no digit' SRL expression.
+- Class `SrlRuby::ASTBuilder` updates to reflect changes in the grammar.
+- Class `Regex::Lookaround` refactored: now inherits from `Regex::MonadicExpression`
+- File `spec/integration_spec` renamed to `spec/srl_ruby_spec.rb`, ssytematic use of the API of SrlRuby module.
+
+### Fixed
+- Method `SrlRuby::ASTBuilder#reduce_one_of` now escapes character inside a character class.
+
+## [0.2.3] - 2018-03-15
+### Fixed
+- Fixed a number of Yard warnings.
+
 ## [0.2.2] - 2018-03-15
 ### Fixed
 - Fixed rley version dependency

data/lib/regex/character.rb

@@ -25,7 +25,8 @@ module Regex # This module is used as a namespace
       "\\7" => 7  
     }.freeze
 
-    MetaChars = '\^$+?.'.freeze
+    MetaChars = '\^$.|+?*()[]{}'.freeze
+    MetaCharsInClass = '\^[]-'.freeze # Characters with special meaning in char. class
 
     # The integer value that uniquely identifies the character.
     attr_reader(:codepoint)

data/lib/regex/lookaround.rb

@@ -5,7 +5,7 @@
 ########################
 
 
-require_relative 'polyadic_expression' # Access the superclass
+require_relative 'monadic_expression' # Access the superclass
 
 module Regex # This module is used as a namespace
   # Lookaround is a zero-width assertion just like the start and end of line
@@ -14,7 +14,7 @@ module Regex # This module is used as a namespace
   # return the result of the match: match or no match.
   # That is why they are called "assertions". They do not consume characters
   # from the subject, but only assert whether a match is possible or not.
-  class Lookaround < PolyadicExpression
+  class Lookaround < MonadicExpression
     # The "direction" of the lookaround. Can be ahead or behind. It specifies
     # the relative position of the expression to match compared to
     # the current 'position' in the subject text.
@@ -30,7 +30,7 @@ module Regex # This module is used as a namespace
     # [theDir]  One of the following values: [ :ahead, :behind ]
     # [theKind] One of the following values: [ :positive, :negative ]
     def initialize(assertedExpression, theDir, theKind)
-      super([assertedExpression])
+      super(assertedExpression)
       @dir = theDir
       @kind = theKind
     end
@@ -38,10 +38,9 @@ module Regex # This module is used as a namespace
     # Conversion method re-definition.
     # Purpose: Return the String representation of the captured expression.
     def to_str()
-      result = children[0].to_str
       dir_syntax = (dir == :ahead) ? '' : '<'
       kind_syntax = (kind == :positive) ? '=' : '!'
-      result << '(?' + dir_syntax + kind_syntax + children[1].to_str + ')'
+      result = '(?' + dir_syntax + kind_syntax + child.to_str + ')'
       return result
     end
   end # class

data/lib/srl_ruby/ast_builder.rb

@@ -91,16 +91,26 @@ module SrlRuby
       return_first_child(aRange, theTokens, theChildren)
     end
 
-    # rule('pattern' => %w[pattern separator quantifiable]).as 'pattern_sequence'
+    # rule('pattern' => %w[pattern separator sub_pattern]).as 'pattern_sequence'
     def reduce_pattern_sequence(_production, _range, _tokens, theChildren)
       return Regex::Concatenation.new(theChildren[0], theChildren[2])
     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'
+    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'
     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]
@@ -151,13 +161,6 @@ module SrlRuby
       return Regex::Anchor.new('$')
     end
 
-    # rule('anchorable' => %w[assertable assertion]).as 'asserted_anchorable'
-    def reduce_asserted_anchorable(_production, _range, _tokens, theChildren)
-      assertion = theChildren.last
-      assertion.children.unshift(theChildren[0])
-      return assertion
-    end
-
     # rule('assertion' => %w[IF FOLLOWED BY assertable]).as 'if_followed'
     def reduce_if_followed(_production, _range, _tokens, theChildren)
       return Regex::Lookaround.new(theChildren.last, :ahead, :positive)
@@ -218,11 +221,6 @@ module SrlRuby
       reduce_lowercase_from_to(aProduction, aRange, theTokens, theChildren)
     end
 
-    # rule('digit_range' => 'digit_or_number').as 'simple_digit_range'
-    def reduce_simple_digit_range(_production, _range, _tokens, _children)
-      char_shorthand('d')
-    end
-
     # rule('character_class' => %w[ANY CHARACTER]).as 'any_character'
     def reduce_any_character(_production, _range, _tokens, _children)
       char_shorthand('w')
@@ -233,6 +231,16 @@ module SrlRuby
       char_shorthand('W')
     end
 
+    # rule('character_class' => 'digit_or_number').as 'digit'
+    def reduce_digit(_production, _range, _tokens, _children)
+      char_shorthand('d')
+    end
+
+    # rule('character_class' => %w[NO DIGIT]).as 'non_digit'
+    def reduce_non_digit(_production, _range, _tokens, _children)
+      char_shorthand('D')
+    end
+
     # rule('character_class' => 'WHITESPACE').as 'whitespace'
     def reduce_whitespace(_production, _range, _tokens, _children)
       char_shorthand('s')
@@ -248,10 +256,18 @@ module SrlRuby
       wildcard
     end
 
-    # rule('alternation' => %w[ANY OF LPAREN alternatives RPAREN]).as 'any_of'
+    # rule('character_class' => %w[ONE OF STRING_LIT]).as 'one_of'
     def reduce_one_of(_production, _range, _tokens, theChildren)
       raw_literal = theChildren[-1].token.lexeme.dup
-      alternatives = raw_literal.chars.map { |ch| Regex::Character.new(ch) }
+      alternatives = raw_literal.chars.map do |ch|
+        if Regex::Character::MetaCharsInClass.include?(ch)
+          chars = [Regex::Character.new("\\"), Regex::Character.new(ch)]
+          Regex::Concatenation.new(*chars)
+        else
+          Regex::Character.new(ch)
+        end
+      end
+
       # TODO check other implementations
       return Regex::CharClass.new(false, *alternatives)
     end
@@ -263,7 +279,7 @@ module SrlRuby
 
     # rule('special_char' => 'BACKSLASH').as 'backslash'
     def reduce_backslash(_production, _range, _tokens, _children)
-      # Double the basckslash (because of escaping)
+      # Double the backslash (because of escaping)
       string_literal("\\", true)
     end
 
@@ -283,7 +299,17 @@ module SrlRuby
 
     # rule('alternation' => %w[ANY OF LPAREN alternatives RPAREN]).as 'any_of'
     def reduce_any_of(_production, _range, _tokens, theChildren)
-      return Regex::Alternation.new(*theChildren[3])
+      first_alternative = theChildren[3].first
+      result = nil
+
+      # Ugly: in SRL, comma is a dummy separator except in any of construct...
+      if theChildren[3].size == 1 && first_alternative.kind_of?(Regex::Concatenation)
+        result = Regex::Alternation.new(*first_alternative.children)
+      else
+        result = Regex::Alternation.new(*theChildren[3])
+      end
+
+      return result
     end
 
     # rule('alternatives' => %w[alternatives separator quantifiable]).as 'alternative_list'

data/lib/srl_ruby/grammar.rb

@@ -6,7 +6,7 @@ module SrlRuby
   builder = Rley::Syntax::GrammarBuilder.new do
     add_terminals('LPAREN', 'RPAREN', 'COMMA')
     add_terminals('DIGIT_LIT', 'INTEGER', 'LETTER_LIT')
-    add_terminals('LITERALLY', 'STRING_LIT')
+    add_terminals('LITERALLY', 'STRING_LIT', 'IDENTIFIER')
     add_terminals('BEGIN', 'STARTS', 'WITH')
     add_terminals('MUST', 'END')
     add_terminals('UPPERCASE', 'LETTER', 'FROM', 'TO')
@@ -26,8 +26,10 @@ module SrlRuby
     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 quantifiable]).as 'pattern_sequence'
-    rule('pattern' => 'quantifiable').as 'basic_pattern'
+    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'
@@ -43,7 +45,6 @@ module SrlRuby
     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('anchorable' => %w[assertable assertion]).as 'asserted_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'
@@ -64,9 +65,10 @@ module SrlRuby
     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('digit_range' => 'digit_or_number').as 'simple_digit_range'
     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'
@@ -84,6 +86,7 @@ module SrlRuby
     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'

data/lib/srl_ruby/tokenizer.rb

@@ -111,9 +111,10 @@ module SrlRuby
         token = build_token('INTEGER', lexeme) # An integer has 2..* digits
       elsif (lexeme = scanner.scan(/[0-9]/))
         token = build_token('DIGIT_LIT', lexeme)
-      elsif (lexeme = scanner.scan(/[a-zA-Z]{2,}/))
-        token = build_token(@@keywords[lexeme.upcase], lexeme)
-        # TODO: handle case unknown identifier
+      elsif (lexeme = scanner.scan(/[a-zA-Z_][a-zA-Z0-9_]+/))
+        keyw = @@keywords[lexeme.upcase]
+        tok_type = keyw ? keyw : 'IDENTIFIER'
+        token = build_token(tok_type, lexeme)
       elsif (lexeme = scanner.scan(/[a-zA-Z]((?=\s)|$)/))
         token = build_token('LETTER_LIT', lexeme)
       elsif (lexeme = scanner.scan(/"(?:\\"|[^"])*"/)) # Double quotes literal?
@@ -126,7 +127,7 @@ module SrlRuby
         erroneous = curr_ch.nil? ? '' : curr_ch
         sequel = scanner.scan(/.{1,20}/)
         erroneous += sequel unless sequel.nil?
-        raise ScanError.new("Unknown token #{erroneous}")
+        raise ScanError.new("Unknown token #{erroneous} on line #{lineno}")
       end
 
       return token
@@ -137,7 +138,7 @@ module SrlRuby
         col = scanner.pos - aLexeme.size - @line_start + 1
         pos = Position.new(@lineno, col)
         token = SrlToken.new(aLexeme, aSymbolName, pos)
-      rescue StandardError => exc
+      rescue Exception => exc
         puts "Failing with '#{aSymbolName}' and '#{aLexeme}'"
         raise exc
       end

data/lib/srl_ruby/version.rb

@@ -1,3 +1,3 @@
 module SrlRuby
-  VERSION = '0.2.2'.freeze
+  VERSION = '0.2.4'.freeze
 end

data/lib/srl_ruby.rb

@@ -21,7 +21,7 @@ module SrlRuby # This module is used as a namespace
   # @return [Regexp]  
   def self.parse(source)
     # Create a Rley facade object
-    engine = Rley::Engine.new
+    engine = Rley::Engine.new { |cfg| cfg.diagnose = true }
 
     # Step 1. Load SRL grammar
     engine.use_grammar(SrlRuby::Grammar)

data/spec/acceptance/srl_test_suite_spec.rb

@@ -3,8 +3,12 @@ require_relative './support/rule_file_parser'
 require_relative '../../lib/srl_ruby'
 
 ##############################
-# Understand how parser fails when first rule begins with %[...] instead of %w[...]
-##############################
+# Some rule files contain undocumented and unsupportd SRL expression:
+# | File name        | unrecognized input |
+# | no_word.rule     | 'no word'          |
+# | none_of.rule     | 'none of abcd'     |
+# | word.rule        | '(word)'           |
+
 
 RSpec.describe Acceptance do
   def rule_path
@@ -17,10 +21,10 @@ RSpec.describe Acceptance do
 
   def test_rule_file(aRuleFileRepr)
     regex = SrlRuby::parse(aRuleFileRepr.srl.value)
-    expect(regex).not_to be_nil
-     
+    expect(regex).to be_kind_of(Regexp)
+
     aRuleFileRepr.match_tests.each do |test|
-      expect(regex.match(test.test_string.value)).not_to be_nil
+      expect(test.test_string.value).to match(regex)
     end
     aRuleFileRepr.no_match_tests.each do |test|
       expect(regex.match(test.test_string.value)).to be_nil
@@ -42,21 +46,26 @@ RSpec.describe Acceptance do
     rule_file_repr = load_file('backslash.rule')
     test_rule_file(rule_file_repr)
   end
-  
+
   it 'should support named capture group' do
     rule_file_repr = load_file('basename_capture_group.rule')
     test_rule_file(rule_file_repr)
   end
-  
+
   it 'should match uppercase letter(s)' do
     rule_file_repr = load_file('issue_17_uppercase_letter.rule')
     test_rule_file(rule_file_repr)
-  end 
-  
+  end
+
   it 'should not trim literal strings' do
     rule_file_repr = load_file('literally_spaces.rule')
     test_rule_file(rule_file_repr)
-  end 
+  end
+
+  it 'should match non digit pattern' do
+    rule_file_repr = load_file('nondigit.rule')
+    test_rule_file(rule_file_repr)
+  end
 
   it 'should match a tab' do
     rule_file_repr = load_file('tab.rule')
@@ -72,4 +81,14 @@ RSpec.describe Acceptance do
     rule_file_repr = load_file('website_example_lookahead.rule')
     test_rule_file(rule_file_repr)
   end
+
+  it 'should not trim literal strings' do
+    rule_file_repr = load_file('website_example_password.rule')
+    test_rule_file(rule_file_repr)
+  end
+
+  it 'should' do
+    rule_file_repr = load_file('website_example_url.rule')
+    test_rule_file(rule_file_repr)
+  end
 end

data/spec/acceptance/support/rule_file_grammar.rb

@@ -17,22 +17,22 @@ builder = Rley::Syntax::GrammarBuilder.new do
   add_terminals('INTEGER', 'STRING_LIT')
   add_terminals('IDENTIFIER', 'SRL_SOURCE')  
 
-  rule('rule_file' => %w[srl_heading srl_tests]).as 'start_rule'
-  rule('srl_heading' => %w[SRL: SRL_SOURCE]).as 'srl_source'
-  rule('srl_tests' => %w[srl_tests single_test]).as 'test_list'
+  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' => %w[MATCH: STRING_LIT]).as 'match_string'
-  rule('no_match_test' => %w[NO MATCH: STRING_LIT]).as 'no_match_string'
-  rule('capture_test' => %w[capture_heading capture_expectations]).as 'capture_test'
-  rule('capture_heading' => %w[CAPTURE FOR STRING_LIT COLON]).as 'capture_string'
-  rule('capture_expectations' => %w[capture_expectations single_expectation]).as 'assertion_list'
+  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' => %w[DASH INTEGER COLON capture_variable COLON STRING_LIT]).as 'capture_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'
 end

data/spec/srl_ruby_spec.rb

@@ -0,0 +1,310 @@
+require_relative 'spec_helper' # Use the RSpec framework
+require_relative '../lib/srl_ruby'
+
+describe SrlRuby do
+  context 'Parsing character ranges:' do
+    it "should parse 'letter from ... to ...' syntax" do
+      regexp = SrlRuby.parse('letter from a to f')
+      expect(regexp.source).to eq('[a-f]')
+    end
+
+    it "should parse 'uppercase letter from ... to ...' syntax" do
+      regexp = SrlRuby.parse('UPPERCASE letter from A to F')
+      expect(regexp.source).to eq('[A-F]')
+    end
+
+    it "should parse 'letter' syntax" do
+      regexp = SrlRuby.parse('letter')
+      expect(regexp.source).to eq('[a-z]')
+    end
+
+    it "should parse 'uppercase letter' syntax" do
+      regexp = SrlRuby.parse('uppercase letter')
+      expect(regexp.source).to eq('[A-Z]')
+    end
+
+    it "should parse 'digit from ... to ...' syntax" do
+      regexp = SrlRuby.parse('digit from 1 to 4')
+      expect(regexp.source).to eq('[1-4]')
+    end
+  end # context
+
+  context 'Parsing string literals:' do
+    it 'should parse double quotes literal string' do
+      regexp = SrlRuby.parse('literally "hello"')
+      expect(regexp.source).to eq('hello')
+    end
+
+    it 'should parse single quotes literal string' do
+      regexp = SrlRuby.parse("literally 'hello'")
+      expect(regexp.source).to eq('hello')
+    end
+
+    it 'should escape special characters' do
+      regexp = SrlRuby.parse("literally '.'")
+      expect(regexp.source).to eq('\.')
+    end
+  end # context
+
+  context 'Parsing character classes:' do
+    it "should parse 'digit' syntax" do
+      regexp = SrlRuby.parse('digit')
+      expect(regexp.source).to eq('\d')
+    end
+
+    it "should parse 'number' syntax" do
+      regexp = SrlRuby.parse('number')
+      expect(regexp.source).to eq('\d')
+    end
+    
+    it "should parse 'no digit' syntax" do
+      regexp = SrlRuby.parse('no digit')
+      expect(regexp.source).to eq('\D')
+    end
+
+    it "should parse 'any character' syntax" do
+      regexp = SrlRuby.parse('any character')
+      expect(regexp.source).to eq('\w')
+    end
+
+    it "should parse 'no character' syntax" do
+      regexp = SrlRuby.parse('no character')
+      expect(regexp.source).to eq('\W')
+    end
+
+    it "should parse 'whitespace' syntax" do
+      regexp = SrlRuby.parse('whitespace')
+      expect(regexp.source).to eq('\s')
+    end
+
+    it "should parse 'no whitespace' syntax" do
+      regexp = SrlRuby.parse('no whitespace')
+      expect(regexp.source).to eq('\S')
+    end
+
+    it "should parse 'anything' syntax" do
+      regexp = SrlRuby.parse('anything')
+      expect(regexp.source).to eq('.')
+    end
+
+    it "should parse 'one of' syntax" do
+      regexp = SrlRuby.parse('one of "._%+-"')
+      # Remark: reference implementation less readable
+      # (escapes more characters than required)
+      expect(regexp.source).to eq('[._%+\-]')
+    end
+  end # context
+
+  context 'Parsing special character declarations:' do
+    it "should parse 'tab' syntax" do
+      regexp = SrlRuby.parse('tab')
+      expect(regexp.source).to eq('\t')
+    end
+
+    it "should parse 'backslash' syntax" do
+      regexp = SrlRuby.parse('backslash')
+      expect(regexp.source).to eq('\\\\')
+    end
+
+    it "should parse 'new line' syntax" do
+      regexp = SrlRuby.parse('new line')
+      expect(regexp.source).to eq('\n')
+    end
+  end # context
+
+  context 'Parsing alternations:' do
+    it "should parse 'any of' syntax" do
+      source = 'any of (any character, one of "._%-+")'
+      regexp = SrlRuby.parse(source)
+      expect(regexp.source).to eq('(?:\w|[._%\-+])')
+    end    
+    
+    it 'should anchor as alternative' do
+      regexp = SrlRuby.parse('any of (literally "?", must end)')
+      expect(regexp.source).to eq('(?:\\?|$)')
+    end    
+  end # context
+
+  context 'Parsing concatenation:' do
+    it 'should reject dangling comma' do
+      source = 'literally "a",'
+      err = StandardError
+      msg_pattern = /Premature end of input after ',' at position line 1, column 14/      
+      expect { SrlRuby.parse(source) }.to raise_error(err, msg_pattern)
+    end
+
+    it 'should parse concatenation' do
+      regexp = SrlRuby.parse('any of (literally "sample", (digit once or more))')
+      expect(regexp.source).to eq('(?:sample|(?:\d+))')
+    end
+
+    it 'should parse a long sequence of patterns' do
+      source = <<-END_SRL
+      any of (any character, one of "._%-+") once or more,
+      literally "@",
+      any of (digit, letter, one of ".-") once or more,
+      literally ".",
+      letter at least 2 times
+END_SRL
+
+      regexp = SrlRuby.parse(source)
+      # SRL: (?:\w|[\._%\-\+])+(?:@)(?:[0-9]|[a-z]|[\.\-])+(?:\.)[a-z]{2,}
+      expectation = '(?:\w|[._%\-+])+@(?:\d|[a-z]|[.\-])+\.[a-z]{2,}'
+      expect(regexp.source).to eq(expectation)
+    end
+  end # context
+
+  context 'Parsing quantifiers:' do
+    let(:prefix) { 'letter from p to t ' }
+
+    it "should parse 'once' syntax" do
+      regexp = SrlRuby.parse(prefix + 'once')
+      expect(regexp.source).to eq('[p-t]{1}')
+    end
+
+    it "should parse 'twice' syntax" do
+      regexp = SrlRuby.parse('digit twice')
+      expect(regexp.source).to eq('\d{2}')
+    end
+
+    it "should parse 'optional' syntax" do
+      regexp = SrlRuby.parse('anything optional')
+      expect(regexp.source).to eq('.?')
+    end
+
+    it "should parse 'exactly ... times' syntax" do
+      regexp = SrlRuby.parse('letter from a to f exactly 4 times')
+      expect(regexp.source).to eq('[a-f]{4}')
+    end
+
+    it "should parse 'between ... and ... times' syntax" do
+      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') 
+      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')
+      expect(regexp.source).to eq('[p-t]+')
+    end
+
+    it "should parse 'never or more' syntax" do
+      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')
+      expect(regexp.source).to eq('[p-t]{10,}')
+    end
+  end # context
+
+  context 'Parsing lookaround:' do
+    it 'should parse positive lookahead' do
+      regexp = SrlRuby.parse('letter if followed by (anything once or more, digit)')
+      expect(regexp.source).to eq('[a-z](?=(?:.+\d))')
+    end
+
+    it 'should parse negative lookahead' do
+      regexp = SrlRuby.parse('letter if not followed by (anything once or more, digit)')
+      expect(regexp.source).to eq('[a-z](?!(?:.+\d))')
+    end
+
+    it 'should parse positive lookbehind' do
+      regexp = SrlRuby.parse('literally "bar" if already had literally "foo"')
+      expect(regexp.source).to eq('bar(?<=foo)')
+    end
+
+    it 'should parse negative lookbehind' do
+      regexp = SrlRuby.parse('literally "bar" if not already had literally "foo"')
+      expect(regexp.source).to eq('bar(?<!foo)')
+    end
+  end # context
+
+  context 'Parsing capturing group:' do
+    it 'should parse simple anonymous capturing group' do
+      regexp = SrlRuby.parse('capture(literally "sample")')
+      expect(regexp.source).to eq('(sample)')
+    end
+
+    it 'should parse complex anonymous capturing group' do
+      source = 'capture(any of (literally "sample", (digit once or more)))'
+      regexp = SrlRuby.parse(source)
+      expect(regexp.source).to eq('((?:sample|(?:\d+)))')
+    end
+
+    it 'should parse simple anonymous until capturing group' do
+      regexp = SrlRuby.parse('capture anything once or more until literally "!"')
+      expect(regexp.source).to eq('(.+)!')
+    end
+
+    it 'should parse unquoted named capturing group' do
+      source = 'capture (anything once or more) as first, must end'
+      regexp = SrlRuby.parse(source)
+      expect(regexp.source).to eq('(?<first>.+)$')
+    end
+    
+    it 'should parse complex named capturing group' do
+      source = <<-END_SRL
+capture(any of (literally "sample", (digit once or more)))
+  as "foo"
+END_SRL
+      regexp = SrlRuby.parse(source)
+      expect(regexp.source).to eq('(?<foo>(?:sample|(?:\d+)))')
+    end
+
+    it 'should parse a sequence with named capturing groups' do
+      source = <<-END_SRL
+      capture (anything once or more) as "first",
+      literally " - ",
+      capture literally "second part" as "second"
+END_SRL
+      regexp = SrlRuby.parse(source)
+      expect(regexp.source).to eq('(?<first>.+) - (?<second>second part)')
+    end
+
+    it 'should parse complex named until capturing group' do
+      source = 'capture (anything once or more) as "foo" until literally "m"'
+      regexp = SrlRuby.parse(source)
+      expect(regexp.source).to eq('(?<foo>.+)m')
+    end
+  end # context
+
+  context 'Parsing anchors:' do
+    it 'should parse begin anchors' do
+      regexp = SrlRuby.parse('starts with literally "match"')
+      expect(regexp.source).to eq('^match')
+    end
+
+    it 'should parse begin anchors (alternative syntax)' do
+      regexp = SrlRuby.parse('begin with literally "match"')
+      expect(regexp.source).to eq('^match')
+    end
+
+    it 'should parse end anchors' do
+      regexp = SrlRuby.parse('literally "match" must end')
+      expect(regexp.source).to eq('match$')
+    end
+
+    it 'should parse combination of begin and end anchors' do
+      regexp = SrlRuby.parse('starts with literally "match" must end')
+      expect(regexp.source).to eq('^match$')
+    end
+
+    it 'should accept anchor with a sequence of patterns' do
+      source = <<-END_SRL
+      begin with any of (digit, letter, one of ".-") once or more,
+      literally ".",
+      letter at least 2 times must end
+END_SRL
+
+      regexp = SrlRuby.parse(source)
+      # SRL: (?:\w|[\._%\-\+])+(?:@)(?:[0-9]|[a-z]|[\.\-])+(?:\.)[a-z]{2,}
+      expect(regexp.source).to eq('^(?:\d|[a-z]|[.\-])+\.[a-z]{2,}$')
+    end        
+  end # context
+end # describe
+# End of file

data/srl_ruby.gemspec

@@ -55,7 +55,7 @@ END_DESCR
   spec.required_ruby_version = '>= 2.1.0'
   
   # Runtime dependencies
-  spec.add_dependency 'rley', '~> 0.6.03'
+  spec.add_dependency 'rley', '~> 0.6.05'
 
   # Development dependencies
   spec.add_development_dependency 'bundler', '~> 1.16'

data/srl_test/Test-Rules/website_example_password.rule

@@ -1,4 +1,4 @@
-srl: if followed by (anything never or more, letter), if followed by (anything never or more, uppercase letter), if followed by (anything never or more, digit), if followed by (anything never or more, one of "!@#$%^&*[]\"';:_-<>., =+/\\"), anything at least 8 time
+srl: if followed by (anything never or more, letter), if followed by (anything never or more, uppercase letter), if followed by (anything never or more, digit), if followed by (anything never or more, one of "!@#$%^&*[]\"';:_-<>., =+/\\"), anything at least 8 times
 match: "P@sSword1"
 match: "Pass-w0rd"
 match: "Th1s is Secure"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: srl_ruby
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.4
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-15 00:00:00.000000000 Z
+date: 2018-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.03
+        version: 0.6.05
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.03
+        version: 0.6.05
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -120,12 +120,12 @@ files:
 - spec/acceptance/support/rule_file_parser.rb
 - spec/acceptance/support/rule_file_token.rb
 - spec/acceptance/support/rule_file_tokenizer.rb
-- spec/integration_spec.rb
 - spec/regex/character_spec.rb
 - spec/regex/multiplicity_spec.rb
 - spec/spec_helper.rb
 - spec/srl_ruby/srl_ruby_spec.rb
 - spec/srl_ruby/tokenizer_spec.rb
+- spec/srl_ruby_spec.rb
 - srl_ruby.gemspec
 - srl_test/README.md
 - srl_test/Test-Rules/README.md
@@ -173,8 +173,8 @@ summary: srl_ruby is a gem implementing a parser for Simple Regex Language (SRL)
   literals.
 test_files:
 - spec/acceptance/srl_test_suite_spec.rb
-- spec/integration_spec.rb
 - spec/regex/character_spec.rb
 - spec/regex/multiplicity_spec.rb
 - spec/srl_ruby/srl_ruby_spec.rb
 - spec/srl_ruby/tokenizer_spec.rb
+- spec/srl_ruby_spec.rb

data/spec/integration_spec.rb

@@ -1,451 +0,0 @@
-require_relative 'spec_helper' # Use the RSpec framework
-require_relative '../lib/srl_ruby/tokenizer'
-require_relative '../lib/srl_ruby/grammar'
-require_relative '../lib/srl_ruby/ast_builder'
-
-module SrlRuby
-  describe 'Integration tests:' do
-    def parse(someSRL)
-      tokenizer = SrlRuby::Tokenizer.new(someSRL)
-      @engine.parse(tokenizer.tokens)
-    end
-
-    def regexp_repr(aResult)
-      # Generate an abstract syntax parse tree from the parse result
-      tree = @engine.convert(aResult)
-      tree.root
-    end
-    
-    before(:each) do
-      @engine = Rley::Engine.new do |config|
-        config.repr_builder = ASTBuilder
-      end
-      @engine.use_grammar(SrlRuby::Grammar)
-    end
-
-    context 'Parsing character ranges:' do
-      it "should parse 'letter from ... to ...' syntax" do
-        result = parse('letter from a to f')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('[a-f]')
-      end
-
-      it "should parse 'uppercase letter from ... to ...' syntax" do
-        result = parse('UPPERCASE letter from A to F')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('[A-F]')
-      end
-
-      it "should parse 'letter' syntax" do
-        result = parse('letter')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('[a-z]')
-      end
-
-      it "should parse 'uppercase letter' syntax" do
-        result = parse('uppercase letter')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('[A-Z]')
-      end
-
-      it "should parse 'digit from ... to ...' syntax" do
-        result = parse('digit from 1 to 4')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('[1-4]')
-      end
-    end # context
-
-    context 'Parsing string literals:' do
-      it 'should parse double quotes literal string' do
-        result = parse('literally "hello"')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('hello')
-      end
-
-      it 'should parse single quotes literal string' do
-        result = parse("literally 'hello'")
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('hello')
-      end
-
-      it 'should escape special characters' do
-        result = parse("literally '.'")
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('\.')
-      end
-    end
-
-    context 'Parsing character classes:' do
-      it "should parse 'digit' syntax" do
-        result = parse('digit')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('\d')
-      end
-
-      it "should parse 'number' syntax" do
-        result = parse('number')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('\d')
-      end
-
-      it "should parse 'any character' syntax" do
-        result = parse('any character')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('\w')
-      end
-
-      it "should parse 'no character' syntax" do
-        result = parse('no character')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('\W')
-      end
-
-      it "should parse 'whitespace' syntax" do
-        result = parse('whitespace')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('\s')
-      end
-
-      it "should parse 'no whitespace' syntax" do
-        result = parse('no whitespace')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('\S')
-      end
-
-      it "should parse 'anything' syntax" do
-        result = parse('anything')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('.')
-      end
-
-      it "should parse 'one of' syntax" do
-        result = parse('one of "._%+-"')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        # Remark: reference implementation less readable
-        # (escapes more characters than required)
-        expect(regexp.to_str).to eq('[._%+\-]')
-      end
-    end # context
-
-    context 'Parsing special character declarations:' do
-      it "should parse 'tab' syntax" do
-        result = parse('tab')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('\t')
-      end
-
-      it "should parse 'backslash' syntax" do
-        result = parse('backslash')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('\\\\')
-      end
-
-      it "should parse 'new line' syntax" do
-        result = parse('new line')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('\n')
-      end
-    end # context
-
-    context 'Parsing alternations:' do
-      it "should parse 'any of' syntax" do
-        source = 'any of (any character, one of "._%-+")'
-        result = parse(source)
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('(?:\w|[._%\-+])')
-      end
-    end # context
-
-    context 'Parsing concatenation:' do
-      it 'should reject dangling comma' do
-        source = 'literally "a",'
-        result = parse(source)
-        expect(result).not_to be_success
-        message_prefix = /Premature end of input after ','/
-        expect(result.failure_reason.message).to match(message_prefix)
-      end
-      
-      it 'should parse concatenation' do
-        result = parse('any of (literally "sample", (digit once or more))')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('(?:sample|(?:\d+))')
-      end
-
-      it 'should parse a long sequence of patterns' do
-        source = <<-ENDS
-        any of (any character, one of "._%-+") once or more,
-        literally "@",
-        any of (digit, letter, one of ".-") once or more,
-        literally ".",
-        letter at least 2 times
-  ENDS
-
-        result = parse(source)
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        # SRL: (?:\w|[\._%\-\+])+(?:@)(?:[0-9]|[a-z]|[\.\-])+(?:\.)[a-z]{2,}
-        expectation = '(?:\w|[._%\-+])+@(?:\d|[a-z]|[.\-])+\.[a-z]{2,}'
-        expect(regexp.to_str).to eq(expectation)
-      end
-    end # context
-
-    context 'Parsing quantifiers:' do
-      let(:prefix) { 'letter from p to t ' }
-
-      it "should parse 'once' syntax" do
-        result = parse(prefix + 'once')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('[p-t]{1}')
-      end
-
-      it "should parse 'twice' syntax" do
-        result = parse('digit twice')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('\d{2}')
-      end
-
-      it "should parse 'optional' syntax" do
-        result = parse('anything optional')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('.?')
-      end
-
-      it "should parse 'exactly ... times' syntax" do
-        result = parse('letter from a to f exactly 4 times')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('[a-f]{4}')
-      end
-
-      it "should parse 'between ... and ... times' syntax" do
-        result = parse(prefix + 'between 2 and 4 times')
-        expect(result).to be_success
-
-        # Dropping 'times' keyword is shorter syntax
-        expect(parse(prefix + 'between 2 and 4')).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('[p-t]{2,4}')
-      end
-
-      it "should parse 'once or more' syntax" do
-        result = parse(prefix + 'once or more')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('[p-t]+')
-      end
-
-      it "should parse 'never or more' syntax" do
-        result = parse(prefix + 'never or more')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('[p-t]*')
-      end
-
-      it "should parse 'at least  ... times' syntax" do
-        result = parse(prefix + 'at least 10 times')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('[p-t]{10,}')
-      end
-    end # context
-
-    context 'Parsing lookaround:' do
-      it 'should parse positive lookahead' do
-        result = parse('letter if followed by (anything once or more, digit)')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('[a-z](?=(?:.+\d))')
-      end
-      
-      it 'should parse negative lookahead' do
-        result = parse('letter if not followed by (anything once or more, digit)')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('[a-z](?!(?:.+\d))')
-      end
-
-      it 'should parse positive lookbehind' do
-        result = parse('literally "bar" if already had literally "foo"')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('bar(?<=foo)')
-      end
-
-      it 'should parse negative lookbehind' do
-        result = parse('literally "bar" if not already had literally "foo"')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('bar(?<!foo)')
-      end    
-    end # context
-    
-    context 'Parsing capturing group:' do
-      it 'should parse simple anonymous capturing group' do
-        result = parse('capture(literally "sample")')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('(sample)')
-      end  
-    
-      it 'should parse complex anonymous capturing group' do
-        source = 'capture(any of (literally "sample", (digit once or more)))'
-        result = parse(source)
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('((?:sample|(?:\d+)))')
-      end
-      
-      it 'should parse simple anonymous until capturing group' do
-        result = parse('capture anything once or more until literally "!"')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('(.+)!')
-      end
-
-      it 'should parse complex named capturing group' do
-        source = <<-END_SRL
-  capture(any of (literally "sample", (digit once or more)))
-    as "foo"      
-  END_SRL
-        result = parse(source)
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('(?<foo>(?:sample|(?:\d+)))')
-      end
-      
-      it 'should parse a sequence with named capturing groups' do
-        source = <<-ENDS
-        capture (anything once or more) as "first",
-        literally " - ", 
-        capture literally "second part" as "second"
-  ENDS
-        result = parse(source)
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('(?<first>.+) - (?<second>second part)')
-      end   
-
-      it 'should parse complex named until capturing group' do
-        source = 'capture (anything once or more) as "foo" until literally "m"'
-        result = parse(source)
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('(?<foo>.+)m')
-      end   
-    end # context
-
-    context 'Parsing anchors:' do
-      it 'should parse begin anchors' do
-        result = parse('starts with literally "match"')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('^match')
-      end
-
-      it 'should parse begin anchors (alternative syntax)' do
-        result = parse('begin with literally "match"')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('^match')
-      end
-
-      it 'should parse end anchors' do
-        result = parse('literally "match" must end')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('match$')
-      end
-
-      it 'should parse combination of begin and end anchors' do
-        result = parse('starts with literally "match" must end')
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        expect(regexp.to_str).to eq('^match$')
-      end
-
-      it 'should accept anchor with a sequence of patterns' do
-        source = <<-ENDS
-        begin with any of (digit, letter, one of ".-") once or more,
-        literally ".",
-        letter at least 2 times must end
-  ENDS
-
-        result = parse(source)
-        expect(result).to be_success
-
-        regexp = regexp_repr(result)
-        # SRL: (?:\w|[\._%\-\+])+(?:@)(?:[0-9]|[a-z]|[\.\-])+(?:\.)[a-z]{2,}
-        expect(regexp.to_str).to eq('^(?:\d|[a-z]|[.\-])+\.[a-z]{2,}$')
-      end
-    end # context
-  end # describe
-end # module
-# End of file