srl_ruby 0.4.13 → 0.4.15

data/spec/regex/match_option_spec.rb

@@ -9,25 +9,26 @@ require_relative '../../lib/regex/match_option'
 module Regex # This module is used as a namespace
   describe MatchOption do
     let(:sample_child) { double('fake-child') }
-    subject { MatchOption.new(sample_child, [Regexp::MULTILINE, Regexp::IGNORECASE]) }
+
+    subject(:option) { described_class.new(sample_child, [Regexp::MULTILINE, Regexp::IGNORECASE]) }
 
     context 'Creation & initialisation' do
-      it 'should be created with a child and flags' do
-        expect { MatchOption.new(sample_child, []) }.not_to raise_error
+      it 'is created with a child and flags' do
+        expect { described_class.new(sample_child, []) }.not_to raise_error
       end
 
-      it 'should know its child' do
-        expect(subject.child).to eq(sample_child)
+      it 'Knows its child' do
+        expect(option.child).to eq(sample_child)
       end
 
-      it 'should know its flags' do
-        expect(subject.flags).to eq([Regexp::MULTILINE, Regexp::IGNORECASE])
+      it 'Knows its flags' do
+        expect(option.flags).to eq([Regexp::MULTILINE, Regexp::IGNORECASE])
       end
     end # context
 
     context 'Provided services' do
-      it 'should combine the flag bits' do
-        expect(subject.combine_opts).to eq(Regexp::MULTILINE | Regexp::IGNORECASE)
+      it 'Combines the flag bits' do
+        expect(option.combine_opts).to eq(Regexp::MULTILINE | Regexp::IGNORECASE)
       end
     end # context
   end # describe

data/spec/regex/monadic_expression_spec.rb

@@ -8,31 +8,32 @@ require_relative '../../lib/regex/monadic_expression'
 module Regex # This module is used as a namespace
   describe MonadicExpression do
     let(:sample_child) { double('fake_regex') }
-    subject { MonadicExpression.new(sample_child) }
+
+    subject(:monadic_expr) { described_class.new(sample_child) }
 
     context 'Creation & initialisation' do
-      it 'should be created with a child expression' do
-        expect { MonadicExpression.new(sample_child) }.not_to raise_error
+      it 'is created with a child expression' do
+        expect { described_class.new(sample_child) }.not_to raise_error
       end
 
-      it 'should know its child' do
-         expect(subject.child).to eq(sample_child)
+      it 'Knows its child' do
+         expect(monadic_expr.child).to eq(sample_child)
       end
 
-      it 'should know that it is not atomic' do
-        expect(subject).not_to be_atomic
+      it 'Know that it is not atomic' do
+        expect(monadic_expr).not_to be_atomic
       end
     end # context
 
     context 'Provided services' do
-      it 'should propagate done! notification' do
-        expect(sample_child).to receive(:done!)
-        expect { subject.done! }.not_to raise_error
+      it 'Propagates done! notification' do
+        allow(sample_child).to receive(:done!)
+        expect { monadic_expr.done! }.not_to raise_error
       end
 
-      it 'should be unchanged by a lazy! notification' do
-        expect(sample_child).to receive(:lazy!)
-        expect { subject.lazy! }.not_to raise_error
+      it 'is unchanged by a lazy! notification' do
+        allow(sample_child).to receive(:lazy!)
+        expect { monadic_expr.lazy! }.not_to raise_error
       end
     end # context
   end # describe

data/spec/regex/multiplicity_spec.rb

@@ -9,39 +9,39 @@ require_relative '../../lib/regex/multiplicity'
 module Regex # This module is used as a namespace
   describe Multiplicity do
     context 'Creation & initialisation' do
-      it 'should be created with 3 arguments' do
+      it 'is created with 3 arguments' do
         # Valid cases: initialized with two integer values and a policy symbol
         %i[greedy lazy possessive].each do |policy|
-          expect { Multiplicity.new(0, 1, policy) }.not_to raise_error
+          expect { described_class.new(0, 1, policy) }.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)
+        expect { described_class.new(0, :more, 'KO') }.to raise_error(err, msg)
       end
     end
 
     context 'Provided services' do
       # rubocop: disable Style/CombinableLoops
-      it 'should know its text representation' do
+      it 'Knows its text representation' do
         policy2text = { greedy: '', lazy: '?', possessive: '+' }
 
         # Case: zero or one
         policy2text.each_key do |policy|
-          multi = Multiplicity.new(0, 1, policy)
+          multi = described_class.new(0, 1, policy)
           expect(multi.to_str).to eq("?#{policy2text[policy]}")
         end
 
         # Case: zero or more
         policy2text.each_key do |policy|
-          multi = Multiplicity.new(0, :more, policy)
+          multi = described_class.new(0, :more, policy)
           expect(multi.to_str).to eq("*#{policy2text[policy]}")
         end
 
         # Case: one or more
         policy2text.each_key do |policy|
-          multi = Multiplicity.new(1, :more, policy)
+          multi = described_class.new(1, :more, policy)
           expect(multi.to_str).to eq("+#{policy2text[policy]}")
         end
 
@@ -49,7 +49,7 @@ module Regex # This module is used as a namespace
         policy2text.each_key do |policy|
           samples = [1, 2, 5, 100]
           samples.each do |count|
-            multi = Multiplicity.new(count, count, policy)
+            multi = described_class.new(count, count, policy)
             expect(multi.to_str).to eq("{#{count}}#{policy2text[policy]}")
           end
         end
@@ -59,7 +59,7 @@ module Regex # This module is used as a namespace
           samples = [1, 2, 5, 100]
           samples.each do |count|
             upper = count + 1 + rand(20)
-            multi = Multiplicity.new(count, upper, policy)
+            multi = described_class.new(count, upper, policy)
             expectation = "{#{count},#{upper}}#{policy2text[policy]}"
             expect(multi.to_str).to eq(expectation)
           end
@@ -69,7 +69,7 @@ module Regex # This module is used as a namespace
         policy2text.each_key do |policy|
           samples = [2, 3, 5, 100]
           samples.each do |count|
-            multi = Multiplicity.new(count, :more, policy)
+            multi = described_class.new(count, :more, policy)
             expect(multi.to_str).to eq("{#{count},}#{policy2text[policy]}")
           end
         end

data/spec/regex/repetition_spec.rb

@@ -9,23 +9,24 @@ module Regex # This module is used as a namespace
   describe Repetition do
     let(:optional) { Multiplicity.new(0, 1, :possessive) }
     let(:sample_child) { double('fake_regex') }
-    subject { Repetition.new(sample_child, optional) }
+
+    subject(:repetition) { described_class.new(sample_child, optional) }
 
     context 'Creation & initialisation' do
-      it 'should be created with a child expression and a multiplicity' do
-        expect { Repetition.new(sample_child, optional) }.not_to raise_error
+      it 'is created with a child expression and a multiplicity' do
+        expect { described_class.new(sample_child, optional) }.not_to raise_error
       end
 
-      it 'should its multiplicity' do
-        expect(subject.multiplicity).to eq(optional)
+      it 'Knows its multiplicity' do
+        expect(repetition.multiplicity).to eq(optional)
       end
     end # context
 
     context 'Provided services' do
-      it 'should change its policy with lazy! notification' do
-        expect(sample_child).to receive(:lazy!)
-        expect { subject.lazy! }.not_to raise_error
-        expect(subject.multiplicity.policy).to eq(:lazy)
+      it 'Changes its policy with lazy! notification' do
+        allow(sample_child).to receive(:lazy!)
+        expect { repetition.lazy! }.not_to raise_error
+        expect(repetition.multiplicity.policy).to eq(:lazy)
       end
     end # context
   end # describe

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