rley 0.7.07 → 0.7.08

data/spec/rley/parse_rep/parse_forest_factory_spec.rb

@@ -25,12 +25,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           builder = Syntax::GrammarBuilder.new do
             add_terminals('a', 'b')
             rule 'Phi' => 'S'
-            rule 'S' => %w[A T]
-            rule 'S' => %w[a T]
+            rule 'S' => 'A T'
+            rule 'S' => 'a T'
             rule 'A' => 'a'
-            rule 'A' => %w[B A]
+            rule 'A' => 'B A'
             rule 'B' => []
-            rule 'T' => %w[b b b]
+            rule 'T' => 'b b b'
           end
           builder.grammar
       end
@@ -49,11 +49,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
 
       # Emit a text representation of the current path.
-      def path_to_s()
+      def path_to_s
         text_parts = subject.curr_path.map do |path_element|
           path_element.to_string(0)
         end
-        return text_parts.join('/')
+        text_parts.join('/')
       end
 
       context 'Initialization:' do

data/spec/rley/parse_rep/parse_tree_factory_spec.rb

@@ -38,11 +38,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
 
       # Emit a text representation of the current path.
-      def path_to_s()
+      def path_to_s
         text_parts = subject.curr_path.map do |path_element|
           path_element.to_string(0)
         end
-        return text_parts.join('/')
+        text_parts.join('/')
       end
 
 

data/spec/rley/parse_tree_visitor_spec.rb

@@ -11,7 +11,7 @@ require_relative './support/grammar_sppf_helper'
 require_relative '../../lib/rley/parse_tree_visitor'
 
 module Rley # Open this namespace to avoid module qualifier prefixes
-  describe ParseTreeVisitor do    
+  describe ParseTreeVisitor do
     let(:grammar_abc) do
       sandbox = Object.new
       sandbox.extend(GrammarABCHelper)
@@ -45,7 +45,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
     # 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
@@ -161,6 +161,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         subject.end_visit_ptree(grm_abc_ptree1)
       end
 
+      # rubocop: disable Naming/VariableNumber
       it 'should begin the visit when requested' do
         # Reminder: parse tree structure is
         # S[0,5]
@@ -209,11 +210,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         expectations.each do |(msg, args)|
           expect(listener1).to receive(msg).with(*args).ordered
         end
-        
+
         # Here we go...
         subject.start
       end
-      
+
       it 'should also visit in pre-order' do
         # Reminder: parse tree structure is
         # S[0,5]
@@ -228,7 +229,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         root = grm_abc_ptree1.root
         # Here we defeat encapsulation for the good cause
         subject.instance_variable_set(:@traversal, :pre_order)
-        
+
         children = root.subnodes
         big_a_1 = children[0]
         big_a_1_children = big_a_1.subnodes
@@ -239,7 +240,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         expectations = [
           [:before_ptree, [grm_abc_ptree1]]
           # TODO: fix this test
-          # [:before_subnodes, [root, children]],          
+          # [:before_subnodes, [root, children]],
           # [:before_non_terminal, [root]],
 
           # [:before_non_terminal, [big_a_1]],
@@ -267,10 +268,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         expectations.each do |(msg, args)|
           expect(listener1).to receive(msg).with(*args).ordered
         end
-        
+
         # Here we go...
         subject.start
-      end      
+      end
+      # rubocop: enable Naming/VariableNumber
     end # context
   end # describe
 end # module

data/spec/rley/parser/error_reason_spec.rb

@@ -46,8 +46,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       context 'Initialization:' do
         it 'should be created with arguments' do
-          expect do 
-            ExpectationNotMet.new(3, err_token, terminals) 
+          expect do
+            ExpectationNotMet.new(3, err_token, terminals)
           end.not_to raise_error
         end
 
@@ -75,8 +75,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       context 'Initialization:' do
         it 'should be created with arguments' do
-          expect do 
-            UnexpectedToken.new(3, err_token, terminals) 
+          expect do
+            UnexpectedToken.new(3, err_token, terminals)
           end.not_to raise_error
         end
       end # context
@@ -107,8 +107,8 @@ MESSAGE_END
 
       context 'Initialization:' do
         it 'should be created with arguments' do
-          expect do 
-            PrematureInputEnd.new(3, err_token, terminals) 
+          expect do
+            PrematureInputEnd.new(3, err_token, terminals)
           end.not_to raise_error
         end
       end # context

data/spec/rley/parser/gfg_earley_parser_spec.rb

@@ -71,7 +71,7 @@ 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()
+      def grm2_tokens
         input_sequence = [
           { '2' => 'integer' },
           '+',
@@ -79,7 +79,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           '*',
           { '4' => 'integer' }
         ]
-        return build_token_sequence(input_sequence, grammar_expr)
+        build_token_sequence(input_sequence, grammar_expr)
       end
 
       # Default instantiation rule
@@ -104,6 +104,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end # context
 
       context 'Parsing: ' do
+        # rubocop: disable Naming/VariableNumber
         it 'should parse a valid simple input' do
           parse_result = subject.parse(grm1_tokens)
           expect(parse_result.success?).to eq(true)
@@ -183,6 +184,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(entry_set_5.entries.size).to eq(4)
           compare_entry_texts(entry_set_5, expected)
         end
+        # rubocop: enable Naming/VariableNumber
 
         it 'should parse a valid simple expression' do
           instance = GFGEarleyParser.new(grammar_expr)

data/spec/rley/parser/gfg_parsing_spec.rb

@@ -95,14 +95,14 @@ SNIPPET
 
       context 'Parsing:' do
         # Utility method to fill the first entry set...
-        def fill_first_set()
+        def fill_first_set
           subject.start_rule(subject.initial_entry, 0)
           subject.call_rule(subject.chart[0].last, 0)
           subject.start_rule(subject.chart[0].last, 0)
         end
 
         # Utility method to initialize the second entry set...
-        def seed_second_set()
+        def seed_second_set
           # Cheating: we change the tokens to scan...
           # Seeding second entry set...
           subject.scan_rule(0, grm1_token_b[0])
@@ -301,8 +301,8 @@ SNIPPET
         it 'should give a text representation of itself' do
           repr = subject.to_s
           expect(repr).to match(/^success\? true/)
-          
-          # Let's test the last chart state only          
+
+          # Let's test the last chart state only
           expectation = <<REPR
 State[5]
   T => integer . | 4
@@ -338,10 +338,6 @@ REPR
         it 'should indicate whether a parse succeeded' do
           expect(subject.success?).to be_truthy
         end
-
-        it 'should build a parse forest' do
-          expect { subject.parse_forest }.not_to raise_error if subject.success?
-        end
       end # context
     end # describe
   end # module

data/spec/rley/parser/parse_entry_spec.rb

@@ -52,7 +52,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should know the origin value' do
           expect(subject.origin).to eq(origin_val)
         end
-        
+
         it 'should have not antecedent at creation' do
           expect(subject.antecedents).to be_empty
           expect(subject).to be_orphan
@@ -91,13 +91,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           instance = ParseEntry.new(GFG::EndVertex.new('NT.'), 3)
           expect(instance).to be_end_entry
         end
-        
+
         it 'should know if the entry is a dotted item vertex' do
           expect(subject).not_to be_dotted_entry
 
           instance = ParseEntry.new(GFG::ItemVertex.new('P => S.'), 3)
           expect(instance).to be_dotted_entry
-        end             
+        end
 
         it 'should know if the vertex is at end of production (if any)' do
           # Case: start vertex
@@ -120,7 +120,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           instance4 = ParseEntry.new(v2, 3)
           expect(instance4).to be_exit_entry
         end
-        
+
         it 'should know if the vertex is at begin of production (if any)' do
           # Case: start vertex
           instance1 = ParseEntry.new(GFG::StartVertex.new('.NT'), 3)
@@ -131,17 +131,17 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(instance2).not_to be_entry_entry
 
           # Case: item vertex not at begin of rhs
-          d1 = Base::DottedItem.new(sample_prod, 1)          
+          d1 = Base::DottedItem.new(sample_prod, 1)
           v1 = GFG::ItemVertex.new(d1)
           instance3 = ParseEntry.new(v1, 3)
           expect(instance3).not_to be_entry_entry
 
           # Case: item vertex at end of rhs
-          d2 = Base::DottedItem.new(sample_prod, 0)          
-          v2 = GFG::ItemVertex.new(d2)          
+          d2 = Base::DottedItem.new(sample_prod, 0)
+          v2 = GFG::ItemVertex.new(d2)
           instance4 = ParseEntry.new(v2, 3)
           expect(instance4).to be_entry_entry
-        end 
+        end
 
         it 'should know the symbol before the dot (if any)' do
           # Case: start vertex
@@ -151,20 +151,20 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # Case: end vertex
           instance2 = ParseEntry.new(GFG::EndVertex.new('NT.'), 3)
           expect(instance2.prev_symbol).to be_nil # Really correct?
-          
+
           # Case: item vertex not at start of rhs
           v1 = double('vertex-not-at-start')
           expect(v1).to receive(:prev_symbol).and_return('symbol')
           instance3 = ParseEntry.new(v1, 3)
-          expect(instance3.prev_symbol).to eq('symbol') 
+          expect(instance3.prev_symbol).to eq('symbol')
 
           # Case: item vertex at start of rhs
           v2 = double('vertex-at-start')
           expect(v2).to receive(:prev_symbol).and_return(nil)
           instance4 = ParseEntry.new(v2, 0)
-          expect(instance4.prev_symbol).to be_nil          
+          expect(instance4.prev_symbol).to be_nil
         end
-        
+
         it 'should know the next expected symbol (if any)' do
           # Case: start vertex
           instance1 = ParseEntry.new(GFG::StartVertex.new('.NT'), 3)
@@ -173,19 +173,19 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # Case: end vertex
           instance2 = ParseEntry.new(GFG::EndVertex.new('NT.'), 3)
           expect(instance2.next_symbol).to be_nil
-          
+
           # Case: item vertex not at end of rhs
           v1 = double('vertex-not-at-end')
           expect(v1).to receive(:next_symbol).and_return('symbol')
           instance3 = ParseEntry.new(v1, 3)
-          expect(instance3.next_symbol).to eq('symbol') 
+          expect(instance3.next_symbol).to eq('symbol')
 
           # Case: item vertex at end of rhs
           v2 = double('vertex-at-end')
           expect(v2).to receive(:next_symbol).and_return(nil)
           instance4 = ParseEntry.new(v2, 3)
-          expect(instance4.next_symbol).to be_nil          
-        end  
+          expect(instance4.next_symbol).to be_nil
+        end
 
         it 'should accept antecedents' do
           antecedent = ParseEntry.new(vertex2, origin_val)
@@ -198,7 +198,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expected = '.sentence | 3'
           expect(subject.to_s).to eq(expected)
         end
-        
+
         it 'should be inspectable' do
           subject.add_antecedent(subject) # Cheat for the good cause...
           # expected = '.sentence | 3'
@@ -209,8 +209,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           pattern2 = /@origin=3 @antecedents=\[/
           expect(subject.inspect).to match(pattern2)
           suffix = /<Rley::GFG::StartVertex:\d+ label=\.sentence> @origin=3\]>$/
-          expect(subject.inspect).to match(suffix)          
-        end        
+          expect(subject.inspect).to match(suffix)
+        end
       end # context
     end # describe
   end # module

data/spec/rley/parser/parse_state_spec.rb

@@ -63,7 +63,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           item = Base::DottedItem.new(aProd, aRank)
           ParseState.new(item, aVal)
         end
-        
+
         it 'should compare with itself' do
           synonym = subject # Fool Rubocop
           expect(subject == synonym).to eq(true)
@@ -81,14 +81,14 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           diff_rule = ParseState.new(other_dotted_rule, 3)
           expect(subject == diff_rule).to eq(false)
         end
-        
+
         it 'should know if the parsing is at the start of the production' do
           expect(subject).not_to be_predicted
           at_start = Base::DottedItem.new(sample_prod, 0)
 
           instance = ParseState.new(at_start, 0)
           expect(instance).to be_predicted
-        end        
+        end
 
         it 'should know if the parsing reached the end of the production' do
           expect(subject).not_to be_complete
@@ -101,7 +101,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should know the next expected symbol' do
           expect(subject.next_symbol).to eq(t_c)
         end
-        
+
         it 'should know whether another instance follows this one' do
           expect(subject.precedes?(subject)).to eq(false)
           state1 = new_parse_state(sample_prod, 1, origin_val)
@@ -112,7 +112,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           state3 = new_parse_state(sample_prod, 3, origin_val)
           expect(state3.precedes?(state0)).to eq(false)
         end
-        
+
         it 'should know its text representation' do
           expected = 'sentence => A B . C | 3'
           expect(subject.to_s).to eq(expected)

data/spec/rley/parser/parse_walker_factory_spec.rb

@@ -303,7 +303,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           event18 = walker.next
           expectations = [:revisit, 'T. | 1', 4]
           event_expectations(event18, expectations)
-          
+
           # Lazy walk: make start entry .T the current one
           # Multiple visit occurred: jump to antecedent of start entry
           event19 = walker.next

data/spec/rley/parser/state_set_spec.rb

@@ -19,7 +19,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should be created without argument' do
           expect { StateSet.new }.not_to raise_error
         end
-        
+
         it 'should be empty at creation' do
           expect(subject.states).to be_empty
         end
@@ -33,19 +33,19 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           subject.push_state(state2)
           expect(subject.states).to eq([state1, state2])
         end
-        
+
         it 'should ignore a second push of a state' do
           expect(subject.states).to be_empty
           subject.push_state(state1)
           subject.push_state(state2)
           expect(subject.states).to eq([state1, state2])
-          
+
           # One tries to push an already pushed state
           expect(subject.push_state(state1)).to be_falsy
-          
+
           # ...It is not added
-          expect(subject.states).to eq([state1, state2])          
-        end        
+          expect(subject.states).to eq([state1, state2])
+        end
 
         it 'should list the states expecting a given terminal' do
           # Case of no state
@@ -73,52 +73,52 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(dotted_rule2).to receive(:production).and_return(a_prod)
           expect(subject.states_for(a_prod)).to eq([state2])
         end
-        
+
         it 'should list the states that rewrite a given non-terminal' do
           non_term = double('fake-non-terminal')
           prod1 = double('fake-production1')
           prod2 = double('fake-production2')
-        
+
           # Adding states
           subject.push_state(state1)
           subject.push_state(state2)
           expect(dotted_rule1).to receive(:production).and_return(prod1)
-          expect(prod1).to receive(:lhs).and_return(:dummy)          
+          expect(prod1).to receive(:lhs).and_return(:dummy)
           expect(dotted_rule2).to receive(:production).and_return(prod2)
           expect(dotted_rule2).to receive(:reduce_item?).and_return(true)
-          expect(prod2).to receive(:lhs).and_return(non_term) 
+          expect(prod2).to receive(:lhs).and_return(non_term)
           expect(subject.states_rewriting(non_term)).to eq([state2])
         end
-        
+
         it 'should list of ambiguous states' do
           prod1 = double('fake-production1')
           prod2 = double('fake-production2')
           expect(subject.ambiguities.size).to eq(0)
-          
+
           # Adding states
           subject.push_state(state1)
           allow(dotted_rule1).to receive(:production).and_return(prod1)
-          allow(dotted_rule1).to receive(:"reduce_item?").and_return(true)
-          allow(dotted_rule1).to receive(:lhs).and_return(:something)     
+          allow(dotted_rule1).to receive(:reduce_item?).and_return(true)
+          allow(dotted_rule1).to receive(:lhs).and_return(:something)
           expect(subject.ambiguities.size).to eq(0)
           allow(dotted_rule2).to receive(:production).and_return(prod2)
-          allow(dotted_rule2).to receive(:"reduce_item?").and_return(true)
-          allow(dotted_rule2).to receive(:lhs).and_return(:something_else)  
+          allow(dotted_rule2).to receive(:reduce_item?).and_return(true)
+          allow(dotted_rule2).to receive(:lhs).and_return(:something_else)
           subject.push_state(state2)
           expect(subject.ambiguities.size).to eq(0)
           dotted_rule3 = double('fake_dotted_rule3')
           allow(dotted_rule3).to receive(:production).and_return(prod2)
-          allow(dotted_rule3).to receive(:"reduce_item?").and_return(true)
-          allow(dotted_rule3).to receive(:lhs).and_return(:something_else)  
+          allow(dotted_rule3).to receive(:reduce_item?).and_return(true)
+          allow(dotted_rule3).to receive(:lhs).and_return(:something_else)
           state3 = ParseState.new(dotted_rule3, 5)
-          subject.push_state(state3) 
-          expect(subject.ambiguities[0]).to eq([state2, state3])          
+          subject.push_state(state3)
+          expect(subject.ambiguities[0]).to eq([state2, state3])
         end
-        
+
         it 'should complain when impossible predecessor of parse state' do
           subject.push_state(state1)
           subject.push_state(state2)
-          expect(dotted_rule1).to receive(:prev_position).and_return(nil) 
+          expect(dotted_rule1).to receive(:prev_position).and_return(nil)
           err = StandardError
           expect { subject.predecessor_state(state1) }.to raise_error(err)
         end