rley 0.3.01 → 0.3.04

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a668b1310cdd11c57771b1c26a85418a129f4c7c
-  data.tar.gz: 81e9d24b519700e79b508e72c9f8ada5b24d04a0
+  metadata.gz: 4c5e18168fe007f5fb819f2df4f1f1944bae971d
+  data.tar.gz: ccb8abe6ea9d8d135a0fc896ebfa4dbf5fe6f674
 SHA512:
-  metadata.gz: 0ed6712c6dcfaf69b5e445fee8694917bb50a93a0bf6fff05931146453f6c129bee9166b128227d0ddfe7798347f97989def511e379d34f185a83290d8feee38
-  data.tar.gz: e83de687d95f2622163e91265feee3d560da37f769a7b6176a4ba73b8b4874b2458a3539d96b67eb909961eee62ba180c71a37ced9e97146942f2c1a5ff87b7e
+  metadata.gz: d2eab437aba2c78676529651cca3a0a1fd9cf0b23f14f7003bf631add424a50295a14ddc1065e63db907c3003a415ae1c20427a1d6594243f5724a25203f248b
+  data.tar.gz: 4fc6fa566e1f8c847dd34a862e27d73d7dc758bfcd557e84343b41951f6f52dd2993d0be4d92c60ec40241887065021ca006ef4b96dd1e609264b9976da6a433

data/CHANGELOG.md

@@ -1,7 +1,21 @@
+### 0.3.04 / 2016-11-01
+* [FIX] File `state_set_spec.rb` : Failing mock tests. Reverted `expect` to `allow` expectations.
+
+### 0.3.03 / 2016-11-01
+* [FIX] File `parse_forest_factory_spec.rb`: Commented out reference to local files.
+* [FIX] Files `*_spec.rb` : Replaced most `allow` expectations by `expect`
+* [CHANGE] Updated development dependency upon RSpec version 3.5
+
+### 0.3.02 / 2016-11-01
+* [FIX] Method `ParseWalkerFactory#visit_entry` didn't generate events for entries with start vertex. This caused issue in parse forest generation.
+* [NEW] File `parse_forest_builder_spec.rb`: added more parse forest building tests.
+* [CHANGE] Method `ParseWalkerFactory#antecedent_of`. Code refactoring.
+* [CHANGE] Method `ParseForestBuilder#receive_event`. Code refactoring.
+
 ### 0.3.01 / 2016-10-23
-* [CHANGED] Method `ParseWalkerFactory#build_walker`. Signature change in order prevent direct dependency on `GFGParsing` class.
-* [CHANGED] Class `ParseForestBuilder`. Removal of `parsing` attribute, no direct dependency on `GFGParsing` class.
-* [CHANGED] Internal changed to `ParseForestFactory` class. 
+* [CHANGE] Method `ParseWalkerFactory#build_walker`. Signature change in order prevent direct dependency on `GFGParsing` class.
+* [CHANGE] Class `ParseForestBuilder`. Removal of `parsing` attribute, no direct dependency on `GFGParsing` class.
+* [CHANGE] Internal changed to `ParseForestFactory` class. 
 
 ### 0.3.00 / 2016-10-23
 * [CHANGE] Many new classes. The gem bundles a second parser that copes with ambiguous grammars. 

data/Gemfile

@@ -3,7 +3,7 @@ source 'https://rubygems.org'
 
 group :development do
   gem 'rake',  '>= 10.0.0' 
-  gem 'rspec', '>= 3.0.0'
+  gem 'rspec', '>= 3.5.0'
   gem 'simplecov', '>= 0.8.0'
   gem 'coveralls', '>= 0.7.0'
 end

data/examples/parsers/parsing_groucho.rb

@@ -1,7 +1,6 @@
 # Purpose: to demonstrate how to parse an emblematic ambiguous sentence
 # Based on example found at: http://www.nltk.org/book_1ed/ch08.html
 
-require 'pp'
 require 'rley'  # Load the gem
 
 # Steps to render a parse tree (of a valid parsed input):
@@ -10,8 +9,7 @@ require 'rley'  # Load the gem
 # 3. Create a parser for that grammar
 # 4. Tokenize the input
 # 5. Let the parser process the input
-# 6. Generate a parse tree from the parse result
-# 7. Render the parse tree (in JSON)
+# 6. Generate a parse forest from the parse result
 
 ########################################
 # Step 1. Define a grammar for a micro English-like language

data/lib/rley/constants.rb

@@ -3,7 +3,7 @@
 
 module Rley # Module used as a namespace
   # The version number of the gem.
-  Version = '0.3.01'
+  Version = '0.3.04'
 
   # Brief description of the gem.
   Description = "Ruby implementation of the Earley's parsing algorithm"

data/lib/rley/parser/gfg_parsing.rb

@@ -1,6 +1,6 @@
 require_relative 'gfg_chart'
 require_relative 'parse_entry_tracker'
-require_relative 'parse_forest_builder'
+require_relative 'parse_forest_factory'
 
 
 module Rley # This module is used as a namespace
@@ -128,33 +128,14 @@ module Rley # This module is used as a namespace
       end
 
 
-=begin
+
       # Factory method. Builds a ParseForest from the parse result.
-      # @return [ParseForest]
-      # Algorithm:
-      # set state_set_index = index of last entry set in chart
-      # Search the completed parse state that corresponds to the full parse
+      # @return [ParseForest]      
       def parse_forest()
-        state_tracker = new_state_tracker
-        builder = forest_builder(state_tracker.state_set_index)
-
-        loop do
-          state_tracker.symbol_on_left
-          # match_symbol = state_tracker.symbol_on_left
-          # puts '--------------------'
-          # puts "Active parse state: #{state_tracker.parse_state}"
-          # puts "Matching symbol: #{match_symbol}"
-          # puts 'Parse tree:'
-          # puts builder.root.to_string(0)
-
-          # Place the symbol on left of the dot in the parse tree
-          done = insert_matched_symbol(state_tracker, builder)
-          break if done
-        end
+        factory = ParseForestFactory.new(self)
 
-        return builder.parse_forest
+        return factory.build_parse_forest
       end
-=end
 
       # Retrieve the very first parse entry added to the chart.
       # This entry corresponds to the start vertex of the GF graph
@@ -171,108 +152,7 @@ module Rley # This module is used as a namespace
         return chart.accepting_entry
       end
 
-=begin
-
-
-
-      # This method is called when a parse entry for chart entry at position
-      # 'pos' expects a terminal as next symbol.
-      # If the input token matches the terminal symbol then:
-      # Retrieve all parse entrys for chart entry at 'aPosition'
-      # that have the given terminal as next symbol.
-      # For each s of the above entrys, push to chart entry aPosition + 1
-      # a new entry like: <next dotted rule, s.origin, aPosition + 1>
-      # In other words, we place the dotted rules in the next entry set
-      # such that the dot appears after terminal.
-      # @param aTerminal [Terminal] a terminal symbol that
-      #   immediately follows a dot
-      # @param aPosition [Fixnum] position in the input token sequence.
-      # @param nextMapping [Proc or Lambda] code to evaluate in order to
-      #   determine the "next" dotted rule for a given one.
-      def scanning(aTerminal, aPosition, &nextMapping)
-        curr_token = tokens[aPosition]
-        return unless curr_token.terminal == aTerminal
-
-        entrys = entrys_expecting(aTerminal, aPosition, false)
-        entrys.each do |s|
-          next_item = nextMapping.call(s.dotted_rule)
-          push_entry(next_item, s.origin, aPosition + 1, :scanning)
-        end
-      end
-
-
-
-      # This method is called when a parse entry at chart entry reaches the end
-      # of a production.
-      # For every entry in chart[aPosition] that is complete
-      #  (i.e. of the form: { dotted_rule: X -> γ •, origin: j}),
-      # Find entrys s in chart[j] of the form
-      #  {dotted_rule: Y -> α • X β, origin: i}
-      #  In other words, rules that predicted the non-terminal X.
-      # For each s, add to chart[aPosition] a entry of the form
-      #  { dotted_rule: Y → α X • β, origin: i})
-      def completion(aState, aPosition, &nextMapping)
-        curr_origin = aState.origin
-        curr_lhs = aState.dotted_rule.lhs
-        entrys = entrys_expecting(curr_lhs, curr_origin, false)
-        entrys.each do |s|
-          next_item = nextMapping.call(s.dotted_rule)
-          push_entry(next_item, s.origin, aPosition, :completion)
-        end
-      end
-
-
-      # The list of ParseState from the chart entry at given position
-      # that expect the given terminal
-      def entrys_expecting(aTerminal, aPosition, toSort)
-        expecting = chart[aPosition].entrys_expecting(aTerminal)
-        return expecting if !toSort || expecting.size < 2
-
-        # Put predicted entrys ahead
-        (predicted, others) = expecting.partition(&:predicted?)
-
-        # Sort entry in reverse order of their origin value
-        [predicted, others].each do |set|
-          set.sort! { |a, b| b.origin <=> a.origin }
-        end
-
-        return predicted + others
-      end
-
-
-
-
-      # Insert in a parse tree the symbol on the left of the
-      # current dotted rule.
-      def insert_matched_symbol(aStateTracker, aBuilder)
-        # Retrieve symbol before the dot in active parse entry
-        match_symbol = aStateTracker.symbol_on_left
 
-        # Retrieve tree node being processed
-        tree_node = aBuilder.current_node
-
-        done = false
-        case [match_symbol.class, tree_node.class]
-          when [Syntax::Terminal, PTree::TerminalNode]
-            aStateTracker.to_prev_entry_set
-            predecessor_entry_terminal(match_symbol, aStateTracker, aBuilder)
-
-          when [NilClass, Rley::PTree::TerminalNode],
-            [NilClass, PTree::NonTerminalNode]
-            # Retrieve all parse entrys that expect the lhs
-            new_entrys = entrys_expecting_lhs(aStateTracker, aBuilder)
-            done = true if new_entrys.empty?
-            # Select an unused parse entry
-            aStateTracker.select_entry(new_entrys)
-
-          when [Syntax::NonTerminal, PTree::NonTerminalNode]
-            completed_entry_for(match_symbol, aStateTracker, aBuilder)
-        end
-
-        done ||= aBuilder.root == aBuilder.current_node
-        return done
-      end
-=end
       private
 
       # Raise an exception to indicate a syntax error.
@@ -322,61 +202,7 @@ module Rley # This module is used as a namespace
 
         return instance
       end
-=begin
-
-      # A terminal symbol is on the left of dot.
-      # Go to the predecessor entry for the given terminal
-      def predecessor_entry_terminal(_a_symb, aStateTracker, aTreeBuilder)
-        index = aStateTracker.entry_set_index
-        aTreeBuilder.current_node.range = { low: index, high: index + 1 }
-        link_node_to_token(aTreeBuilder, aStateTracker.entry_set_index)
-        unless aTreeBuilder.current_node.is_a?(PTree::TerminalNode)
-          fail StandardError, 'Expected terminal node'
-        end
-        aTreeBuilder.move_back
-        entry_set = chart[aStateTracker.entry_set_index]
-        previous_entry = entry_set.predecessor_entry(aStateTracker.parse_entry)
-        aStateTracker.parse_entry = previous_entry
-      end
-
-
-      # Retrieve a complete entry with given terminal symbol as lhs.
-      def completed_entry_for(a_symb, aTracker, aTreeBuilder)
-        new_entrys = chart[aTracker.entry_set_index].entrys_rewriting(a_symb)
-        aTracker.select_entry(new_entrys)
-        aTreeBuilder.range = { high: aTracker.entry_set_index }
-        aTreeBuilder.use_complete_entry(aTracker.parse_entry)
-        link_node_to_token(aTreeBuilder, aTracker.entry_set_index - 1)
-        aTreeBuilder.move_down
-      end
-
-
-      def entrys_expecting_lhs(aStateTracker, aTreeBuilder)
-        lhs = aStateTracker.curr_dotted_item.production.lhs
-        new_entrys = entrys_expecting(lhs, aStateTracker.entry_set_index, true)
-        new_entrys.reject! { |st| st == aStateTracker.parse_entry }
-        # Filter out parse entrys with incompatible range
-        if new_entrys.size > 1
-          previous_node = aTreeBuilder.current_path[-3]
-          new_entrys.select! do |parse_entry|
-            parse_entry.dotted_rule.production.lhs == previous_node.symbol
-          end
-        end
-
-        return new_entrys
-      end
-
-      # If the current node is a terminal node
-      # then link the token to that node
-      def link_node_to_token(aTreeBuilder, aStateSetIndex)
-        return unless aTreeBuilder.current_node.is_a?(PTree::TerminalNode)
-        return unless aTreeBuilder.current_node.token.nil?
-
-        a_node = aTreeBuilder.current_node
-        a_node.token = tokens[aStateSetIndex] unless a_node.token
-      end
 
-=end
     end # class
   end # module
 end # module

data/lib/rley/parser/parse_forest_builder.rb

@@ -1,3 +1,8 @@
+require_relative '../syntax/terminal'
+require_relative '../syntax/non_terminal'
+require_relative '../gfg/end_vertex'
+require_relative '../gfg/item_vertex'
+require_relative '../gfg/start_vertex'
 require_relative '../sppf/epsilon_node'
 require_relative '../sppf/non_terminal_node'
 require_relative '../sppf/alternative_node'
@@ -9,7 +14,7 @@ module Rley # This module is used as a namespace
     # (say, a parse forest) from simpler objects (terminal and non-terminal
     # nodes) and using a step by step approach.
     class ParseForestBuilder
-      # The sequence of input tokens  
+      # The sequence of input tokens
       attr_reader(:tokens)
 
       # Link to forest object
@@ -18,6 +23,9 @@ module Rley # This module is used as a namespace
       # Link to current path
       attr_reader(:curr_path)
 
+      # The last parse entry visited
+      attr_reader(:last_visitee)
+
       # A hash with pairs of the form: visited parse entry => forest node
       attr_reader(:entry2node)
 
@@ -34,18 +42,17 @@ module Rley # This module is used as a namespace
 
       def receive_event(anEvent, anEntry, anIndex)
         # puts "Event: #{anEvent} #{anEntry} #{anIndex}"
-        case anEntry.vertex
-          when GFG::StartVertex
-            process_start_entry(anEvent, anEntry, anIndex)
-
-          when GFG::ItemVertex
-            process_item_entry(anEvent, anEntry, anIndex)
-
-          when GFG::EndVertex
-            process_end_entry(anEvent, anEntry, anIndex)
-          else
-            fail NotImplementedError
+        if anEntry.dotted_entry?
+          process_item_entry(anEvent, anEntry, anIndex)
+        elsif anEntry.start_entry?
+          process_start_entry(anEvent, anEntry, anIndex)
+        elsif anEntry.end_entry?
+          process_end_entry(anEvent, anEntry, anIndex)
+        else
+          fail NotImplementedError
         end
+
+        @last_visitee = anEntry
       end
 
       # Return the current_parent node
@@ -56,32 +63,20 @@ module Rley # This module is used as a namespace
 private
 
       def process_start_entry(anEvent, anEntry, anIndex)
-        self.curr_path.pop while curr_parent.kind_of?(SPPF::AlternativeNode)
         self.curr_path.pop
       end
 
       def process_end_entry(anEvent, anEntry, anIndex)
         case anEvent
         when :visit
-          if curr_path.empty?
-            # Build parse forest with root node derived from the
-            # accepting parse entry.
-            @forest = create_forest(anEntry, anIndex)
-          else
-            # if current_parent node matches the lhs non-terminal of anEntry
-            # set its origin to the origin of its first child (if not yet assigned)
-            curr_parent.range.assign(low: anEntry.origin)
-            @entry2node[anEntry] = self.curr_parent
-            if anEntry.antecedents.size > 1
-              # Store current path for later backtracking
-              # puts "Store backtrack context #{anEntry}"
-              # puts "path [#{curr_path.join(', ')}]"
-              self.entry2path_to_alt[anEntry] = curr_path.dup
-              curr_parent.refinement = :or
-
-              create_alternative_node(anEntry.antecedents.first)
-            end
-          end
+          # create a node with the non-terminal
+          #   with same right extent as curr_entry_set_index
+          # add the new node as first child of current_parent
+          # append the new node to the curr_path
+          range = { low: anEntry.origin, high: anIndex }
+          non_terminal = anEntry.vertex.non_terminal
+          create_non_terminal_node(anEntry, range, non_terminal)
+          @forest = create_forest(curr_parent) unless @last_visitee
 
         when :backtrack
           # Restore path
@@ -90,15 +85,9 @@ private
           antecedent_index = curr_parent.subnodes.size
           # puts "Current parent #{curr_parent.to_string(0)}"
           # puts "Antecedent index #{antecedent_index}"
-          create_alternative_node(anEntry.antecedents[antecedent_index])
-
-        when :revisit
-          # Remove most recent entry in path
-          @curr_path.pop
 
-          # Remove also its reference in parent
-          curr_parent.subnodes.pop
 
+        when :revisit
           # Retrieve the already existing node corresponding to re-visited entry
           popular = @entry2node[anEntry]
 
@@ -110,55 +99,45 @@ private
         end
       end
 
-=begin
-  if it is a dotted item entry (pattern is: X => α . β):
-    if there is at least one symbol before the dot
-      if that symbol is a non-terminal:
-
-      if that symbol is a terminal # else
-        create a token node,
-          with same origin as token,
-          with same right extent = origin + 1
-        add the new node as first child of current_parent
-        set curr_entry_set_index to curr_entry_set_index - 1
-    if it is a dotted item entry with a beginning dot: # else
-      if current_parent node matches the lhs non-terminal of anEntry
-        set its origin to the origin of its first child (if not yet assigned)
-      remove this node from the path
-=end
+
       def process_item_entry(anEvent, anEntry, anIndex)
+        if anEntry.exit_entry?
+          # Previous entry was an end entry (X. pattern)
+          # Does the previous entry have multiple antecedent?
+          if last_visitee.end_entry? && last_visitee.antecedents.size > 1
+            # Store current path for later backtracking
+            # puts "Store backtrack context #{last_visitee}"
+            # puts "path [#{curr_path.join(', ')}]"
+            self.entry2path_to_alt[last_visitee] = curr_path.dup
+            curr_parent.refinement = :or
+
+            create_alternative_node(anEntry)
+          end
+        end
+
         # Retrieve the grammar symbol before the dot (if any)
         prev_symbol = anEntry.prev_symbol
         case prev_symbol
           when Syntax::Terminal
-            # create a token node,
-            #   with same origin as token,
-            #   with same right extent = origin + 1
-            # add the new node as first child of current_parent
+            # Add node without changing current path
             create_token_node(anEntry, anIndex)
 
-
           when Syntax::NonTerminal
-            # create a node with the non-terminal before the dot,
-            #   with same right extent as curr_entry_set_index
-            # add the new node as first child of current_parent
-            # append the new node to the curr_path
-            range = { high: anIndex }
-            create_non_terminal_node(anEntry, range, prev_symbol)
+            # Do nothing
 
           when NilClass # Dot at the beginning of production
             if anEntry.vertex.dotted_item.production.empty?
-              # Empty rhs => create an epsilon node
+              # Empty rhs => create an epsilon node ...
+              # ... without changing current path
               create_epsilon_node(anEntry, anIndex)
             end
+            self.curr_path.pop if curr_parent.kind_of?(SPPF::AlternativeNode)
         end
       end
-      
+
       # Create an empty parse forest
-      def create_forest(anEntry, anIndex)
-        full_range = { low: 0, high: anIndex }
-        root_node = create_non_terminal_node(anEntry, full_range)
-        return Rley::SPPF::ParseForest.new(root_node)      
+      def create_forest(aRootNode)
+        return Rley::SPPF::ParseForest.new(aRootNode)
       end
 
 
@@ -167,6 +146,7 @@ private
         non_terminal = nonTSymb.nil? ? anEntry.vertex.non_terminal : nonTSymb
         new_node = Rley::SPPF::NonTerminalNode.new(non_terminal, aRange)
         entry2node[anEntry] = new_node
+        # puts "FOREST ADD #{curr_parent.key if curr_parent}/#{new_node.key}"
         add_subnode(new_node)
 
         return new_node
@@ -177,29 +157,34 @@ private
       def create_alternative_node(anEntry)
         alternative = Rley::SPPF::AlternativeNode.new(anEntry.vertex, curr_parent.range)
         add_subnode(alternative)
+        # puts "FOREST ADD #{alternative.key}"
 
         return alternative
       end
 
+      # create a token node,
+      #   with same origin as token,
+      #   with same right extent = origin + 1
+      # add the new node as first child of current_parent
       def create_token_node(anEntry, anIndex)
         token_position = anIndex - 1
         curr_token = tokens[token_position]
         new_node = SPPF::TokenNode.new(curr_token, token_position)
         candidate = add_node_to_forest(new_node)
-        entry2node[anEntry] = candidate        
+        entry2node[anEntry] = candidate
 
-        return candidate        
+        return candidate
       end
 
 
       def create_epsilon_node(anEntry, anIndex)
         new_node = SPPF::EpsilonNode.new(anIndex)
         candidate = add_node_to_forest(new_node)
-        entry2node[anEntry] = candidate        
+        entry2node[anEntry] = candidate
 
         return candidate
       end
-      
+
       # Add the given node if not yet present in parse forest
       def add_node_to_forest(aNode)
         key_node = aNode.key
@@ -210,7 +195,7 @@ private
           forest.key2node[key_node] = new_node
           # puts "FOREST ADD #{key_node}"
         end
-        add_subnode(new_node, false)  
+        add_subnode(new_node, false)
 
         return new_node
       end

data/lib/rley/parser/parse_walker_factory.rb

@@ -1,4 +1,10 @@
 require 'set'
+require_relative '../gfg/call_edge'
+require_relative '../gfg/scan_edge'
+require_relative '../gfg/epsilon_edge'
+require_relative '../gfg/end_vertex'
+require_relative '../gfg/item_vertex'
+require_relative '../gfg/start_vertex'
 
 module Rley # This module is used as a namespace
   module Parser # This module is used as a namespace
@@ -87,8 +93,7 @@ private
           aContext.nterm2start[anEntry.vertex.non_terminal] = anEntry
         end
 
-        if aContext.visitees.include?(anEntry)
-          # multiple time visit
+        if aContext.visitees.include?(anEntry) # Already visited?...
           case anEntry.vertex
             when GFG::EndVertex
               # Jump to related start entry...
@@ -98,8 +103,7 @@ private
               event = [:revisit, anEntry, index]
 
             when GFG::StartVertex
-              # Skip start entries while revisiting
-              event = nil
+              event = [:revisit, anEntry, index]
 
             when GFG::ItemVertex
               # Skip item entries while revisiting
@@ -142,18 +146,23 @@ private
         new_entry = aContext.curr_entry.antecedents.first
         events = [new_entry]
         traversed_edge = new_entry.vertex.edges.first
-        case new_entry.vertex
-          when GFG::EndVertex
-            # Return edge encountered
-            # Push current entry onto stack
-            # puts "Push on return stack #{aContext.curr_entry}"
-            aContext.return_stack << aContext.curr_entry
-          else
-            if traversed_edge.is_a?(GFG::ScanEdge)
-              # Scan edge encountered, decrease sigma set index
-              aContext.entry_set_index -= 1
-            end
-          end
+        if new_entry.vertex.kind_of?(GFG::EndVertex)
+          # Return edge encountered
+          # Push current entry onto stack
+          # puts "Push on return stack #{aContext.curr_entry}"
+          aContext.return_stack << aContext.curr_entry
+        elsif traversed_edge.kind_of?(GFG::CallEdge)
+          # Pop top of stack
+          tos = aContext.return_stack.pop
+          # puts "Pop from return stack matching entry #{new_entry}"
+        elsif traversed_edge.kind_of?(GFG::ScanEdge)  
+          # Scan edge encountered, decrease sigma set index
+          aContext.entry_set_index -= 1
+        elsif traversed_edge.kind_of?(GFG::EpsilonEdge)
+          # Do nothing
+        else
+          fail NotImplementedError, "edge is a #{traversed_edge.class}"        
+        end
 
         return events
       end
@@ -169,7 +178,6 @@ private
             new_entry = bp.visitee.antecedents[bp.antecedent_index]
 
           when GFG::StartVertex
-            # An start vertex with multiple requires a backtrack point
             new_entry = select_calling_entry(aContext)
           else
             fail StandardError, "Internal error"
@@ -204,6 +212,7 @@ private
         if bp.antecedent_index == bp.visitee.antecedents.size - 1
           aContext.backtrack_points.pop
         end
+        # puts "Backtracking to #{bp.visitee}"
         
         # Emit a backtrack event
         return [:backtrack, bp.visitee, aContext.entry_set_index]

data/lib/rley.rb

@@ -6,6 +6,7 @@ require_relative './rley/constants'
 require_relative './rley/syntax/grammar_builder'
 require_relative './rley/parser/token'
 require_relative './rley/parser/earley_parser'
+require_relative './rley/parser/gfg_earley_parser'
 require_relative './rley/parse_tree_visitor'
 require_relative './rley/formatter/debug'
 require_relative './rley/formatter/json'

data/spec/rley/gfg/end_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
         

data/spec/rley/gfg/shortcut_edge_spec.rb

@@ -15,23 +15,23 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       context 'Initialization:' do
         it 'should be created with two vertice arguments & a non-terminal' do
-          allow(vertex1).to receive(:shortcut=)
-          allow(vertex1).to receive(:next_symbol).and_return(nt_b_sequence)
+          expect(vertex1).to receive(:shortcut=)
+          expect(vertex1).to receive(:next_symbol).and_return(nt_b_sequence)
 
           expect { ShortcutEdge.new(vertex1, vertex2) }
             .not_to raise_error
         end
 
         it 'should know the successor vertex' do
-          allow(vertex1).to receive(:shortcut=)
-          allow(vertex1).to receive(:next_symbol).and_return(nt_b_sequence)
+          expect(vertex1).to receive(:shortcut=)
+          expect(vertex1).to receive(:next_symbol).and_return(nt_b_sequence)
           
           expect(subject.successor).to eq(vertex2)
         end
 
         it 'should know the related terminal' do
-          allow(vertex1).to receive(:shortcut=)
-          allow(vertex1).to receive(:next_symbol).and_return(nt_b_sequence)
+          expect(vertex1).to receive(:shortcut=)
+          expect(vertex1).to receive(:next_symbol).and_return(nt_b_sequence)
 
           expect(subject.nonterminal).to eq(nt_b_sequence)
         end