rley 0.3.04 → 0.3.05

data/lib/rley/syntax/symbol_seq.rb

@@ -23,7 +23,7 @@ module Rley # This module is used as a namespace
           when Array then result = other == members
           else
             msg = "Cannot compare a SymbolSeq with a #{other.class}"
-            fail StandardError, msg
+            raise StandardError, msg
         end
 
         return result

data/spec/rley/gfg/call_edge_spec.rb

@@ -1,51 +1,50 @@
-require_relative '../../spec_helper'
-
-require_relative '../../../lib/rley/syntax/terminal'
-require_relative '../../../lib/rley/syntax/non_terminal'
-require_relative '../../../lib/rley/syntax/production'
-require_relative '../../../lib/rley/parser/dotted_item'
-require_relative '../../../lib/rley/gfg/start_vertex'
-require_relative '../../../lib/rley/gfg/item_vertex'
-
-# Load the class under test
-require_relative '../../../lib/rley/gfg/call_edge'
-
-module Rley # Open this namespace to avoid module qualifier prefixes
-  module GFG # Open this namespace to avoid module qualifier prefixes
-    describe CallEdge do
-      # Factory method. Builds a production with given left-hand side (LHS)
-      # and given RHS (right-hand side)
-      def build_prod(theLHS, *theRHSSymbols)
-        return Syntax::Production.new(theLHS, theRHSSymbols)
-      end
-
-      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_sentence) { Rley::Syntax::NonTerminal.new('sentence') }
-      let(:nt_b_sequence) { Rley::Syntax::NonTerminal.new('b_sequence') }
-      let(:sample_prod) { build_prod(nt_sentence, t_a, nt_b_sequence, t_c) }
-      let(:sample_item) { Parser::DottedItem.new(sample_prod, 1) }    
-
-      let(:vertex1) { ItemVertex.new(sample_item) }
-      let(:vertex2) { StartVertex.new('to') }
-      subject { CallEdge.new(vertex1, vertex2) }
-
-      context 'Initialization:' do
-        it 'should be created with two vertice arguments' do
-          expect { CallEdge.new(vertex1, vertex2) }.not_to raise_error
-        end
-      end # context
-      
-      
-      context 'Provided services:' do
-        it 'should know its key' do
-          expectation = "CALL_#{sample_prod.object_id}_#{sample_item.position}"
-          expect(subject.key).to eq(expectation)
-        end
-      end # context      
-    end # describe
-  end # module
-end # module
-
-# End of file
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/rley/syntax/terminal'
+require_relative '../../../lib/rley/syntax/non_terminal'
+require_relative '../../../lib/rley/syntax/production'
+require_relative '../../../lib/rley/parser/dotted_item'
+require_relative '../../../lib/rley/gfg/start_vertex'
+require_relative '../../../lib/rley/gfg/item_vertex'
+
+# Load the class under test
+require_relative '../../../lib/rley/gfg/call_edge'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module GFG # Open this namespace to avoid module qualifier prefixes
+    describe CallEdge do
+      # Factory method. Builds a production with given left-hand side (LHS)
+      # and given RHS (right-hand side)
+      def build_prod(theLHS, *theRHSSymbols)
+        return Syntax::Production.new(theLHS, theRHSSymbols)
+      end
+
+      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_sentence) { Rley::Syntax::NonTerminal.new('sentence') }
+      let(:nt_b_sequence) { Rley::Syntax::NonTerminal.new('b_sequence') }
+      let(:sample_prod) { build_prod(nt_sentence, t_a, nt_b_sequence, t_c) }
+      let(:sample_item) { Parser::DottedItem.new(sample_prod, 1) }
+
+      let(:vertex1) { ItemVertex.new(sample_item) }
+      let(:vertex2) { StartVertex.new('to') }
+      subject { CallEdge.new(vertex1, vertex2) }
+
+      context 'Initialization:' do
+        it 'should be created with two vertice arguments' do
+          expect { CallEdge.new(vertex1, vertex2) }.not_to raise_error
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should know its key' do
+          expectation = "CALL_#{sample_prod.object_id}_#{sample_item.position}"
+          expect(subject.key).to eq(expectation)
+        end
+      end # context
+    end # describe
+  end # module
+end # module
+
+# End of file

data/spec/rley/gfg/edge_spec.rb

@@ -1,33 +1,33 @@
-require_relative '../../spec_helper'
-
-require_relative '../../../lib/rley/gfg/start_vertex'
-require_relative '../../../lib/rley/gfg/end_vertex'
-
-# Load the class under test
-require_relative '../../../lib/rley/gfg/edge'
-
-module Rley # Open this namespace to avoid module qualifier prefixes
-  module GFG # Open this namespace to avoid module qualifier prefixes
-    describe Edge do
-      let(:vertex1) { StartVertex.new('from') }
-      let(:vertex2) { StartVertex.new('to') }
-      subject { Edge.new(vertex1, vertex2) }
-
-      context 'Initialization:' do
-        it 'should be created with two vertice arguments' do
-          expect { Edge.new(vertex1, vertex2) }.not_to raise_error
-        end
-        
-        it 'should be registered by the predecessor vertex' do
-          expect(subject).to eq(vertex1.edges.last)
-        end
-        
-        it 'should know the successor vertex' do
-          expect(subject.successor).to eq(vertex2)
-        end
-      end # context
-    end # describe
-  end # module
-end # module
-
-# End of file
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/rley/gfg/start_vertex'
+require_relative '../../../lib/rley/gfg/end_vertex'
+
+# Load the class under test
+require_relative '../../../lib/rley/gfg/edge'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module GFG # Open this namespace to avoid module qualifier prefixes
+    describe Edge do
+      let(:vertex1) { StartVertex.new('from') }
+      let(:vertex2) { StartVertex.new('to') }
+      subject { Edge.new(vertex1, vertex2) }
+
+      context 'Initialization:' do
+        it 'should be created with two vertice arguments' do
+          expect { Edge.new(vertex1, vertex2) }.not_to raise_error
+        end
+
+        it 'should be registered by the predecessor vertex' do
+          expect(subject).to eq(vertex1.edges.last)
+        end
+
+        it 'should know the successor vertex' do
+          expect(subject.successor).to eq(vertex2)
+        end
+      end # context
+    end # describe
+  end # module
+end # module
+
+# End of file

data/spec/rley/gfg/end_vertex_spec.rb

@@ -1,27 +1,26 @@
-require_relative '../../spec_helper'
-
-# Load the class under test
-require_relative '../../../lib/rley/gfg/end_vertex'
-
-module Rley # Open this namespace to avoid module qualifier prefixes
-  module GFG # Open this namespace to avoid module qualifier prefixes
-    describe EndVertex do
-      let(:sample_nt) { double('NT') }
-      subject { EndVertex.new(sample_nt) }
-
-      context 'Initialization:' do
-        it 'should be created with a non-terminal symbol' do
-          expect { EndVertex.new(sample_nt) }.not_to raise_error
-        end
-
-        it 'should know its label' do
-          expect(sample_nt).to receive(:to_s).and_return('NT')
-          expect(subject.label).to eq('NT.')
-        end
-        
-      end # context
-    end # describe
-  end # module
-end # module
-
-# End of file
+require_relative '../../spec_helper'
+
+# Load the class under test
+require_relative '../../../lib/rley/gfg/end_vertex'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module GFG # Open this namespace to avoid module qualifier prefixes
+    describe EndVertex do
+      let(:sample_nt) { double('NT') }
+      subject { EndVertex.new(sample_nt) }
+
+      context 'Initialization:' do
+        it 'should be created with a non-terminal symbol' do
+          expect { EndVertex.new(sample_nt) }.not_to raise_error
+        end
+
+        it 'should know its label' do
+          expect(sample_nt).to receive(:to_s).and_return('NT')
+          expect(subject.label).to eq('NT.')
+        end
+      end # context
+    end # describe
+  end # module
+end # module
+
+# End of file

data/spec/rley/gfg/epsilon_edge_spec.rb

@@ -1,25 +1,25 @@
-require_relative '../../spec_helper'
-
-require_relative '../../../lib/rley/gfg/start_vertex'
-require_relative '../../../lib/rley/gfg/end_vertex'
-
-# Load the class under test
-require_relative '../../../lib/rley/gfg/epsilon_edge'
-
-module Rley # Open this namespace to avoid module qualifier prefixes
-  module GFG # Open this namespace to avoid module qualifier prefixes
-    describe Edge do
-      let(:vertex1) { StartVertex.new('from') }
-      let(:vertex2) { StartVertex.new('to') }
-      subject { EpsilonEdge.new(vertex1, vertex2) }
-
-      context 'Initialization:' do
-        it 'should be created with two vertice arguments' do
-          expect { EpsilonEdge.new(vertex1, vertex2) }.not_to raise_error
-        end
-      end # context
-    end # describe
-  end # module
-end # module
-
-# End of file
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/rley/gfg/start_vertex'
+require_relative '../../../lib/rley/gfg/end_vertex'
+
+# Load the class under test
+require_relative '../../../lib/rley/gfg/epsilon_edge'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module GFG # Open this namespace to avoid module qualifier prefixes
+    describe Edge do
+      let(:vertex1) { StartVertex.new('from') }
+      let(:vertex2) { StartVertex.new('to') }
+      subject { EpsilonEdge.new(vertex1, vertex2) }
+
+      context 'Initialization:' do
+        it 'should be created with two vertice arguments' do
+          expect { EpsilonEdge.new(vertex1, vertex2) }.not_to raise_error
+        end
+      end # context
+    end # describe
+  end # module
+end # module
+
+# End of file

data/spec/rley/gfg/grm_flow_graph_spec.rb

@@ -158,4 +158,4 @@ module Rley # Open this namespace to avoid module qualifier prefixes
   end # module
 end # module
 
-# End of file
+# End of file

data/spec/rley/gfg/item_vertex_spec.rb

@@ -11,7 +11,6 @@ require_relative '../../../lib/rley/gfg/item_vertex'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module GFG # Open this namespace to avoid module qualifier prefixes
     describe ItemVertex do
-
       # Factory method. Builds a production with given left-hand side (LHS)
       # and given RHS (right-hand side)
       def build_prod(theLHS, *theRHSSymbols)
@@ -25,8 +24,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:nt_b_sequence) { Rley::Syntax::NonTerminal.new('b_sequence') }
       let(:sample_prod) { build_prod(nt_sentence, t_a, nt_b_sequence, t_c) }
       let(:other_prod) {  build_prod(nt_sentence, t_a) }
-      let(:recursive_prod) {build_prod(nt_b_sequence, nt_b_sequence, t_b )}
-      let(:b_prod) {build_prod(nt_b_sequence, t_b )}
+      let(:recursive_prod) { build_prod(nt_b_sequence, nt_b_sequence, t_b) }
+      let(:b_prod) { build_prod(nt_b_sequence, t_b) }
       let(:empty_prod) { build_prod(nt_sentence) }
       let(:sample_item) { Parser::DottedItem.new(sample_prod, 1) }
       let(:next_item) { Parser::DottedItem.new(sample_prod, 2) }
@@ -88,7 +87,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         
         
         it 'should know the next symbol (if any) in the rhs' do
-          #Case: dot is not penultimate
+          # Case: dot is not penultimate
           expect(subject.next_symbol).to eq(nt_b_sequence)
 
           # Case: dot is penultimate

data/spec/rley/gfg/return_edge_spec.rb

@@ -1,51 +1,51 @@
-require_relative '../../spec_helper'
-
-require_relative '../../../lib/rley/syntax/terminal'
-require_relative '../../../lib/rley/syntax/non_terminal'
-require_relative '../../../lib/rley/syntax/production'
-require_relative '../../../lib/rley/parser/dotted_item'
-require_relative '../../../lib/rley/gfg/end_vertex'
-require_relative '../../../lib/rley/gfg/item_vertex'
-
-# Load the class under test
-require_relative '../../../lib/rley/gfg/return_edge'
-
-module Rley # Open this namespace to avoid module qualifier prefixes
-  module GFG # Open this namespace to avoid module qualifier prefixes
-    describe ReturnEdge do
-      # Factory method. Builds a production with given left-hand side (LHS)
-      # and given RHS (right-hand side)
-      def build_prod(theLHS, *theRHSSymbols)
-        return Syntax::Production.new(theLHS, theRHSSymbols)
-      end
-
-      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_sentence) { Rley::Syntax::NonTerminal.new('sentence') }
-      let(:nt_b_sequence) { Rley::Syntax::NonTerminal.new('b_sequence') }
-      let(:sample_prod) { build_prod(nt_sentence, t_a, nt_b_sequence, t_c) }
-      let(:sample_item) { Parser::DottedItem.new(sample_prod, 1) }    
-
-      let(:vertex1) { EndVertex.new('from') }
-      let(:vertex2) { ItemVertex.new(sample_item) }      
-      subject { ReturnEdge.new(vertex1, vertex2) }
-
-      context 'Initialization:' do
-        it 'should be created with two vertice arguments' do
-          expect { ReturnEdge.new(vertex1, vertex2) }.not_to raise_error
-        end
-      end # context
-      
-      
-      context 'Provided services:' do
-        it 'should know its key' do
-          expectation = "RET_#{sample_prod.object_id}_#{sample_item.position - 1}"
-          expect(subject.key).to eq(expectation)
-        end
-      end # context      
-    end # describe
-  end # module
-end # module
-
-# End of file
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/rley/syntax/terminal'
+require_relative '../../../lib/rley/syntax/non_terminal'
+require_relative '../../../lib/rley/syntax/production'
+require_relative '../../../lib/rley/parser/dotted_item'
+require_relative '../../../lib/rley/gfg/end_vertex'
+require_relative '../../../lib/rley/gfg/item_vertex'
+
+# Load the class under test
+require_relative '../../../lib/rley/gfg/return_edge'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module GFG # Open this namespace to avoid module qualifier prefixes
+    describe ReturnEdge do
+      # Factory method. Builds a production with given left-hand side (LHS)
+      # and given RHS (right-hand side)
+      def build_prod(theLHS, *theRHSSymbols)
+        return Syntax::Production.new(theLHS, theRHSSymbols)
+      end
+
+      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_sentence) { Rley::Syntax::NonTerminal.new('sentence') }
+      let(:nt_b_sequence) { Rley::Syntax::NonTerminal.new('b_sequence') }
+      let(:sample_prod) { build_prod(nt_sentence, t_a, nt_b_sequence, t_c) }
+      let(:sample_item) { Parser::DottedItem.new(sample_prod, 1) }
+
+      let(:vertex1) { EndVertex.new('from') }
+      let(:vertex2) { ItemVertex.new(sample_item) }
+      subject { ReturnEdge.new(vertex1, vertex2) }
+
+      context 'Initialization:' do
+        it 'should be created with two vertice arguments' do
+          expect { ReturnEdge.new(vertex1, vertex2) }.not_to raise_error
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should know its key' do
+          pos = sample_item.position
+          expectation = "RET_#{sample_prod.object_id}_#{pos - 1}"
+          expect(subject.key).to eq(expectation)
+        end
+      end # context
+    end # describe
+  end # module
+end # module
+
+# End of file

data/spec/rley/gfg/scan_edge_spec.rb

@@ -1,30 +1,32 @@
-require_relative '../../spec_helper'
-
-require_relative '../../../lib/rley/gfg/start_vertex'
-require_relative '../../../lib/rley/gfg/end_vertex'
-
-# Load the class under test
-require_relative '../../../lib/rley/gfg/scan_edge'
-
-module Rley # Open this namespace to avoid module qualifier prefixes
-  module GFG # Open this namespace to avoid module qualifier prefixes
-    describe Edge do
-      let(:vertex1) { StartVertex.new('from') }
-      let(:vertex2) { StartVertex.new('to') }
-      let(:sample_terminal) { double('fake-terminal') }
-      subject { ScanEdge.new(vertex1, vertex2, sample_terminal) }
-
-      context 'Initialization:' do
-        it 'should be created with two vertice arguments & a terminal' do
-          expect { ScanEdge.new(vertex1, vertex2, sample_terminal) }.not_to raise_error
-        end
-        
-        it 'should know the related terminal' do
-          expect(subject.terminal).to eq(sample_terminal)
-        end
-      end # context
-    end # describe
-  end # module
-end # module
-
-# End of file
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/rley/gfg/start_vertex'
+require_relative '../../../lib/rley/gfg/end_vertex'
+
+# Load the class under test
+require_relative '../../../lib/rley/gfg/scan_edge'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module GFG # Open this namespace to avoid module qualifier prefixes
+    describe Edge do
+      let(:vertex1) { StartVertex.new('from') }
+      let(:vertex2) { StartVertex.new('to') }
+      let(:sample_terminal) { double('fake-terminal') }
+      subject { ScanEdge.new(vertex1, vertex2, sample_terminal) }
+
+      context 'Initialization:' do
+        it 'should be created with two vertice arguments & a terminal' do
+          v1 = vertex1
+          v2 = vertex2
+          expect { ScanEdge.new(v1, v2, sample_terminal) }.not_to raise_error
+        end
+
+        it 'should know the related terminal' do
+          expect(subject.terminal).to eq(sample_terminal)
+        end
+      end # context
+    end # describe
+  end # module
+end # module
+
+# End of file