rley 0.6.07 → 0.6.08

data/lib/rley/parse_rep/parse_rep_creator.rb

@@ -5,7 +5,8 @@ module Rley # This module is used as a namespace
     # Utility class that helps to create a representation of a parse from
     # a given Parsing object.
     class ParseRepCreator
-      # @return [GFGParsing] Link to Parsing object (= results of recognizer)
+      # @return [Rley::Parser::GFGParsing] 
+      #  Link to Parsing object (= results of recognizer)
       attr_reader(:parsing)
       
       # Constructor. Creates and initialize a ParseRepCreator instance.
@@ -15,7 +16,8 @@ module Rley # This module is used as a namespace
       end      
       
       # Factory method that produces the representation of the parse.
-      # @return [ParseTree] The parse representation.
+      # @return [Rley::PTree::ParseTree, Rley::SPPF::ParseForest] 
+      #   The parse representation.
       def create(aBuilder = nil)
         a_walker = walker(parsing)
         a_builder = builder(parsing, aBuilder)

data/lib/rley/parse_tree_visitor.rb

@@ -97,9 +97,9 @@ module Rley # This module is used as a namespace
     # @param msg [Symbol] event to notify
     # @param args [Array] arguments of the notification.
     def broadcast(msg, *args)
-      subscribers.each do |a_subscriber|
-        next unless a_subscriber.respond_to?(msg)
-        a_subscriber.send(msg, *args)
+      subscribers.each do |subscr|
+        next unless subscr.respond_to?(msg) || subscr.respond_to?(:accept_all)
+        subscr.send(msg, *args)
       end
     end
   end # class

data/lib/rley/ptree/parse_tree.rb

@@ -20,9 +20,9 @@ module Rley # This module is used as a namespace
         @root = theRootNode
       end
       
-      # Notify the builder that the construction is over.
-      # This method can be overriden
-      def done!()
+      # Notification from the builder telling that the parse tree construction
+      # is over. This method can be overriden.
+      def done!
         @root.done!
       end
 

data/lib/rley/sppf/alternative_node.rb

@@ -28,6 +28,12 @@ module Rley # This module is used as a namespace
       def to_string(indentation)
         return "Alt(#{label})#{range.to_string(indentation)}"
       end
+      
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param aVisitor[ParseTreeVisitor] the visitor
+      def accept(aVisitor)
+        aVisitor.visit_alternative(self)
+      end      
     end # class
   end # module
 end # module

data/lib/rley/sppf/composite_node.rb

@@ -7,6 +7,8 @@ module Rley # This module is used as a namespace
     class CompositeNode < SPPFNode
       # @return [Array<SPFFNode>] Sub-nodes (children).
       attr_reader(:subnodes)
+      
+      alias children subnodes      
 
       # Constructor
       # @param aRange [Lexical::TokenRange]      

data/lib/rley/sppf/epsilon_node.rb

@@ -17,6 +17,12 @@ module Rley # This module is used as a namespace
       def to_string(indentation)
         return "_#{range.to_string(indentation)}"
       end
+      
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param aVisitor[ParseTreeVisitor] the visitor
+      def accept(aVisitor)
+        aVisitor.visit_epsilon(self)
+      end      
     end # class
   end # module
 end # module

data/lib/rley/sppf/non_terminal_node.rb

@@ -14,7 +14,7 @@ module Rley # This module is used as a namespace
 
       # Constructor
       # @param aNonTerminal [Syntax::NonTerminal]
-      # @param aRange [Lexical::TokenRange]      
+      # @param aRange [Lexical::TokenRange]
       def initialize(aNonTerminal, aRange)
         super(aRange)
         @symbol = aNonTerminal
@@ -22,7 +22,7 @@ module Rley # This module is used as a namespace
       end
 
       # Add a sub-node (child) to this one.
-      # @param aSubnode [SPPFNode]      
+      # @param aSubnode [SPPFNode]
       def add_subnode(aSubnode)
         if refinement == :or
           subnodes << aSubnode
@@ -33,10 +33,16 @@ module Rley # This module is used as a namespace
 
       # Emit a (formatted) string representation of the node.
       # Mainly used for diagnosis/debugging purposes.
-      # @return [String] a text representation of the node.      
+      # @return [String] a text representation of the node.
       def to_string(indentation)
         return "#{symbol.name}#{range.to_string(indentation)}"
       end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param aVisitor[ParseTreeVisitor] the visitor
+      def accept(aVisitor)
+        aVisitor.visit_nonterminal(self)
+      end
     end # class
   end # module
 end # module

data/lib/rley/sppf/parse_forest.rb

@@ -30,7 +30,7 @@ module Rley # This module is used as a namespace
       end
       
       # Notification that the SPPF construction is over
-      def done!()
+      def done!
       end
       
       # Returns true if the given node is present in the forest.
@@ -43,6 +43,17 @@ module Rley # This module is used as a namespace
       def ambiguous?()
         return @is_ambiguous
       end
+      
+      # Create an Enumerator that helps to iterate over the possible parse trees. 
+      # That enumerator will generate a parse tree when called with `next` method.
+      # @return [Enumerator]
+      def to_ptree_enum()
+         # How to implement?
+         # One visits the forest => beware of dependency
+         # At each visited item create a corresponding  tree node.
+         # At end of visit & stack not empty
+         # Re-generate another ptree
+      end      
 
       # Part of the 'visitee' role in the Visitor design pattern.
       #   A visitee is expected to accept the visit from a visitor object

data/lib/rley/sppf/token_node.rb

@@ -25,6 +25,12 @@ module Rley # This module is used as a namespace
       def to_string(indentation)
         return "#{token.terminal.name}#{range.to_string(indentation)}"
       end
+      
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param aVisitor[ParseTreeVisitor] the visitor
+      def accept(aVisitor)
+        aVisitor.visit_terminal(self)
+      end      
     end # class
   end # module
 end # module

data/spec/rley/engine_spec.rb

@@ -3,7 +3,6 @@ require_relative '../spec_helper'
 
 require_relative '../../lib/rley/lexical/token'
 require_relative '../../lib/rley/parse_rep/cst_builder'
-require_relative '../../lib/rley/parse_tree_visitor'
 
 # Load the class under test
 require_relative '../../lib/rley/engine'
@@ -93,10 +92,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         add_sample_grammar(instance)
         instance
       end
-      
+
       let(:sample_tokenizer) do
         sample_text = 'a a b c c'
-        ABCTokenizer.new(sample_text)      
+        ABCTokenizer.new(sample_text)
       end
 
       it 'should build default parse trees' do
@@ -107,18 +106,45 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       it 'should build custom parse trees' do
         # Cheating: we point to default tree builder (CST)
-        subject.configuration.repr_builder = ParseRep::CSTBuilder        
+        subject.configuration.repr_builder = ParseRep::CSTBuilder
         raw_result = subject.parse(sample_tokenizer)
         ptree = subject.convert(raw_result)
         expect(ptree).to be_kind_of(PTree::ParseTree)
       end
-      
+
       it 'should provide a parse visitor' do
         raw_result = subject.parse(sample_tokenizer)
         ptree = subject.to_ptree(raw_result)
         visitor = subject.ptree_visitor(ptree)
         expect(visitor).to be_kind_of(ParseTreeVisitor)
-      end    
+      end
+    end # context
+
+    context 'Parse forest manipulation:' do
+      subject do
+        instance = Engine.new
+        add_sample_grammar(instance)
+        instance
+      end
+
+      let(:sample_tokenizer) do
+        sample_text = 'a a b c c'
+        ABCTokenizer.new(sample_text)
+      end
+      
+      it 'should build parse forest' do
+        raw_result = subject.parse(sample_tokenizer)
+        pforest = subject.to_pforest(raw_result)
+        expect(pforest).to be_kind_of(SPPF::ParseForest)
+      end      
+      
+      it 'should provide a parse visitor' do
+        raw_result = subject.parse(sample_tokenizer)
+        ptree = subject.to_pforest(raw_result)
+        visitor = subject.pforest_visitor(ptree)
+        expect(visitor).to be_kind_of(ParseForestVisitor)
+      end
+
     end # context
   end # describe
 end # module

data/spec/rley/formatter/debug_spec.rb

@@ -1,19 +1,20 @@
 require_relative '../../spec_helper'
 require 'stringio'
 
-require_relative '../support/grammar_abc_helper'
 require_relative '../../../lib/rley/lexical/token'
-require_relative '../../../lib/rley/parser/gfg_earley_parser'
-require_relative '../../../lib/rley/ptree/parse_tree'
-require_relative '../../../lib/rley/parse_tree_visitor'
 require_relative '../../../lib/rley/engine'
+require_relative '../support/grammar_abc_helper'
+require_relative '../support/grammar_sppf_helper'
+
 # Load the class under test
 require_relative '../../../lib/rley/formatter/debug'
 
 module Rley # Re-open the module to get rid of qualified names
   module Formatter
     describe Debug do
-      # Factory method. Build a production with the given sequence    
+      include GrammarSPPFHelper # Mix-in module with builder for grammar sppf
+
+      # Factory method. Build a production with the given sequence
       # of symbols as its rhs.
       let(:grammar_abc) do
         sandbox = Object.new
@@ -21,18 +22,27 @@ module Rley # Re-open the module to get rid of qualified names
         builder = sandbox.grammar_abc_builder
         builder.grammar
       end
-      
+
       # Variables for the terminal symbols
       let(:a_) { grammar_abc.name2symbol['a'] }
       let(:b_) { grammar_abc.name2symbol['b'] }
       let(:c_) { grammar_abc.name2symbol['c'] }
-      
+
       # Helper method that mimicks the output of a tokenizer
       # for the language specified by grammar_abc
       let(:grm_abc_tokens1) do
         %w[a a b c c].map { |ch| Lexical::Token.new(ch, ch) }
       end
 
+      let(:grammar_sppf) do
+        builder = grammar_sppf_builder
+        builder.grammar
+      end
+
+      let(:sample_tokens) do
+        %w[a b b b].map { |ch| Lexical::Token.new(ch, ch) }
+      end
+
       # Factory method that builds a sample parse tree.
       # Generated tree has the following structure:
       # S[0,5]
@@ -47,30 +57,43 @@ module Rley # Re-open the module to get rid of qualified names
       # Capital letters represent non-terminal nodes
       let(:grm_abc_ptree1) do
         engine = Rley::Engine.new
-        engine.use_grammar(grammar_abc)     
+        engine.use_grammar(grammar_abc)
         parse_result = engine.parse(grm_abc_tokens1)
         ptree = engine.convert(parse_result)
         ptree
       end
-  
+
+      # Factory method that builds a sample parse forest.
+      # Generated forest has the following structure:
+      let(:grm_sppf_pforest1) do
+        engine = Rley::Engine.new
+        engine.use_grammar(grammar_sppf)
+        parse_result = engine.parse(sample_tokens)
+        engine.to_pforest(parse_result)
+      end
+
       let(:destination) { StringIO.new('', 'w') }
 
       context 'Standard creation & initialization:' do
         it 'should be initialized with an IO argument' do
           expect { Debug.new(StringIO.new('', 'w')) }.not_to raise_error
         end
-        
+
         it 'should know its output destination' do
           instance = Debug.new(destination)
           expect(instance.output).to eq(destination)
         end
+
+        it 'should have a zero indentation' do
+          instance = Debug.new(destination)
+          expect(instance.indentation).to be_zero
+        end
       end # context
-  
 
- 
-      context 'Formatting events:' do   
+      context 'Formatting events:' do
         it 'should support visit events of a parse tree' do
           instance = Debug.new(destination)
+          expect(instance.output).to eq(destination)
           visitor = Rley::ParseTreeVisitor.new(grm_abc_ptree1)
           instance.render(visitor)
           expectations = <<-SNIPPET
@@ -102,6 +125,96 @@ before_ptree
     after_subnodes
   after_non_terminal
 after_ptree
+SNIPPET
+          expect(destination.string).to eq(expectations)
+        end
+
+        it 'should support visit events of a parse forest' do
+          instance = Debug.new(destination)
+          expect(instance.output).to eq(destination)
+          visitor = Rley::ParseForestVisitor.new(grm_sppf_pforest1)
+          instance.render(visitor)
+          expectations = <<-SNIPPET
+before_pforest
+  before_non_terminal
+    before_subnodes
+      before_non_terminal
+        before_subnodes
+          before_alternative
+            before_subnodes
+              before_terminal
+              after_terminal
+              before_non_terminal
+                before_subnodes
+                  before_terminal
+                  after_terminal
+                  before_terminal
+                  after_terminal
+                  before_terminal
+                  after_terminal
+                after_subnodes
+              after_non_terminal
+            after_subnodes
+          after_alternative
+          before_alternative
+            before_subnodes
+              before_non_terminal
+                before_subnodes
+                  before_alternative
+                    before_subnodes
+                      before_terminal
+                      after_terminal
+                    after_subnodes
+                  after_alternative
+                  before_alternative
+                    before_subnodes
+                      before_non_terminal
+                        before_subnodes
+                          before_epsilon
+                          after_epsilon
+                        after_subnodes
+                      after_non_terminal
+                      before_non_terminal
+                        before_subnodes
+                          before_alternative
+                            before_subnodes
+                              before_terminal
+                              after_terminal
+                            after_subnodes
+                          after_alternative
+                          before_alternative
+                            before_subnodes
+                              before_non_terminal
+                                before_subnodes
+                                  before_epsilon
+                                  after_epsilon
+                                after_subnodes
+                              after_non_terminal
+                            after_subnodes
+                          after_alternative
+                        after_subnodes
+                      after_non_terminal
+                    after_subnodes
+                  after_alternative
+                after_subnodes
+              after_non_terminal
+              before_non_terminal
+                before_subnodes
+                  before_terminal
+                  after_terminal
+                  before_terminal
+                  after_terminal
+                  before_terminal
+                  after_terminal
+                after_subnodes
+              after_non_terminal
+            after_subnodes
+          after_alternative
+        after_subnodes
+      after_non_terminal
+    after_subnodes
+  after_non_terminal
+after_pforest
 SNIPPET
           expect(destination.string).to eq(expectations)
         end

data/spec/rley/parse_forest_visitor_spec.rb

@@ -4,8 +4,10 @@ require_relative './support/grammar_helper'
 require_relative './support/grammar_sppf_helper'
 require_relative '../../lib/rley/lexical/token'
 require_relative '../../lib/rley/parser/gfg_earley_parser'
+require_relative '../../lib/rley/parse_rep/parse_forest_factory'
 require_relative '../../lib/rley/sppf/non_terminal_node'
 require_relative '../../lib/rley/sppf/parse_forest'
+require_relative '../../lib/rley/formatter/debug'
 
 # Load the class under test
 require_relative '../../lib/rley/parse_forest_visitor'
@@ -31,7 +33,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
     end
 
     # A forest with just a root node
-    let(:rooted_forest) do
+    let(:forest_root) do
       parser = Parser::GFGEarleyParser.new(grammar_sppf)
       parse_result = parser.parse(sample_tokens)
       accepting_entry = parse_result.accepting_entry
@@ -40,37 +42,27 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       Rley::SPPF::ParseForest.new(root_node)
     end
 
-=begin
     # Factory method that builds a sample parse forest.
     # Generated forest has the following structure:
-    # S[0,5]
-    # +- A[0,5]
-    #    +- a[0,0]
-    #    +- A[1,4]
-    #    |  +- a[1,1]
-    #    |  +- A[2,3]
-    #    |  |  +- b[2,3]
-    #    |  +- c[3,4]
-    #    +- c[4,5]
-    # Capital letters represent non-terminal nodes
-    let(:grm_abc_pforest1) do
-      parser = Parser::EarleyParser.new(grammar_abc)
-      parse_result = parser.parse(grm_abc_tokens1)
-      parse_result.parse_forest
+    let(:grm_sppf_pforest1) do
+      parser = Parser::GFGEarleyParser.new(grammar_sppf)
+      parse_result = parser.parse(sample_tokens)
+      factory = ParseRep::ParseForestFactory.new(parse_result)
+      factory.create
     end
-=end
+
 
     # Default instantiation rule
-    subject { ParseForestVisitor.new(rooted_forest) }
+    subject { ParseForestVisitor.new(forest_root) }
 
 
     context 'Standard creation & initialization:' do
       it 'should be initialized with a parse forest argument' do
-        expect { ParseForestVisitor.new(rooted_forest) }.not_to raise_error
+        expect { ParseForestVisitor.new(forest_root) }.not_to raise_error
       end
 
       it 'should know the parse forest to visit' do
-        expect(subject.pforest).to eq(rooted_forest)
+        expect(subject.pforest).to eq(forest_root)
       end
 
       it "shouldn't have subscribers at start" do
@@ -104,134 +96,370 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
     end # context
 
+    class EventDispatcher
+      # return [Array<Proc>]
+      attr_accessor(:expectations)
+      attr_reader(:event_count)
 
-    context 'Notifying visit events:' do
-      # Use doubles/mocks to simulate subscribers
-      let(:listener1) { double('fake-subscriber1') }
-      let(:listener2) { double('fake-subscriber2') }
-
-      it 'should react to the start_visit_pforest message' do
-        subject.subscribe(listener1)
-
-        # Notify subscribers when start the visit of the pforest
-        expect(listener1).to receive(:before_pforest).with(rooted_forest)
-        subject.start_visit_pforest(rooted_forest)
-      end
-=begin
-      # Default instantiation rule
-      subject do
-        instance = ParseForestVisitor.new(grm_abc_pforest1)
-        instance.subscribe(listener1)
-        instance
+      def initialize
+        @event_count = 0
       end
 
-
-
-      # Sample non-terminal node
-      let(:nterm_node) do
-        first_big_a = grm_abc_pforest1.root.children[0]
-        second_big_a = first_big_a.children[1]
-        second_big_a.children[1]
+      def accept_all
+        true
       end
 
-      # Sample terminal node
-      let(:term_node) { nterm_node.children[0] }
-
-      it 'should react to the start_visit_pforest message' do
-        # Notify subscribers when start the visit of the pforest
-        expect(listener1).to receive(:before_pforest).with(grm_abc_pforest1)
-        subject.start_visit_pforest(grm_abc_pforest1)
+      def method_missing(mth, *args)
+        if expectations.at(event_count)
+          if mth =~ /_subnodes$/
+            parent = args[0]
+            children = args[1]
+            expectations[event_count].call(mth, parent, children)
+          else
+            actual_item = args[0]
+            expectations[event_count].call(mth, actual_item)
+          end
+        end
+        @event_count += 1
       end
+    end # class
 
-      it 'should react to the start_visit_nonterminal message' do
-        # Notify subscribers when start the visit of a non-terminal node
-        expect(listener1).to receive(:before_non_terminal).with(nterm_node)
-        subject.visit_nonterminal(nterm_node)
+    context 'Notifying visit events:' do
+      # expectations [Array<Array<Symbol, String>>]
+      def check_event(actual_event, actual_item, expectations)
+        (event, item) = expectations
+        expect(actual_event).to eq(event)
+        case item
+          when String
+          expect(actual_item.to_string(0)).to eq(item)
+        end
       end
 
-      it 'should react to the visit_children message' do
-        # Notify subscribers when start the visit of children nodes
-        children = nterm_node.children
-        args = [nterm_node, children]
-        expect(listener1).to receive(:before_children).with(*args)
-        expect(listener1).to receive(:before_terminal).with(children[0])
-        expect(listener1).to receive(:after_terminal).with(children[0])
-        expect(listener1).to receive(:after_children).with(nterm_node, children)
-        subject.send(:traverse_children, nterm_node)
+      def check_legs(expectations)
+        (parent, path_signature) = subject.legs[-1]
+        expect(parent.to_string(0)).to eq(expectations[0])
+        expect(path_signature).to eq(expectations[1])
       end
 
-      it 'should react to the end_visit_nonterminal message' do
-        # Notify subscribers when ending the visit of a non-terminal node
-        expect(listener1).to receive(:after_non_terminal).with(nterm_node)
-        subject.end_visit_nonterminal(nterm_node)
+      def check_node_accesses(node, paths)
+        actual_paths = subject.node_accesses.fetch(node)
+        expect(actual_paths).to eq(paths)
       end
 
-      it 'should react to the visit_terminal message' do
-        # Notify subscribers when start & ending the visit of a terminal node
-        expect(listener1).to receive(:before_terminal).with(term_node)
-        expect(listener1).to receive(:after_terminal).with(term_node)
-        subject.visit_terminal(term_node)
-      end
+      let(:checker) { EventDispatcher.new }
 
-      it 'should react to the end_visit_pforest message' do
-        # Notify subscribers when ending the visit of the pforest
-        expect(listener1).to receive(:after_pforest).with(grm_abc_pforest1)
-        subject.end_visit_pforest(grm_abc_pforest1)
+      # Default instantiation rule
+      subject do
+        instance = ParseForestVisitor.new(grm_sppf_pforest1)
+        instance.subscribe(checker)
+        instance
       end
 
-      it 'should begin the visit when requested' do
-        # Reminder: parse forest structure is
-        # S[0,5]
-        # +- A[0,5]
-        #    +- a[0,0]
-        #    +- A[1,4]
-        #    |  +- a[1,1]
-        #    |  +- A[2,3]
-        #    |  |  +- b[2,3]
-        #    |  +- c[3,4]
-        #    +- c[4,5]
-        root = grm_abc_pforest1.root
-        children = root.children
-        big_a_1 = children[0]
-        big_a_1_children = big_a_1.children
-        big_a_2 = big_a_1_children[1]
-        big_a_2_children = big_a_2.children
-        big_a_3 = big_a_2_children[1]
-        big_a_3_children = big_a_3.children
-        expectations = [
-          [:before_pforest, [grm_abc_pforest1]],
-          [:before_non_terminal, [root]],
-          [:before_children, [root, children]],
-          [:before_non_terminal, [big_a_1]],
-          [:before_children, [big_a_1, big_a_1_children]],
-          [:before_terminal, [big_a_1_children[0]]],
-          [:after_terminal, [big_a_1_children[0]]],
-          [:before_non_terminal, [big_a_2]],
-          [:before_children, [big_a_2, big_a_2_children]],
-          [:before_terminal, [big_a_2_children[0]]],
-          [:after_terminal, [big_a_2_children[0]]],
-          [:before_non_terminal, [big_a_3]],
-          [:before_children, [big_a_3, big_a_3_children]],
-          [:before_terminal, [big_a_3_children[0]]],
-          [:after_terminal, [big_a_3_children[0]]],
-          [:after_children, [big_a_3, big_a_3_children]],
-          [:before_terminal, [big_a_2_children[2]]],
-          [:after_terminal, [big_a_2_children[2]]],
-          [:after_children, [big_a_2, big_a_2_children]],
-          [:before_terminal, [big_a_1_children[2]]],
-          [:after_terminal, [big_a_1_children[2]]],
-          [:after_children, [big_a_1, big_a_1_children]],
-          [:after_children, [root, children]],
-          [:after_pforest, [grm_abc_pforest1]]
+      it 'should react to the start_visit_pforest message' do
+        # Notify subscribers when start the visit of the pforest
+        # expect(listener1).to receive(:before_pforest).with(forest_root)
+        checker.expectations = [
+          ->(event, item) {
+            check_event(event, item, [:before_pforest, grm_sppf_pforest1])
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_non_terminal, 'Phi[0, 4]'])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:before_subnodes, 'Phi[0, 4]'])
+            expect(children.size).to eq(1)
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_non_terminal, 'S[0, 4]'])
+            check_legs(['S[0, 4]', 2]) # 2
+            check_node_accesses(item, [2])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:before_subnodes, 'S[0, 4]'])
+            expect(children.size).to eq(2)
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_alternative, 'Alt(S => a T .)[0, 4]'])
+            check_legs(['Alt(S => a T .)[0, 4]', 6]) # 2 * 3
+            check_node_accesses(item, [6])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:before_subnodes, 'Alt(S => a T .)[0, 4]'])
+            expect(children.size).to eq(2)
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_terminal, 'a[0, 1]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_terminal, 'a[0, 1]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_non_terminal, 'T[1, 4]'])
+            check_legs(['T[1, 4]', 66]) # 2 * 3 * 11
+            check_node_accesses(item, [66])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:before_subnodes, 'T[1, 4]'])
+            expect(children.size).to eq(3)
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_terminal, 'b[1, 2]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_terminal, 'b[1, 2]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_terminal, 'b[2, 3]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_terminal, 'b[2, 3]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_terminal, 'b[3, 4]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_terminal, 'b[3, 4]'])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:after_subnodes, 'T[1, 4]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_non_terminal, 'T[1, 4]'])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:after_subnodes, 'Alt(S => a T .)[0, 4]'])
+            expect(children.size).to eq(2)
+            check_legs(['Alt(S => a T .)[0, 4]', 6]) # 2 * 3
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_alternative, 'Alt(S => a T .)[0, 4]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_alternative, 'Alt(S => A T .)[0, 4]'])
+            check_legs(['Alt(S => A T .)[0, 4]', 10]) # 2 * 5
+            check_node_accesses(item, [10])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:before_subnodes, 'Alt(S => A T .)[0, 4]'])
+            expect(children.size).to eq(2)
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_non_terminal, 'A[0, 1]'])
+            check_legs(['A[0, 1]', 230]) # 2 * 5 * 23
+            check_node_accesses(item, [230])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:before_subnodes, 'A[0, 1]'])
+            expect(children.size).to eq(2)
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_alternative, 'Alt(A => a .)[0, 1]'])
+            check_legs(['Alt(A => a .)[0, 1]', 7130]) # 2 * 5 * 23 * 31
+            check_node_accesses(item, [7130])
+            # p(subject.legs)
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:before_subnodes, 'Alt(A => a .)[0, 1]'])
+            expect(children.size).to eq(1)
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_terminal, 'a[0, 1]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_terminal, 'a[0, 1]'])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:after_subnodes, 'Alt(A => a .)[0, 1]'])
+            check_legs(['Alt(A => a .)[0, 1]', 7130]) # 2 * 5 * 23 * 31
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_alternative, 'Alt(A => a .)[0, 1]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_alternative, 'Alt(A => B A .)[0, 1]'])
+            check_legs(['Alt(A => B A .)[0, 1]', 8510]) # 2 * 5 * 23 * 37
+            check_node_accesses(item, [8510])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:before_subnodes, 'Alt(A => B A .)[0, 1]'])
+            expect(children.size).to eq(2)
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_non_terminal, 'B[0, 0]'])
+            check_legs(['B[0, 0]', 365930]) # 2 * 5 * 23 * 37 * 43
+            check_node_accesses(item, [365930])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:before_subnodes, 'B[0, 0]'])
+            expect(children.size).to eq(1)
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_epsilon, '_[0, 0]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_epsilon, '_[0, 0]'])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:after_subnodes, 'B[0, 0]'])
+            check_legs(['B[0, 0]', 365930]) # 2 * 5 * 23 * 37 * 43
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_non_terminal, 'B[0, 0]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_non_terminal, 'A[0, 1]'])
+            check_legs(['A[0, 1]', 399970]) # 2 * 5 * 23 * 37 * 47
+            check_node_accesses(item, [230, 399970])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:before_subnodes, 'A[0, 1]'])
+            expect(children.size).to eq(2)
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_alternative, 'Alt(A => a .)[0, 1]'])
+            check_legs(['Alt(A => a .)[0, 1]', 12399070])  # 2 * 5 * 23 * 37 * 47 * 31
+            check_node_accesses(item, [7130, 12399070])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:before_subnodes, 'Alt(A => a .)[0, 1]'])
+            expect(children.size).to eq(1)
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_terminal, 'a[0, 1]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_terminal, 'a[0, 1]'])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:after_subnodes, 'Alt(A => a .)[0, 1]'])
+            check_legs(['Alt(A => a .)[0, 1]', 12399070]) # 2 * 5 * 23 * 37 * 47 * 31
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_alternative, 'Alt(A => a .)[0, 1]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_alternative, 'Alt(A => B A .)[0, 1]'])
+            # For prime factoring: https://www.calculatorsoup.com/calculators/math/prime-factors.php
+            check_legs(['Alt(A => B A .)[0, 1]', 399970]) # 2 * 5 * 23 * 37 * 47
+            check_node_accesses(item, [8510, 399970])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:before_subnodes, 'Alt(A => B A .)[0, 1]'])
+            expect(children.size).to eq(2)
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_non_terminal, 'B[0, 0]'])
+            check_legs(['B[0, 0]', 17198710]) # 2 * 5 * 23 * 37 * 47 * 43
+            check_node_accesses(item, [365930, 17198710])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:before_subnodes, 'B[0, 0]'])
+            expect(children.size).to eq(1)
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_epsilon, '_[0, 0]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_epsilon, '_[0, 0]'])
+          },
+           ->(event, parent, children) {
+            check_event(event, parent, [:after_subnodes, 'B[0, 0]'])
+            check_legs(['B[0, 0]', 17198710]) # 2 * 5 * 23 * 37 * 43 * 47
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_non_terminal, 'B[0, 0]'])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:after_subnodes, 'Alt(A => B A .)[0, 1]'])
+            check_legs(['Alt(A => B A .)[0, 1]', 399970]) # 2 * 5 * 23 * 37 * 47
+            check_node_accesses(parent, [8510, 399970])
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_alternative, 'Alt(A => B A .)[0, 1]'])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:after_subnodes, 'A[0, 1]'])
+            check_legs(['A[0, 1]', 399970]) # 2 * 5 * 23 * 37 * 47
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_non_terminal, 'A[0, 1]'])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:after_subnodes, 'Alt(A => B A .)[0, 1]'])
+            check_legs(['Alt(A => B A .)[0, 1]', 8510]) # 2 * 5 * 23 * 37
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_alternative, 'Alt(A => B A .)[0, 1]'])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:after_subnodes, 'A[0, 1]'])
+            check_legs(['A[0, 1]', 230]) # 2 * 5 * 23
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_non_terminal, 'A[0, 1]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_non_terminal, 'T[1, 4]'])
+            check_legs(['T[1, 4]', 290]) # 2 * 5 * 29
+            check_node_accesses(item, [66, 290])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:before_subnodes, 'T[1, 4]'])
+            expect(children.size).to eq(3)
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_terminal, 'b[1, 2]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_terminal, 'b[1, 2]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_terminal, 'b[2, 3]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_terminal, 'b[2, 3]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:before_terminal, 'b[3, 4]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_terminal, 'b[3, 4]'])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:after_subnodes, 'T[1, 4]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_non_terminal, 'T[1, 4]'])
+          },
+          ->(event, parent, children) {
+            check_event(event, parent, [:after_subnodes, 'Alt(S => A T .)[0, 4]'])
+            expect(children.size).to eq(2)
+            check_legs(['Alt(S => A T .)[0, 4]', 10]) # 2 * 5
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_alternative, 'Alt(S => A T .)[0, 4]'])
+          }, 
+          ->(event, parent, children) {
+            check_event(event, parent, [:after_subnodes, 'S[0, 4]'])
+            expect(children.size).to eq(2)
+            check_legs(['S[0, 4]', 2]) # 2
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_non_terminal, 'S[0, 4]'])
+          },          
+           ->(event, parent, children) {
+            check_event(event, parent, [:after_subnodes, 'Phi[0, 4]'])
+            expect(children.size).to eq(1)
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_non_terminal, 'Phi[0, 4]'])
+          },
+          ->(event, item) {
+            check_event(event, item, [:after_pforest, grm_sppf_pforest1])
+          }
         ]
-        expectations.each do |(msg, args)|
-          expect(listener1).to receive(msg).with(*args).ordered
-        end
-
-        # Here we go...
         subject.start
       end
-=end
     end # context
   end # describe
 end # module