rley 0.3.04 → 0.3.05

data/spec/rley/parser/dotted_item_spec.rb

@@ -126,7 +126,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           
           # Case: different productions
           instance = DottedItem.new(empty_prod, 0)
-          expect(subject).not_to be_successor_of(subject)
+          expect(subject).not_to be_successor_of(instance)
 
           # Case: one position difference
           instance = DottedItem.new(sample_prod, 0)

data/spec/rley/parser/earley_parser_spec.rb

@@ -220,8 +220,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           ######################
           # Expectation chart[5]:
           expected = [
-            "A => 'a' A 'c' . | 0",  # scan from S(4) 1
-            'S => A . | 0'  # complete from 0 and S(0) 0
+            "A => 'a' A 'c' . | 0", # scan from S(4) 1
+            'S => A . | 0' # complete from 0 and S(0) 0
           ]
           state_set_5 = parse_result.chart[5]
           expect(state_set_5.states.size).to eq(2)
@@ -325,7 +325,7 @@ SNIPPET
           ###################### S(5): 2 + 3 * 4 .
           # Expectation chart[5]:
           expected = [
-            'T => integer . | 4',    # scan from S(4) 2
+            'T => integer . | 4',   # scan from S(4) 2
             "M => M '*' T . | 2",   # complete from (1) and S(4) 1
             "S => S '+' M . | 0",   # complete from (2) and S(2) 1
             "M => M . '*' T | 2",   # complete from (2) and S(2) 2
@@ -357,14 +357,14 @@ SNIPPET
             "Ss => . A A 'x' | 0",  # Start rule
             'A => . | 0',           # predict from (1)
             "Ss => A . A 'x' | 0",  # modified predict from (1)
-            "Ss => A A . 'x' | 0",  # modified predict from (1)
+            "Ss => A A . 'x' | 0"   # modified predict from (1)
           ]
           compare_state_texts(parse_result.chart[0], expected)
 
           ###################### S(1): x .
           # Expectation chart[1]:
           expected = [
-            "Ss => A A 'x' . | 0",  # scan from S(0) 4
+            "Ss => A A 'x' . | 0" # scan from S(0) 4
           ]
           compare_state_texts(parse_result.chart[1], expected)
         end
@@ -415,7 +415,7 @@ SNIPPET
           ###################### S(1): 2 . + 3 * 4
           # Expectation chart[1]:
           expected = [
-            'L => integer . | 0',  # scan from S(0) 4
+            'L => integer . | 0', # scan from S(0) 4
             'S => L . | 0',       # complete from (1) and S(0) 4
             'P => S . | 0',       # complete from (2) and S(0) 1
             "S => S . '+' S | 0", # complete from (2) and S(0) 2
@@ -439,7 +439,7 @@ SNIPPET
           expected = [
             'L => integer . | 2', # scan from S(2) 5
             'S => L . | 2',       # complete from (1) and S(2) 4
-            "S => S '+' S . | 0",  # complete from (2) and S(2) 1
+            "S => S '+' S . | 0", # complete from (2) and S(2) 1
             "S => S . '+' S | 2", # complete from (2) and S(2) 2
             "S => S . '*' S | 2", # complete from (2) and S(2) 3
             'P => S . | 0',       # complete from (2) and S(0) 1
@@ -649,15 +649,15 @@ MSG
           ###################### S(1) == a . a / a
           # Expectation chart[1]:
           expected = [
-            "F => 'a' . | 0", # scan from S(0) 4
-            'E => F . | 0',   # complete from (1) and S(0) 3
-            'Z => E . | 0',   # complete from (2) and S(0) 1
-            'E => E . Q F | 0',  # complete from (2) and S(0) 2
-            "Q => . '*' | 1",  # Predict from (4)
-            "Q => . '/' | 1",  # Predict from (4)
-            'Q => . | 1',      # Predict from (4)
-            'E => E Q . F | 0',  # Modified predict from (4)
-            "F => . 'a' | 1"   # Predict from (8)
+            "F => 'a' . | 0",   # scan from S(0) 4
+            'E => F . | 0',     # complete from (1) and S(0) 3
+            'Z => E . | 0',     # complete from (2) and S(0) 1
+            'E => E . Q F | 0', # complete from (2) and S(0) 2
+            "Q => . '*' | 1",   # Predict from (4)
+            "Q => . '/' | 1",   # Predict from (4)
+            'Q => . | 1',       # Predict from (4)
+            'E => E Q . F | 0', # Modified predict from (4)
+            "F => . 'a' | 1"    # Predict from (8)
           ]
           compare_state_texts(parse_result.chart[1], expected)
 

data/spec/rley/parser/gfg_earley_parser_spec.rb

@@ -66,11 +66,15 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       # Helper method that mimicks the output of a tokenizer
       # for the language specified by grammar_expr
-      def grm2_tokens()       
-        input_sequence = [ {'2' => 'integer'}, '+', {'3' => 'integer'},
-          '*', {'4' => 'integer'}
+      def grm2_tokens()
+        input_sequence = [
+          { '2' => 'integer' }, 
+          '+', 
+          { '3' => 'integer' },
+          '*', 
+          { '4' => 'integer' }
         ]
-        return  build_token_sequence(input_sequence, grammar_expr)
+        return build_token_sequence(input_sequence, grammar_expr)
       end
 
       # Default instantiation rule
@@ -272,7 +276,7 @@ SNIPPET
             "M => M . '*' T | 2",   # end rule
             'S. | 0',               # exit rule
             'P => S . | 0',         # end rule
-            "S => S . '+' M | 0", # end rule
+            "S => S . '+' M | 0",   # end rule
             'P. | 0'                # exit rule
           ]
           compare_entry_texts(parse_result.chart[3], expected)
@@ -361,12 +365,12 @@ SNIPPET
           builder.add_production('S' => %w(S * S))
           builder.add_production('S' => 'L')
           builder.add_production('L' => 'integer')
-          input_sequence = [ 
-            {'2' => 'integer'},
-            '+', 
-            {'3' => 'integer'}, 
-            '*', 
-            {'4' => 'integer'}
+          input_sequence = [
+            { '2' => 'integer' },
+            '+',
+            { '3' => 'integer' },
+            '*',
+            { '4' => 'integer' }
           ]
           tokens = build_token_sequence(input_sequence, builder.grammar)
           instance = GFGEarleyParser.new(builder.grammar)
@@ -470,7 +474,7 @@ SNIPPET
             'P. | 0'                # exit rule
           ]
           compare_entry_texts(parse_result.chart[5], expected)
-          
+
           expected_antecedents = {
             'L => integer . | 4' => ['L => . integer | 4'],
             'L. | 4' => ['L => integer . | 4'],
@@ -478,14 +482,14 @@ SNIPPET
             'S. | 4' => ['S => L . | 4'],
             "S => S '*' S . | 2" => ['S. | 4'],
             "S => S '*' S . | 0" => ['S. | 4'],
-            "S => S . '+' S | 4" => ['S. | 4'], 
+            "S => S . '+' S | 4" => ['S. | 4'],
             "S => S . '*' S | 4" => ['S. | 4'],
             'S. | 2' => ["S => S '*' S . | 2"],
             'S. | 0' => ["S => S '*' S . | 0", "S => S '+' S . | 0"],
             "S => S '+' S . | 0" => ['S. | 2'],
             "S => S . '+' S | 2" => ['S. | 2'],
             "S => S . '*' S | 2" => ['S. | 2'],
-            'P => S . | 0'  => ['S. | 0'],
+            'P => S . | 0' => ['S. | 0'],
             "S => S . '+' S | 0" => ['S. | 0'],
             "S => S . '*' S | 0" => ['S. | 0'],
             'P. | 0' => ['P => S . | 0']
@@ -518,7 +522,7 @@ SNIPPET
           # Expectation chart[1]:
           expected = [
             'E => id . | 0',      # scan 'abc'
-            'E. | 0',              # exit rule
+            'E. | 0',             # exit rule
             'S => E . | 0',       # end rule
             'E => E . + E | 0',   # end rule
             'S. | 0'              # exit rule
@@ -603,14 +607,14 @@ MSG
           builder.add_terminals(t_int, t_plus, t_lparen, t_rparen)
           builder.add_production('S' => 'E')
           builder.add_production('E' => 'int')
-          builder.add_production('E' => %w[( E + E )])
-          builder.add_production('E' => %w( E + E ))
-          input_sequence = [ 
-            {'7' => 'int'},
-            '+', 
-            {'8' => 'int'}, 
-            '+', 
-            {'9' => 'int'}
+          builder.add_production('E' => %w(( E + E )))
+          builder.add_production('E' => %w(E + E))
+          input_sequence = [
+            { '7' => 'int' },
+            '+',
+            { '8' => 'int' },
+            '+',
+            { '9' => 'int' }
           ]
           tokens = build_token_sequence(input_sequence, builder.grammar)
           instance = GFGEarleyParser.new(builder.grammar)
@@ -644,7 +648,7 @@ MSG
           expected = [
             "E => E '+' . E | 0",         # scan '+'
             '.E | 2',                     # exit rule
-           'E => . int | 2',              # start rule
+            'E => . int | 2',             # start rule
             "E => . '(' E '+' E ')' | 2", # start rule
             "E => . E '+' E | 2"          # start rule
           ]
@@ -718,7 +722,7 @@ MSG
           builder.add_production('Q' => t_star)
           builder.add_production('Q' => t_slash)
           builder.add_production('Q' => []) # Empty production
-          
+
           tokens = build_token_sequence(%w(a a / a), builder.grammar)
           instance = GFGEarleyParser.new(builder.grammar)
           expect { instance.parse(tokens) }.not_to raise_error
@@ -823,9 +827,6 @@ MSG
           # S => ;
           # This grammar requires a time that is quadratic in the number of
           # input tokens
-
-          t_x = Syntax::VerbatimSymbol.new('x')
-
           builder = Syntax::GrammarBuilder.new
           builder.add_terminals('a')
           builder.add_production('S' => %w(a S))
@@ -909,10 +910,8 @@ MSG
           ]
           compare_entry_texts(parse_result.chart[4], expected)
         end
-
       end # context
     end # describe
   end # module
 end # module
-
-# End of module
+# End of file

data/spec/rley/parser/gfg_parsing_spec.rb

@@ -79,8 +79,9 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
 
         it 'should have no antecedence for the initial parse entry' do
-           expect(subject.antecedence.size).to eq(1)
-          expect(subject.antecedence.fetch(subject.initial_entry)).to be_empty
+          antecedence = subject.antecedence
+          expect(antecedence.size).to eq(1)
+          expect(antecedence.fetch(subject.initial_entry)).to be_empty
         end
 
 =begin
@@ -186,7 +187,7 @@ SNIPPET
 
         it 'should apply the scan rule correctly' do
           # Filling manually first entry set...
-          fill_first_set()
+          fill_first_set
           # There are two entries expecting a terminal:
           # ['A => . a A c', 'A => . b']
           fourth_entry = subject.chart[0].entries[3] # 'A => . a A c'
@@ -201,15 +202,16 @@ SNIPPET
           # Entry must be past the terminal symbol
           expect(last_entry.vertex.label).to eq('A => a . A c')
           expect(last_entry.origin).to eq(0)
-          expect(subject.antecedence.fetch(last_entry)).to eq([fourth_entry])          
+          antecedence = subject.antecedence
+          expect(antecedence.fetch(last_entry)).to eq([fourth_entry])          
         end
 
         it 'should apply the exit rule correctly' do
           # Filling manually first entry set...
-          fill_first_set()
+          fill_first_set
 
           # Initial manually first entry set...
-          seed_second_set()
+          seed_second_set
 
           # Given that the scanned token is 'b'...
           # Then a new entry is added in next entry set
@@ -231,10 +233,10 @@ SNIPPET
 
         it 'should apply the end rule correctly' do
           # Filling manually first entry set...
-          fill_first_set()
+          fill_first_set
 
           # Initial manually first entry set...
-          seed_second_set()
+          seed_second_set
           last_entry = subject.chart[1].last
 
           # Given that the scanned token is 'b'...
@@ -290,7 +292,6 @@ SNIPPET
       end # context
 
       context 'Parse forest building:' do
-
         let(:sample_grammar1) do
           builder = grammar_abc_builder
           builder.grammar
@@ -318,7 +319,7 @@ SNIPPET
         end
 
         it 'should build a parse forest' do
-          expect{subject.parse_forest }.not_to raise_error
+          expect { subject.parse_forest }.not_to raise_error
           
         end
 =begin

data/spec/rley/parser/grm_items_builder_spec.rb

@@ -31,7 +31,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             'A => a A . c',
             'A => a A c .',
             'A => . b',
-            'A => b .',
+            'A => b .'
           ]
           expect(items.map(&:to_s)).to eq(expectations)
         end
@@ -40,4 +40,4 @@ module Rley # Open this namespace to avoid module qualifier prefixes
   end # module
 end # module
 
-# End of file
+# End of file

data/spec/rley/parser/parse_entry_set_spec.rb

@@ -20,10 +20,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:t_a) { Rley::Syntax::Terminal.new('a') }
       let(:t_b) { Rley::Syntax::Terminal.new('b') }
       let(:t_c) { Rley::Syntax::Terminal.new('c') }
-      let(:nt_repeated_c) { Rley::Syntax::NonTerminal.new('Repetition') }
-      let(:repeated_prod) { build_prod(nt_repeated_c, t_c, nt_repeated_c) }
+      let(:nt_rep_c) { Rley::Syntax::NonTerminal.new('Repetition') }
+      let(:repeated_prod) { build_prod(nt_rep_c, t_c, nt_rep_c) }
       let(:nt_sentence) { Rley::Syntax::NonTerminal.new('Sentence') }
-      let(:sample_prod) { build_prod(nt_sentence, t_a, t_b, t_b, nt_repeated_c) }
+      let(:sample_prod) { build_prod(nt_sentence, t_a, t_b, t_b, nt_rep_c) }
 
       let(:sample_item1) { Parser::DottedItem.new(sample_prod, 1) }
       let(:sample_item2) { Parser::DottedItem.new(sample_prod, 2) }
@@ -88,7 +88,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should list the entries expecting a given non-terminal' do
           # Case: an entry expecting a non-terminal
           subject.push_entry(entry3)
-          expect(subject.entries4n_term(nt_repeated_c)).to eq([entry3])
+          expect(subject.entries4n_term(nt_rep_c)).to eq([entry3])
         end
 
 =begin

data/spec/rley/parser/parse_entry_spec.rb

@@ -11,7 +11,6 @@ require_relative '../../../lib/rley/parser/parse_entry'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Parser # Open this namespace to avoid module qualifier prefixes
     describe ParseEntry do
-
       let(:t_a) { Syntax::Terminal.new('A') }
       let(:t_b) { Syntax::Terminal.new('B') }
       let(:t_c) { Syntax::Terminal.new('C') }
@@ -25,7 +24,6 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         Syntax::Production.new(nt_sentence, [])
       end
 
-
       let(:dotted_rule) { DottedItem.new(sample_prod, 2) }
       let(:origin_val) { 3 }
       let(:vertex_faked) { double('fake-vertex') }

data/spec/rley/parser/parse_forest_builder_spec.rb

@@ -5,7 +5,7 @@ require_relative '../../../lib/rley/parser/parse_walker_factory'
 
 require_relative '../support/grammar_helper'
 require_relative '../support/expectation_helper'
-require_relative '../support/grammar_L0_helper'
+require_relative '../support/grammar_l0_helper'
 
 # Load the class under test
 require_relative '../../../lib/rley/parser/parse_forest_builder'
@@ -23,13 +23,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # contains a hidden left recursion and a cycle
           builder = Syntax::GrammarBuilder.new
           builder.add_terminals('a', 'b')
-          builder.add_production('Phi' => %'S')
-          builder.add_production('S' => %w[A T])
-          builder.add_production('S' => %w[a T])
+          builder.add_production('Phi' => 'S')
+          builder.add_production('S' => %w(A T))
+          builder.add_production('S' => %w(a T))
           builder.add_production('A' => 'a')
-          builder.add_production('A' => %w[B A])
+          builder.add_production('A' => %w(B A))
           builder.add_production('B' => [])
-          builder.add_production('T' => %w( b b b))
+          builder.add_production('T' => %w(b b b))
           builder.grammar
       end
 
@@ -53,7 +53,9 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       # Emit a text representation of the current path.
       def path_to_s()
-        text_parts = subject.curr_path.map { |path_element|  path_element.to_string(0) }
+        text_parts = subject.curr_path.map do |path_element|
+          path_element.to_string(0)
+        end
         return text_parts.join('/')
       end
 
@@ -70,10 +72,9 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should have an empty path' do
           expect(subject.curr_path).to be_empty
         end
-      end
+      end # context
 
       context 'Parse forest construction' do
-
         it 'should initialize the root node' do
           first_event = walker.next
           subject.receive_event(*first_event)
@@ -108,7 +109,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           event4 = walker.next
           subject.receive_event(*event4)
 
-          expect(subject.curr_parent.to_string(0)).to eq('Alt(S => a T .)[0, 4]')
+          parent_as_text = subject.curr_parent.to_string(0)
+          expect(parent_as_text).to eq('Alt(S => a T .)[0, 4]')
           expected_path4 = 'Phi[0, 4]/S[0, 4]/Alt(S => a T .)[0, 4]'
           expect(path_to_s).to eq(expected_path4)
           expect(subject.curr_path[-2].refinement).to eq(:or)
@@ -136,7 +138,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(path_to_s).to eq(expected_path6)
           expect(subject.curr_parent.subnodes.size).to eq(1)
           token_event6 = 'b[3, 4]'
-          expect(subject.curr_parent.subnodes.first.to_string(0)).to eq(token_event6)
+          child = subject.curr_parent.subnodes.first
+          expect(child.to_string(0)).to eq(token_event6)
 
           event7 = walker.next
           subject.receive_event(*event7)
@@ -146,7 +149,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(path_to_s).to eq(expected_path7)
           expect(subject.curr_parent.subnodes.size).to eq(2)
           token_event7 = 'b[2, 3]'
-          expect(subject.curr_parent.subnodes.first.to_string(0)).to eq(token_event7)
+          child = subject.curr_parent.subnodes.first
+          expect(child.to_string(0)).to eq(token_event7)
 
           event8 = walker.next
           subject.receive_event(*event8)
@@ -156,7 +160,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(path_to_s).to eq(expected_path8)
           expect(subject.curr_parent.subnodes.size).to eq(3)
           token_event8 = 'b[1, 2]'
-          expect(subject.curr_parent.subnodes.first.to_string(0)).to eq(token_event8)
+          child = subject.curr_parent.subnodes.first
+          expect(child.to_string(0)).to eq(token_event8)
 
           event9 = walker.next
           subject.receive_event(*event9)
@@ -168,19 +173,22 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           event10 = walker.next
           subject.receive_event(*event10)
           expect(event10[1].to_s).to eq('.T | 1')
-          expect(subject.curr_parent.to_string(0)).to eq('Alt(S => a T .)[0, 4]')
+          parent_as_text = subject.curr_parent.to_string(0)
+          expect(parent_as_text).to eq('Alt(S => a T .)[0, 4]')
           expected_path10 = 'Phi[0, 4]/S[0, 4]/Alt(S => a T .)[0, 4]'
           expect(path_to_s).to eq(expected_path10)
 
           event11 = walker.next
           subject.receive_event(*event11)
           expect(event11[1].to_s).to eq('S => a . T | 0')
-          expect(subject.curr_parent.to_string(0)).to eq('Alt(S => a T .)[0, 4]')
+          parent_as_text = subject.curr_parent.to_string(0)
+          expect(parent_as_text).to eq('Alt(S => a T .)[0, 4]')
           expected_path11 = 'Phi[0, 4]/S[0, 4]/Alt(S => a T .)[0, 4]'
           expect(path_to_s).to eq(expected_path11)
           expect(subject.curr_parent.subnodes.size).to eq(2)
           token_event11 = 'a[0, 1]'
-          expect(subject.curr_parent.subnodes.first.to_string(0)).to eq(token_event11)
+          child = subject.curr_parent.subnodes.first
+          expect(child.to_string(0)).to eq(token_event11)
 
           event12 = walker.next
           subject.receive_event(*event12)
@@ -219,7 +227,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
           event16 = walker.next
           subject.receive_event(*event16)
-          expect(event16[0]).to eq(:backtrack)  # Backtrack event!
+          expect(event16[0]).to eq(:backtrack) # Backtrack event!
           expect(event16[1].to_s).to eq('S. | 0')
           expect(subject.curr_parent.to_string(0)).to eq('S[0, 4]')
           expected_path16 = 'Phi[0, 4]/S[0, 4]'
@@ -229,7 +237,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           event17 = walker.next
           subject.receive_event(*event17)
           expect(event17[1].to_s).to eq('S => A T . | 0')
-          expect(subject.curr_parent.to_string(0)).to eq('Alt(S => A T .)[0, 4]')
+          parent_as_text = subject.curr_parent.to_string(0)
+          expect(parent_as_text).to eq('Alt(S => A T .)[0, 4]')
           expected_path17 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]'
           expect(path_to_s).to eq(expected_path17)
           expect(subject.curr_path[-2].refinement).to eq(:or)
@@ -243,16 +252,18 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
           event18 = walker.next
           subject.receive_event(*event18)
-          expect(event18[0]).to eq(:revisit)  # Revisit event!
+          expect(event18[0]).to eq(:revisit) # Revisit event!
           expect(event18[1].to_s).to eq('T. | 1')
-          expect(subject.curr_parent.to_string(0)).to eq('Alt(S => A T .)[0, 4]')
+          parent_as_text = subject.curr_parent.to_string(0)
+          expect(parent_as_text).to eq('Alt(S => A T .)[0, 4]')
           expected_path18 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]'
           expect(path_to_s).to eq(expected_path18)
 
           event19 = walker.next
           subject.receive_event(*event19)
           expect(event19[1].to_s).to eq('S => A . T | 0')
-          expect(subject.curr_parent.to_string(0)).to eq('Alt(S => A T .)[0, 4]')
+          parent_as_text = subject.curr_parent.to_string(0)
+          expect(parent_as_text).to eq('Alt(S => A T .)[0, 4]')
           expected_path19 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]'
           expect(path_to_s).to eq(expected_path19)
 
@@ -268,8 +279,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           event21 = walker.next
           subject.receive_event(*event21)
           expect(event21[1].to_s).to eq('A => a . | 0')
-          expect(subject.curr_parent.to_string(0)).to eq('Alt(A => a .)[0, 1]')
-          expected_path21 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]/A[0, 1]/Alt(A => a .)[0, 1]'
+          parent_as_text = subject.curr_parent.to_string(0)
+          expect(parent_as_text).to eq('Alt(A => a .)[0, 1]')
+          path_prefix = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]/A[0, 1]/'
+          expected_path21 = path_prefix + 'Alt(A => a .)[0, 1]'
           expect(path_to_s).to eq(expected_path21)
           expect(subject.curr_path[-2].refinement).to eq(:or)
 
@@ -283,7 +296,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           event23 = walker.next
           subject.receive_event(*event23)
           expect(event23[1].to_s).to eq('.A | 0')
-          expect(subject.curr_parent.to_string(0)).to eq('Alt(S => A T .)[0, 4]')
+          parent_as_text = subject.curr_parent.to_string(0)
+          expect(parent_as_text).to eq('Alt(S => A T .)[0, 4]')
           expected_path23 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]'
           expect(path_to_s).to eq(expected_path23)
 
@@ -318,7 +332,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
           event27 = walker.next
           subject.receive_event(*event27)
-          expect(event27[0]).to eq(:backtrack)  # Backtrack event!
+          expect(event27[0]).to eq(:backtrack) # Backtrack event!
           expect(event27[1].to_s).to eq('A. | 0')
           expect(subject.curr_parent.to_string(0)).to eq('A[0, 1]')
           expected_path27 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]/A[0, 1]'
@@ -328,24 +342,28 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           subject.receive_event(*event28)
           expect(event28[0]).to eq(:visit)
           expect(event28[1].to_s).to eq('A => B A . | 0')
-          expect(subject.curr_parent.to_string(0)).to eq('Alt(A => B A .)[0, 1]')
-          expected_path28 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]/A[0, 1]/Alt(A => B A .)[0, 1]'
+          parent_as_text = subject.curr_parent.to_string(0)
+          expect(parent_as_text).to eq('Alt(A => B A .)[0, 1]')
+          path_prefix = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]/A[0, 1]/'
+          expected_path28 = path_prefix + 'Alt(A => B A .)[0, 1]'
           expect(path_to_s).to eq(expected_path28)
 
           event29 = walker.next
           subject.receive_event(*event29)
-          expect(event29[0]).to eq(:revisit)  # Revisit event!
+          expect(event29[0]).to eq(:revisit) # Revisit event!
           expect(event29[1].to_s).to eq('A. | 0')
-          expect(subject.curr_parent.to_string(0)).to eq('Alt(A => B A .)[0, 1]')
-          expected_path29 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]/A[0, 1]/Alt(A => B A .)[0, 1]'
+          parent_as_text = subject.curr_parent.to_string(0)
+          expect(parent_as_text).to eq('Alt(A => B A .)[0, 1]')
+          expected_path29 = path_prefix + 'Alt(A => B A .)[0, 1]'
           expect(path_to_s).to eq(expected_path29)
 
           event30 = walker.next
           subject.receive_event(*event30)
           expect(event30[0]).to eq(:visit)
           expect(event30[1].to_s).to eq('A => B . A | 0')
-          expect(subject.curr_parent.to_string(0)).to eq('Alt(A => B A .)[0, 1]')
-          expected_path30 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]/A[0, 1]/Alt(A => B A .)[0, 1]'
+          parent_as_text = subject.curr_parent.to_string(0)
+          expect(parent_as_text).to eq('Alt(A => B A .)[0, 1]')
+          expected_path30 = path_prefix + 'Alt(A => B A .)[0, 1]'
           expect(path_to_s).to eq(expected_path30)
 
           event31 = walker.next
@@ -353,7 +371,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(event31[0]).to eq(:visit)
           expect(event31[1].to_s).to eq('B. | 0')
           expect(subject.curr_parent.to_string(0)).to eq('B[0, 0]')
-          expected_path31 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]/A[0, 1]/Alt(A => B A .)[0, 1]/B[0, 0]'
+          expected_path31 = path_prefix + 'Alt(A => B A .)[0, 1]/B[0, 0]'
           expect(path_to_s).to eq(expected_path31)
 
           event32 = walker.next
@@ -362,15 +380,16 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # Empty production!
           expect(event32[1].to_s).to eq('B => . | 0')
           expect(subject.curr_parent.to_string(0)).to eq('B[0, 0]')
-          expected_path30 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]/A[0, 1]/Alt(A => B A .)[0, 1]/B[0, 0]'
+          expected_path30 = path_prefix + 'Alt(A => B A .)[0, 1]/B[0, 0]'
           expect(path_to_s).to eq(expected_path30)
 
           event33 = walker.next
           subject.receive_event(*event33)
           expect(event33[0]).to eq(:visit)
           expect(event33[1].to_s).to eq('.B | 0')
-          expect(subject.curr_parent.to_string(0)).to eq('Alt(A => B A .)[0, 1]')
-          expected_path33 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]/A[0, 1]/Alt(A => B A .)[0, 1]'
+          parent_as_text = subject.curr_parent.to_string(0)
+          expect(parent_as_text).to eq('Alt(A => B A .)[0, 1]')
+          expected_path33 = path_prefix + 'Alt(A => B A .)[0, 1]'
           expect(path_to_s).to eq(expected_path33)
 
           event34 = walker.next
@@ -378,14 +397,15 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(event34[0]).to eq(:visit)
           expect(event34[1].to_s).to eq('A => . B A | 0')
           expect(subject.curr_parent.to_string(0)).to eq('A[0, 1]')
-          expected_path34 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]/A[0, 1]'
-          expect(path_to_s).to eq(expected_path34)
+          path34 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]/A[0, 1]'
+          expect(path_to_s).to eq(path34)
 
           event35 = walker.next
           subject.receive_event(*event35)
           expect(event35[0]).to eq(:revisit)
           expect(event35[1].to_s).to eq('.A | 0')
-          expect(subject.curr_parent.to_string(0)).to eq('Alt(S => A T .)[0, 4]')
+          parent_as_text = subject.curr_parent.to_string(0)
+          expect(parent_as_text).to eq('Alt(S => A T .)[0, 4]')
           expected_path35 = 'Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]'
           expect(path_to_s).to eq(expected_path35)
 
@@ -410,18 +430,18 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       context 'Natural language processing' do
         include GrammarL0Helper
 
-        let(:grammar_L0) do
-          builder = grammar_L0_builder
+        let(:grammar_l0) do
+          builder = grammar_l0_builder
           builder.grammar
         end
 
         let(:sentence_tokens) do
           sentence = 'I prefer a morning flight'
-          tokenizer_L0(sentence, grammar_L0)
+          tokenizer_l0(sentence, grammar_l0)
         end
 
         let(:sentence_result) do
-          parser = Parser::GFGEarleyParser.new(grammar_L0)
+          parser = Parser::GFGEarleyParser.new(grammar_l0)
           parser.parse(sentence_tokens)
         end
 
@@ -500,7 +520,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(path_to_s).to eq(expected_path8)
           expect(subject.curr_parent.subnodes.size).to eq(1)
           token_event8 = 'Noun[4, 5]'
-          expect(subject.curr_parent.subnodes.first.to_string(0)).to eq(token_event8)
+          child = subject.curr_parent.subnodes.first
+          expect(child.to_string(0)).to eq(token_event8)
 
           event9 = walker.next
           subject.receive_event(*event9)
@@ -515,27 +536,28 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(event10[0]).to eq(:visit)
           expect(event10[1].to_s).to eq('Nominal. | 3')
           expect(subject.curr_parent.to_string(0)).to eq('Nominal[3, 4]')
-          expected_path10 = 'S[0, 5]/VP[1, 5]/NP[2, 5]/Nominal[3, 5]/Nominal[3, 4]'
-          expect(path_to_s).to eq(expected_path10)
+          path10 = 'S[0, 5]/VP[1, 5]/NP[2, 5]/Nominal[3, 5]/Nominal[3, 4]'
+          expect(path_to_s).to eq(path10)
 
           event11 = walker.next
           subject.receive_event(*event11)
           expect(event11[0]).to eq(:visit)
           expect(event11[1].to_s).to eq('Nominal => Noun . | 3')
           expect(subject.curr_parent.to_string(0)).to eq('Nominal[3, 4]')
-          expected_path11 = 'S[0, 5]/VP[1, 5]/NP[2, 5]/Nominal[3, 5]/Nominal[3, 4]'
-          expect(path_to_s).to eq(expected_path11)
+          path11 = 'S[0, 5]/VP[1, 5]/NP[2, 5]/Nominal[3, 5]/Nominal[3, 4]'
+          expect(path_to_s).to eq(path11)
           expect(subject.curr_parent.subnodes.size).to eq(1)
           token_event11 = 'Noun[3, 4]'
-          expect(subject.curr_parent.subnodes.first.to_string(0)).to eq(token_event11)
+          child = subject.curr_parent.subnodes.first
+          expect(child.to_string(0)).to eq(token_event11)
 
           event12 = walker.next
           subject.receive_event(*event12)
           expect(event12[0]).to eq(:visit)
           expect(event12[1].to_s).to eq('Nominal => . Noun | 3')
           expect(subject.curr_parent.to_string(0)).to eq('Nominal[3, 4]')
-          expected_path12 = 'S[0, 5]/VP[1, 5]/NP[2, 5]/Nominal[3, 5]/Nominal[3, 4]'
-          expect(path_to_s).to eq(expected_path12)
+          path12 = 'S[0, 5]/VP[1, 5]/NP[2, 5]/Nominal[3, 5]/Nominal[3, 4]'
+          expect(path_to_s).to eq(path12)
 
           event13 = walker.next
           subject.receive_event(*event13)
@@ -569,7 +591,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expected_path16 = 'S[0, 5]/VP[1, 5]/NP[2, 5]'
           expect(path_to_s).to eq(expected_path16)
           token_event16 = 'Determiner[2, 3]'
-          expect(subject.curr_parent.subnodes.first.to_string(0)).to eq(token_event16)
+          child = subject.curr_parent.subnodes.first
+          expect(child.to_string(0)).to eq(token_event16)
 
           event17 = walker.next
           subject.receive_event(*event17)
@@ -595,7 +618,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expected_path19 = 'S[0, 5]/VP[1, 5]'
           expect(path_to_s).to eq(expected_path19)
           token_event19 = 'Verb[1, 2]'
-          expect(subject.curr_parent.subnodes.first.to_string(0)).to eq(token_event19)
+          child = subject.curr_parent.subnodes.first
+          expect(child.to_string(0)).to eq(token_event19)
 
           event20 = walker.next
           subject.receive_event(*event20)
@@ -637,8 +661,9 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expected_path24 = 'S[0, 5]/NP[0, 1]'
           expect(path_to_s).to eq(expected_path24)
           token_event24 = 'Pronoun[0, 1]'
-          expect(subject.curr_parent.subnodes.first.to_string(0)).to eq(token_event24)           
-          
+          child = subject.curr_parent.subnodes.first
+          expect(child.to_string(0)).to eq(token_event24)
+
           event25 = walker.next
           subject.receive_event(*event25)
           expect(event25[0]).to eq(:visit)
@@ -668,10 +693,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(event28[0]).to eq(:visit)
           expect(event28[1].to_s).to eq('.S | 0')
           expected_path28 = ''
-          expect(path_to_s).to eq(expected_path28)           
+          expect(path_to_s).to eq(expected_path28)
         end
       end # context
     end # describe
   end # module
 end # module
-# End of file
+# End of file