srl_ruby 0.3.5 → 0.4.0

data/spec/acceptance/support/rule_file_token.rb

@@ -2,7 +2,7 @@ require 'rley' # Load the Rley gem
 
 module Acceptance
   Position = Struct.new(:line, :column) do
-    def to_s()
+    def to_s
       "line #{line}, column #{column}"
     end
   end

data/spec/acceptance/support/rule_file_tokenizer.rb

@@ -44,7 +44,7 @@ module Acceptance
       @state = :default
     end
 
-    def tokens()
+    def tokens
       tok_sequence = []
       until @scanner.eos?
         token = _next_token
@@ -56,7 +56,7 @@ module Acceptance
 
     private
 
-    def _next_token()
+    def _next_token
       skip_noise
       curr_ch = scanner.peek(1)
       return nil if curr_ch.nil? || curr_ch.empty?
@@ -70,7 +70,7 @@ module Acceptance
       return token
     end
 
-    def default_mode()
+    def default_mode
       curr_ch = scanner.peek(1)
       token = nil
 
@@ -100,7 +100,7 @@ module Acceptance
       return token
     end
 
-    def expecting_srl()
+    def expecting_srl
       scanner.skip(/^:/)
       lexeme = scanner.scan(/[^\r\n]*/)
       @state = :default
@@ -120,7 +120,7 @@ module Acceptance
       return token
     end
 
-    def skip_noise()
+    def skip_noise
       loop do
         noise_found = false
         noise_found = true if skip_whitespaces
@@ -129,7 +129,7 @@ module Acceptance
       end
     end
 
-    def skip_whitespaces()
+    def skip_whitespaces
       pre_pos = scanner.pos
 
       loop do
@@ -146,10 +146,10 @@ module Acceptance
       end
 
       curr_pos = scanner.pos
-      return !(curr_pos == pre_pos)
+      return curr_pos != pre_pos
     end
 
-    def skip_comment()
+    def skip_comment
       scanner.skip(/#[^\n\r]+/)
     end
   end # class

data/spec/regex/character_spec.rb

@@ -25,26 +25,26 @@ module Regex # Open this namespace, to get rid of scope qualifiers
 
     context 'Creation & initialization' do
       it 'should be created with a with an integer value (codepoint) or...' do
-        SampleInts.each do |aCodepoint|
-          expect { Character.new(aCodepoint) }.not_to raise_error
+        SampleInts.each do |codepoint|
+          expect { Character.new(codepoint) }.not_to raise_error
         end
       end
 
       it '...could be created with a single character String or...' do
-        SampleChars.each do |aChar|
-          expect { Character.new(aChar) }.not_to raise_error
+        SampleChars.each do |ch|
+          expect { Character.new(ch) }.not_to raise_error
         end
       end
 
       it '...could be created with an escape sequence' do
         # Case 1: escape sequence is a digram
-        SampleDigrams.each do |anEscapeSeq|
-          expect { Character.new(anEscapeSeq) }.not_to raise_error
+        SampleDigrams.each do |escape_seq|
+          expect { Character.new(escape_seq) }.not_to raise_error
         end
 
         # Case 2: escape sequence is an escaped octal or hexadecimal literal
-        SampleNumEscs.each do |anEscapeSeq|
-          expect { Character.new(anEscapeSeq) }.not_to raise_error
+        SampleNumEscs.each do |escape_seq|
+          expect { Character.new(escape_seq) }.not_to raise_error
         end
       end
     end # context
@@ -52,15 +52,15 @@ module Regex # Open this namespace, to get rid of scope qualifiers
     context 'Provided services' do
       it 'Should know its lexeme if created from a string' do
         # Lexeme is defined when the character was initialised from a text
-        SampleChars.each do |aChar|
-          ch = Character.new(aChar)
-          expect(ch.lexeme).to eq(aChar)
+        SampleChars.each do |ch|
+          ch = Character.new(ch)
+          expect(ch.lexeme).to eq(ch)
         end
       end
 
       it 'Should not know its lexeme representation from a codepoint' do
-        SampleInts.each do |aChar|
-          ch = Character.new(aChar)
+        SampleInts.each do |ch|
+          ch = Character.new(ch)
           expect(ch.lexeme).to be_nil
         end
       end
@@ -72,21 +72,21 @@ module Regex # Open this namespace, to get rid of scope qualifiers
         expect(newOne.to_str).to eq("\u03A3")
 
         # Try with our chars sample
-        SampleChars.each do |aChar|
-          new_ch = Character.new(aChar).to_str
-          new_ch == aChar
+        SampleChars.each do |ch|
+          new_ch = Character.new(ch).to_str
+          new_ch == ch
         end
 
         # Try with our codepoint sample
-        mapped_chars = SampleInts.map do |aCodepoint|
-          Character.new(aCodepoint).char
+        mapped_chars = SampleInts.map do |codepoint|
+          Character.new(codepoint).char
         end
         expect(mapped_chars).to eq(SampleChars)
 
         # Try with our escape sequence samples
-        (SampleDigrams + SampleNumEscs).each do |anEscSeq|
-          expectation = String.class_eval(%Q|"#{anEscSeq}"|, __FILE__, __LINE__)
-          new_ch = Character.new(anEscSeq).to_str
+        (SampleDigrams + SampleNumEscs).each do |escape_seq|
+          expectation = String.class_eval(%Q|"#{escape_seq}"|, __FILE__, __LINE__)
+          new_ch = Character.new(escape_seq).to_str
           new_ch == expectation
         end
       end
@@ -97,20 +97,20 @@ module Regex # Open this namespace, to get rid of scope qualifiers
         expect(newOne.codepoint).to eq(0x03a3)
 
         # Try with our chars sample
-        allCodepoints = SampleChars.map do |aChar|
-          Character.new(aChar).codepoint
+        allCodepoints = SampleChars.map do |ch|
+          Character.new(ch).codepoint
         end
         expect(allCodepoints).to eq(SampleInts)
 
         # Try with our codepoint sample
-        SampleInts.each do |aCodepoint|
-          expect(Character.new(aCodepoint).codepoint).to eq(aCodepoint)
+        SampleInts.each do |codepoint|
+          expect(Character.new(codepoint).codepoint).to eq(codepoint)
         end
 
         # Try with our escape sequence samples
-        (SampleDigrams + SampleNumEscs).each do |anEscSeq|
-          expectation = String.class_eval(%Q|"#{anEscSeq}".ord()|, __FILE__, __LINE__)
-          expect(Character.new(anEscSeq).codepoint).to eq(expectation)
+        (SampleDigrams + SampleNumEscs).each do |escape_seq|
+          expectation = String.class_eval(%Q|"#{escape_seq}".ord()|, __FILE__, __LINE__)
+          expect(Character.new(escape_seq).codepoint).to eq(expectation)
         end
       end
 
@@ -147,8 +147,8 @@ module Regex # Open this namespace, to get rid of scope qualifiers
 
         # Create a module that re-defines the existing to_s method
         module Tweak_to_s
-          def to_s() # Overwrite the existing to_s method
-            return ?\u03a3
+          def to_s # Overwrite the existing to_s method
+            ?\u03a3
           end
         end # module
         weird = Object.new

data/spec/regex/multiplicity_spec.rb

@@ -9,8 +9,8 @@ module Regex # This module is used as a namespace
     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
+        %i[greedy lazy possessive].each do |policy|
+          expect { Multiplicity.new(0, 1, policy) }.not_to raise_error
         end
 
         # Invalid case: initialized with invalid policy value
@@ -25,49 +25,49 @@ module Regex # This module is used as a namespace
         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]}")
+        policy2text.each_key do |policy|
+          multi = Multiplicity.new(0, 1, policy)
+          expect(multi.to_str).to eq("?#{policy2text[policy]}")
         end
 
         # Case: zero or more
-        policy2text.each_key do |aPolicy|
-          multi = Multiplicity.new(0, :more, aPolicy)
-          expect(multi.to_str).to eq("*#{policy2text[aPolicy]}")
+        policy2text.each_key do |policy|
+          multi = Multiplicity.new(0, :more, policy)
+          expect(multi.to_str).to eq("*#{policy2text[policy]}")
         end
 
         # Case: one or more
-        policy2text.each_key do |aPolicy|
-          multi = Multiplicity.new(1, :more, aPolicy)
-          expect(multi.to_str).to eq("+#{policy2text[aPolicy]}")
+        policy2text.each_key do |policy|
+          multi = Multiplicity.new(1, :more, policy)
+          expect(multi.to_str).to eq("+#{policy2text[policy]}")
         end
 
         # Case: exactly m times
-        policy2text.each_key do |aPolicy|
+        policy2text.each_key do |policy|
           samples = [1, 2, 5, 100]
-          samples.each do |aCount|
-            multi = Multiplicity.new(aCount, aCount, aPolicy)
-            expect(multi.to_str).to eq("{#{aCount}}#{policy2text[aPolicy]}")
+          samples.each do |count|
+            multi = Multiplicity.new(count, count, policy)
+            expect(multi.to_str).to eq("{#{count}}#{policy2text[policy]}")
           end
         end
 
         # Case: m, n times
-        policy2text.each_key do |aPolicy|
+        policy2text.each_key do |policy|
           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]}"
+          samples.each do |count|
+            upper = count + 1 + rand(20)
+            multi = Multiplicity.new(count, upper, policy)
+            expectation = "{#{count},#{upper}}#{policy2text[policy]}"
             expect(multi.to_str).to eq(expectation)
           end
         end
 
         # Case: m or more
-        policy2text.each_key do |aPolicy|
+        policy2text.each_key do |policy|
           samples = [2, 3, 5, 100]
-          samples.each do |aCount|
-            multi = Multiplicity.new(aCount, :more, aPolicy)
-            expect(multi.to_str).to eq("{#{aCount},}#{policy2text[aPolicy]}")
+          samples.each do |count|
+            multi = Multiplicity.new(count, :more, policy)
+            expect(multi.to_str).to eq("{#{count},}#{policy2text[policy]}")
           end
         end
       end

data/srl_ruby.gemspec

@@ -17,13 +17,16 @@ module PkgExtending
       'LICENSE.txt',
       'README.md',
       'srl_ruby.gemspec',
-      'lib/*.*',
-      'lib/**/*.rb',
-      'spec/**/*.rb',
+      'bin/*.srl',
+      'bin/*.rb',
       'features/*.*',
       'features/**/*.*',
       'features/**/**/*.features',
-      'srl_test/**/*.*'
+      'lib/*.*',
+      'lib/**/*.rb',
+      'spec/**/*.rb',
+      'srl_test/**/*.*',
+      'templates/*.erb'
     ]
     aPackage.files = file_list
     aPackage.test_files = Dir['spec/**/*_spec.rb']
@@ -56,7 +59,7 @@ SUMMARY
   spec.license       = 'MIT'
 
   spec.bindir = 'bin'
-  spec.executables << 'srl_ruby'
+  spec.executables << 'srl2ruby'
   spec.require_paths = ['lib']
   PkgExtending.pkg_files(spec)
   PkgExtending.pkg_documentation(spec)

data/templates/base.erb

@@ -0,0 +1,2 @@
+<% # base.erb: Outputs just the Regexp literal %>
+/<%= (regexp.to_s =~ /\(\?\-mix/) ? regexp.source : regexp.to_s %>/

data/templates/srl_and_ruby.erb

@@ -0,0 +1,9 @@
+<% # srl_and_ruby.erb: Outputs the SRL expression in comment, then the Ruby Regexp %>
+# SRL expression follows:
+<% srl_lines = srl_source.split(/(?:\r\n)|\n/)%>
+<% srl_lines.each do |line| %>
+<%=  '# ' + line + "\n" %>
+<% end %>
+#
+# ... and its Regexp equivalent:
+/<%= (regexp.to_s =~ /\(\?\-mix/) ? regexp.source : regexp.to_s %>/

data/templates/srl_block_and_ruby.erb

@@ -0,0 +1,10 @@
+<% # srl_and_ruby.erb: Outputs the SRL expression in block comment, then the Ruby Regexp %>
+# SRL expression follows:
+=begin
+<% srl_lines = srl_source.split(/(?:\r\n)|\n/)%>
+<% srl_lines.each do |line| %>
+<%=  '  ' + line + "\n" %>
+<% end %>
+=end
+# ... and its Regexp equivalent:
+/<%= (regexp.to_s =~ /\(\?\-mix/) ? regexp.source : regexp.to_s %>/

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: srl_ruby
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.4.0
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-29 00:00:00.000000000 Z
+date: 2018-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -86,7 +86,7 @@ description: |2
 email:
 - famished.tiger@yahoo.com
 executables:
-- srl_ruby
+- srl2ruby
 extensions: []
 extra_rdoc_files:
 - README.md
@@ -100,7 +100,8 @@ files:
 - README.md
 - Rakefile
 - appveyor.yml
-- bin/srl_ruby
+- bin/srl2ruby
+- bin/srl2ruby_cli_parser.rb
 - cucumber.yml
 - features/basic/anchors.feature
 - features/basic/characters.feature
@@ -183,6 +184,9 @@ files:
 - srl_test/Test-Rules/website_example_password.rule
 - srl_test/Test-Rules/website_example_url.rule
 - srl_test/Test-Rules/word.rule
+- templates/base.erb
+- templates/srl_and_ruby.erb
+- templates/srl_block_and_ruby.erb
 homepage: https://github.com/famished-tiger/SRL-Ruby
 licenses:
 - MIT

data/bin/srl_ruby

@@ -1,51 +0,0 @@
-#!/usr/bin/env 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?
-  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
-
-
-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