rley 0.2.15 → 0.3.00

data/spec/rley/parser/parse_entry_set_spec.rb

@@ -0,0 +1,179 @@
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/rley/syntax/production'
+require_relative '../../../lib/rley/parser/dotted_item'
+require_relative '../../../lib/rley/gfg/item_vertex'
+require_relative '../../../lib/rley/parser/parse_entry'
+
+# Load the class under test
+require_relative '../../../lib/rley/parser/parse_entry_set'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module Parser # Open this namespace to avoid module qualifier prefixes
+    describe ParseEntrySet do
+      # Factory method. Builds a production with given left-hand side (LHS)
+      # and given RHS (right-hand side)
+      def build_prod(theLHS, *theRHSSymbols)
+        return Syntax::Production.new(theLHS, theRHSSymbols)
+      end
+
+      let(:t_a) { Rley::Syntax::Terminal.new('a') }
+      let(:t_b) { Rley::Syntax::Terminal.new('b') }
+      let(:t_c) { Rley::Syntax::Terminal.new('c') }
+      let(:nt_repeated_c) { Rley::Syntax::NonTerminal.new('Repetition') }
+      let(:repeated_prod) { build_prod(nt_repeated_c, t_c, nt_repeated_c) }
+      let(:nt_sentence) { Rley::Syntax::NonTerminal.new('Sentence') }
+      let(:sample_prod) { build_prod(nt_sentence, t_a, t_b, t_b, nt_repeated_c) }
+
+      let(:sample_item1) { Parser::DottedItem.new(sample_prod, 1) }
+      let(:sample_item2) { Parser::DottedItem.new(sample_prod, 2) }
+      let(:sample_item3) { Parser::DottedItem.new(sample_prod, 3) }
+
+      let(:vertex1) { GFG::ItemVertex.new(sample_item1) }
+      let(:entry1) { ParseEntry.new(vertex1, 2) }
+      let(:vertex2) { GFG::ItemVertex.new(sample_item2) }
+      let(:entry2) { ParseEntry.new(vertex2, 3) }
+      let(:vertex3) { GFG::ItemVertex.new(sample_item3) }
+      let(:entry3) { ParseEntry.new(vertex3, 4) }
+
+      context 'Initialization:' do
+        it 'should be created without argument' do
+          expect { ParseEntrySet.new }.not_to raise_error
+        end
+
+        it 'should be empty after creation' do
+          expect(subject.entries).to be_empty
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should accept the addition of an entry' do
+          # Case: first time e,try addition
+          expect(subject.push_entry(entry1)).to eq(entry1)
+          expect(subject).not_to be_empty
+
+          # Case: duplicate entry
+          expect(subject.push_entry(entry1)).to eq(entry1)
+
+          # Yet another entry
+          expect(subject.push_entry(entry2)).to eq(entry2)
+          expect(subject.entries).to eq([entry1, entry2])
+        end
+
+        it 'should retrieve the entry at given position' do
+          subject.push_entry(entry1)
+          subject.push_entry(entry2)
+          expect(subject[0]).to eq(entry1)
+          expect(subject[1]).to eq(entry2)
+        end
+
+        it 'should list the entries expecting a given terminal' do
+          # Case: an entry expecting a terminal
+          subject.push_entry(entry1)
+          expect(subject.entries4term(t_b)).to eq([entry1])
+
+          # Case: a second entry expecting same terminal
+          subject.push_entry(entry2)
+          expect(subject.entries4term(t_b)).to eq([entry1, entry2])
+        end
+        
+        it 'should list the expected terminals' do
+          subject.push_entry(entry1)
+          subject.push_entry(entry2)
+          subject.push_entry(entry3)
+
+          expect(subject.expected_terminals).to eq([t_b])
+        end
+
+        it 'should list the entries expecting a given non-terminal' do
+          # Case: an entry expecting a non-terminal
+          subject.push_entry(entry3)
+          expect(subject.entries4n_term(nt_repeated_c)).to eq([entry3])
+        end
+
+=begin
+        it 'should list of ambiguous states' do
+          prod1 = double('fake-production1')
+          prod2 = double('fake-production2')
+          expect(subject.ambiguities.size).to eq(0)
+
+          # Adding states
+          subject.push_entry(entry1)
+          allow(vertex1).to receive(:production).and_return(prod1)
+          allow(vertex1).to receive(:"reduce_item?").and_return(true)
+          allow(vertex1).to receive(:lhs).and_return(:something)
+          expect(subject.ambiguities.size).to eq(0)
+          allow(vertex2).to receive(:production).and_return(prod2)
+          allow(vertex2).to receive(:"reduce_item?").and_return(true)
+          allow(vertex2).to receive(:lhs).and_return(:something_else)
+          subject.push_entry(entry2)
+          expect(subject.ambiguities.size).to eq(0)
+          # dotted_rule3 = double('fake_dotted_rule3')
+          # allow(dotted_rule3).to receive(:production).and_return(prod2)
+          # allow(dotted_rule3).to receive(:"reduce_item?").and_return(true)
+          # allow(dotted_rule3).to receive(:lhs).and_return(:something_else)
+          # entry3 = ParseEntry.new(dotted_rule3, 5)
+          subject.push_entry(entry3)
+          expect(subject.ambiguities[0]).to eq([entry2, entry3])
+        end
+=end
+=begin
+        it 'should list the states expecting a given terminal' do
+          # Case of no state
+          expect(subject.states_expecting(:a)).to be_empty
+
+          # Adding states
+          subject.push_entry(entry1)
+          subject.push_entry(entry2)
+          allow(vertex1).to receive(:next_symbol).and_return(:b)
+          allow(vertex2).to receive(:next_symbol).and_return(:a)
+          expect(subject.states_expecting(:a)).to eq([entry2])
+          expect(subject.states_expecting(:b)).to eq([entry1])
+        end
+
+        it 'should list the states related to a production' do
+          a_prod = double('fake-production')
+
+          # Case of no state
+          expect(subject.states_for(a_prod)).to be_empty
+
+          # Adding states
+          subject.push_entry(entry1)
+          subject.push_entry(entry2)
+          allow(vertex1).to receive(:production).and_return(:dummy)
+          allow(vertex2).to receive(:production).and_return(a_prod)
+          expect(subject.states_for(a_prod)).to eq([entry2])
+        end
+
+        it 'should list the states that rewrite a given non-terminal' do
+          non_term = double('fake-non-terminal')
+          prod1 = double('fake-production1')
+          prod2 = double('fake-production2')
+
+          # Adding states
+          subject.push_entry(entry1)
+          subject.push_entry(entry2)
+          allow(vertex1).to receive(:production).and_return(prod1)
+          allow(prod1).to receive(:lhs).and_return(:dummy)
+          allow(vertex2).to receive(:production).and_return(prod2)
+          allow(vertex2).to receive(:reduce_item?).and_return(true)
+          allow(prod2).to receive(:lhs).and_return(non_term)
+          expect(subject.states_rewriting(non_term)).to eq([entry2])
+        end
+
+
+
+        it 'should complain when impossible predecessor of parse state' do
+          subject.push_entry(entry1)
+          subject.push_entry(entry2)
+          allow(vertex1).to receive(:prev_position).and_return(nil)
+          err = StandardError
+          expect { subject.predecessor_state(entry1) }.to raise_error(err)
+        end
+=end
+      end # context
+    end # describe
+  end # module
+end # module
+
+# End of file

data/spec/rley/parser/parse_entry_spec.rb

@@ -0,0 +1,208 @@
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/rley/syntax/terminal'
+require_relative '../../../lib/rley/syntax/non_terminal'
+require_relative '../../../lib/rley/syntax/production'
+require_relative '../../../lib/rley/parser/dotted_item'
+
+# Load the class under test
+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
+
+      let(:t_a) { Syntax::Terminal.new('A') }
+      let(:t_b) { Syntax::Terminal.new('B') }
+      let(:t_c) { Syntax::Terminal.new('C') }
+      let(:nt_sentence) { Syntax::NonTerminal.new('sentence') }
+
+      let(:sample_prod) do
+        Syntax::Production.new(nt_sentence, [t_a, t_b, t_c])
+      end
+
+      let(:empty_prod) do
+        Syntax::Production.new(nt_sentence, [])
+      end
+
+
+      let(:dotted_rule) { DottedItem.new(sample_prod, 2) }
+      let(:origin_val) { 3 }
+      let(:vertex_faked) { double('fake-vertex') }
+      let(:vertex2) { double('vertex-mock') }
+      # Default instantiation rule
+      subject { ParseEntry.new(vertex_faked, origin_val) }
+
+      context 'Initialization:' do
+        it 'should be created with a vertex and an origin position' do
+          args = [vertex_faked, origin_val]
+          expect { ParseEntry.new(*args) }.not_to raise_error
+        end
+
+        it 'should complain when the vertex is nil' do
+          err = StandardError
+          msg = 'GFG vertex cannot be nil'
+          expect { ParseEntry.new(nil, 2) }.to raise_error(err, msg)
+        end
+
+        it 'should know the vertex' do
+          expect(subject.vertex).to eq(vertex_faked)
+        end
+
+        it 'should know the origin value' do
+          expect(subject.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
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should compare with itself' do
+          synonym = subject # Fool Rubocop
+          expect(subject == synonym).to eq(true)
+        end
+
+        it 'should compare with another' do
+          equal = ParseEntry.new(vertex_faked, origin_val)
+          expect(subject == equal).to eq(true)
+
+          # Same vertex, different origin
+          diff_origin = ParseEntry.new(vertex_faked, 2)
+          expect(subject == diff_origin).to eq(false)
+
+          # Different vertices, same origin
+          diff_vertex = ParseEntry.new(double('other_vertex_faked'), 3)
+          expect(subject == diff_vertex).to eq(false)
+        end
+
+        it 'should know if the vertex is a start vertex' do
+          expect(subject).not_to be_start_entry
+
+          instance = ParseEntry.new(GFG::StartVertex.new('.NT'), 3)
+          expect(instance).to be_start_entry
+        end
+
+        it 'should know if the vertex is an end vertex' do
+          expect(subject).not_to be_end_entry
+
+          instance = ParseEntry.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
+
+          instance = ParseEntry.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
+          # Case: start vertex
+          instance1 = ParseEntry.new(GFG::StartVertex.new('.NT'), 3)
+          expect(instance1).not_to be_exit_entry
+
+          # Case: end vertex
+          instance2 = ParseEntry.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')
+          allow(v1).to receive(:complete?).and_return(false)
+          instance3 = ParseEntry.new(v1, 3)
+          expect(instance3).not_to be_exit_entry
+
+          # Case: item vertex at end of rhs
+          v2 = double('vertex-at-end')
+          allow(v2).to receive(:complete?).and_return(true)
+          instance4 = ParseEntry.new(v2, 3)
+          expect(instance4).to be_exit_entry
+        end
+        
+        it 'should know if the vertex is at begin of production (if any)' do
+          # Case: start vertex
+          instance1 = ParseEntry.new(GFG::StartVertex.new('.NT'), 3)
+          expect(instance1).not_to be_entry_entry
+
+          # Case: end vertex
+          instance2 = ParseEntry.new(GFG::EndVertex.new('NT.'), 3)
+          expect(instance2).not_to be_entry_entry
+
+          # Case: item vertex not at begin of rhs
+          d1 = DottedItem.new(sample_prod, 1)          
+          v1 = GFG::ItemVertex.new(d1)
+          instance3 = ParseEntry.new(v1, 3)
+          expect(instance3).not_to be_entry_entry
+
+          # Case: item vertex at end of rhs
+          d2 = DottedItem.new(sample_prod, 0)          
+          v2 = GFG::ItemVertex.new(d2)          
+          instance4 = ParseEntry.new(v2, 3)
+          expect(instance4).to be_entry_entry
+        end 
+
+        it 'should know the symbol before the dot (if any)' do
+          # Case: start vertex
+          instance1 = ParseEntry.new(GFG::StartVertex.new('.NT'), 3)
+          expect(instance1.prev_symbol).to be_nil
+
+          # Case: end vertex
+          instance2 = ParseEntry.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')
+          allow(v1).to receive(:prev_symbol).and_return('symbol')
+          instance3 = ParseEntry.new(v1, 3)
+          expect(instance3.prev_symbol).to eq('symbol') 
+
+          # Case: item vertex at start of rhs
+          v2 = double('vertex-at-start')
+          allow(v2).to receive(:prev_symbol).and_return(nil)
+          instance4 = ParseEntry.new(v2, 0)
+          expect(instance4.prev_symbol).to be_nil          
+        end
+        
+        it 'should know the next expected symbol (if any)' do
+          # Case: start vertex
+          instance1 = ParseEntry.new(GFG::StartVertex.new('.NT'), 3)
+          expect(instance1.next_symbol).to be_nil
+
+          # Case: end vertex
+          instance2 = ParseEntry.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')
+          allow(v1).to receive(:next_symbol).and_return('symbol')
+          instance3 = ParseEntry.new(v1, 3)
+          expect(instance3.next_symbol).to eq('symbol') 
+
+          # Case: item vertex at end of rhs
+          v2 = double('vertex-at-end')
+          allow(v2).to receive(:next_symbol).and_return(nil)
+          instance4 = ParseEntry.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
+        end
+=begin
+
+        it 'should know its text representation' do
+          expected = 'sentence => A B . C | 3'
+          expect(subject.to_s).to eq(expected)
+        end
+=end
+      end # context
+    end # describe
+  end # module
+end # module
+
+# End of file

data/spec/rley/parser/parse_forest_builder_spec.rb

@@ -0,0 +1,382 @@
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/rley/parser/gfg_earley_parser'
+
+require_relative '../../../lib/rley/syntax/grammar_builder'
+require_relative '../support/grammar_helper'
+require_relative '../support/expectation_helper'
+
+require_relative '../../../lib/rley/parser/parse_walker_factory'
+
+# Load the class under test
+require_relative '../../../lib/rley/parser/parse_forest_builder'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module Parser
+    describe ParseForestBuilder do
+      include GrammarHelper     # Mix-in with token factory method
+      include ExpectationHelper # Mix-in with expectation on parse entry sets
+
+      let(:sample_grammar) do
+          # Grammar based on paper from Elisabeth Scott
+          # "SPPF=Style Parsing From Earley Recognizers" in
+          # Notes in Theoretical Computer Science 203, (2008), pp. 53-67
+          # contains a hidden left recursion and a cycle
+          builder = Syntax::GrammarBuilder.new
+          builder.add_terminals('a', 'b')
+          builder.add_production('Phi' => %'S')
+          builder.add_production('S' => %w[A T])
+          builder.add_production('S' => %w[a T])
+          builder.add_production('A' => 'a')
+          builder.add_production('A' => %w[B A])
+          builder.add_production('B' => [])
+          builder.add_production('T' => %w( b b b))
+          builder.grammar
+      end
+
+      let(:sample_tokens) do
+        build_token_sequence(%w(a b b b), sample_grammar)
+      end
+
+      let(:sample_result) do
+        parser = Parser::GFGEarleyParser.new(sample_grammar)
+        parser.parse(sample_tokens)
+      end
+
+      let(:walker) do
+        factory = ParseWalkerFactory.new
+        factory.build_walker(sample_result)
+      end
+
+      subject do
+        ParseForestBuilder.new(sample_result)
+      end
+
+      # Emit a text representation of the current path.
+      def path_to_s()
+        text_parts = subject.curr_path.map { |path_element|  path_element.to_string(0) }
+        return text_parts.join('/')
+      end
+
+
+      context 'Initialization:' do
+        it 'should be created with a GFGParsing' do
+          expect { ParseForestBuilder.new(sample_result) }.not_to raise_error
+        end
+
+        it 'should know the parse result' do
+          expect(subject.parsing).to eq(sample_result)
+        end
+
+        it 'should have an empty path' do
+          expect(subject.curr_path).to be_empty
+        end
+      end
+
+      context 'Parse forest construction' do
+
+        it 'should initialize the root node' do
+          first_event = walker.next
+          subject.receive_event(*first_event)
+          forest = subject.forest
+
+          expect(forest.root.to_string(0)).to eq('Phi[0, 4]')
+          expect(subject.curr_path).to eq([forest.root])
+          expect(subject.entry2node[first_event[1]]).to eq(forest.root)
+        end
+
+        it 'should initialize the first child of the root node' do
+          event1 = walker.next
+          subject.receive_event(*event1)
+
+          event2 = walker.next
+          subject.receive_event(*event2)
+
+          expect(subject.curr_parent.to_string(0)).to eq('S[?, 4]')
+          expected_path2 = 'Phi[0, 4]/S[?, 4]'
+          expect(path_to_s).to eq(expected_path2)
+        end
+
+        it 'should build alternative node when detecting backtrack point' do
+          2.times do
+            event = walker.next
+            subject.receive_event(*event)
+          end
+
+          event3 = walker.next
+          subject.receive_event(*event3)
+
+          expect(subject.curr_parent.to_string(0)).to eq('Alt(S => a T .)[0, 4]')
+          expected_path3 = 'Phi[0, 4]/S[0, 4]/Alt(S => a T .)[0, 4]'
+          expect(path_to_s).to eq(expected_path3)
+          expect(subject.curr_path[-2].refinement).to eq(:or)
+        end
+
+        it 'should build token node when scan edge was detected' do
+          3.times do
+            event = walker.next
+            subject.receive_event(*event)
+          end
+
+          event4 = walker.next
+          subject.receive_event(*event4)
+          expect(event4[1].to_s).to eq('S => a T . | 0')
+          expect(subject.curr_parent.to_string(0)).to eq('T[?, 4]')
+          expected_path4 = 'Phi[0, 4]/S[0, 4]/Alt(S => a T .)[0, 4]/T[?, 4]'
+          expect(path_to_s).to eq(expected_path4)
+          expect(subject.curr_parent.subnodes).to be_empty
+
+          event5 = walker.next
+          subject.receive_event(*event5)
+          expect(event5[1].to_s).to eq('T. | 1')
+          expect(subject.curr_parent.to_string(0)).to eq('T[1, 4]')
+          expected_path5 = 'Phi[0, 4]/S[0, 4]/Alt(S => a T .)[0, 4]/T[1, 4]'
+          expect(path_to_s).to eq(expected_path5)
+          expect(subject.curr_parent.subnodes).to be_empty
+
+          event6 = walker.next
+          subject.receive_event(*event6)
+          expect(event6[1].to_s).to eq('T => b b b . | 1')
+          expect(subject.curr_parent.to_string(0)).to eq('T[1, 4]')
+          expected_path6 = 'Phi[0, 4]/S[0, 4]/Alt(S => a T .)[0, 4]/T[1, 4]'
+          expect(path_to_s).to eq(expected_path6)
+          expect(subject.curr_parent.subnodes.size).to eq(1)
+          token_event6 = 'b[3, 4]'
+          expect(subject.curr_parent.subnodes.first.to_string(0)).to eq(token_event6)
+
+          event7 = walker.next
+          subject.receive_event(*event7)
+          expect(event7[1].to_s).to eq('T => b b . b | 1')
+          expect(subject.curr_parent.to_string(0)).to eq('T[1, 4]')
+          expected_path7 = 'Phi[0, 4]/S[0, 4]/Alt(S => a T .)[0, 4]/T[1, 4]'
+          expect(path_to_s).to eq(expected_path7)
+          expect(subject.curr_parent.subnodes.size).to eq(2)
+          token_event7 = 'b[2, 3]'
+          expect(subject.curr_parent.subnodes.first.to_string(0)).to eq(token_event7)
+
+          event8 = walker.next
+          subject.receive_event(*event8)
+          expect(event8[1].to_s).to eq('T => b . b b | 1')
+          expect(subject.curr_parent.to_string(0)).to eq('T[1, 4]')
+          expected_path8 = 'Phi[0, 4]/S[0, 4]/Alt(S => a T .)[0, 4]/T[1, 4]'
+          expect(path_to_s).to eq(expected_path8)
+          expect(subject.curr_parent.subnodes.size).to eq(3)
+          token_event8 = 'b[1, 2]'
+          expect(subject.curr_parent.subnodes.first.to_string(0)).to eq(token_event8)
+
+          event9 = walker.next
+          subject.receive_event(*event9)
+          expect(event9[1].to_s).to eq('T => . b b b | 1')
+          expect(subject.curr_parent.to_string(0)).to eq('T[1, 4]')
+          expected_path9 = 'Phi[0, 4]/S[0, 4]/Alt(S => a T .)[0, 4]/T[1, 4]'
+          expect(path_to_s).to eq(expected_path9)
+
+          event10 = walker.next
+          subject.receive_event(*event10)
+          expect(event10[1].to_s).to eq('.T | 1')
+          expect(subject.curr_parent.to_string(0)).to eq('Alt(S => a T .)[0, 4]')
+          expected_path10 = 'Phi[0, 4]/S[0, 4]/Alt(S => a T .)[0, 4]'
+          expect(path_to_s).to eq(expected_path10)
+
+          event11 = walker.next
+          subject.receive_event(*event11)
+          expect(event11[1].to_s).to eq('S => a . T | 0')
+          expect(subject.curr_parent.to_string(0)).to eq('Alt(S => a T .)[0, 4]')
+          expected_path11 = 'Phi[0, 4]/S[0, 4]/Alt(S => a T .)[0, 4]'
+          expect(path_to_s).to eq(expected_path11)
+          expect(subject.curr_parent.subnodes.size).to eq(2)
+          token_event11 = 'a[0, 1]'
+          expect(subject.curr_parent.subnodes.first.to_string(0)).to eq(token_event11)
+
+          event12 = walker.next
+          subject.receive_event(*event12)
+          expect(event12[1].to_s).to eq('S => . a T | 0')
+          expect(subject.curr_parent.to_string(0)).to eq('Alt(S => a T .)[0, 4]')
+          expected_path12 = 'Phi[0, 4]/S[0, 4]/Alt(S => a T .)[0, 4]'
+          expect(path_to_s).to eq(expected_path12)
+          expect(subject.curr_parent.subnodes.size).to eq(2)  # Is this OK?
+
+          # Pop all Alternative nodes until no Alternative found, pop this last too
+          event13 = walker.next
+          subject.receive_event(*event13)
+          expect(event13[1].to_s).to eq('.S | 0')
+          expect(subject.curr_parent.to_string(0)).to eq('Phi[0, 4]')
+          expected_path13 = 'Phi[0, 4]'
+          expect(path_to_s).to eq(expected_path13)
+
+          event14 = walker.next
+          subject.receive_event(*event14)
+          expect(event14[1].to_s).to eq('Phi => . S | 0')
+          expect(subject.curr_parent.to_string(0)).to eq('Phi[0, 4]')
+          expected_path14 = 'Phi[0, 4]'
+          expect(path_to_s).to eq(expected_path14)
+
+          event15 = walker.next
+          subject.receive_event(*event15)
+          expect(event15[1].to_s).to eq('.Phi | 0')
+          expect(path_to_s).to be_empty
+        end
+
+        it 'should handle backtracking' do
+          15.times do
+            event = walker.next
+            subject.receive_event(*event)
+          end
+
+          event16 = walker.next
+          subject.receive_event(*event16)
+          expect(event16[0]).to eq(:backtrack)  # Backtrack event!
+          expect(event16[1].to_s).to eq('S. | 0')
+          # A new alternative node must be created
+          expect(subject.curr_parent.to_string(0)).to eq('Alt(S => A T .)[0, 4]')
+          expected_path16 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]'
+          expect(path_to_s).to eq(expected_path16)
+
+
+          event17 = walker.next
+          subject.receive_event(*event17)
+          expect(event17[1].to_s).to eq('S => A T . | 0')
+          expect(subject.curr_parent.to_string(0)).to eq('T[?, 4]')
+          expected_path17 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]/T[?, 4]'
+          expect(path_to_s).to eq(expected_path17)
+        end
+
+        it 'should detect second time visit of an entry' do
+          17.times do
+            event = walker.next
+            subject.receive_event(*event)
+          end
+
+          event18 = walker.next
+          subject.receive_event(*event18)
+          expect(event18[0]).to eq(:revisit)  # Revisit event!
+          expect(event18[1].to_s).to eq('T. | 1')
+          expect(subject.curr_parent.to_string(0)).to eq('Alt(S => A T .)[0, 4]')
+          expected_path18 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]'
+          expect(path_to_s).to eq(expected_path18)
+
+          event19 = walker.next
+          subject.receive_event(*event19)
+          expect(event19[1].to_s).to eq('S => A . T | 0')
+          expect(subject.curr_parent.to_string(0)).to eq('A[?, 1]')
+          expected_path19 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]/A[?, 1]'
+          expect(path_to_s).to eq(expected_path19)
+
+          event20 = walker.next
+          subject.receive_event(*event20)
+          # Next entry is an end entry...
+          expect(event20[1].to_s).to eq('A. | 0')
+          # ... with multiple antecedents => alternative nodes required
+          expect(subject.curr_parent.to_string(0)).to eq('Alt(A => a .)[0, 1]')
+          expected_path20 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]/A[0, 1]/Alt(A => a .)[0, 1]'
+          expect(path_to_s).to eq(expected_path20)
+          expect(subject.curr_path[-2].refinement).to eq(:or)
+
+          event21 = walker.next
+          subject.receive_event(*event21)
+          expect(event21[1].to_s).to eq('A => a . | 0')
+          expect(subject.curr_parent.to_string(0)).to eq('Alt(A => a .)[0, 1]')
+          expected_path21 = expected_path20
+          expect(path_to_s).to eq(expected_path21)
+
+          event22 = walker.next
+          subject.receive_event(*event22)
+          expect(event22[1].to_s).to eq('A => . a | 0')
+          expect(subject.curr_parent.to_string(0)).to eq('Alt(A => a .)[0, 1]')
+          expected_path22 = expected_path20
+          expect(path_to_s).to eq(expected_path22)
+
+          event23 = walker.next
+          subject.receive_event(*event23)
+          # Next entry is an start entry...
+          expect(event23[1].to_s).to eq('.A | 0')
+          # ... with multiple antecedents => alternative nodes required
+          expect(subject.curr_parent.to_string(0)).to eq('Alt(S => A T .)[0, 4]')
+          expected_path23 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]'
+          expect(path_to_s).to eq(expected_path23)
+
+          event24 = walker.next
+          subject.receive_event(*event24)
+          expect(event24[1].to_s).to eq('S => . A T | 0')
+          # ... with multiple antecedents => alternative nodes required
+          expect(subject.curr_parent.to_string(0)).to eq('Alt(S => A T .)[0, 4]')
+          expected_path24 = expected_path23
+          expect(path_to_s).to eq(expected_path24)
+        end
+
+        it 'should handle remaining events' do
+          24.times do
+            event = walker.next
+            subject.receive_event(*event)
+          end
+
+          event25 = walker.next
+          subject.receive_event(*event25)
+          expect(event25[0]).to eq(:backtrack)  # Backtrack event!
+          expect(event25[1].to_s).to eq('A. | 0')
+          expect(subject.curr_parent.to_string(0)).to eq('Alt(A => B A .)[0, 1]')
+          expected_path25 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]/A[0, 1]/Alt(A => B A .)[0, 1]'
+          expect(path_to_s).to eq(expected_path25)
+
+          event26 = walker.next
+          subject.receive_event(*event26)
+          expect(event26[1].to_s).to eq('A => B A . | 0')
+          expect(subject.curr_parent.to_string(0)).to eq('A[?, 1]')
+          expected_path26 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]/A[0, 1]/Alt(A => B A .)[0, 1]/A[?, 1]'
+          expect(path_to_s).to eq(expected_path26)
+
+          event27 = walker.next
+          subject.receive_event(*event27)
+          expect(event27[0]).to eq(:revisit)  # Revisit event!
+          expect(event27[1].to_s).to eq('A. | 0')
+          expect(subject.curr_parent.to_string(0)).to eq('Alt(A => B A .)[0, 1]')
+          expected_path27 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]/A[0, 1]/Alt(A => B A .)[0, 1]'
+          expect(path_to_s).to eq(expected_path27)
+
+          event28 = walker.next
+          subject.receive_event(*event28)
+          expect(event28[0]).to eq(:visit)
+          expect(event28[1].to_s).to eq('A => B . A | 0')
+          expect(subject.curr_parent.to_string(0)).to eq('B[?, 0]')
+          expected_path28 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]/A[0, 1]/Alt(A => B A .)[0, 1]/B[?, 0]'
+          expect(path_to_s).to eq(expected_path28)
+
+          event29 = walker.next
+          subject.receive_event(*event29)
+          expect(event29[0]).to eq(:visit)
+          expect(event29[1].to_s).to eq('B. | 0')
+          expect(subject.curr_parent.to_string(0)).to eq('B[0, 0]')
+          expected_path29 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]/A[0, 1]/Alt(A => B A .)[0, 1]/B[0, 0]'
+          expect(path_to_s).to eq(expected_path29)
+
+          event30 = walker.next
+          subject.receive_event(*event30)
+          expect(event30[0]).to eq(:visit)
+          # Empty production!
+          expect(event30[1].to_s).to eq('B => . | 0')
+          expect(subject.curr_parent.to_string(0)).to eq('B[0, 0]')
+          expected_path30 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]/A[0, 1]/Alt(A => B A .)[0, 1]/B[0, 0]'
+          expect(path_to_s).to eq(expected_path30)
+          
+          event31 = walker.next
+          subject.receive_event(*event31)
+          expect(event31[0]).to eq(:visit)
+          expect(event31[1].to_s).to eq('.B | 0')
+          expect(subject.curr_parent.to_string(0)).to eq('Alt(A => B A .)[0, 1]')
+          expected_path31 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]/A[0, 1]/Alt(A => B A .)[0, 1]'
+          expect(path_to_s).to eq(expected_path31)
+
+          event32 = walker.next
+          subject.receive_event(*event32)
+          expect(event32[0]).to eq(:visit)
+          expect(event32[1].to_s).to eq('A => . B A | 0')
+          expect(subject.curr_parent.to_string(0)).to eq('Alt(A => B A .)[0, 1]')
+          expected_path32 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]/A[0, 1]/Alt(A => B A .)[0, 1]'
+          expect(path_to_s).to eq(expected_path32)           
+        end   
+      end # context
+
+    end # describe
+  end # module
+end # module
+# End of file