rley 0.7.03 → 0.7.08

data/spec/rley/gfg/return_edge_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../spec_helper'
 
 require_relative '../../../lib/rley/syntax/terminal'

data/spec/rley/gfg/scan_edge_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../spec_helper'
 
 require_relative '../../../lib/rley/gfg/start_vertex'

data/spec/rley/gfg/shortcut_edge_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../spec_helper'
 require_relative '../../../lib/rley/syntax/non_terminal'
 
@@ -25,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../spec_helper'
 require_relative '../../../lib/rley/syntax/non_terminal'
 
@@ -20,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../spec_helper'
 
 # Load the class under test
@@ -22,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
@@ -38,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../spec_helper'
 
 # Load the class under test
@@ -25,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)
@@ -59,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
 
@@ -117,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../spec_helper'
 
 require_relative '../../../lib/rley/syntax/terminal'
@@ -27,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../spec_helper'
 
 require_relative './support/grammar_helper'
@@ -96,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)
@@ -123,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>>]
@@ -159,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