rley 0.7.03 → 0.7.08

data/spec/rley/parser/parse_entry_set_spec.rb

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

data/spec/rley/parser/parse_entry_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../spec_helper'
 
 require_relative '../../../lib/rley/syntax/terminal'
@@ -50,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
@@ -89,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
@@ -118,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)
@@ -129,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
@@ -149,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)
@@ -171,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)
@@ -196,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'
@@ -207,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../spec_helper'
 
 require_relative '../../../lib/rley/syntax/terminal'
@@ -61,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)
@@ -79,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
@@ -99,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)
@@ -110,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_tracer_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../spec_helper'
 require 'stringio'
 
@@ -14,7 +16,7 @@ require_relative '../../../lib/rley/parser/parse_tracer'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Parser # Open this namespace to avoid module qualifier prefixes
     describe ParseTracer do
-      let(:output) { StringIO.new('', 'w') }
+      let(:output) { StringIO.new(+'', 'w') }
       let(:tpos) { Lexical::Position.new(3, 4) }
 
       let(:token_seq) do
@@ -82,7 +84,7 @@ SNIPPET
 
         it 'should render a scanning step' do
           # Case: token at the beginning
-          subject.ostream.string = ''
+          subject.ostream.string = +''
           subject.trace_scanning(1, parse_state(0, dotted_rule))
           expectations = <<-SNIPPET
 |[------]      .      .      .      .      .| [0:1] sentence => A B . C
@@ -90,7 +92,7 @@ SNIPPET
           expect(output.string).to eq(expectations)
 
           # Case: token in the middle
-          subject.ostream.string = ''
+          subject.ostream.string = +''
           subject.trace_scanning(4, sample_parse_state)
           expectations = <<-SNIPPET
 |.      .      .      [------]      .      .| [3:4] sentence => A B . C
@@ -98,7 +100,7 @@ SNIPPET
           expect(output.string).to eq(expectations)
 
           # Case: token at the end
-          subject.ostream.string = ''
+          subject.ostream.string = +''
           subject.trace_scanning(6, parse_state(5, dotted_rule))
           expectations = <<-SNIPPET
 |.      .      .      .      .      [------]| [5:6] sentence => A B . C
@@ -109,7 +111,7 @@ SNIPPET
 
         it 'should render a prediction step' do
           # Case: initial stateset
-          subject.ostream.string = ''
+          subject.ostream.string = +''
           subject.trace_prediction(0, parse_state(0, dotted_rule))
           expectations = <<-SNIPPET
 |>      .      .      .      .      .      .| [0:0] sentence => A B . C
@@ -117,7 +119,7 @@ SNIPPET
           expect(output.string).to eq(expectations)
 
           # Case: stateset in the middle
-          subject.ostream.string = ''
+          subject.ostream.string = +''
           subject.trace_prediction(3, sample_parse_state)
           expectations = <<-SNIPPET
 |.      .      .      >      .      .      .| [3:3] sentence => A B . C
@@ -125,7 +127,7 @@ SNIPPET
           expect(output.string).to eq(expectations)
 
           # Case: final stateset
-          subject.ostream.string = ''
+          subject.ostream.string = +''
           subject.trace_prediction(6, parse_state(6, dotted_rule))
           expectations = <<-SNIPPET
 |.      .      .      .      .      .      >| [6:6] sentence => A B . C
@@ -135,7 +137,7 @@ SNIPPET
 
         it 'should render a completion step' do
           # Case: full parse completed
-          subject.ostream.string = ''
+          subject.ostream.string = +''
           subject.trace_completion(6, parse_state(0, complete_rule))
           expectations = <<-SNIPPET
 |[=========================================]| [0:6] sentence => A B C .
@@ -143,7 +145,7 @@ SNIPPET
           expect(output.string).to eq(expectations)
 
           # Case: step at the start (complete)
-          subject.ostream.string = ''
+          subject.ostream.string = +''
           subject.trace_completion(1, parse_state(0, complete_rule))
           expectations = <<-SNIPPET
 |[------]      .      .      .      .      .| [0:1] sentence => A B C .
@@ -151,7 +153,7 @@ SNIPPET
           expect(output.string).to eq(expectations)
 
           # Case: step at the start (not complete)
-          subject.ostream.string = ''
+          subject.ostream.string = +''
           subject.trace_completion(1, parse_state(0, dotted_rule))
           expectations = <<-SNIPPET
 |[------>      .      .      .      .      .| [0:1] sentence => A B . C
@@ -159,7 +161,7 @@ SNIPPET
           expect(output.string).to eq(expectations)
 
           # Case: step at the middle (complete)
-          subject.ostream.string = ''
+          subject.ostream.string = +''
           subject.trace_completion(4, parse_state(2, complete_rule))
           expectations = <<-SNIPPET
 |.      .      [-------------]      .      .| [2:4] sentence => A B C .
@@ -167,7 +169,7 @@ SNIPPET
           expect(output.string).to eq(expectations)
 
           # Case: step at the middle (not complete)
-          subject.ostream.string = ''
+          subject.ostream.string = +''
           subject.trace_completion(4, parse_state(2, dotted_rule))
           expectations = <<-SNIPPET
 |.      .      [------------->      .      .| [2:4] sentence => A B . C
@@ -175,7 +177,7 @@ SNIPPET
           expect(output.string).to eq(expectations)
 
           # Case: step at the end (complete)
-          subject.ostream.string = ''
+          subject.ostream.string = +''
           subject.trace_completion(6, parse_state(3, complete_rule))
           expectations = <<-SNIPPET
 |.      .      .      [--------------------]| [3:6] sentence => A B C .
@@ -183,7 +185,7 @@ SNIPPET
           expect(output.string).to eq(expectations)
 
           # Case: step at the end (not complete)
-          subject.ostream.string = ''
+          subject.ostream.string = +''
           subject.trace_completion(6, parse_state(3, dotted_rule))
           expectations = <<-SNIPPET
 |.      .      .      [-------------------->| [3:6] sentence => A B . C

data/spec/rley/parser/parse_walker_factory_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../spec_helper'
 
 require_relative '../../../lib/rley/syntax/grammar_builder'
@@ -45,13 +47,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # contains a hidden left recursion and a cycle
           builder = Syntax::GrammarBuilder.new do
             add_terminals('a', 'b')
-            rule'Phi' => 'S'
-            rule'S' => %w[A T]
-            rule'S' => %w[a T]
-            rule'A' => 'a'
-            rule'A' => %w[B A]
-            rule'B' => []
-            rule'T' => %w[b b b]
+            rule 'Phi' => 'S'
+            rule 'S' => %w[A T]
+            rule 'S' => %w[a T]
+            rule 'A' => 'a'
+            rule 'A' => %w[B A]
+            rule 'B' => []
+            rule 'T' => %w[b b b]
           end
           builder.grammar
       end
@@ -301,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../spec_helper'
 
 require_relative '../../../lib/rley/parser/parse_state'
@@ -17,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
@@ -31,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
@@ -71,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