srl_ruby 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 192758cce667147a6b7369cf6d575aa7fb22b627
-  data.tar.gz: 3f851cdb8557bc8baba910ded6e4e0433851fa6a
+  metadata.gz: 5d359b7fdd648df4b9e77e0bf64266b3fec2d474
+  data.tar.gz: 7a8a1efb3f978b8f45b15c47c0b457a6109daf37
 SHA512:
-  metadata.gz: d88c26d001764e3b224e9e6f2346791300624d348d825098bf1fedd658bcb3b66234c868144d83d6a8f6a02740dc36805cd765417af16f44ed6f4e6698ac647f
-  data.tar.gz: ced3406cfd86aed12bb5ca64ec7917cb9f3fdcbf20b29027c993b6e1402d793b2a5d5b9907c4de75cc293e04148f037208d232b7e7ed373b11d1d958a7e4f025
+  metadata.gz: 20c7d24104afefa0371692ca2f0713916b9a6edbc1825c32bb77ff1c29760fa46bd04731ab88914f8dbd1d97f1cbd523f8b5e765d57ad0cf9ea7938110161c95
+  data.tar.gz: 9110435c0ae7bf089c167a46c81f6aabe91a7f9d52926843654972877aef2ccc1838c5a5218e8eac1f628cf95328f1f044a62b9d1fc4cfbcc6db49752b24b9ee

data/.rubocop.yml

@@ -1,3 +1,31 @@
+AllCops:
+  Exclude:
+    - 'exp/**/*'    
+
 Layout/EndOfLine:
   Enabled: true
-  EnforcedStyle: lf
+  EnforcedStyle: lf
+ 
+Metrics/BlockLength:
+  Enabled: true
+  Max: 300
+  
+Metrics/MethodLength:
+  Enabled: true
+  Max: 30
+ 
+Metrics/ModuleLength:
+  Enabled: true
+  Max: 500
+  
+Naming/ConstantName:
+  Enabled: false
+  
+Naming/VariableName:
+  Enabled: false
+  
+Style/CommentedKeyword:
+  Enabled: false
+  
+Style/RedundantReturn:
+  Enabled: false  

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [0.3.3] - 2018-04-19
+### Changed
+- Binary `srl_ruby` now accepts a SRL filename as command-line argument. Command-line documentation updated.
+
+### Fixed
+- Method `Tokenizer#_next_token` failed to recognize single letter followed by a comma
+- Binary `srl_ruby` now loads source files from correct filepath
+- Module `SRL` is no more an ancestor of class `Multiplicity`.
+
+
 ## [0.3.2] - 2018-04-13
 ### Added
 - `Cucumber` feature files are now part of the gem.

data/Rakefile

@@ -7,13 +7,12 @@ RSpec::Core::RakeTask.new do |spec|
   spec.pattern = 'spec/**/*_spec.rb'
 end
 
-
 Cucumber::Rake::Task.new do |_|
 end
 
 # Combine RSpec and Cucumber tests
 desc 'Run tests, with RSpec and Cucumber'
-task test: [:spec, :cucumber]
+task test: %i[spec cucumber]
 
 # Default rake task
 task default: :test

data/bin/srl_ruby

@@ -1,28 +1,51 @@
 #!/usr/bin/env ruby
-require_relative '../lib/srl_ruby/srl_ruby'
+require_relative '../lib/srl_ruby'
 
+my_name = File.basename(__FILE__)
+my_version = SrlRuby::VERSION
+puts "#{my_name} v. #{my_version}"
 
 # Parse the input expression in command-line
 if ARGV.empty?
-  my_name = File.basename(__FILE__)
-  msg = <<-END_MSG
-Simple Regex Language parser:
-- Parses a subset of the SRL language and displays the parse tree
-
-Command-line syntax:
-  ruby #{my_name} "SRL expression"
-  where:
-    the SRL expression is enclosed between double quotes (")
-
-  Examples:
-  ruby #{my_name} "letter from a to f exactly 4 times"
-  ruby #{my_name} "uppercase letter between 2 and 3 times"
-  ruby #{my_name} "digit from 0 to 7 once or more"
-END_MSG
+  msg = <<-MSG
+  Simple Regex Language compiler:
+  - Parses an SRL expression and displays the corresponding Regexp literal
+
+  Command-line syntax (I):
+  ========================
+    #{my_name} "SRL expression"
+    where:
+      the SRL expression is enclosed between double quotes (")
+
+    Examples:
+    #{my_name} "letter from a to f exactly 4 times"
+    #{my_name} "uppercase letter between 2 and 3 times"
+    #{my_name} "digit from 0 to 7 once or more"
+    
+  Command-line syntax (II):
+  ========================
+    #{my_name} -f filename
+    where:
+      the filename is a text file containing the SRL expression to compile
+      
+    Examples:
+    #{my_name} -f hexadecimal.srl
+MSG
   puts msg
   exit(1)
 end
-puts 'SRL input: ' + ARGV[0]
-puts 'Resulting Regexp: /' + SrlRuby.parse(ARGV[0]) + '/'
+
+
+if ARGV[0] =~ /^--?fi?l?e?$/
+  srl_file = ARGV[1]
+  result = SrlRuby.load_file(srl_file)
+else
+  srl_expr = ARGV[0]
+  puts 'SRL input: ' + srl_expr
+  result = SrlRuby.parse(srl_expr)
+end
+
+puts 'Resulting Regexp: /' + result.to_s + '/'
+
 
 # End of file

data/lib/regex/char_range.rb

@@ -7,9 +7,9 @@ module Regex # This module is used as a namespace
   # Assumption: characters are ordered by codepoint
   class CharRange < PolyadicExpression
     # Constructor.
-    # [thelowerBound] 
+    # [thelowerBound]
     #   A character that will be the lower bound value for the range.
-    # [theUpperBound] 
+    # [theUpperBound]
     #   A character that will be the upper bound value for the range.
     # TODO: optimisation. Build a Character if lower bound == upper bound.
     def initialize(theLowerBound, theUpperBound)

data/lib/regex/multiplicity.rb

@@ -1,91 +1,89 @@
 # File: Multiplicity.rb
 
-module SRL
-  module Regex # This module is used as a namespace
-    # The multiplicity specifies by how much a given expression can be repeated.
-    class Multiplicity
-      # The lowest acceptable repetition count
-      attr_reader(:lower_bound)
+module Regex # This module is used as a namespace
+  # The multiplicity specifies by how much a given expression can be repeated.
+  class Multiplicity
+    # The lowest acceptable repetition count
+    attr_reader(:lower_bound)
 
-      # The highest possible repetition count
-      attr_reader(:upper_bound)
+    # The highest possible repetition count
+    attr_reader(:upper_bound)
 
-      # An indicator that specifies how to repeat (:greedy, :lazy, :possessive)
-      attr_reader(:policy)
+    # An indicator that specifies how to repeat (:greedy, :lazy, :possessive)
+    attr_reader(:policy)
 
-      # @param aLowerBound [Integer]
-      # @param anUpperBound [Integer, Symbol] integer or :more symbol
-      # @param aPolicy [Symbol] One of: (:greedy, :lazy, :possessive)
-      def initialize(aLowerBound, anUpperBound, aPolicy)
-        @lower_bound = valid_lower_bound(aLowerBound)
-        @upper_bound = valid_upper_bound(anUpperBound)
-        @policy = valid_policy(aPolicy)
-      end
-
-      # Purpose: Return the String representation of the multiplicity.
-      def to_str()
-        case upper_bound
-          when :more
-            case lower_bound
-              when 0
-                subresult = '*'
-              when 1
-                subresult = '+'
-              else
-                subresult = "{#{lower_bound},}"
-            end
+    # @param aLowerBound [Integer]
+    # @param anUpperBound [Integer, Symbol] integer or :more symbol
+    # @param aPolicy [Symbol] One of: (:greedy, :lazy, :possessive)
+    def initialize(aLowerBound, anUpperBound, aPolicy)
+      @lower_bound = valid_lower_bound(aLowerBound)
+      @upper_bound = valid_upper_bound(anUpperBound)
+      @policy = valid_policy(aPolicy)
+    end
 
-          when lower_bound
-            subresult = "{#{lower_bound}}"
-          else
-            if [lower_bound, upper_bound] == [0, 1]
-              subresult = '?'
+    # Purpose: Return the String representation of the multiplicity.
+    def to_str()
+      case upper_bound
+        when :more
+          case lower_bound
+            when 0
+              subresult = '*'
+            when 1
+              subresult = '+'
             else
-              subresult = "{#{lower_bound},#{upper_bound}}"
-            end
-        end
+              subresult = "{#{lower_bound},}"
+          end
 
-        suffix = case policy
-          when :greedy
-            ''
-          when :lazy
-            '?'
-          when :possessive
-            '+'
-        end
+        when lower_bound
+          subresult = "{#{lower_bound}}"
+        else
+          if [lower_bound, upper_bound] == [0, 1]
+            subresult = '?'
+          else
+            subresult = "{#{lower_bound},#{upper_bound}}"
+          end
+      end
 
-        return subresult + suffix
+      suffix = case policy
+        when :greedy
+          ''
+        when :lazy
+          '?'
+        when :possessive
+          '+'
       end
 
-      private
+      return subresult + suffix
+    end
 
-      # Validation method. Return the validated lower bound value
-      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
+    private
 
-      # Validation method. Return the validated lower bound value
-      def valid_upper_bound(anUpperBound)
-        err_msg = "Invalid upper bound of repetition count #{anUpperBound}"
-        unless anUpperBound.kind_of?(Integer) || (anUpperBound == :more)
-          raise StandardError, err_msg
-        end
+    # Validation method. Return the validated lower bound value
+    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
 
-        return anUpperBound
+    # Validation method. Return the validated lower bound value
+    def valid_upper_bound(anUpperBound)
+      err_msg = "Invalid upper bound of repetition count #{anUpperBound}"
+      unless anUpperBound.kind_of?(Integer) || (anUpperBound == :more)
+        raise StandardError, err_msg
       end
 
-      # Validation method. Return the validated policy value.
-      def valid_policy(aPolicy)
-        err_msg = "Invalid repetition policy '#{aPolicy}'."
-        valid_policies = %i[greedy lazy possessive]
-        raise StandardError, err_msg unless valid_policies.include? aPolicy
+      return anUpperBound
+    end
 
-        return aPolicy
-      end
-    end # class
-  end # module
+    # Validation method. Return the validated policy value.
+    def valid_policy(aPolicy)
+      err_msg = "Invalid repetition policy '#{aPolicy}'."
+      valid_policies = %i[greedy lazy possessive]
+      raise StandardError, err_msg unless valid_policies.include? aPolicy
+
+      return aPolicy
+    end
+  end # class
 end # module
 
 # End of file

data/lib/srl_ruby/ast_builder.rb

@@ -34,7 +34,7 @@ module SrlRuby
     end
 
     def multiplicity(lowerBound, upperBound)
-      return SRL::Regex::Multiplicity.new(lowerBound, upperBound, :greedy)
+      return Regex::Multiplicity.new(lowerBound, upperBound, :greedy)
     end
 
     def string_literal(aString, to_escape = true)

data/lib/srl_ruby/grammar.rb

@@ -6,11 +6,11 @@ module SrlRuby
   builder = Rley::Syntax::GrammarBuilder.new do
     # Separators...
     add_terminals('LPAREN', 'RPAREN', 'COMMA')
-    
+
     # Literal values...
     add_terminals('DIGIT_LIT', 'INTEGER', 'LETTER_LIT', 'CHAR_CLASS')
     add_terminals('LITERALLY', 'STRING_LIT', 'IDENTIFIER')
-    
+
     # Keywords...
     add_terminals('BEGIN', 'STARTS', 'WITH')
     add_terminals('MUST', 'END', 'RAW')
@@ -74,8 +74,8 @@ module SrlRuby
     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' => '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'
@@ -123,5 +123,6 @@ module SrlRuby
   end
 
   # And now build the grammar and make it accessible via a global constant
+  # [Rley::Syntax::Grammar]
   Grammar = builder.grammar
 end # module

data/lib/srl_ruby/tokenizer.rb

@@ -124,7 +124,7 @@ module SrlRuby
       elsif (lexeme = scanner.scan(/'(?:\\'|[^'])*'/)) # Single quotes literal?
         unquoted = lexeme.gsub(/(^')|('$)/, '')
         token = build_token('STRING_LIT', unquoted)
-      elsif (lexeme = scanner.scan(/[a-zA-Z]((?=\s)|$)/))        
+      elsif (lexeme = scanner.scan(/[a-zA-Z]((?=\s|,)|$)/))        
         token = build_token('LETTER_LIT', lexeme)
       elsif (lexeme = scanner.scan(/[a-zA-Z_][a-zA-Z0-9_]+/))
         keyw = @@keywords[lexeme.upcase]
@@ -133,7 +133,7 @@ module SrlRuby
       elsif (lexeme = scanner.scan(/[^,"\s]{2,}/))
         token = build_token('CHAR_CLASS', lexeme)
       else # Unknown token
-        erroneous = curr_ch.nil? ? '' : curr_ch
+        erroneous = curr_ch.nil? ? '' : scanner.scan(/./)
         sequel = scanner.scan(/.{1,20}/)
         erroneous += sequel unless sequel.nil?
         raise ScanError.new("Unknown token #{erroneous} on line #{lineno}")

data/lib/srl_ruby/version.rb

@@ -1,3 +1,3 @@
 module SrlRuby
-  VERSION = '0.3.2'.freeze
+  VERSION = '0.3.3'.freeze
 end

data/lib/srl_ruby.rb

@@ -3,22 +3,29 @@ require_relative './srl_ruby/tokenizer'
 require_relative './srl_ruby/grammar'
 require_relative './srl_ruby/ast_builder'
 
-module SrlRuby # This module is used as a namespace
-  # Load the SRL expression contained in filename. 
-  # Returns an equivalent Regexp object. 
-  # @param filename [String] file name to parse.
-  # @return [Regexp]
+module SrlRuby
+  # Compile the SRL expression in given filename into a Regexp object.
+  # @param filename [String] Name of SRL file to parse
+  # @return [Regexp] A regexp object equivalent to the SRL expression.
   def self.load_file(filename)
     source = nil
     File.open(filename, 'r') { |f| source = f.read }
     return source if source.nil? || source.empty?
-    
+
     return parse(source)
   end
-  
-  # Parse the SRL expression into its Regexp equivalent.
-  # @param source [String] the SRL source to parse and convert.
-  # @return [Regexp]  
+
+  # Compile the given SRL expression into its Regexp equivalent.
+  # @param source [String] SRL expression to parse
+  # @return [Regexp] A regexp object equivalent to the SRL expression.
+  # @example Matching a (signed) integer literal
+  #   some_srl =<<-SRL
+  #     begin with
+  #       (one of "+-") optional,
+  #       digit once or more,
+  #     must end
+  #   SRL
+  #   regex = SrlRuby::API.parse(some_srl) # => regex == /^[+\-]?\d+$/
   def self.parse(source)
     # Create a Rley facade object
     engine = Rley::Engine.new { |cfg| cfg.diagnose = true }
@@ -42,8 +49,6 @@ module SrlRuby # This module is used as a namespace
 
     # Now output the regexp literal
     root = ast_ptree.root
-    # puts root.to_str # TODO remove this line
-    # pp root
     return Regexp.new(root.to_str)
   end
 end # module

data/spec/acceptance/support/rule_file_nodes.rb

@@ -37,9 +37,9 @@ module Acceptance
       self.srl = aSRLExpression.dup
       self.match_tests = []
       self.no_match_tests = []
-		  self.capture_tests = []
+      self.capture_tests = []
     end
-	end
+  end
 
   MatchTest = Struct.new(:test_string)
   NoMatchTest = Struct.new(:test_string)

data/spec/regex/multiplicity_spec.rb

@@ -3,77 +3,75 @@
 require_relative '../spec_helper' # Use the RSpec test framework
 require_relative '../../lib/regex/multiplicity'
 
-module SRL
-  # Reopen the module, in order to get rid of fully qualified names
-  module Regex # This module is used as a namespace
-    describe Multiplicity do
-      context 'Creation & initialisation' do
-        it 'should be created with 3 arguments' do
-          # Valid cases: initialized with two integer values and a policy symbol
-          %i[greedy lazy possessive].each do |aPolicy|
-            expect { Multiplicity.new(0, 1, aPolicy) }.not_to raise_error
-          end
-
-          # Invalid case: initialized with invalid policy value
-          err = StandardError
-          msg = "Invalid repetition policy 'KO'."
-          expect { Multiplicity.new(0, :more, 'KO') }.to raise_error(err, msg)
+# Reopen the module, in order to get rid of fully qualified names
+module Regex # This module is used as a namespace
+  describe Multiplicity do
+    context 'Creation & initialisation' do
+      it 'should be created with 3 arguments' do
+        # Valid cases: initialized with two integer values and a policy symbol
+        %i[greedy lazy possessive].each do |aPolicy|
+          expect { Multiplicity.new(0, 1, aPolicy) }.not_to raise_error
         end
+
+        # Invalid case: initialized with invalid policy value
+        err = StandardError
+        msg = "Invalid repetition policy 'KO'."
+        expect { Multiplicity.new(0, :more, 'KO') }.to raise_error(err, msg)
       end
+    end
 
-      context 'Provided services' do
-        it 'should know its text representation' do
-          policy2text = { greedy: '', lazy: '?', possessive: '+' }
+    context 'Provided services' do
+      it 'should know its text representation' do
+        policy2text = { greedy: '', lazy: '?', possessive: '+' }
 
-          # Case: zero or one
-          policy2text.each_key do |aPolicy|
-            multi = Multiplicity.new(0, 1, aPolicy)
-            expect(multi.to_str).to eq("?#{policy2text[aPolicy]}")
-          end
+        # Case: zero or one
+        policy2text.each_key do |aPolicy|
+          multi = Multiplicity.new(0, 1, aPolicy)
+          expect(multi.to_str).to eq("?#{policy2text[aPolicy]}")
+        end
 
-          # Case: zero or more
-          policy2text.each_key do |aPolicy|
-            multi = Multiplicity.new(0, :more, aPolicy)
-            expect(multi.to_str).to eq("*#{policy2text[aPolicy]}")
-          end
+        # Case: zero or more
+        policy2text.each_key do |aPolicy|
+          multi = Multiplicity.new(0, :more, aPolicy)
+          expect(multi.to_str).to eq("*#{policy2text[aPolicy]}")
+        end
 
-          # Case: one or more
-          policy2text.each_key do |aPolicy|
-            multi = Multiplicity.new(1, :more, aPolicy)
-            expect(multi.to_str).to eq("+#{policy2text[aPolicy]}")
-          end
+        # Case: one or more
+        policy2text.each_key do |aPolicy|
+          multi = Multiplicity.new(1, :more, aPolicy)
+          expect(multi.to_str).to eq("+#{policy2text[aPolicy]}")
+        end
 
-          # Case: exactly m times
-          policy2text.each_key do |aPolicy|
-            samples = [1, 2, 5, 100]
-            samples.each do |aCount|
-              multi = Multiplicity.new(aCount, aCount, aPolicy)
-              expect(multi.to_str).to eq("{#{aCount}}#{policy2text[aPolicy]}")
-            end
+        # Case: exactly m times
+        policy2text.each_key do |aPolicy|
+          samples = [1, 2, 5, 100]
+          samples.each do |aCount|
+            multi = Multiplicity.new(aCount, aCount, aPolicy)
+            expect(multi.to_str).to eq("{#{aCount}}#{policy2text[aPolicy]}")
           end
+        end
 
-          # Case: m, n times
-          policy2text.each_key do |aPolicy|
-            samples = [1, 2, 5, 100]
-            samples.each do |aCount|
-              upper = aCount + 1 + rand(20)
-              multi = Multiplicity.new(aCount, upper, aPolicy)
-              expectation = "{#{aCount},#{upper}}#{policy2text[aPolicy]}"
-              expect(multi.to_str).to eq(expectation)
-            end
+        # Case: m, n times
+        policy2text.each_key do |aPolicy|
+          samples = [1, 2, 5, 100]
+          samples.each do |aCount|
+            upper = aCount + 1 + rand(20)
+            multi = Multiplicity.new(aCount, upper, aPolicy)
+            expectation = "{#{aCount},#{upper}}#{policy2text[aPolicy]}"
+            expect(multi.to_str).to eq(expectation)
           end
+        end
 
-          # Case: m or more
-          policy2text.each_key do |aPolicy|
-            samples = [2, 3, 5, 100]
-            samples.each do |aCount|
-              multi = Multiplicity.new(aCount, :more, aPolicy)
-              expect(multi.to_str).to eq("{#{aCount},}#{policy2text[aPolicy]}")
-            end
+        # Case: m or more
+        policy2text.each_key do |aPolicy|
+          samples = [2, 3, 5, 100]
+          samples.each do |aCount|
+            multi = Multiplicity.new(aCount, :more, aPolicy)
+            expect(multi.to_str).to eq("{#{aCount},}#{policy2text[aPolicy]}")
           end
         end
       end
     end
-  end # module
+  end
 end # module
 # End of file

data/spec/spec_helper.rb

@@ -5,7 +5,7 @@ require_relative '../lib/srl_ruby'
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure
   config.example_status_persistence_file_path = '.rspec_status'
-  
+
   config.expect_with :rspec do |c|
     # Disable the `should` syntax...
     c.syntax = :expect

data/spec/srl_ruby/tokenizer_spec.rb

@@ -10,9 +10,9 @@ module SrlRuby
         expect(token.lexeme).to eq(lexeme)
       end
     end
-  
-    subject { Tokenizer.new('') }    
-    
+
+    subject { Tokenizer.new('') }
+
     context 'Initialization:' do
       it 'should be initialized with a text to tokenize and a grammar' do
         expect { Tokenizer.new('anything') }.not_to raise_error
@@ -31,7 +31,7 @@ module SrlRuby
         expect(token.terminal).to eq('COMMA')
         expect(token.lexeme).to eq(',')
       end
-      
+
       it 'should tokenize keywords' do
         sample = 'between Exactly oncE optional TWICE'
         subject.scanner.string = sample
@@ -40,14 +40,14 @@ module SrlRuby
           expect(tok.terminal).to eq(tok.lexeme.upcase)
         end
       end
-      
+
       it 'should tokenize integer values' do
         subject.scanner.string = ' 123 '
         token = subject.tokens.first
         expect(token).to be_kind_of(Rley::Lexical::Token)
         expect(token.terminal).to eq('INTEGER')
         expect(token.lexeme).to eq('123')
-      end 
+      end
 
       it 'should tokenize single digits' do
         subject.scanner.string = ' 1 '
@@ -55,9 +55,9 @@ module SrlRuby
         expect(token).to be_kind_of(Rley::Lexical::Token)
         expect(token.terminal).to eq('DIGIT_LIT')
         expect(token.lexeme).to eq('1')
-      end       
+      end
     end # context
-    
+
     context 'String literal tokenization:' do
       it "should recognize 'literally ...'" do
         input = 'literally "hello"'
@@ -67,9 +67,9 @@ module SrlRuby
           %w[STRING_LIT hello]
         ]
         match_expectations(subject, expectations)
-      end    
-    end # context    
-    
+      end
+    end # context
+
     context 'Character range tokenization:' do
       it "should recognize 'letter from ... to ...'" do
         input = 'letter a to f'
@@ -81,9 +81,9 @@ module SrlRuby
           %w[LETTER_LIT f]
         ]
         match_expectations(subject, expectations)
-      end    
+      end
     end # context
-    
+
     context 'Quantifier tokenization:' do
       it "should recognize 'exactly ... times'" do
         input = 'exactly 4 Times'
@@ -95,7 +95,7 @@ module SrlRuby
         ]
         match_expectations(subject, expectations)
       end
-      
+
       it "should recognize 'between ... and ... times'" do
         input = 'Between 2 AND 4 times'
         subject.scanner.string = input
@@ -129,7 +129,7 @@ module SrlRuby
           %w[MORE more]
         ]
         match_expectations(subject, expectations)
-      end 
+      end
 
       it "should recognize 'at least  ... times'" do
         input = 'at least 10 times'
@@ -141,7 +141,7 @@ module SrlRuby
           %w[TIMES times]
         ]
         match_expectations(subject, expectations)
-      end      
+      end
     end # context
   end # describe
 end # module

data/spec/srl_ruby_spec.rb

@@ -44,7 +44,7 @@ describe SrlRuby do
       regexp = SrlRuby.parse("literally '.'")
       expect(regexp.source).to eq('\.')
     end
-    
+
     it 'should parse single quotes literal string' do
       regexp = SrlRuby.parse('literally "an", whitespace, raw "[a-zA-Z]"')
       expect(regexp.source).to eq('an\s[a-zA-Z]')
@@ -61,7 +61,7 @@ describe SrlRuby 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')
@@ -98,41 +98,41 @@ describe SrlRuby do
       # (escapes more characters than required)
       expect(regexp.source).to eq('[._%+\-]')
     end
-    
+
     it "should parse 'one of' with unquoted character class syntax" do
       # Case of digit sequence
       regexp = SrlRuby.parse('one of 13579, must end')
       expect(regexp.source).to eq('[13579]$')
-      
+
       # Case of identifier-like character class
       regexp = SrlRuby.parse('one of abcd, must end')
       expect(regexp.source).to eq('[abcd]$')
 
       # Case of arbitrary character class
       regexp = SrlRuby.parse('one of 12hms:, must end')
-      expect(regexp.source).to eq('[12hms:]$')       
-    end    
-    
+      expect(regexp.source).to eq('[12hms:]$')
+    end
+
     it "should parse 'none of' syntax" do
       regexp = SrlRuby.parse('none of "._%+-"')
       # Remark: reference implementation less readable
       # (escapes more characters than required)
       expect(regexp.source).to eq('[^._%+\-]')
-    end 
+    end
 
     it "should parse 'none of' with unquoted character class syntax" do
       # Case of digit sequence
       regexp = SrlRuby.parse('none of 13579, must end')
       expect(regexp.source).to eq('[^13579]$')
-      
+
       # Case of identifier-like character class
       regexp = SrlRuby.parse('none of abcd, must end')
       expect(regexp.source).to eq('[^abcd]$')
 
       # Case of arbitrary character class
       regexp = SrlRuby.parse('none of 12hms:^, must end')
-      expect(regexp.source).to eq('[^12hms:\^]$')       
-    end    
+      expect(regexp.source).to eq('[^12hms:\^]$')
+    end
   end # context
 
   context 'Parsing special character declarations:' do
@@ -140,7 +140,7 @@ describe SrlRuby do
       regexp = SrlRuby.parse('tab')
       expect(regexp.source).to eq('\t')
     end
-    
+
     it "should parse 'vertical tab' syntax" do
       regexp = SrlRuby.parse('vertical tab')
       expect(regexp.source).to eq('\v')
@@ -155,21 +155,21 @@ describe SrlRuby do
       regexp = SrlRuby.parse('new line')
       expect(regexp.source).to eq('\n')
     end
-    
+
     it "should parse 'carriage return' syntax" do
       regexp = SrlRuby.parse('carriage return')
       expect(regexp.source).to eq('\r')
-    end 
+    end
 
     it "should parse 'word' syntax" do
       regexp = SrlRuby.parse('word, literally "is"')
       expect(regexp.source).to eq('\bis')
-    end 
+    end
 
     it "should parse 'no word' syntax" do
       regexp = SrlRuby.parse('no word, literally "is"')
       expect(regexp.source).to eq('\Bis')
-    end    
+    end
   end # context
 
   context 'Parsing alternations:' do
@@ -177,25 +177,25 @@ describe SrlRuby do
       source = 'any of (any character, one of "._%-+")'
       regexp = SrlRuby.parse(source)
       expect(regexp.source).to eq('(?:\w|[._%\-+])')
-    end 
+    end
 
     it "should parse 'either of' syntax" do
       source = 'either of (any character, one of "._%-+")'
       regexp = SrlRuby.parse(source)
       expect(regexp.source).to eq('(?:\w|[._%\-+])')
-    end    
-    
+    end
+
     it 'should anchor as alternative' do
       regexp = SrlRuby.parse('any of (literally "?", must end)')
       expect(regexp.source).to eq('(?:\\?|$)')
-    end    
+    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/      
+      msg_pattern = /Premature end of input after ',' at position line 1, column 14/
       expect { SrlRuby.parse(source) }.to raise_error(err, msg_pattern)
     end
 
@@ -205,13 +205,13 @@ describe SrlRuby do
     end
 
     it 'should parse a long sequence of patterns' do
-      source = <<-END_SRL
+      source = <<-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
+SRL
 
       regexp = SrlRuby.parse(source)
       # SRL: (?:\w|[\._%\-\+])+(?:@)(?:[0-9]|[a-z]|[\.\-])+(?:\.)[a-z]{2,}
@@ -246,9 +246,9 @@ END_SRL
     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') 
+      regexp = SrlRuby.parse(prefix + 'between 2 and 4')
       expect(regexp.source).to eq('[p-t]{2,4}')
     end
 
@@ -312,22 +312,22 @@ END_SRL
       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)))
+      source = <<-SRL
+  capture(any of (literally "sample", (digit once or more)))
   as "foo"
-END_SRL
+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
+      source = <<-SRL
       capture (anything once or more) as "first",
       literally " - ",
       capture literally "second part" as "second"
-END_SRL
+SRL
       regexp = SrlRuby.parse(source)
       expect(regexp.source).to eq('(?<first>.+) - (?<second>second part)')
     end
@@ -361,16 +361,16 @@ END_SRL
     end
 
     it 'should accept anchor with a sequence of patterns' do
-      source = <<-END_SRL
+      source = <<-SRL
       begin with any of (digit, letter, one of ".-") once or more,
       literally ".",
       letter at least 2 times must end
-END_SRL
+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
   end # context
 end # describe
 # End of file

data/srl_ruby.gemspec

@@ -1,8 +1,8 @@
-
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'srl_ruby/version'
 
+# Implementation module
 module PkgExtending
   def self.pkg_files(aPackage)
     file_list = Dir[
@@ -42,29 +42,31 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Dimitri Geshef']
   spec.email         = ['famished.tiger@yahoo.com']
 
-  spec.description   = %Q(Build easily regular expressions thanks to Simple Regex Language)
-  spec.summary   = <<-END_DESCR
-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 self-documenting, human readable, SRL expressions
-to craft your new awesome regular expressions.
-END_DESCR
+  spec.description   = <<-DESCR
+  Build easily regular expressions thanks to Simple Regex Language
+DESCR
+  spec.summary = <<-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 self-documenting, human readable, SRL expressions
+  to craft your new awesome regular expressions.
+SUMMARY
   spec.homepage      = 'https://github.com/famished-tiger/SRL-Ruby'
   spec.license       = 'MIT'
 
   spec.bindir = 'bin'
   spec.executables << 'srl_ruby'
   spec.require_paths = ['lib']
-  PkgExtending::pkg_files(spec)
-  PkgExtending::pkg_documentation(spec)
+  PkgExtending.pkg_files(spec)
+  PkgExtending.pkg_documentation(spec)
   spec.required_ruby_version = '>= 2.1.0'
-  
+
   # Runtime dependencies
   spec.add_dependency 'rley', '~> 0.6.06'
 
   # Development dependencies
   spec.add_development_dependency 'bundler', '~> 1.16'
-  spec.add_development_dependency 'cucumber', '>= 2.2.0'  
+  spec.add_development_dependency 'cucumber', '>= 2.2.0'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: srl_ruby
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-13 00:00:00.000000000 Z
+date: 2018-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -80,7 +80,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: Build easily regular expressions thanks to Simple Regex Language
+description: |2
+    Build easily regular expressions thanks to Simple Regex Language
 email:
 - famished.tiger@yahoo.com
 executables:
@@ -202,9 +203,9 @@ rubygems_version: 2.6.13
 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 self-documenting, human readable, SRL expressions to craft your new awesome
-  regular expressions.
+  patterns expressed in SRL into plain Ruby Regexp objects or in regex literals. Use
+  self-documenting, human readable, SRL expressions to craft your new awesome regular
+  expressions.
 test_files:
 - spec/acceptance/srl_test_suite_spec.rb
 - spec/regex/character_spec.rb