rley 0.8.14 → 0.8.15

data/spec/rley/parser/parse_entry_spec.rb

@@ -13,6 +13,9 @@ require_relative '../../../lib/rley/parser/parse_entry'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Parser # Open this namespace to avoid module qualifier prefixes
     describe ParseEntry do
+      # Default instantiation rule
+      subject(:an_entry) { described_class.new(sample_vertex, origin_val) }
+
       let(:t_a) { Syntax::Terminal.new('A') }
       let(:t_b) { Syntax::Terminal.new('B') }
       let(:t_c) { Syntax::Terminal.new('C') }
@@ -30,186 +33,185 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:origin_val) { 3 }
       let(:sample_vertex) { GFG::StartVertex.new(nt_sentence) }
       let(:vertex2) { double('vertex-mock') }
-      # Default instantiation rule
-      subject { ParseEntry.new(sample_vertex, origin_val) }
+
 
       context 'Initialization:' do
-        it 'should be created with a vertex and an origin position' do
+        it 'is created with a vertex and an origin position' do
           args = [sample_vertex, origin_val]
-          expect { ParseEntry.new(*args) }.not_to raise_error
+          expect { described_class.new(*args) }.not_to raise_error
         end
 
-        it 'should complain when the vertex is nil' do
+        it 'complains when the vertex is nil' do
           err = StandardError
           msg = 'GFG vertex cannot be nil'
-          expect { ParseEntry.new(nil, 2) }.to raise_error(err, msg)
+          expect { described_class.new(nil, 2) }.to raise_error(err, msg)
         end
 
-        it 'should know the vertex' do
-          expect(subject.vertex).to eq(sample_vertex)
+        it 'knows the vertex' do
+          expect(an_entry.vertex).to eq(sample_vertex)
         end
 
-        it 'should know the origin value' do
-          expect(subject.origin).to eq(origin_val)
+        it 'knows the origin value' do
+          expect(an_entry.origin).to eq(origin_val)
         end
 
-        it 'should have not antecedent at creation' do
-          expect(subject.antecedents).to be_empty
-          expect(subject).to be_orphan
+        it 'has not antecedent at creation' do
+          expect(an_entry.antecedents).to be_empty
+          expect(an_entry).to be_orphan
         end
       end # context
 
       context 'Provided services:' do
-        it 'should compare with itself' do
-          synonym = subject # Fool Rubocop
-          expect(subject == synonym).to eq(true)
+        it 'compares with itself' do
+          synonym = an_entry # Fool Rubocop
+          expect(an_entry == synonym).to be(true)
         end
 
-        it 'should compare with another' do
-          equal = ParseEntry.new(sample_vertex, origin_val)
-          expect(subject == equal).to eq(true)
+        it 'compares with another' do
+          equal = described_class.new(sample_vertex, origin_val)
+          expect(an_entry == equal).to be(true)
 
           # Same vertex, different origin
-          diff_origin = ParseEntry.new(sample_vertex, 2)
-          expect(subject == diff_origin).to eq(false)
+          diff_origin = described_class.new(sample_vertex, 2)
+          expect(an_entry == diff_origin).to be(false)
 
           # Different vertices, same origin
-          diff_vertex = ParseEntry.new(double('other_sample_vertex'), 3)
-          expect(subject == diff_vertex).to eq(false)
+          diff_vertex = described_class.new(double('other_sample_vertex'), 3)
+          expect(an_entry == diff_vertex).to be(false)
         end
 
-        it 'should know if the vertex is a start vertex' do
-          expect(subject).to be_start_entry
+        it 'knows if the vertex is a start vertex' do
+          expect(an_entry).to be_start_entry
 
-          instance = ParseEntry.new(GFG::EndVertex.new('.NT'), 3)
+          instance = described_class.new(GFG::EndVertex.new('.NT'), 3)
           expect(instance).not_to be_start_entry
         end
 
-        it 'should know if the vertex is an end vertex' do
-          expect(subject).not_to be_end_entry
+        it 'knows if the vertex is an end vertex' do
+          expect(an_entry).not_to be_end_entry
 
-          instance = ParseEntry.new(GFG::EndVertex.new('NT.'), 3)
+          instance = described_class.new(GFG::EndVertex.new('NT.'), 3)
           expect(instance).to be_end_entry
         end
 
-        it 'should know if the entry is a dotted item vertex' do
-          expect(subject).not_to be_dotted_entry
+        it 'knows if the entry is a dotted item vertex' do
+          expect(an_entry).not_to be_dotted_entry
 
-          instance = ParseEntry.new(GFG::ItemVertex.new('P => S.'), 3)
+          instance = described_class.new(GFG::ItemVertex.new('P => S.'), 3)
           expect(instance).to be_dotted_entry
         end
 
-        it 'should know if the vertex is at end of production (if any)' do
+        it 'knows if the vertex is at end of production (if any)' do
           # Case: start vertex
-          instance1 = ParseEntry.new(GFG::StartVertex.new('.NT'), 3)
+          instance1 = described_class.new(GFG::StartVertex.new('.NT'), 3)
           expect(instance1).not_to be_exit_entry
 
           # Case: end vertex
-          instance2 = ParseEntry.new(GFG::EndVertex.new('NT.'), 3)
+          instance2 = described_class.new(GFG::EndVertex.new('NT.'), 3)
           expect(instance2).not_to be_exit_entry
 
           # Case: item vertex not at end of rhs
           v1 = double('vertex-not-at-end')
-          expect(v1).to receive(:complete?).and_return(false)
-          instance3 = ParseEntry.new(v1, 3)
+          allow(v1).to receive(:complete?).and_return(false)
+          instance3 = described_class.new(v1, 3)
           expect(instance3).not_to be_exit_entry
 
           # Case: item vertex at end of rhs
           v2 = double('vertex-at-end')
-          expect(v2).to receive(:complete?).and_return(true)
-          instance4 = ParseEntry.new(v2, 3)
+          allow(v2).to receive(:complete?).and_return(true)
+          instance4 = described_class.new(v2, 3)
           expect(instance4).to be_exit_entry
         end
 
-        it 'should know if the vertex is at begin of production (if any)' do
+        it 'knows if the vertex is at begin of production (if any)' do
           # Case: start vertex
-          instance1 = ParseEntry.new(GFG::StartVertex.new('.NT'), 3)
+          instance1 = described_class.new(GFG::StartVertex.new('.NT'), 3)
           expect(instance1).not_to be_entry_entry
 
           # Case: end vertex
-          instance2 = ParseEntry.new(GFG::EndVertex.new('NT.'), 3)
+          instance2 = described_class.new(GFG::EndVertex.new('NT.'), 3)
           expect(instance2).not_to be_entry_entry
 
           # Case: item vertex not at begin of rhs
           d1 = Base::DottedItem.new(sample_prod, 1)
           v1 = GFG::ItemVertex.new(d1)
-          instance3 = ParseEntry.new(v1, 3)
+          instance3 = described_class.new(v1, 3)
           expect(instance3).not_to be_entry_entry
 
           # Case: item vertex at end of rhs
           d2 = Base::DottedItem.new(sample_prod, 0)
           v2 = GFG::ItemVertex.new(d2)
-          instance4 = ParseEntry.new(v2, 3)
+          instance4 = described_class.new(v2, 3)
           expect(instance4).to be_entry_entry
         end
 
-        it 'should know the symbol before the dot (if any)' do
+        it 'knows the symbol before the dot (if any)' do
           # Case: start vertex
-          instance1 = ParseEntry.new(GFG::StartVertex.new('.NT'), 3)
+          instance1 = described_class.new(GFG::StartVertex.new('.NT'), 3)
           expect(instance1.prev_symbol).to be_nil
 
           # Case: end vertex
-          instance2 = ParseEntry.new(GFG::EndVertex.new('NT.'), 3)
+          instance2 = described_class.new(GFG::EndVertex.new('NT.'), 3)
           expect(instance2.prev_symbol).to be_nil # Really correct?
 
           # Case: item vertex not at start of rhs
           v1 = double('vertex-not-at-start')
-          expect(v1).to receive(:prev_symbol).and_return('symbol')
-          instance3 = ParseEntry.new(v1, 3)
+          allow(v1).to receive(:prev_symbol).and_return('symbol')
+          instance3 = described_class.new(v1, 3)
           expect(instance3.prev_symbol).to eq('symbol')
 
           # Case: item vertex at start of rhs
           v2 = double('vertex-at-start')
-          expect(v2).to receive(:prev_symbol).and_return(nil)
-          instance4 = ParseEntry.new(v2, 0)
+          allow(v2).to receive(:prev_symbol).and_return(nil)
+          instance4 = described_class.new(v2, 0)
           expect(instance4.prev_symbol).to be_nil
         end
 
-        it 'should know the next expected symbol (if any)' do
+        it 'knows the next expected symbol (if any)' do
           # Case: start vertex
-          instance1 = ParseEntry.new(GFG::StartVertex.new('.NT'), 3)
+          instance1 = described_class.new(GFG::StartVertex.new('.NT'), 3)
           expect(instance1.next_symbol).to be_nil
 
           # Case: end vertex
-          instance2 = ParseEntry.new(GFG::EndVertex.new('NT.'), 3)
+          instance2 = described_class.new(GFG::EndVertex.new('NT.'), 3)
           expect(instance2.next_symbol).to be_nil
 
           # Case: item vertex not at end of rhs
           v1 = double('vertex-not-at-end')
-          expect(v1).to receive(:next_symbol).and_return('symbol')
-          instance3 = ParseEntry.new(v1, 3)
+          allow(v1).to receive(:next_symbol).and_return('symbol')
+          instance3 = described_class.new(v1, 3)
           expect(instance3.next_symbol).to eq('symbol')
 
           # Case: item vertex at end of rhs
           v2 = double('vertex-at-end')
-          expect(v2).to receive(:next_symbol).and_return(nil)
-          instance4 = ParseEntry.new(v2, 3)
+          allow(v2).to receive(:next_symbol).and_return(nil)
+          instance4 = described_class.new(v2, 3)
           expect(instance4.next_symbol).to be_nil
         end
 
-        it 'should accept antecedents' do
-          antecedent = ParseEntry.new(vertex2, origin_val)
-          subject.add_antecedent(antecedent)
-          expect(subject.antecedents).to eql([antecedent])
-          expect(subject).not_to be_orphan
+        it 'accepts antecedents' do
+          antecedent = described_class.new(vertex2, origin_val)
+          an_entry.add_antecedent(antecedent)
+          expect(an_entry.antecedents).to eql([antecedent])
+          expect(an_entry).not_to be_orphan
         end
 
-        it 'should know its text representation' do
+        it 'knows its text representation' do
           expected = '.sentence | 3'
-          expect(subject.to_s).to eq(expected)
+          expect(an_entry.to_s).to eq(expected)
         end
 
-        it 'should be inspectable' do
-          subject.add_antecedent(subject) # Cheat for the good cause...
+        it 'is be inspectable' do
+          an_entry.add_antecedent(an_entry) # Cheat for the good cause...
           # expected = '.sentence | 3'
           prefix = /^#<Rley::Parser::ParseEntry:\d+ @vertex/
-          expect(subject.inspect).to match(prefix)
+          expect(an_entry.inspect).to match(prefix)
           pattern = /@vertex=<Rley::GFG::StartVertex:\d+ label=\.sentence/
-          expect(subject.inspect).to match(pattern)
+          expect(an_entry.inspect).to match(pattern)
           pattern2 = /@origin=3 @antecedents=\[/
-          expect(subject.inspect).to match(pattern2)
+          expect(an_entry.inspect).to match(pattern2)
           suffix = /<Rley::GFG::StartVertex:\d+ label=\.sentence> @origin=3\]>$/
-          expect(subject.inspect).to match(suffix)
+          expect(an_entry.inspect).to match(suffix)
         end
       end # context
     end # describe

data/spec/rley/parser/parse_walker_factory_spec.rb

@@ -11,7 +11,6 @@ require_relative '../../../lib/rley/parser/gfg_earley_parser'
 # Load the class under test
 require_relative '../../../lib/rley/parser/parse_walker_factory'
 
-
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Parser
     describe ParseWalkerFactory do
@@ -40,6 +39,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         expect(index).to eq(expectations[2])
       end
 
+      subject(:a_factory) { described_class.new }
+
       let(:sample_grammar) do
           # Grammar based on paper from Elisabeth Scott
           # "SPPF=Style Parsing From Earley Recognizers" in
@@ -69,31 +70,29 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       let(:accept_entry) { sample_result.accepting_entry }
       let(:accept_index) { sample_result.chart.last_index }
-      subject { ParseWalkerFactory.new }
-
 
       context 'Initialization:' do
-        it 'should be created without argument' do
-          expect { ParseWalkerFactory.new }.not_to raise_error
+        it 'is created without argument' do
+          expect { described_class.new }.not_to raise_error
         end
       end # context
 
       context 'Parse graph traversal:' do
-        it 'should create an Enumerator as a walker' do
+        it 'creates an Enumerator as a walker' do
           entry = accept_entry
           index = accept_index
-          expect(subject.build_walker(entry, index)).to be_kind_of(Enumerator)
+          expect(a_factory.build_walker(entry, index)).to be_a(Enumerator)
         end
 
-        it 'should return the accepting parse entry in the first place' do
-          walker = subject.build_walker(accept_entry, accept_index, false)
+        it 'returns the accepting parse entry in the first place' do
+          walker = a_factory.build_walker(accept_entry, accept_index, false)
           first_event = walker.next
           expectations = [:visit, sample_result.accepting_entry, 4]
           event_expectations(first_event, expectations)
         end
 
-        it 'could traverse the parse graph backwards' do
-          walker = subject.build_walker(accept_entry, accept_index, false)
+        it 'traverses the parse graph backwards' do
+          walker = a_factory.build_walker(accept_entry, accept_index, false)
           event1 = walker.next
           expectations = [:visit, 'Phi. | 0', 4]
           event_expectations(event1, expectations)
@@ -295,8 +294,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
 
 
-        it 'could traverse lazily the parse graph backwards' do
-          walker = subject.build_walker(accept_entry, accept_index, true)
+        it 'traverses lazily the parse graph backwards' do
+          walker = a_factory.build_walker(accept_entry, accept_index, true)
 
           17.times { walker.next }
 
@@ -397,8 +396,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           event_expectations(event40, expectations)
         end
 
-        it 'should raise an exception at end of visit' do
-          walker = subject.build_walker(accept_entry, accept_index, true)
+        it 'raises an exception at end of visit' do
+          walker = a_factory.build_walker(accept_entry, accept_index, true)
           40.times { walker.next }
 
           expect { walker.next }.to raise_error(StopIteration)

data/spec/rley/ptree/non_terminal_node_spec.rb

@@ -15,16 +15,16 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         return Lexical::TokenRange.new(low: low, high: high)
       end
 
+      subject(:a_node) { described_class.new(sample_symbol, sample_range) }
+
       let(:sample_symbol) do
         OpenStruct.new(name: 'VP')
       end
       let(:sample_range) { range(0, 3) }
 
-      subject { NonTerminalNode.new(sample_symbol, sample_range) }
-
       context 'Initialization:' do
-        it "shouldn't have subnodes yet" do
-          expect(subject.subnodes).to be_empty
+        it "doesn't have subnodes yet" do
+          expect(a_node.subnodes).to be_empty
         end
       end # context
 
@@ -34,36 +34,36 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           return OpenStruct.new(lexeme: aLexeme, terminal: terminal)
         end
 
-        it 'should accept the addition of subnodes' do
+        it 'accepts the addition of subnodes' do
           child1 = double('first_child')
           child2 = double('second_child')
           child3 = double('third_child')
-          expect { subject.add_subnode(child1) }.not_to raise_error
-          subject.add_subnode(child2)
-          subject.add_subnode(child3)
-          expect(subject.subnodes).to eq([child3, child2, child1])
+          expect { a_node.add_subnode(child1) }.not_to raise_error
+          a_node.add_subnode(child2)
+          a_node.add_subnode(child3)
+          expect(a_node.subnodes).to eq([child3, child2, child1])
         end
 
         # rubocop: disable Naming/VariableNumber
-        it 'should provide a text representation of itself' do
+        it 'provides a text representation of itself' do
           # Case 1: no child
           expected_text = 'VP[0, 3]'
-          expect(subject.to_string(0)).to eq(expected_text)
+          expect(a_node.to_string(0)).to eq(expected_text)
 
           # Case 2: with subnodes
           verb = build_token('catch', 'Verb')
           child_1_1 = TerminalNode.new(verb, range(0, 1))
           np = OpenStruct.new(name: 'NP')
-          child_1_2 = NonTerminalNode.new(np, range(1, 3))
+          child_1_2 = described_class.new(np, range(1, 3))
           det = build_token('that', 'Determiner')
           child_2_1 = TerminalNode.new(det, range(1, 2))
           nominal = OpenStruct.new(name: 'Nominal')
-          child_2_2 = NonTerminalNode.new(nominal, range(2, 3))
+          child_2_2 = described_class.new(nominal, range(2, 3))
           noun = build_token('bus', 'Noun')
           child_3_1 = TerminalNode.new(noun, range(2, 3))
           # We reverse the sequence of subnode addition
-          subject.add_subnode(child_1_2)
-          subject.add_subnode(child_1_1)
+          a_node.add_subnode(child_1_2)
+          a_node.add_subnode(child_1_1)
           child_1_2.add_subnode(child_2_2)
           child_1_2.add_subnode(child_2_1)
           child_2_2.add_subnode(child_3_1)
@@ -75,7 +75,7 @@ VP[0, 3]
    +- Nominal[2, 3]
       +- Noun[2, 3]: 'bus'
 SNIPPET
-          expect(subject.to_string(0)).to eq(expected_text.chomp)
+          expect(a_node.to_string(0)).to eq(expected_text.chomp)
         end
         # rubocop: enable Naming/VariableNumber
       end # context

data/spec/rley/ptree/parse_tree_node_spec.rb

@@ -8,30 +8,30 @@ require_relative '../../../lib/rley/ptree/parse_tree_node'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module PTree # Open this namespace to avoid module qualifier prefixes
     describe ParseTreeNode do
+      subject(:a_node) { described_class.new(sample_symbol, sample_range) }
+
       let(:sample_symbol) { double('fake-symbol') }
       let(:sample_range) { { low: 0, high: 5 } }
 
-      subject { ParseTreeNode.new(sample_symbol, sample_range) }
-
       context 'Initialization:' do
-        it 'should be created with a symbol and a range' do
+        it 'is created with a symbol and a range' do
           args = [sample_symbol, sample_range]
-          expect { ParseTreeNode.new(*args) }.not_to raise_error
+          expect { described_class.new(*args) }.not_to raise_error
         end
 
-        it 'should know its symbol' do
-          expect(subject.symbol).to eq(sample_symbol)
+        it 'knows its symbol' do
+          expect(a_node.symbol).to eq(sample_symbol)
         end
 
-        it 'should know its range' do
-          expect(subject.range).to eq(sample_range)
+        it 'knows its range' do
+          expect(a_node.range).to eq(sample_range)
         end
       end # context
 
-      context 'Initialization:' do
-        it 'should assign undefined range bounds' do
+      context 'Provided services:' do
+        it 'assigns undefined range bounds' do
           partial_range = { low: 0 } # High bound left undefined
-          instance = ParseTreeNode.new(sample_symbol, partial_range)
+          instance = described_class.new(sample_symbol, partial_range)
 
           another = { low: 1, high: 4 } # High bound is specified
           instance.range = another

data/spec/rley/ptree/parse_tree_spec.rb

@@ -13,6 +13,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
     describe ParseTree do
       include GrammarABCHelper # Mix-in module with builder for grammar abc
 
+      subject(:ptree) { described_class.new(sample_root) }
+
       let(:sample_grammar) do
         builder = grammar_abc_builder
         builder.grammar
@@ -22,17 +24,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:sample_range) { { low: 0, high: 5 } }
       let(:sample_root) { ParseTreeNode.new(sample_prod.lhs, sample_range) }
 
-      subject do
-        ParseTree.new(sample_root)
-      end
-
       context 'Initialization:' do
-        it 'should be created with a root node' do
-          expect { ParseTree.new(sample_root) }.not_to raise_error
+        it 'is created with a root node' do
+          expect { described_class.new(sample_root) }.not_to raise_error
         end
 
-        it 'should know its root node' do
-          its_root = subject.root
+        it 'knows its root node' do
+          its_root = ptree.root
           expect(its_root.symbol.name).to eq('S')
           expect(its_root.range).to eq(sample_range)
         end

data/spec/rley/ptree/terminal_node_spec.rb

@@ -9,24 +9,24 @@ require_relative '../../../lib/rley/ptree/terminal_node'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module PTree # Open this namespace to avoid module qualifier prefixes
     describe TerminalNode do
+      subject(:a_node) { described_class.new(sample_token, sample_range) }
+
       let(:sample_symbol) { OpenStruct.new(name: 'Noun') }
       let(:sample_token) do
         OpenStruct.new(lexeme: 'world', terminal: sample_symbol)
       end
       let(:sample_range) { double('fake-range') }
 
-      subject { TerminalNode.new(sample_token, sample_range) }
-
       context 'Initialization:' do
-        it 'should be bound to a token' do
-          expect(subject.token).to eq(sample_token)
+        it 'is bound to a token' do
+          expect(a_node.token).to eq(sample_token)
         end
       end # context
 
       context 'Provided services:' do
-        it 'should provide a text representation of itself' do
+        it 'provides a text representation of itself' do
           expected_text = "Noun[?, ?]: 'world'"
-          expect(subject.to_string(0)).to eq(expected_text)
+          expect(a_node.to_string(0)).to eq(expected_text)
         end
       end # context
     end # describe