rley 0.3.01 → 0.3.04

data/spec/rley/gfg/start_vertex_spec.rb

@@ -15,7 +15,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
 
         it 'should know its label' do
-          allow(sample_nt).to receive(:to_s).and_return('NT')
+          expect(sample_nt).to receive(:to_s).and_return('NT')
           expect(subject.label).to eq('.NT')
         end
       end # context

data/spec/rley/parse_forest_visitor_spec.rb

@@ -224,7 +224,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           [:after_pforest, [grm_abc_pforest1]]
         ]
         expectations.each do |(msg, args)|
-          allow(listener1).to receive(msg).with(*args).ordered
+          expect(listener1).to receive(msg).with(*args).ordered
         end
         
         # Here we go...

data/spec/rley/parse_tree_visitor_spec.rb

@@ -206,7 +206,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           [:after_ptree, [grm_abc_ptree1]]
         ]
         expectations.each do |(msg, args)|
-          allow(listener1).to receive(msg).with(*args).ordered
+          expect(listener1).to receive(msg).with(*args).ordered
         end
         
         # Here we go...

data/spec/rley/parser/gfg_parsing_spec.rb

@@ -317,12 +317,9 @@ SNIPPET
           parser.parse(tokens)
         end
 
-        # Helper. Build a state tracker and a parse tree builder.
-        def prepare_parse_forest(aParsing)
-          # Accessing private methods by sending message
-          entry_tracker = aParsing.send(:new_entry_tracker)
-          builder = aParsing.send(:forest_builder, entry_tracker.entry_set_index)
-          return [entry_tracker, builder]
+        it 'should build a parse forest' do
+          expect{subject.parse_forest }.not_to raise_error
+          
         end
 =begin
         it 'should create the root of a parse forest' do

data/spec/rley/parser/parse_entry_set_spec.rb

@@ -99,19 +99,19 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
           # Adding states
           subject.push_entry(entry1)
-          allow(vertex1).to receive(:production).and_return(prod1)
-          allow(vertex1).to receive(:"reduce_item?").and_return(true)
-          allow(vertex1).to receive(:lhs).and_return(:something)
+          expect(vertex1).to receive(:production).and_return(prod1)
+          expect(vertex1).to receive(:"reduce_item?").and_return(true)
+          expect(vertex1).to receive(:lhs).and_return(:something)
           expect(subject.ambiguities.size).to eq(0)
-          allow(vertex2).to receive(:production).and_return(prod2)
-          allow(vertex2).to receive(:"reduce_item?").and_return(true)
-          allow(vertex2).to receive(:lhs).and_return(:something_else)
+          expect(vertex2).to receive(:production).and_return(prod2)
+          expect(vertex2).to receive(:"reduce_item?").and_return(true)
+          expect(vertex2).to receive(:lhs).and_return(:something_else)
           subject.push_entry(entry2)
           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)
+          # expect(dotted_rule3).to receive(:production).and_return(prod2)
+          # expect(dotted_rule3).to receive(:"reduce_item?").and_return(true)
+          # expect(dotted_rule3).to receive(:lhs).and_return(:something_else)
           # entry3 = ParseEntry.new(dotted_rule3, 5)
           subject.push_entry(entry3)
           expect(subject.ambiguities[0]).to eq([entry2, entry3])
@@ -125,8 +125,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # Adding states
           subject.push_entry(entry1)
           subject.push_entry(entry2)
-          allow(vertex1).to receive(:next_symbol).and_return(:b)
-          allow(vertex2).to receive(:next_symbol).and_return(:a)
+          expect(vertex1).to receive(:next_symbol).and_return(:b)
+          expect(vertex2).to receive(:next_symbol).and_return(:a)
           expect(subject.states_expecting(:a)).to eq([entry2])
           expect(subject.states_expecting(:b)).to eq([entry1])
         end
@@ -140,8 +140,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # Adding states
           subject.push_entry(entry1)
           subject.push_entry(entry2)
-          allow(vertex1).to receive(:production).and_return(:dummy)
-          allow(vertex2).to receive(:production).and_return(a_prod)
+          expect(vertex1).to receive(:production).and_return(:dummy)
+          expect(vertex2).to receive(:production).and_return(a_prod)
           expect(subject.states_for(a_prod)).to eq([entry2])
         end
 
@@ -153,11 +153,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # Adding states
           subject.push_entry(entry1)
           subject.push_entry(entry2)
-          allow(vertex1).to receive(:production).and_return(prod1)
-          allow(prod1).to receive(:lhs).and_return(:dummy)
-          allow(vertex2).to receive(:production).and_return(prod2)
-          allow(vertex2).to receive(:reduce_item?).and_return(true)
-          allow(prod2).to receive(:lhs).and_return(non_term)
+          expect(vertex1).to receive(:production).and_return(prod1)
+          expect(prod1).to receive(:lhs).and_return(:dummy)
+          expect(vertex2).to receive(:production).and_return(prod2)
+          expect(vertex2).to receive(:reduce_item?).and_return(true)
+          expect(prod2).to receive(:lhs).and_return(non_term)
           expect(subject.states_rewriting(non_term)).to eq([entry2])
         end
 
@@ -166,7 +166,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should complain when impossible predecessor of parse state' do
           subject.push_entry(entry1)
           subject.push_entry(entry2)
-          allow(vertex1).to receive(:prev_position).and_return(nil)
+          expect(vertex1).to receive(:prev_position).and_return(nil)
           err = StandardError
           expect { subject.predecessor_state(entry1) }.to raise_error(err)
         end

data/spec/rley/parser/parse_entry_spec.rb

@@ -110,13 +110,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
           # Case: item vertex not at end of rhs
           v1 = double('vertex-not-at-end')
-          allow(v1).to receive(:complete?).and_return(false)
+          expect(v1).to receive(:complete?).and_return(false)
           instance3 = ParseEntry.new(v1, 3)
           expect(instance3).not_to be_exit_entry
 
           # Case: item vertex at end of rhs
           v2 = double('vertex-at-end')
-          allow(v2).to receive(:complete?).and_return(true)
+          expect(v2).to receive(:complete?).and_return(true)
           instance4 = ParseEntry.new(v2, 3)
           expect(instance4).to be_exit_entry
         end
@@ -154,13 +154,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           
           # Case: item vertex not at start of rhs
           v1 = double('vertex-not-at-start')
-          allow(v1).to receive(:prev_symbol).and_return('symbol')
+          expect(v1).to receive(:prev_symbol).and_return('symbol')
           instance3 = ParseEntry.new(v1, 3)
           expect(instance3.prev_symbol).to eq('symbol') 
 
           # Case: item vertex at start of rhs
           v2 = double('vertex-at-start')
-          allow(v2).to receive(:prev_symbol).and_return(nil)
+          expect(v2).to receive(:prev_symbol).and_return(nil)
           instance4 = ParseEntry.new(v2, 0)
           expect(instance4.prev_symbol).to be_nil          
         end
@@ -176,13 +176,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           
           # Case: item vertex not at end of rhs
           v1 = double('vertex-not-at-end')
-          allow(v1).to receive(:next_symbol).and_return('symbol')
+          expect(v1).to receive(:next_symbol).and_return('symbol')
           instance3 = ParseEntry.new(v1, 3)
           expect(instance3.next_symbol).to eq('symbol') 
 
           # Case: item vertex at end of rhs
           v2 = double('vertex-at-end')
-          allow(v2).to receive(:next_symbol).and_return(nil)
+          expect(v2).to receive(:next_symbol).and_return(nil)
           instance4 = ParseEntry.new(v2, 3)
           expect(instance4.next_symbol).to be_nil          
         end