srl_ruby 0.3.3 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5d359b7fdd648df4b9e77e0bf64266b3fec2d474
-  data.tar.gz: 7a8a1efb3f978b8f45b15c47c0b457a6109daf37
+  metadata.gz: 75b3f62195385724cef744d9d066001cacb56da7
+  data.tar.gz: c987288da96445ada26f5b115e1b9e64e5062fbb
 SHA512:
-  metadata.gz: 20c7d24104afefa0371692ca2f0713916b9a6edbc1825c32bb77ff1c29760fa46bd04731ab88914f8dbd1d97f1cbd523f8b5e765d57ad0cf9ea7938110161c95
-  data.tar.gz: 9110435c0ae7bf089c167a46c81f6aabe91a7f9d52926843654972877aef2ccc1838c5a5218e8eac1f628cf95328f1f044a62b9d1fc4cfbcc6db49752b24b9ee
+  metadata.gz: 288976a2ff3ce17282af5c74385c84ccd8a318626c773a6c567953e9937f9ef7c146af941646a7f426fea08b2072c88d2385dd1a13ed7b217e38dd7400a4cbb7
+  data.tar.gz: 2321788937a965131c417acdb731d7d5a1278790cd2e2933b5e163296272acb2a526d0add3fc080041836b2ba1224f11429fd2c65055b30c072fcc58cb8c35b6

data/.rubocop.yml

@@ -1,31 +1,189 @@
 AllCops:
   Exclude:
-    - 'exp/**/*'    
+    - 'exp/**/*'
+
+Layout/CaseIndentation:
+  Enabled: false
+
+Layout/CommentIndentation:
+  Enabled: false
+
+Layout/ElseAlignment:
+  Enabled: false
+
+Layout/EmptyLines:
+  Enabled: false
+  
+Layout/EndAlignment:
+  Enabled: false
 
 Layout/EndOfLine:
   Enabled: true
   EnforcedStyle: lf
- 
+
+Layout/IndentationWidth:
+  Enabled: false
+
+Layout/IndentationConsistency:
+  Enabled: false
+  
+Layout/MultilineHashBraceLayout:
+  Enabled: false
+
+Layout/SpaceAroundOperators:
+  Enabled: false
+
+Layout/SpaceInsideParens:
+  Enabled: false
+  
+Layout/Tab:
+  Enabled: true
+  
+Layout/TrailingBlankLines:
+  Enabled: false
+
+Layout/TrailingWhitespace:
+  Enabled: false
+
+Lint/Loop:
+  Enabled: false
+
+Lint/RescueException:
+  Enabled: false
+
+Lint/UnusedMethodArgument:
+  Enabled: false
+
+Lint/UselessAccessModifier:
+  Enabled: false
+
+Lint/Void:
+  Enabled: false
+
+Lint/UselessAssignment:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
 Metrics/BlockLength:
   Enabled: true
   Max: 300
-  
+
+Metrics/ClassLength:
+  Enabled: true
+  Max: 300
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/LineLength:
+  Enabled: false
+  Max: 90
+
 Metrics/MethodLength:
   Enabled: true
-  Max: 30
- 
+  Max: 40
+
 Metrics/ModuleLength:
   Enabled: true
   Max: 500
-  
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
 Naming/ConstantName:
   Enabled: false
+
+Naming/ClassAndModuleCamelCase:
+  Enabled: false
   
-Naming/VariableName:
+Naming/UncommunicativeBlockParamName:
   Enabled: false
   
+Naming/UncommunicativeMethodParamName:
+  Enabled: false
+
+Naming/VariableName:
+  Enabled: false
+
+Style/Alias:
+  Enabled: false
+
+Layout/AlignHash:
+  Enabled: false
+
+Style/AsciiComments:
+  Enabled: false
+
+Style/BarePercentLiterals:
+  Enabled: false
+
+Style/BlockComments:
+  Enabled: false
+
+Style/CharacterLiteral:
+  Enabled: false
+
+Style/ClassCheck:
+  Enabled: false
+
+Style/ClassVars:
+  Enabled: false
+
+Style/ColonMethodCall:
+  Enabled: false
+
+Style/CommentAnnotation:
+  Enabled: false
+
 Style/CommentedKeyword:
   Enabled: false
-  
+
+Style/ConditionalAssignment:
+  Enabled: false
+
+Style/DefWithParentheses:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/ExpandPathArguments:
+  Enabled: false
+
+Style/GuardClause:
+  Enabled: false
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/InverseMethods:
+  Enabled: false
+
+Style/Next:
+  Enabled: false
+
+Style/RaiseArgs:
+  Enabled: true
+
 Style/RedundantReturn:
-  Enabled: false  
+  Enabled: false
+  
+Style/RedundantSelf:
+  Enabled: true
+
+Style/RegexpLiteral:
+  Enabled: false
+
+Style/PercentLiteralDelimiters:
+  Enabled: false
+
+Style/StringLiterals:
+  Enabled: false
+
+Style/TernaryParentheses:
+  Enabled: false
+  
+Style/UnlessElse:
+  Enabled: false

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## [0.3.4] - 2018-04-20
+
+### Fixed
+- Method `Tokenizer#_next_token` failed to recognize digit or integer value immediately followed by a comma
+
 ## [0.3.3] - 2018-04-19
 ### Changed
 - Binary `srl_ruby` now accepts a SRL filename as command-line argument. Command-line documentation updated.

data/lib/regex/character.rb

@@ -125,10 +125,10 @@ module Regex # This module is used as a namespace
     def ==(other)
       result = case other
         when Character
-          self.to_str == other.to_str
+          to_str == other.to_str
 
         when Integer
-          self.codepoint == other
+          codepoint == other
 
         when String
           other.size > 1 ? false : to_str == other

data/lib/regex/raw_expression.rb

@@ -4,7 +4,7 @@ module Regex # This module is used as a namespace
   # A raw expression is a string that will be copied verbatim (as is)
   # in the generated regular expression.
   class RawExpression < AtomicExpression
-	attr_reader :raw
+  attr_reader :raw
   
     # Constructor
     def initialize(rawLiteral)
@@ -16,7 +16,7 @@ module Regex # This module is used as a namespace
 
     # Conversion method re-definition.
     # Purpose: Return the String representation of the expression.
-	alias_method :text_repr, :raw
+  alias_method :text_repr, :raw
   end # class
 end # module
 

data/lib/srl_ruby/tokenizer.rb

@@ -5,6 +5,8 @@ require_relative 'srl_token'
 
 
 module SrlRuby
+  # A tokenizer for the Simple Regex Language.
+  # Responsibility: break input SRL into a sequence of token objects.
   # The tokenizer should recognize:
   # Keywords: as, capture, letter
   # Integer literals including single digit
@@ -86,6 +88,8 @@ module SrlRuby
 
     class ScanError < StandardError; end
 
+    # Constructor. Initialize a tokenizer for SRL.
+    # @param srl_source [String] SRL text to tokenize.
     def initialize(source)
       @scanner = StringScanner.new(source)
       @lineno = 1
@@ -114,10 +118,10 @@ module SrlRuby
       if '(),'.include? curr_ch
         # Delimiters, separators => single character token
         token = build_token(@@lexeme2name[curr_ch], scanner.getch)
-      elsif (lexeme = scanner.scan(/[0-9]{2,}((?=\s)|$)/))
+      elsif (lexeme = scanner.scan(/[0-9]{2,}((?=\s|,)|$)/))
         token = build_token('INTEGER', lexeme) # An integer has 2..* digits
-      elsif (lexeme = scanner.scan(/[0-9]((?=\s)|$)/))
-        token = build_token('DIGIT_LIT', lexeme)
+      elsif (lexeme = scanner.scan(/[0-9]((?=\s|,)|$)/))
+      token = build_token('DIGIT_LIT', lexeme)
       elsif (lexeme = scanner.scan(/"(?:\\"|[^"])*"/)) # Double quotes literal?
         unquoted = lexeme.gsub(/(^")|("$)/, '')
         token = build_token('STRING_LIT', unquoted)
@@ -136,7 +140,7 @@ module SrlRuby
         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}")
+        raise ScanError, "Unknown token #{erroneous} on line #{lineno}"
       end
 
       return token

data/lib/srl_ruby/version.rb

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

data/spec/acceptance/support/rule_file_tokenizer.rb

@@ -94,7 +94,7 @@ module Acceptance
         erroneous = curr_ch.nil? ? '' : curr_ch
         sequel = scanner.scan(/.{1,20}/)
         erroneous += sequel unless sequel.nil?
-        raise ScanError.new("Unknown token #{erroneous}")
+        raise ScanError, "Unknown token #{erroneous}"
       end
 
       return token

data/spec/regex/character_spec.rb

@@ -1,166 +1,170 @@
-# File: character_spec.rb
-require_relative '../spec_helper' # Use the RSpec test framework
-require_relative '../../lib/regex/character'
-
-module Regex # Open this namespace, to get rid of scope qualifiers
-  describe Character do
-    # This constant holds an arbitrary selection of characters
-    SampleChars = [?a, ?\0, ?\u0107].freeze
-
-    # This constant holds the codepoints of the character selection
-    SampleInts = [0x61, 0, 0x0107].freeze
-
-    # This constant holds an arbitrary selection of two characters (digrams) 
-    # escape sequences
-    SampleDigrams = %w[\n \e \0 \6 \k].freeze
-
-    # This constant holds an arbitrary selection of escaped octal 
-    # or hexadecimal literals
-    SampleNumEscs = %w[\0 \07 \x07 \xa \x0F \u03a3 \u{a}].freeze
-
-    before(:all) do
-      # Ensure that the set of codepoints is mapping the set of chars...
-      expect(SampleChars.map(&:ord)).to eq(SampleInts)
-    end
-
-    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
-        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
-        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
-        end
-
-        # Case 2: escape sequence is an escaped octal or hexadecimal literal
-        SampleNumEscs.each do |anEscapeSeq|
-          expect { Character.new(anEscapeSeq) }.not_to raise_error
-        end
-      end
-    end # context
-
-    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)
-        end
-      end
-
-      it 'Should not know its lexeme representation from a codepoint' do
-        SampleInts.each do |aChar|
-          ch = Character.new(aChar)
-          expect(ch.lexeme).to be_nil
-        end
-      end
-
-      it 'should know its String representation' do
-        # Try for one character
-        newOne = Character.new(?\u03a3)
-        expect(newOne.char).to eq('Σ')
-        expect(newOne.to_str).to eq("\u03A3")
-
-        # Try with our chars sample
-        SampleChars.each { |aChar| Character.new(aChar).to_str == aChar }
-
-        # Try with our codepoint sample
-        mapped_chars = SampleInts.map do |aCodepoint|
-          Character.new(aCodepoint).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__)
-          Character.new(anEscSeq).to_str == expectation
-        end
-      end
-
-      it 'should know its codepoint' do
-        # Try for one character
-        newOne = Character.new(?\u03a3)
-        expect(newOne.codepoint).to eq(0x03a3)
-
-        # Try with our chars sample
-        allCodepoints = SampleChars.map do |aChar|
-          Character.new(aChar).codepoint
-        end
-        expect(allCodepoints).to eq(SampleInts)
-
-        # Try with our codepoint sample
-        mapped_chars = SampleInts.each do |aCodepoint|
-          expect(Character.new(aCodepoint).codepoint).to eq(aCodepoint)
-        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)
-        end
-      end
-
-      it 'should known whether it is equal to another Object' do
-        newOne = Character.new(?\u03a3)
-
-        # Case 1: test equality with itself
-        expect(newOne).to eq(newOne)
-
-        # Case 2: test equality with another Character
-        expect(newOne).to eq(Character.new(?\u03a3))
-        expect(newOne).not_to eq(Character.new(?\u0333))
-
-        # Case 3: test equality with an integer value
-        # (equality based on codepoint value)
-        expect(newOne).to eq(0x03a3)
-        expect(newOne).not_to eq(0x0333)
-
-        # Case 4: test equality with a single-character String
-        expect(newOne).to eq(?\u03a3)
-        expect(newOne).not_to eq(?\u0333)
-
-        # Case 5: test fails with multiple character strings
-        expect(newOne).not_to eq('03a3')
-
-        # Case 6: equality testing with arbitray object
-        expect(newOne).not_to eq(nil)
-        expect(newOne).not_to eq(Object.new)
-
-        # In case 6, equality is based on to_s method.
-        simulator = double('fake')
-        expect(simulator).to receive(:to_s).and_return(?\u03a3)
-        expect(newOne).to eq(simulator)
-
-        # Create a module that re-defines the existing to_s method
-        module Tweak_to_s
-          def to_s() # Overwrite the existing to_s method
-            return ?\u03a3
-          end
-        end # module
-        weird = Object.new
-        weird.extend(Tweak_to_s)
-        expect(newOne).to eq(weird)
-      end
-
-      it 'should know its readable description' do
-        ch1 = Character.new('a')
-        expect(ch1.explain).to eq("the character 'a'")
-
-        ch2 = Character.new(?\u03a3)
-        expect(ch2.explain).to eq("the character '\u03a3'")
-      end
-    end # context
-  end # describe
-end # module
-
-# End of file
+# File: character_spec.rb
+require_relative '../spec_helper' # Use the RSpec test framework
+require_relative '../../lib/regex/character'
+
+module Regex # Open this namespace, to get rid of scope qualifiers
+  describe Character do
+    # This constant holds an arbitrary selection of characters
+    SampleChars = [?a, ?\0, ?\u0107].freeze
+
+    # This constant holds the codepoints of the character selection
+    SampleInts = [0x61, 0, 0x0107].freeze
+
+    # This constant holds an arbitrary selection of two characters (digrams) 
+    # escape sequences
+    SampleDigrams = %w[\n \e \0 \6 \k].freeze
+
+    # This constant holds an arbitrary selection of escaped octal 
+    # or hexadecimal literals
+    SampleNumEscs = %w[\0 \07 \x07 \xa \x0F \u03a3 \u{a}].freeze
+
+    before(:all) do
+      # Ensure that the set of codepoints is mapping the set of chars...
+      expect(SampleChars.map(&:ord)).to eq(SampleInts)
+    end
+
+    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
+        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
+        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
+        end
+
+        # Case 2: escape sequence is an escaped octal or hexadecimal literal
+        SampleNumEscs.each do |anEscapeSeq|
+          expect { Character.new(anEscapeSeq) }.not_to raise_error
+        end
+      end
+    end # context
+
+    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)
+        end
+      end
+
+      it 'Should not know its lexeme representation from a codepoint' do
+        SampleInts.each do |aChar|
+          ch = Character.new(aChar)
+          expect(ch.lexeme).to be_nil
+        end
+      end
+
+      it 'should know its String representation' do
+        # Try for one character
+        newOne = Character.new(?\u03a3)
+        expect(newOne.char).to eq('Σ')
+        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
+        end
+
+        # Try with our codepoint sample
+        mapped_chars = SampleInts.map do |aCodepoint|
+          Character.new(aCodepoint).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
+          new_ch == expectation
+        end
+      end
+
+      it 'should know its codepoint' do
+        # Try for one character
+        newOne = Character.new(?\u03a3)
+        expect(newOne.codepoint).to eq(0x03a3)
+
+        # Try with our chars sample
+        allCodepoints = SampleChars.map do |aChar|
+          Character.new(aChar).codepoint
+        end
+        expect(allCodepoints).to eq(SampleInts)
+
+        # Try with our codepoint sample
+        mapped_chars = SampleInts.each do |aCodepoint|
+          expect(Character.new(aCodepoint).codepoint).to eq(aCodepoint)
+        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)
+        end
+      end
+
+      it 'should known whether it is equal to another Object' do
+        newOne = Character.new(?\u03a3)
+
+        # Case 1: test equality with itself
+        expect(newOne).to eq(newOne)
+
+        # Case 2: test equality with another Character
+        expect(newOne).to eq(Character.new(?\u03a3))
+        expect(newOne).not_to eq(Character.new(?\u0333))
+
+        # Case 3: test equality with an integer value
+        # (equality based on codepoint value)
+        expect(newOne).to eq(0x03a3)
+        expect(newOne).not_to eq(0x0333)
+
+        # Case 4: test equality with a single-character String
+        expect(newOne).to eq(?\u03a3)
+        expect(newOne).not_to eq(?\u0333)
+
+        # Case 5: test fails with multiple character strings
+        expect(newOne).not_to eq('03a3')
+
+        # Case 6: equality testing with arbitray object
+        expect(newOne).not_to eq(nil)
+        expect(newOne).not_to eq(Object.new)
+
+        # In case 6, equality is based on to_s method.
+        simulator = double('fake')
+        expect(simulator).to receive(:to_s).and_return(?\u03a3)
+        expect(newOne).to eq(simulator)
+
+        # Create a module that re-defines the existing to_s method
+        module Tweak_to_s
+          def to_s() # Overwrite the existing to_s method
+            return ?\u03a3
+          end
+        end # module
+        weird = Object.new
+        weird.extend(Tweak_to_s)
+        expect(newOne).to eq(weird)
+      end
+
+      it 'should know its readable description' do
+        ch1 = Character.new('a')
+        expect(ch1.explain).to eq("the character 'a'")
+
+        ch2 = Character.new(?\u03a3)
+        expect(ch2.explain).to eq("the character '\u03a3'")
+      end
+    end # context
+  end # describe
+end # module
+
+# End of file

data/spec/srl_ruby/tokenizer_spec.rb

@@ -82,6 +82,19 @@ module SrlRuby
         ]
         match_expectations(subject, expectations)
       end
+      
+      it "should recognize 'letter from ... to ... followed by comma'" do
+        input = 'letter a to f,'
+        subject.scanner.string = input
+        expectations = [
+          %w[LETTER letter],
+          %w[LETTER_LIT a],
+          %w[TO to],
+          %w[LETTER_LIT f],
+          %w[COMMA ,]
+        ]
+        match_expectations(subject, expectations)
+      end      
     end # context
 
     context 'Quantifier tokenization:' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: srl_ruby
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.4
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-19 00:00:00.000000000 Z
+date: 2018-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley