rley 0.8.14 → 0.9.01

data/spec/rley/gfg/edge_spec.rb

@@ -11,21 +11,22 @@ require_relative '../../../lib/rley/gfg/edge'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module GFG # Open this namespace to avoid module qualifier prefixes
     describe Edge do
+      subject(:an_edge) { described_class.new(vertex1, vertex2) }
+
       let(:vertex1) { StartVertex.new('from') }
       let(:vertex2) { StartVertex.new('to') }
-      subject { Edge.new(vertex1, vertex2) }
 
       context 'Initialization:' do
-        it 'should be created with two vertice arguments' do
-          expect { Edge.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
 
-        it 'should be registered by the predecessor vertex' do
-          expect(subject).to eq(vertex1.edges.last)
+        it 'is registered by the predecessor vertex' do
+          expect(an_edge).to eq(vertex1.edges.last)
         end
 
-        it 'should know the successor vertex' do
-          expect(subject.successor).to eq(vertex2)
+        it 'knows the successor vertex' do
+          expect(an_edge.successor).to eq(vertex2)
         end
       end # context
     end # describe

data/spec/rley/gfg/end_vertex_spec.rb

@@ -9,24 +9,25 @@ require_relative '../../../lib/rley/gfg/end_vertex'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module GFG # Open this namespace to avoid module qualifier prefixes
     describe EndVertex do
+      subject(:a_vertex) { described_class.new(sample_nt) }
+
       let(:sample_nt) { Syntax::NonTerminal.new('NT') }
-      subject { EndVertex.new(sample_nt) }
 
       context 'Initialization:' do
-        it 'should be created with a non-terminal symbol' do
-          expect { EndVertex.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
+        it 'knows its label' do
           expect(sample_nt).to receive(:to_s).and_return('NT')
-          expect(subject.label).to eq('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::EndVertex:\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/epsilon_edge_spec.rb

@@ -10,14 +10,15 @@ require_relative '../../../lib/rley/gfg/epsilon_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 EpsilonEdge do
+      subject { described_class.new(vertex1, vertex2) }
+
       let(:vertex1) { StartVertex.new('from') }
       let(:vertex2) { StartVertex.new('to') }
-      subject { EpsilonEdge.new(vertex1, vertex2) }
 
       context 'Initialization:' do
-        it 'should be created with two vertice arguments' do
-          expect { EpsilonEdge.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
     end # describe

data/spec/rley/gfg/grm_flow_graph_spec.rb

@@ -34,6 +34,9 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
       end
 
+      # Default instantiation rule
+      subject(:a_graph) { described_class.new(items_from_grammar) }
+
       # Factory method. Build a production with the given sequence
       # of symbols as its rhs.
       let(:grammar_abc) do
@@ -45,52 +48,48 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       # from the abc grammar
       let(:items_from_grammar) { build_items_for_grammar(grammar_abc) }
 
-      # Default instantiation rule
-      subject { GrmFlowGraph.new(items_from_grammar) }
-
-
       context 'Initialization:' do
-        it 'should be created with an array of dotted items' do
-          expect { GrmFlowGraph.new(items_from_grammar) }.not_to raise_error
+        it 'is created with an array of dotted items' do
+          expect { described_class.new(items_from_grammar) }.not_to raise_error
         end
 
-        it 'should know its main start vertex' do
-          expect(subject.start_vertex).to eq(subject.vertices.first)
+        it 'knows its main start vertex' do
+          expect(a_graph.start_vertex).to eq(a_graph.vertices.first)
         end
 
-        it 'should have the correct number of vertices' do
+        it 'has the correct number of vertices' do
           # Number of vertices = count of dotted items +...
           #   ... 2 * count of non-terminals
           count_vertices = 2 * grammar_abc.non_terminals.size
           count_vertices += items_from_grammar.size
-          expect(subject.vertices.size).to eq(count_vertices)
+          expect(a_graph.vertices.size).to eq(count_vertices)
         end
 
-        it 'should have for each non-terminal one start and end vertex' do
+        it 'has for each non-terminal one start and end vertex' do
           # Iterate over all non-terminals of grammar...
           grammar_abc.non_terminals.each do |nterm|
             # ...to each non-terminal there should be a start vertex
-            start_vertex = subject.start_vertex_for[nterm]
-            expect(start_vertex).to be_kind_of(StartVertex)
+            start_vertex = a_graph.start_vertex_for[nterm]
+            expect(start_vertex).to be_a(StartVertex)
             expect(start_vertex.label).to eq(".#{nterm}")
 
             # ...to each non-terminal there should be an end vertex
-            end_vertex = subject.end_vertex_for[nterm]
-            expect(end_vertex).to be_kind_of(EndVertex)
+            end_vertex = a_graph.end_vertex_for[nterm]
+            expect(end_vertex).to be_a(EndVertex)
             expect(end_vertex.label).to eq("#{nterm}.")
           end
         end
 
-        it 'should have one or more entry edges per start vertex' do
-          subject.start_vertex_for.each_value do |a_start|
+        it 'has one or more entry edges per start vertex' do
+          a_graph.start_vertex_for.each_value do |a_start|
             expect(a_start.edges.size >= 1).to be_truthy
             a_start.edges.each do |edge|
-              expect(edge.successor.dotted_item.at_start?).to be_truthy
+              expect(edge.successor.dotted_item).to be_at_start
             end
           end
         end
 
-        it 'should have the correct graph structure' do
+        it 'has the correct graph structure' do
           # We use the abc grammar
           expected = [
             '.S --> S => . A',
@@ -108,10 +107,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             'A => b . --> A.'
           ]
 
-          compare_graph_expectations(subject, expected)
+          compare_graph_expectations(a_graph, expected)
         end
 
-        it 'should handle empty productions' do
+        it 'handles empty productions' do
             builder = Rley::Syntax::BaseGrammarBuilder.new
             builder.add_terminals('a')
             builder.add_production('S' => 'A')
@@ -121,7 +120,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             grammar = builder.grammar
             items = build_items_for_grammar(grammar)
 
-            graph = GrmFlowGraph.new(items)
+            graph = described_class.new(items)
             expected = [
               '.S --> S => . A',
               '.A --> A => . a',
@@ -137,8 +136,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             compare_graph_expectations(graph, expected)
         end
 
-        it 'should have shortcut edges' do
-          subject.vertices.each do |a_vertex|
+        it 'has shortcut edges' do
+          a_graph.vertices.each do |a_vertex|
             next unless a_vertex.kind_of?(ItemVertex)
 
             if a_vertex.next_symbol.kind_of?(Syntax::NonTerminal)
@@ -177,9 +176,9 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           builder.grammar
         end
 
-        it 'should provide depth-first traversal' do
+        it 'provides depth-first traversal' do
           result = []
-          subject.traverse_df(subject.start_vertex) do |vertex|
+          a_graph.traverse_df(a_graph.start_vertex) do |vertex|
             result << vertex.label
           end
 
@@ -200,28 +199,28 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(result).to eq(expected)
         end
 
-        it 'should provide human-readable representation of itself' do
+        it 'provides human-readable representation of itself' do
           prefix = /^#<Rley::GFG::GrmFlowGraph:\d+ @vertices=\[/
-          expect(subject.inspect).to match(prefix)
+          expect(a_graph.inspect).to match(prefix)
           pattern = /@vertices=\[#<Rley::GFG::StartVertex:\d+ label="\.S"/
-          expect(subject.inspect).to match(pattern)
+          expect(a_graph.inspect).to match(pattern)
           suffix = /]>$/
-          expect(subject.inspect).to match(suffix)
+          expect(a_graph.inspect).to match(suffix)
         end
 
-        it 'should perform a diagnosis of a correct grammar' do
-          expect { subject.diagnose }.not_to raise_error
+        it 'performs a diagnosis of a correct grammar' do
+          expect { a_graph.diagnose }.not_to raise_error
           grammar_abc.non_terminals.each do |nterm|
             expect(nterm).not_to be_undefined
             expect(nterm).not_to be_unreachable
           end
         end
 
-        it 'should detect when a non-terminal is unreachable' do
+        it 'detects when a non-terminal is unreachable' do
           grammar = problematic_grammar
           items = build_items_for_grammar(grammar)
 
-          graph = GrmFlowGraph.new(items)
+          graph = described_class.new(items)
           expect { graph.diagnose }.not_to raise_error
           grammar.non_terminals.each do |nterm|
             expect(nterm).not_to be_undefined

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