srl_ruby 0.4.13 → 0.4.14

data/spec/srl_ruby/srl_ruby_spec.rb

@@ -4,6 +4,6 @@ require_relative '../spec_helper'
 
 RSpec.describe SrlRuby do
   it 'has a version number' do
-    expect(SrlRuby::VERSION).not_to be nil
+    expect(SrlRuby::VERSION).not_to be_nil
   end
 end

data/spec/srl_ruby/tokenizer_spec.rb

@@ -13,81 +13,81 @@ module SrlRuby
       end
     end
 
-    subject { Tokenizer.new('') }
+    subject(:tokenizer) { described_class.new('') }
 
     context 'Initialization:' do
-      it 'should be initialized with a text to tokenize' do
-        expect { Tokenizer.new('anything') }.not_to raise_error
+      it 'is initialized with a text to tokenize' do
+        expect { described_class.new('anything') }.not_to raise_error
       end
 
-      it 'should have its scanner initialized' do
-        expect(subject.scanner).to be_kind_of(StringScanner)
+      it 'has its scanner initialized' do
+        expect(tokenizer.scanner).to be_a(StringScanner)
       end
     end # context
 
     context 'Single token recognition:' do
-      it 'should tokenize delimiters and separators' do
-        subject.scanner.string = ','
-        token = subject.tokens.first
-        expect(token).to be_kind_of(Rley::Lexical::Token)
+      it 'tokenizes delimiters and separators' do
+        tokenizer.scanner.string = ','
+        token = tokenizer.tokens.first
+        expect(token).to be_a(Rley::Lexical::Token)
         expect(token.terminal).to eq('COMMA')
         expect(token.lexeme).to eq(',')
       end
 
-      it 'should tokenize keywords' do
+      it 'tokenizes keywords' do
         sample = 'between Exactly oncE optional TWICE'
-        subject.scanner.string = sample
-        subject.tokens.each do |tok|
-          expect(tok).to be_kind_of(Rley::Lexical::Token)
+        tokenizer.scanner.string = sample
+        tokenizer.tokens.each do |tok|
+          expect(tok).to be_a(Rley::Lexical::Token)
           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)
+      it 'tokenizes integer values' do
+        tokenizer.scanner.string = ' 123 '
+        token = tokenizer.tokens.first
+        expect(token).to be_a(Rley::Lexical::Token)
         expect(token.terminal).to eq('INTEGER')
         expect(token.lexeme).to eq('123')
       end
 
-      it 'should tokenize single digits' do
-        subject.scanner.string = ' 1 '
-        token = subject.tokens.first
-        expect(token).to be_kind_of(Rley::Lexical::Token)
+      it 'tokenizes single digits' do
+        tokenizer.scanner.string = ' 1 '
+        token = tokenizer.tokens.first
+        expect(token).to be_a(Rley::Lexical::Token)
         expect(token.terminal).to eq('DIGIT_LIT')
         expect(token.lexeme).to eq('1')
       end
     end # context
 
     context 'String literal tokenization:' do
-      it "should recognize 'literally ...'" do
+      it "Recognizes 'literally ...'" do
         input = 'literally "hello"'
-        subject.scanner.string = input
+        tokenizer.scanner.string = input
         expectations = [
           %w[LITERALLY literally],
           %w[STRING_LIT hello]
         ]
-        match_expectations(subject, expectations)
+        match_expectations(tokenizer, expectations)
       end
     end # context
 
     context 'Character range tokenization:' do
-      it "should recognize 'letter from ... to ...'" do
+      it "recognizes 'letter from ... to ...'" do
         input = 'letter a to f'
-        subject.scanner.string = input
+        tokenizer.scanner.string = input
         expectations = [
           %w[LETTER letter],
           %w[LETTER_LIT a],
           %w[TO to],
           %w[LETTER_LIT f]
         ]
-        match_expectations(subject, expectations)
+        match_expectations(tokenizer, expectations)
       end
 
-      it "should recognize 'letter from ... to ... followed by comma'" do
+      it "recognizes 'letter from ... to ... followed by comma'" do
         input = 'letter a to f,'
-        subject.scanner.string = input
+        tokenizer.scanner.string = input
         expectations = [
           %w[LETTER letter],
           %w[LETTER_LIT a],
@@ -95,25 +95,25 @@ module SrlRuby
           %w[LETTER_LIT f],
           %w[COMMA ,]
         ]
-        match_expectations(subject, expectations)
+        match_expectations(tokenizer, expectations)
       end
     end # context
 
     context 'Quantifier tokenization:' do
-      it "should recognize 'exactly ... times'" do
+      it "recognizes 'exactly ... times'" do
         input = 'exactly 4 Times'
-        subject.scanner.string = input
+        tokenizer.scanner.string = input
         expectations = [
           %w[EXACTLY exactly],
           %w[DIGIT_LIT 4],
           %w[TIMES Times]
         ]
-        match_expectations(subject, expectations)
+        match_expectations(tokenizer, expectations)
       end
 
-      it "should recognize 'between ... and ... times'" do
+      it "recognizes 'between ... and ... times'" do
         input = 'Between 2 AND 4 times'
-        subject.scanner.string = input
+        tokenizer.scanner.string = input
         expectations = [
           %w[BETWEEN Between],
           %w[DIGIT_LIT 2],
@@ -121,41 +121,41 @@ module SrlRuby
           %w[DIGIT_LIT 4],
           %w[TIMES times]
         ]
-        match_expectations(subject, expectations)
+        match_expectations(tokenizer, expectations)
       end
 
-      it "should recognize 'once or more'" do
+      it "recognizes 'once or more'" do
         input = 'Once or MORE'
-        subject.scanner.string = input
+        tokenizer.scanner.string = input
         expectations = [
           %w[ONCE Once],
           %w[OR or],
           %w[MORE MORE]
         ]
-        match_expectations(subject, expectations)
+        match_expectations(tokenizer, expectations)
       end
 
-      it "should recognize 'never or more'" do
+      it "recognizes 'never or more'" do
         input = 'never or more'
-        subject.scanner.string = input
+        tokenizer.scanner.string = input
         expectations = [
           %w[NEVER never],
           %w[OR or],
           %w[MORE more]
         ]
-        match_expectations(subject, expectations)
+        match_expectations(tokenizer, expectations)
       end
 
-      it "should recognize 'at least  ... times'" do
+      it "recognizes 'at least ... times'" do
         input = 'at least 10 times'
-        subject.scanner.string = input
+        tokenizer.scanner.string = input
         expectations = [
           %w[AT at],
           %w[LEAST least],
           %w[INTEGER 10],
           %w[TIMES times]
         ]
-        match_expectations(subject, expectations)
+        match_expectations(tokenizer, expectations)
       end
     end # context
   end # describe