rley 0.8.14 → 0.8.15

data/spec/rley/gfg/item_vertex_spec.rb

@@ -18,6 +18,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       def build_prod(theLHS, *theRHSSymbols)
         return Syntax::Production.new(theLHS, theRHSSymbols)
       end
+      subject(:a_vertex) { described_class.new(sample_item) }
 
       let(:t_a) { Rley::Syntax::Terminal.new('a') }
       let(:t_b) { Rley::Syntax::Terminal.new('b') }
@@ -31,101 +32,98 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:empty_prod) { build_prod(nt_sentence) }
       let(:sample_item) { Base::DottedItem.new(sample_prod, 1) }
       let(:next_item) { Base::DottedItem.new(sample_prod, 2) }
-      subject { ItemVertex.new(sample_item) }
 
       context 'Initialization:' do
-        it 'should be created with a dotted item' do
-          expect { ItemVertex.new(sample_item) }.not_to raise_error
+        it 'is created with a dotted item' do
+          expect { described_class.new(sample_item) }.not_to raise_error
         end
 
-        it 'should know its dotted item' do
-          expect(subject.dotted_item).to eq(sample_item)
+        it 'knows its dotted item' do
+          expect(a_vertex.dotted_item).to eq(sample_item)
         end
 
-        it 'should not have any shortcut edge at start' do
-          expect(subject.shortcut).to be_nil
+        it 'does not have any shortcut edge at start' do
+          expect(a_vertex.shortcut).to be_nil
         end
       end # context
 
       context 'Provided services:' do
-        it 'should know its label' do
-          expect(subject.label).to eq(sample_item.to_s)
+        it 'knows its label' do
+          expect(a_vertex.label).to eq(sample_item.to_s)
         end
 
-        it 'should know the lhs of the production' do
-          expect(subject.lhs).to eq(nt_sentence)
+        it 'knows the lhs of the production' do
+          expect(a_vertex.lhs).to eq(nt_sentence)
         end
 
-        it 'should know whether it has a dot at the end of the rhs' do
+        it 'knows whether it has a dot at the end of the rhs' do
           # Case: dot not at the end
-          expect(subject).not_to be_complete
+          expect(a_vertex).not_to be_complete
 
           # Case: dot at the end
-          instance1 = ItemVertex.new(Base::DottedItem.new(sample_prod, 3))
+          instance1 = described_class.new(Base::DottedItem.new(sample_prod, 3))
           expect(instance1).to be_complete
 
           # Case: empty production
-          instance2 = ItemVertex.new(Base::DottedItem.new(empty_prod, 0))
+          instance2 = described_class.new(Base::DottedItem.new(empty_prod, 0))
           expect(instance2).to be_complete
         end
 
-        it 'should know the previous symbol (if any) in the rhs' do
+        it 'knows the previous symbol (if any) in the rhs (i)' do
           # Case: dot is after first symbol
-          instance1 = ItemVertex.new(sample_item)
+          instance1 = described_class.new(sample_item)
           expect(instance1.prev_symbol).to eq(t_a)
 
           # Case: dot is after second or later symbol
-          instance2 = ItemVertex.new(next_item)
+          instance2 = described_class.new(next_item)
           expect(instance2.prev_symbol).to eq(nt_b_sequence)
 
           # Case: dot is at begin
-          instance3 = ItemVertex.new(Base::DottedItem.new(sample_prod, 0))
+          instance3 = described_class.new(Base::DottedItem.new(sample_prod, 0))
           expect(instance3.prev_symbol).to be_nil
 
           # Case: empty production
-          instance4 = ItemVertex.new(Base::DottedItem.new(empty_prod, 0))
+          instance4 = described_class.new(Base::DottedItem.new(empty_prod, 0))
           expect(instance4.prev_symbol).to be_nil
         end
 
 
-        it 'should know the next symbol (if any) in the rhs' do
+        it 'knows the next symbol (if any) in the rhs (ii)' do
           # Case: dot is not penultimate
-          expect(subject.next_symbol).to eq(nt_b_sequence)
+          expect(a_vertex.next_symbol).to eq(nt_b_sequence)
 
           # Case: dot is penultimate
-          instance1 = ItemVertex.new(next_item)
+          instance1 = described_class.new(next_item)
           expect(instance1.next_symbol).to eq(t_c)
 
           # Case: dot is at end
-          instance2 = ItemVertex.new(Base::DottedItem.new(sample_prod, 3))
+          instance2 = described_class.new(Base::DottedItem.new(sample_prod, 3))
           expect(instance2.next_symbol).to be_nil
 
           # Case: empty production
-          instance3 = ItemVertex.new(Base::DottedItem.new(empty_prod, 0))
+          instance3 = described_class.new(Base::DottedItem.new(empty_prod, 0))
           expect(instance3.next_symbol).to be_nil
         end
 
-        it 'should accept a shortcut edge' do
-          next_vertex = ItemVertex.new(next_item)
+        it 'accepts a shortcut edge' do
+          next_vertex = described_class.new(next_item)
 
           # The ShortcutEdge constructor invokes the shortcut setter
-          shortcut = ShortcutEdge.new(subject, next_vertex)
-          expect(subject.shortcut).to eq(shortcut)
+          shortcut = ShortcutEdge.new(a_vertex, next_vertex)
+          expect(a_vertex.shortcut).to eq(shortcut)
         end
 
-        it 'should reject an invalid shortcut edge' do
+        it 'rejects an invalid shortcut edge' do
           err = StandardError
           err_msg = 'Invalid shortcut argument'
-          expect { subject.shortcut = 'invalid' }.to raise_error(err, err_msg)
+          expect { a_vertex.shortcut = 'invalid' }.to raise_error(err, err_msg)
         end
-      end # context
 
-      context 'Provided services:' do
-        it 'should provide human-readable representation of itself' do
+        it 'provides human-readable representation of itself' do
           prefix = /^#<Rley::GFG::ItemVertex:\d+/
-          expect(subject.inspect).to match(prefix)
+          expect(a_vertex.inspect).to match(prefix)
           suffix = /label="sentence => a \. b_sequence c">$/
-          expect(subject.inspect).to match(suffix)
+          expect(a_vertex.inspect).to match(suffix)
         end
       end # context
     end # describe

data/spec/rley/gfg/non_terminal_vertex_spec.rb

@@ -8,30 +8,30 @@ require_relative '../../../lib/rley/gfg/non_terminal_vertex'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module GFG # Open this namespace to avoid module qualifier prefixes
     describe NonTerminalVertex do
+      subject(:a_vertex) { described_class.new(sample_nt) }
       let(:sample_nt) { double('fake-non-terminal') }
-      subject { NonTerminalVertex.new(sample_nt) }
 
       context 'Initialization:' do
-        it 'should be created with a non-terminal symbol' do
-          expect { NonTerminalVertex.new(sample_nt) }.not_to raise_error
+        it 'is created with a non-terminal symbol' do
+          expect { described_class.new(sample_nt) }.not_to raise_error
         end
 
-        it 'should know its non-terminal' do
-          expect(subject.non_terminal).to eq(sample_nt)
+        it 'knows its non-terminal' do
+          expect(a_vertex.non_terminal).to eq(sample_nt)
         end
 
 
-        it 'should accept at more than one outgoing edge' do
+        it 'accepts at more than one outgoing edge' do
           edge1 = double('fake-edge1')
           edge2 = double('fake-edge2')
 
-          expect { subject.add_edge(edge1) }.not_to raise_error
-          expect(subject.edges.size).to eq(1)
-          expect(subject.edges.last).to eq(edge1)
+          expect { a_vertex.add_edge(edge1) }.not_to raise_error
+          expect(a_vertex.edges.size).to eq(1)
+          expect(a_vertex.edges.last).to eq(edge1)
 
-          expect { subject.add_edge(edge2) }.not_to raise_error
-          expect(subject.edges.size).to eq(2)
-          expect(subject.edges.last).to eq(edge2)
+          expect { a_vertex.add_edge(edge2) }.not_to raise_error
+          expect(a_vertex.edges.size).to eq(2)
+          expect(a_vertex.edges.last).to eq(edge2)
         end
       end # context
     end # describe

data/spec/rley/gfg/return_edge_spec.rb

@@ -21,6 +21,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         return Syntax::Production.new(theLHS, theRHSSymbols)
       end
 
+      subject(:an_edge) { described_class.new(vertex1, vertex2) }
+
       let(:t_a) { Rley::Syntax::Terminal.new('a') }
       let(:t_b) { Rley::Syntax::Terminal.new('b') }
       let(:t_c) { Rley::Syntax::Terminal.new('c') }
@@ -28,22 +30,20 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:nt_b_sequence) { Rley::Syntax::NonTerminal.new('b_sequence') }
       let(:sample_prod) { build_prod(nt_sentence, t_a, nt_b_sequence, t_c) }
       let(:sample_item) { Base::DottedItem.new(sample_prod, 1) }
-
       let(:vertex1) { EndVertex.new('from') }
       let(:vertex2) { ItemVertex.new(sample_item) }
-      subject { ReturnEdge.new(vertex1, vertex2) }
 
       context 'Initialization:' do
-        it 'should be created with two vertice arguments' do
-          expect { ReturnEdge.new(vertex1, vertex2) }.not_to raise_error
+        it 'is created with two vertice arguments' do
+          expect { described_class.new(vertex1, vertex2) }.not_to raise_error
         end
       end # context
 
       context 'Provided services:' do
-        it 'should know its key' do
+        it 'knows its key' do
           pos = sample_item.position
           expectation = "RET_#{sample_prod.object_id}_#{pos - 1}"
-          expect(subject.key).to eq(expectation)
+          expect(an_edge.key).to eq(expectation)
         end
       end # context
     end # describe

data/spec/rley/gfg/scan_edge_spec.rb

@@ -10,21 +10,22 @@ require_relative '../../../lib/rley/gfg/scan_edge'
 
 module Rley # Open this namespace to avoid module qualifier prefixes
   module GFG # Open this namespace to avoid module qualifier prefixes
-    describe Edge do
+    describe ScanEdge do
+      subject(:an_edge) { described_class.new(vertex1, vertex2, sample_terminal) }
+
       let(:vertex1) { StartVertex.new('from') }
       let(:vertex2) { StartVertex.new('to') }
       let(:sample_terminal) { double('fake-terminal') }
-      subject { ScanEdge.new(vertex1, vertex2, sample_terminal) }
 
       context 'Initialization:' do
-        it 'should be created with two vertice arguments & a terminal' do
+        it 'is created with two vertice arguments & a terminal' do
           v1 = vertex1
           v2 = vertex2
-          expect { ScanEdge.new(v1, v2, sample_terminal) }.not_to raise_error
+          expect { described_class.new(v1, v2, sample_terminal) }.not_to raise_error
         end
 
-        it 'should know the related terminal' do
-          expect(subject.terminal).to eq(sample_terminal)
+        it 'knows the related terminal' do
+          expect(an_edge.terminal).to eq(sample_terminal)
         end
       end # context
     end # describe

data/spec/rley/gfg/shortcut_edge_spec.rb

@@ -8,34 +8,34 @@ require_relative '../../../lib/rley/gfg/shortcut_edge'
 
 module Rley # Open this namespace to avoid module qualifier prefixes
   module GFG # Open this namespace to avoid module qualifier prefixes
-    describe Edge do
-      let(:nt_b_sequence) { Rley::Syntax::NonTerminal.new('b_sequence') }
+    describe ShortcutEdge do
+      subject(:an_edge) { described_class.new(vertex1, vertex2) }
 
+      let(:nt_b_sequence) { Rley::Syntax::NonTerminal.new('b_sequence') }
       let(:vertex1) { double('fake_vertex1') }
       let(:vertex2) { double('fake_vertex2') }
-      subject { ShortcutEdge.new(vertex1, vertex2) }
 
       context 'Initialization:' do
-        it 'should be created with two vertice arguments & a non-terminal' do
-          expect(vertex1).to receive(:shortcut=)
-          expect(vertex1).to receive(:next_symbol).and_return(nt_b_sequence)
+        it 'is created with two vertice arguments & a non-terminal' do
+          allow(vertex1).to receive(:shortcut=)
+          allow(vertex1).to receive(:next_symbol).and_return(nt_b_sequence)
 
-          expect { ShortcutEdge.new(vertex1, vertex2) }
+          expect { described_class.new(vertex1, vertex2) }
             .not_to raise_error
         end
 
-        it 'should know the successor vertex' do
-          expect(vertex1).to receive(:shortcut=)
-          expect(vertex1).to receive(:next_symbol).and_return(nt_b_sequence)
+        it 'knows the successor vertex' do
+          allow(vertex1).to receive(:shortcut=)
+          allow(vertex1).to receive(:next_symbol).and_return(nt_b_sequence)
 
-          expect(subject.successor).to eq(vertex2)
+          expect(an_edge.successor).to eq(vertex2)
         end
 
-        it 'should know the related terminal' do
-          expect(vertex1).to receive(:shortcut=)
-          expect(vertex1).to receive(:next_symbol).and_return(nt_b_sequence)
+        it 'knows the related terminal' do
+          allow(vertex1).to receive(:shortcut=)
+          allow(vertex1).to receive(:next_symbol).and_return(nt_b_sequence)
 
-          expect(subject.nonterminal).to eq(nt_b_sequence)
+          expect(an_edge.nonterminal).to eq(nt_b_sequence)
         end
       end # context
     end # describe

data/spec/rley/gfg/start_vertex_spec.rb

@@ -9,24 +9,24 @@ require_relative '../../../lib/rley/gfg/start_vertex'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module GFG # Open this namespace to avoid module qualifier prefixes
     describe StartVertex do
+      subject(:a_vertex) { described_class.new(sample_nt) }
       let(:sample_nt) { Syntax::NonTerminal.new('NT') }
-      subject { StartVertex.new(sample_nt) }
 
       context 'Initialization:' do
-        it 'should be created with a non-terminal symbol' do
-          expect { StartVertex.new(sample_nt) }.not_to raise_error
+        it 'is created with a non-terminal symbol' do
+          expect { described_class.new(sample_nt) }.not_to raise_error
         end
 
-        it 'should know its label' do
-          expect(sample_nt).to receive(:to_s).and_return('NT')
-          expect(subject.label).to eq('.NT')
+        it 'knows its label' do
+          allow(sample_nt).to receive(:to_s).and_return('NT')
+          expect(a_vertex.label).to eq('.NT')
         end
       end # context
 
       context 'Provided services:' do
-        it 'should provide human-readable representation of itself' do
+        it 'provides human-readable representation of itself' do
           pattern = /^#<Rley::GFG::StartVertex:\d+ label="\.NT"/
-          expect(subject.inspect).to match(pattern)
+          expect(a_vertex.inspect).to match(pattern)
         end
       end # context
     end # describe

data/spec/rley/gfg/vertex_spec.rb

@@ -8,44 +8,44 @@ require_relative '../../../lib/rley/gfg/vertex'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module GFG # Open this namespace to avoid module qualifier prefixes
     describe Vertex do
-      subject { Vertex.new }
+      subject(:a_vertex) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be created without argument' do
-          expect { Vertex.new }.not_to raise_error
+        it 'is created without argument' do
+          expect { described_class.new }.not_to raise_error
         end
 
-        it "shouldn't have edges at start" do
-          expect(subject.edges.empty?).to eq(true)
+        it "doesn't have edges at start" do
+          expect(a_vertex.edges.empty?).to be(true)
         end
       end # context
 
       context 'Provided services:' do
-        it 'should know whether it has a dot at the end of the rhs' do
-          expect(subject).not_to be_complete
+        it 'knows whether it has a dot at the end of the rhs' do
+          expect(a_vertex).not_to be_complete
         end
 
-        it 'should know the previous symbol (if any) in the rhs' do
-          expect(subject.prev_symbol).to be_nil
+        it 'knows the previous symbol (if any) in the rhs' do
+          expect(a_vertex.prev_symbol).to be_nil
         end
 
-        it 'should know the next symbol (if any) in the rhs' do
-          expect(subject.next_symbol).to be_nil
+        it 'knows the next symbol (if any) in the rhs' do
+          expect(a_vertex.next_symbol).to be_nil
         end
 
-        it 'should accept at most one new edge' do
+        it 'accepts at most one new edge' do
           edge1 = double('fake-edge1')
           edge2 = double('fake-edge2')
 
-          expect { subject.add_edge(edge1) }.not_to raise_error
-          expect(subject.edges.size).to eq(1)
-          expect(subject.edges.last).to eq(edge1)
+          expect { a_vertex.add_edge(edge1) }.not_to raise_error
+          expect(a_vertex.edges.size).to eq(1)
+          expect(a_vertex.edges.last).to eq(edge1)
 
           err = StandardError
           msg = 'At most one edge accepted'
-          expect { subject.add_edge(edge2) }.to raise_error err, msg
-          expect(subject.edges.size).to eq(1)
-          expect(subject.edges.last).to eq(edge1)
+          expect { a_vertex.add_edge(edge2) }.to raise_error err, msg
+          expect(a_vertex.edges.size).to eq(1)
+          expect(a_vertex.edges.last).to eq(edge1)
         end
       end # context
     end # describe

data/spec/rley/lexical/literal_spec.rb

@@ -16,14 +16,14 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       context 'Initialization:' do
         # Default instantiation rule
-        subject { Literal.new(lexeme.to_f, lexeme, a_terminal, a_pos) }
+        subject(:a_literal) { described_class.new(lexeme.to_f, lexeme, a_terminal, a_pos) }
 
-        it 'should be created with a value, lexeme, terminal and position' do
-          expect { Literal.new(lexeme.to_f, lexeme, a_terminal, a_pos) }.not_to raise_error
+        it 'is created with a value, lexeme, terminal and position' do
+          expect { described_class.new(lexeme.to_f, lexeme, a_terminal, a_pos) }.not_to raise_error
         end
 
-        it 'should know its value' do
-          expect(subject.value).to eq(lexeme.to_f)
+        it 'knows its value' do
+          expect(a_literal.value).to eq(lexeme.to_f)
         end
       end # context
     end # describe

data/spec/rley/lexical/token_range_spec.rb

@@ -11,87 +11,87 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:sample_range) { { low: 0, high: 5 } }
 
       # Default instantiation rule
-      subject { TokenRange.new(sample_range) }
+      subject(:a_range) { described_class.new(sample_range) }
 
       context 'Initialization:' do
-        it 'could be created with a range Hash' do
+        it 'is created with a range Hash' do
           # No bounds provided
-          expect { TokenRange.new({}) }.not_to raise_error
+          expect { described_class.new({}) }.not_to raise_error
 
           # Low bound provided
-          expect { TokenRange.new(low: 0) }.not_to raise_error
+          expect { described_class.new(low: 0) }.not_to raise_error
 
           # High bound provided
-          expect { TokenRange.new(high: 5) }.not_to raise_error
+          expect { described_class.new(high: 5) }.not_to raise_error
 
           # Both bounds provided
-          expect { TokenRange.new(low: 0, high: 5) }.not_to raise_error
+          expect { described_class.new(low: 0, high: 5) }.not_to raise_error
         end
 
-        it 'could be created with another TokenRange' do
+        it 'is created with another TokenRange' do
           # Low bound provided
-          instance = TokenRange.new(low: 0)
-          expect { TokenRange.new(instance) }.not_to raise_error
+          instance = described_class.new(low: 0)
+          expect { described_class.new(instance) }.not_to raise_error
 
           # High bound provided
-          instance = TokenRange.new(high: 5)
-          expect { TokenRange.new(instance) }.not_to raise_error
+          instance = described_class.new(high: 5)
+          expect { described_class.new(instance) }.not_to raise_error
 
           # Both bounds provided
-          instance = TokenRange.new(low: 0, high: 5)
-          expect { TokenRange.new(instance) }.not_to raise_error
+          instance = described_class.new(low: 0, high: 5)
+          expect { described_class.new(instance) }.not_to raise_error
         end
 
-        it 'should know its low bound' do
-          expect(subject.low).to eq(0)
+        it 'knows its low bound' do
+          expect(a_range.low).to eq(0)
         end
 
-        it 'should know its low bound' do
-          expect(subject.high).to eq(5)
+        it 'knows its high bound' do
+          expect(a_range.high).to eq(5)
         end
       end # context
 
       context 'Provided services:' do
-        it 'should compare to another range' do
-          me = subject
-          expect(subject == me).to eq(true)
-          equal = TokenRange.new(low: 0, high: 5)
-          expect(subject == equal).to eq(true)
-          # expect(subject == [0..5]).to eq(true)
-          expect(subject == [0, 5]).to eq(true)
+        it 'compares to another range' do
+          me = a_range
+          expect(a_range == me).to be(true)
+          equal = described_class.new(low: 0, high: 5)
+          expect(a_range == equal).to be(true)
+          # expect(a_range == [0..5]).to be(true)
+          expect(a_range == [0, 5]).to be(true)
         end
 
 
-        it 'should know whether it is bounded or not' do
-          expect(subject).to be_bounded
+        it 'knows whether it is bounded or not' do
+          expect(a_range).to be_bounded
 
           # Case: only low bound is set
-          instance = TokenRange.new(low: 0)
+          instance = described_class.new(low: 0)
           expect(instance).not_to be_bounded
 
           # Case: only upper bound is set
-          instance = TokenRange.new(high: 5)
+          instance = described_class.new(high: 5)
           expect(instance).not_to be_bounded
 
           # No bound is set
-          instance = TokenRange.new({})
+          instance = described_class.new({})
           expect(instance).not_to be_bounded
         end
 
-        it 'should assign its open bounds' do
+        it 'assigns its open bounds' do
           some_range = { low: 1, high: 4 }
 
           ###########
           # Case of bounded token range...
-          subject.assign(some_range)
+          a_range.assign(some_range)
 
           # ... should be unchanged
-          expect(subject.low).to eq(sample_range[:low])
-          expect(subject.high).to eq(sample_range[:high])
+          expect(a_range.low).to eq(sample_range[:low])
+          expect(a_range.high).to eq(sample_range[:high])
 
           ###########
           # Case: only low bound is set
-          instance = TokenRange.new(low: 0)
+          instance = described_class.new(low: 0)
           instance.assign(some_range)
 
           # Expectation: high is assigned the new value
@@ -101,7 +101,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
           ###########
           # Case: only high bound is set
-          instance = TokenRange.new(high: 5)
+          instance = described_class.new(high: 5)
           instance.assign(some_range)
 
           # Expectation: low is assigned the new value
@@ -111,7 +111,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
           ###########
           # Case: no bound is set
-          instance = TokenRange.new({})
+          instance = described_class.new({})
           instance.assign(some_range)
 
           # Expectation: low is assigned the new value
@@ -120,48 +120,48 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(instance.high).to eq(4)
         end
 
-        it 'should tell whether an index value lies outside the range' do
+        it 'tells whether an index value lies outside the range' do
           # Out of range...
-          expect(subject.out_of_range?(-1)).to eq(true)
-          expect(subject.out_of_range?(6)).to eq(true)
+          expect(a_range.out_of_range?(-1)).to be(true)
+          expect(a_range.out_of_range?(6)).to be(true)
 
           # On boundaries...
-          expect(subject.out_of_range?(0)).to eq(false)
-          expect(subject.out_of_range?(5)).to eq(false)
+          expect(a_range.out_of_range?(0)).to be(false)
+          expect(a_range.out_of_range?(5)).to be(false)
 
           # Inside boundaries
-          expect(subject.out_of_range?(2)).to eq(false)
+          expect(a_range.out_of_range?(2)).to be(false)
 
-          instance = TokenRange.new(low: nil, high: 5)
+          instance = described_class.new(low: nil, high: 5)
 
           # Lower bound is nil
-          expect(instance.out_of_range?(-1)).to eq(false)
-          expect(instance.out_of_range?(5)).to eq(false)
-          expect(instance.out_of_range?(6)).to eq(true)
+          expect(instance.out_of_range?(-1)).to be(false)
+          expect(instance.out_of_range?(5)).to be(false)
+          expect(instance.out_of_range?(6)).to be(true)
 
-          instance = TokenRange.new(low: 0, high: nil)
+          instance = described_class.new(low: 0, high: nil)
 
           # Upper bound is nil
-          expect(instance.out_of_range?(-1)).to eq(true)
-          expect(instance.out_of_range?(0)).to eq(false)
-          expect(instance.out_of_range?(6)).to eq(false)
+          expect(instance.out_of_range?(-1)).to be(true)
+          expect(instance.out_of_range?(0)).to be(false)
+          expect(instance.out_of_range?(6)).to be(false)
         end
 
-        it 'should provide a text representation of itself' do
+        it 'provides a text representation of itself' do
           # Case 1: not bound is set
-          instance = TokenRange.new({})
+          instance = described_class.new({})
           expect(instance.to_string(0)).to eq('[?, ?]')
 
           # Case: only low bound is set
-          instance = TokenRange.new(low: 0)
+          instance = described_class.new(low: 0)
           expect(instance.to_string(0)).to eq('[0, ?]')
 
           # Case: only upper bound is set
-          instance = TokenRange.new(high: 5)
+          instance = described_class.new(high: 5)
           expect(instance.to_string(0)).to eq('[?, 5]')
 
           # Case: both bounds are set
-          instance = TokenRange.new(low: 0, high: 5)
+          instance = described_class.new(low: 0, high: 5)
           expect(instance.to_string(0)).to eq('[0, 5]')
         end
       end