rley 0.7.07 → 0.7.08

data/spec/rley/formatter/asciitree_spec.rb

@@ -23,12 +23,12 @@ 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
@@ -50,12 +50,12 @@ 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
-  
+
       let(:destination) { StringIO.new(+'', 'w') }
       subject { Asciitree.new(destination) }
 
@@ -63,14 +63,14 @@ module Rley # Re-open the module to get rid of qualified names
         it 'should be initialized with an IO argument' do
           expect { Asciitree.new(StringIO.new(+'', 'w')) }.not_to raise_error
         end
-        
+
         it 'should know its output destination' do
           expect(subject.output).to eq(destination)
         end
       end # context
-  
 
-      context 'Rendering:' do   
+
+      context 'Rendering:' do
         it 'should render a parse tree' do
           visitor = Rley::ParseTreeVisitor.new(grm_abc_ptree1)
           subject.render(visitor)

data/spec/rley/formatter/bracket_notation_spec.rb

@@ -23,12 +23,12 @@ 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
@@ -50,45 +50,45 @@ 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   
+        ptree
       end
-  
+
       let(:destination) { StringIO.new(+'', 'w') }
       subject { BracketNotation.new(destination) }
 
       context 'Standard creation & initialization:' do
         it 'should be initialized with an IO argument' do
-          expect do 
-            BracketNotation.new(StringIO.new(+'', 'w')) 
+          expect do
+            BracketNotation.new(StringIO.new(+'', 'w'))
           end.not_to raise_error
         end
-        
+
         it 'should know its output destination' do
           expect(subject.output).to eq(destination)
         end
       end # context
-  
 
-      context 'Formatting events:' do   
+
+      context 'Formatting events:' do
         it 'should support visit events of a parse tree' do
           visitor = Rley::ParseTreeVisitor.new(grm_abc_ptree1)
           subject.render(visitor)
           expectations = '[S [A [a a][A [a a][A [b b]][c c]][c c]]]'
           expect(destination.string).to eq(expectations)
         end
-        
+
         it 'should escape square brackets' do
           f_node = double('fake-node')
           f_token = double('fake-token')
           expect(f_node).to receive(:token).and_return(f_token)
           expect(f_token).to receive(:lexeme).and_return('[][]')
-          
+
           subject.after_terminal(f_node)
           expectations = '\[\]\[\]]'
-          expect(destination.string).to eq(expectations)          
+          expect(destination.string).to eq(expectations)
         end
       end # context
     end # describe

data/spec/rley/formatter/json_spec.rb

@@ -49,7 +49,7 @@ 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

data/spec/rley/gfg/end_vertex_spec.rb

@@ -23,12 +23,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
       end # context
 
-      context 'Provided services:' do       
+      context 'Provided services:' do
         it 'should provide human-readable representation of itself' do
-          pattern = /^#<Rley::GFG::EndVertex:\d+ label="NT\."/         
-          expect(subject.inspect).to match(pattern)       
-        end        
-      end # context      
+          pattern = /^#<Rley::GFG::EndVertex:\d+ label="NT\."/
+          expect(subject.inspect).to match(pattern)
+        end
+      end # context
     end # describe
   end # module
 end # module

data/spec/rley/gfg/item_vertex_spec.rb

@@ -73,10 +73,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # Case: dot is after first symbol
           instance1 = ItemVertex.new(sample_item)
           expect(instance1.prev_symbol).to eq(t_a)
-          
+
           # Case: dot is after second or later symbol
           instance2 = ItemVertex.new(next_item)
-          expect(instance2.prev_symbol).to eq(nt_b_sequence)          
+          expect(instance2.prev_symbol).to eq(nt_b_sequence)
 
           # Case: dot is at begin
           instance3 = ItemVertex.new(Base::DottedItem.new(sample_prod, 0))
@@ -86,8 +86,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           instance4 = ItemVertex.new(Base::DottedItem.new(empty_prod, 0))
           expect(instance4.prev_symbol).to be_nil
         end
-        
-        
+
+
         it 'should know the next symbol (if any) in the rhs' do
           # Case: dot is not penultimate
           expect(subject.next_symbol).to eq(nt_b_sequence)
@@ -112,21 +112,21 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           shortcut = ShortcutEdge.new(subject, next_vertex)
           expect(subject.shortcut).to eq(shortcut)
         end
-        
+
         it 'should reject an invalid shortcut edge' do
           err = StandardError
           err_msg = 'Invalid shortcut argument'
           expect { subject.shortcut = 'invalid' }.to raise_error(err, err_msg)
-        end        
+        end
       end # context
 
       context 'Provided services:' do
         it 'should provide human-readable representation of itself' do
-          prefix = /^#<Rley::GFG::ItemVertex:\d+/           
+          prefix = /^#<Rley::GFG::ItemVertex:\d+/
           expect(subject.inspect).to match(prefix)
-          suffix = /label="sentence => a \. b_sequence c">$/        
-          expect(subject.inspect).to match(suffix)            
-        end        
+          suffix = /label="sentence => a \. b_sequence c">$/
+          expect(subject.inspect).to match(suffix)
+        end
       end # context
     end # describe
   end # module

data/spec/rley/gfg/non_terminal_vertex_spec.rb

@@ -19,7 +19,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should know its non-terminal' do
           expect(subject.non_terminal).to eq(sample_nt)
         end
-        
+
 
         it 'should accept at more than one outgoing edge' do
           edge1 = double('fake-edge1')
@@ -28,11 +28,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect { subject.add_edge(edge1) }.not_to raise_error
           expect(subject.edges.size).to eq(1)
           expect(subject.edges.last).to eq(edge1)
-          
+
           expect { subject.add_edge(edge2) }.not_to raise_error
           expect(subject.edges.size).to eq(2)
           expect(subject.edges.last).to eq(edge2)
-        end         
+        end
       end # context
     end # describe
   end # module

data/spec/rley/gfg/shortcut_edge_spec.rb

@@ -27,7 +27,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should know the successor vertex' do
           expect(vertex1).to receive(:shortcut=)
           expect(vertex1).to receive(:next_symbol).and_return(nt_b_sequence)
-          
+
           expect(subject.successor).to eq(vertex2)
         end
 

data/spec/rley/gfg/start_vertex_spec.rb

@@ -22,12 +22,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(subject.label).to eq('.NT')
         end
       end # context
-      
-      context 'Provided services:' do       
+
+      context 'Provided services:' do
         it 'should provide human-readable representation of itself' do
-          pattern = /^#<Rley::GFG::StartVertex:\d+ label="\.NT"/         
-          expect(subject.inspect).to match(pattern)       
-        end        
+          pattern = /^#<Rley::GFG::StartVertex:\d+ label="\.NT"/
+          expect(subject.inspect).to match(pattern)
+        end
       end # context
     end # describe
   end # module

data/spec/rley/gfg/vertex_spec.rb

@@ -24,10 +24,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should know whether it has a dot at the end of the rhs' do
           expect(subject).not_to be_complete
         end
-        
+
         it 'should know the previous symbol (if any) in the rhs' do
           expect(subject.prev_symbol).to be_nil
-        end        
+        end
 
         it 'should know the next symbol (if any) in the rhs' do
           expect(subject.next_symbol).to be_nil
@@ -40,7 +40,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect { subject.add_edge(edge1) }.not_to raise_error
           expect(subject.edges.size).to eq(1)
           expect(subject.edges.last).to eq(edge1)
-          
+
           err = StandardError
           msg = 'At most one edge accepted'
           expect { subject.add_edge(edge2) }.to raise_error err, msg

data/spec/rley/lexical/token_range_spec.rb

@@ -27,7 +27,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # Both bounds provided
           expect { TokenRange.new(low: 0, high: 5) }.not_to raise_error
         end
-        
+
         it 'could be created with another TokenRange' do
           # Low bound provided
           instance = TokenRange.new(low: 0)
@@ -61,7 +61,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(subject == [0, 5]).to eq(true)
         end
 
-      
+
         it 'should know whether it is bounded or not' do
           expect(subject).to be_bounded
 
@@ -119,50 +119,50 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(instance.low).to eq(1)
           expect(instance.high).to eq(4)
         end
-        
+
         it 'should tell whether an index value lies outside the range' do
           # Out of range...
           expect(subject.out_of_range?(-1)).to eq(true)
           expect(subject.out_of_range?(6)).to eq(true)
-          
+
           # On boundaries...
           expect(subject.out_of_range?(0)).to eq(false)
           expect(subject.out_of_range?(5)).to eq(false)
-          
+
           # Inside boundaries
           expect(subject.out_of_range?(2)).to eq(false)
 
           instance = TokenRange.new(low: nil, high: 5)
-          
+
           # Lower bound is nil
           expect(instance.out_of_range?(-1)).to eq(false)
           expect(instance.out_of_range?(5)).to eq(false)
           expect(instance.out_of_range?(6)).to eq(true)
-          
+
           instance = TokenRange.new(low: 0, high: nil)
-          
+
           # Upper bound is nil
           expect(instance.out_of_range?(-1)).to eq(true)
           expect(instance.out_of_range?(0)).to eq(false)
           expect(instance.out_of_range?(6)).to eq(false)
         end
-        
+
         it 'should provide a text representation of itself' do
           # Case 1: not bound is set
           instance = TokenRange.new({})
-          expect(instance.to_string(0)).to eq('[?, ?]') 
-          
+          expect(instance.to_string(0)).to eq('[?, ?]')
+
           # Case: only low bound is set
           instance = TokenRange.new(low: 0)
-          expect(instance.to_string(0)).to eq('[0, ?]') 
+          expect(instance.to_string(0)).to eq('[0, ?]')
 
           # Case: only upper bound is set
-          instance = TokenRange.new(high: 5) 
-          expect(instance.to_string(0)).to eq('[?, 5]') 
+          instance = TokenRange.new(high: 5)
+          expect(instance.to_string(0)).to eq('[?, 5]')
 
           # Case: both bounds are set
-          instance = TokenRange.new(low: 0, high: 5) 
-          expect(instance.to_string(0)).to eq('[0, 5]')            
+          instance = TokenRange.new(low: 0, high: 5)
+          expect(instance.to_string(0)).to eq('[0, 5]')
         end
       end
     end # describe

data/spec/rley/lexical/token_spec.rb

@@ -29,10 +29,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should know its terminal' do
           expect(subject.terminal).to eq(a_terminal)
         end
-        
+
         it 'should know its terminal' do
           expect(subject.position).to eq(a_pos)
-        end        
+        end
       end # context
     end # describe
   end # module

data/spec/rley/parse_forest_visitor_spec.rb

@@ -98,6 +98,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
     end # context
 
+    # rubocop: disable Lint/ConstantDefinitionInBlock
     class EventDispatcher
       # return [Array<Proc>]
       attr_accessor(:expectations)
@@ -125,6 +126,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         @event_count += 1
       end
     end # class
+    # rubocop: enable Lint/ConstantDefinitionInBlock
 
     context 'Notifying visit events:' do
       # expectations [Array<Array<Symbol, String>>]
@@ -161,329 +163,329 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         # Notify subscribers when start the visit of the pforest
         # expect(listener1).to receive(:before_pforest).with(forest_root)
         checker.expectations = [
-          ->(event, item) {
+          lambda do |event, item|
             check_event(event, item, [:before_pforest, grm_sppf_pforest1])
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:before_non_terminal, 'Phi[0, 4]'])
-          },
-          ->(event, parent, children) {
+          end,
+          lambda do |event, parent, children|
             check_event(event, parent, [:before_subnodes, 'Phi[0, 4]'])
             expect(children.size).to eq(1)
-          },
-          ->(event, item) {
+          end,
+          lambda do |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) {
+          end,
+          lambda do |event, parent, children|
             check_event(event, parent, [:before_subnodes, 'S[0, 4]'])
             expect(children.size).to eq(2)
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             prediction = 'Alt(S => a T .)[0, 4]'
             check_event(event, item, [:before_alternative, prediction])
             check_legs(['Alt(S => a T .)[0, 4]', 6]) # 2 * 3
             check_node_accesses(item, [6])
-          },
-          ->(event, parent, children) {
+          end,
+          lambda do |event, parent, children|
             prediction = 'Alt(S => a T .)[0, 4]'
             check_event(event, parent, [:before_subnodes, prediction])
             expect(children.size).to eq(2)
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:before_terminal, 'a[0, 1]'])
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:after_terminal, 'a[0, 1]'])
-          },
-          ->(event, item) {
+          end,
+          lambda do |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) {
+          end,
+          lambda do |event, parent, children|
             check_event(event, parent, [:before_subnodes, 'T[1, 4]'])
             expect(children.size).to eq(3)
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:before_terminal, 'b[1, 2]'])
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:after_terminal, 'b[1, 2]'])
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:before_terminal, 'b[2, 3]'])
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:after_terminal, 'b[2, 3]'])
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:before_terminal, 'b[3, 4]'])
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:after_terminal, 'b[3, 4]'])
-          },
-          ->(event, parent, _children) {
+          end,
+          lambda do |event, parent, _children|
             check_event(event, parent, [:after_subnodes, 'T[1, 4]'])
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:after_non_terminal, 'T[1, 4]'])
-          },
-          ->(event, parent, children) {
+          end,
+          lambda do |event, parent, children|
             prediction = 'Alt(S => a T .)[0, 4]'
             check_event(event, parent, [:after_subnodes, prediction])
             expect(children.size).to eq(2)
             check_legs(['Alt(S => a T .)[0, 4]', 6]) # 2 * 3
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             prediction = 'Alt(S => a T .)[0, 4]'
             check_event(event, item, [:after_alternative, prediction])
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             prediction = 'Alt(S => A T .)[0, 4]'
             check_event(event, item, [:before_alternative, prediction])
             check_legs(['Alt(S => A T .)[0, 4]', 10]) # 2 * 5
             check_node_accesses(item, [10])
-          },
-          ->(event, parent, children) {
+          end,
+          lambda do |event, parent, children|
             prediction = 'Alt(S => A T .)[0, 4]'
             check_event(event, parent, [:before_subnodes, prediction])
             expect(children.size).to eq(2)
-          },
-          ->(event, item) {
+          end,
+          lambda do |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) {
+          end,
+          lambda do |event, parent, children|
             check_event(event, parent, [:before_subnodes, 'A[0, 1]'])
             expect(children.size).to eq(2)
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             prediction = 'Alt(A => a .)[0, 1]'
             check_event(event, item, [:before_alternative, prediction])
             check_legs(['Alt(A => a .)[0, 1]', 7130]) # 2 * 5 * 23 * 31
             check_node_accesses(item, [7130])
             # p(subject.legs)
-          },
-          ->(event, parent, children) {
+          end,
+          lambda do |event, parent, children|
             prediction = 'Alt(A => a .)[0, 1]'
             check_event(event, parent, [:before_subnodes, prediction])
             expect(children.size).to eq(1)
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:before_terminal, 'a[0, 1]'])
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:after_terminal, 'a[0, 1]'])
-          },
-          ->(event, parent, _children) {
+          end,
+          lambda do |event, parent, _children|
             prediction = 'Alt(A => a .)[0, 1]'
             check_event(event, parent, [:after_subnodes, prediction])
             check_legs(['Alt(A => a .)[0, 1]', 7130]) # 2 * 5 * 23 * 31
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             prediction = 'Alt(A => a .)[0, 1]'
             check_event(event, item, [:after_alternative, prediction])
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             prediction = 'Alt(A => B A .)[0, 1]'
             check_event(event, item, [:before_alternative, prediction])
             check_legs(['Alt(A => B A .)[0, 1]', 8510]) # 2 * 5 * 23 * 37
             check_node_accesses(item, [8510])
-          },
-          ->(event, parent, children) {
+          end,
+          lambda do |event, parent, children|
             prediction = 'Alt(A => B A .)[0, 1]'
             check_event(event, parent, [:before_subnodes, prediction])
             expect(children.size).to eq(2)
-          },
-          ->(event, item) {
+          end,
+          lambda do |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) {
+          end,
+          lambda do |event, parent, children|
             check_event(event, parent, [:before_subnodes, 'B[0, 0]'])
             expect(children.size).to eq(1)
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:before_epsilon, '_[0, 0]'])
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:after_epsilon, '_[0, 0]'])
-          },
-          ->(event, parent, _children) {
+          end,
+          lambda do |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) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:after_non_terminal, 'B[0, 0]'])
-          },
-          ->(event, item) {
+          end,
+          lambda do |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) {
+          end,
+          lambda do |event, parent, children|
             check_event(event, parent, [:before_subnodes, 'A[0, 1]'])
             expect(children.size).to eq(2)
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             prediction = 'Alt(A => a .)[0, 1]'
             check_event(event, item, [:before_alternative, prediction])
             # 12399070 = 2 * 5 * 23 * 37 * 47 * 31
             check_legs(['Alt(A => a .)[0, 1]', 12399070])
             check_node_accesses(item, [7130, 12399070])
-          },
-          ->(event, parent, children) {
+          end,
+          lambda do |event, parent, children|
             prediction = 'Alt(A => a .)[0, 1]'
             check_event(event, parent, [:before_subnodes, prediction])
             expect(children.size).to eq(1)
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:before_terminal, 'a[0, 1]'])
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:after_terminal, 'a[0, 1]'])
-          },
-          ->(event, parent, _children) {
+          end,
+          lambda do |event, parent, _children|
             check_event(event, parent, [:after_subnodes, 'Alt(A => a .)[0, 1]'])
             # 12399070 = 2 * 5 * 23 * 37 * 47 * 31
-            check_legs(['Alt(A => a .)[0, 1]', 12399070]) 
-          },
-          ->(event, item) {
+            check_legs(['Alt(A => a .)[0, 1]', 12399070])
+          end,
+          lambda do |event, item|
             prediction = 'Alt(A => a .)[0, 1]'
             check_event(event, item, [:after_alternative, prediction])
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             prediction = 'Alt(A => B A .)[0, 1]'
             check_event(event, item, [:before_alternative, prediction])
-            # For prime factoring: 
+            # 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) {
+          end,
+          lambda do |event, parent, children|
             prediction = 'Alt(A => B A .)[0, 1]'
             check_event(event, parent, [:before_subnodes, prediction])
             expect(children.size).to eq(2)
-          },
-          ->(event, item) {
+          end,
+          lambda do |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) {
+          end,
+          lambda do |event, parent, children|
             check_event(event, parent, [:before_subnodes, 'B[0, 0]'])
             expect(children.size).to eq(1)
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:before_epsilon, '_[0, 0]'])
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:after_epsilon, '_[0, 0]'])
-          },
-          ->(event, parent, _children) {
+          end,
+          lambda do |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) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:after_non_terminal, 'B[0, 0]'])
-          },
-          ->(event, parent, _children) {
+          end,
+          lambda do |event, parent, _children|
             prediction = 'Alt(A => B A .)[0, 1]'
             check_event(event, parent, [:after_subnodes, prediction])
             check_legs(['Alt(A => B A .)[0, 1]', 399970]) # 2 * 5 * 23 * 37 * 47
             check_node_accesses(parent, [8510, 399970])
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             prediction = 'Alt(A => B A .)[0, 1]'
             check_event(event, item, [:after_alternative, prediction])
-          },
-          ->(event, parent, _children) {
+          end,
+          lambda do |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) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:after_non_terminal, 'A[0, 1]'])
-          },
-          ->(event, parent, _children) {
+          end,
+          lambda do |event, parent, _children|
             prediction = 'Alt(A => B A .)[0, 1]'
             check_event(event, parent, [:after_subnodes, prediction])
             check_legs(['Alt(A => B A .)[0, 1]', 8510]) # 2 * 5 * 23 * 37
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             prediction = 'Alt(A => B A .)[0, 1]'
             check_event(event, item, [:after_alternative, prediction])
-          },
-          ->(event, parent, _children) {
+          end,
+          lambda do |event, parent, _children|
             check_event(event, parent, [:after_subnodes, 'A[0, 1]'])
             check_legs(['A[0, 1]', 230]) # 2 * 5 * 23
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:after_non_terminal, 'A[0, 1]'])
-          },
-          ->(event, item) {
+          end,
+          lambda do |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) {
+          end,
+          lambda do |event, parent, children|
             check_event(event, parent, [:before_subnodes, 'T[1, 4]'])
             expect(children.size).to eq(3)
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:before_terminal, 'b[1, 2]'])
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:after_terminal, 'b[1, 2]'])
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:before_terminal, 'b[2, 3]'])
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:after_terminal, 'b[2, 3]'])
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:before_terminal, 'b[3, 4]'])
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:after_terminal, 'b[3, 4]'])
-          },
-          ->(event, parent, _children) {
+          end,
+          lambda do |event, parent, _children|
             check_event(event, parent, [:after_subnodes, 'T[1, 4]'])
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:after_non_terminal, 'T[1, 4]'])
-          },
-          ->(event, parent, children) {
+          end,
+          lambda do |event, parent, children|
             prediction = 'Alt(S => A T .)[0, 4]'
             check_event(event, parent, [:after_subnodes, prediction])
             expect(children.size).to eq(2)
             check_legs(['Alt(S => A T .)[0, 4]', 10]) # 2 * 5
-          },
-          ->(evt, itm) {
-            check_event(evt, itm, [:after_alternative, 'Alt(S => A T .)[0, 4]'])
-          }, 
-          ->(event, parent, children) {
+          end,
+          lambda do |event, item|
+            check_event(event, item, [:after_alternative, 'Alt(S => A T .)[0, 4]'])
+          end,
+          lambda do |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) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:after_non_terminal, 'S[0, 4]'])
-          },          
-          ->(event, parent, children) {
+          end,
+          lambda do |event, parent, children|
             check_event(event, parent, [:after_subnodes, 'Phi[0, 4]'])
             expect(children.size).to eq(1)
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:after_non_terminal, 'Phi[0, 4]'])
-          },
-          ->(event, item) {
+          end,
+          lambda do |event, item|
             check_event(event, item, [:after_pforest, grm_sppf_pforest1])
-          }
+          end
         ]
         subject.start
       end