rley 0.2.14 → 0.2.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3487e06363e33e6a4e0c0e5c05a74379913589ab
-  data.tar.gz: f0907aa318f914f1ae63082b4e7158f929b2e746
+  metadata.gz: 9a8824f31c8801d99d12566267a5e8cd95bb26c1
+  data.tar.gz: d5a0887f857d5b0efe154f10a202932960bc2e9e
 SHA512:
-  metadata.gz: bdda4a8211470a1290befe63adfd65c278a3376a706ca367542f7ed1a7bbacc072a0167f08f539d94272ca3145e8b4821ac1f9912dc0d2d8824e01768689ea10
-  data.tar.gz: a23fe29e4573e412275e5ae8fcc5da35763954e130085628353cfce78651f30b0bc5a08ce0130c6edfd317ed952d57029fbfec1842c6fd46f895475061289750
+  metadata.gz: cbf13dc6ac58dced26074ed1b2f9a4aab99b2834ea720743621d0cec7f0e0b17b7dc89e19956765b4921f4e1f4601b1858da92bcf0260b86c41de5c1c040579d
+  data.tar.gz: fed291494d3178e6813f561ef301ac60fc88604c81c0f8b40ee8fa8639e20873cef29fc79d90b47993e228134b1dcf0a8502ad1c3336b7e91659cb3a0c006345

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+### 0.2.15 / 2016-02-14
+* [CHANGE] A lot of internal changes. This is the last version before a Grammar Flow Graph-based parsing implementation.
+
 ### 0.2.14 / 2015-11-25
 * [FIX] Method `StateSet#ambiguities` overlooked some ambiguities in parse sets.
 

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014-2015 Dimitri Geshef
+Copyright (c) 2014-2016 Dimitri Geshef
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -7,6 +7,7 @@ Rley
 [![Coverage Status](https://img.shields.io/coveralls/famished-tiger/Rley.svg)](https://coveralls.io/r/famished-tiger/Rley?branch=master)
 [![Gem Version](https://badge.fury.io/rb/rley.svg)](http://badge.fury.io/rb/rley)
 [![Dependency Status](https://gemnasium.com/famished-tiger/Rley.svg)](https://gemnasium.com/famished-tiger/Rley)
+[![Inline docs](http://inch-ci.org/github/famished-tiger/Rley.svg?branch=master)](http://inch-ci.org/github/famished-tiger/Rley)
 [![License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)](https://github.com/famished-tiger/Rley/blob/master/LICENSE.txt)
 
 __Rley__ is a Ruby implementation of a parser using the [Earley](http://en.wikipedia.org/wiki/Earley_parser) algorithm.  
@@ -29,13 +30,10 @@ The Earley's algorithm being more general is able to parse input that conforms t
 
 This project is in "earley" stage.  
 ####Roadmap:
+- Rewrite the parser using the GFG (Grammar Flow Graph) approach
+- Replace parse trees by shared packed parse forests
 - Document the parser API
 - Add more validation tests and sample grammars
-- Add AST generation (and semantic actions?)
-- Add DSL for grammar specification
-- Add grammar validations
-- Add error reporting
-
 - Add a command-line interface
 - Provide documentation and examples
 
@@ -59,5 +57,5 @@ Here are a few other ones:
 
 Copyright
 ---------
-Copyright (c) 2014-2015, Dimitri Geshef. 
+Copyright (c) 2014-2016, Dimitri Geshef. 
 __Rley__ is released under the MIT License see [LICENSE.txt](https://github.com/famished-tiger/Rley/blob/master/LICENSE.txt) for details.

data/examples/parsers/parsing_another.rb

@@ -0,0 +1,70 @@
+# Purpose: to demonstrate how to build and render a parse tree
+
+require 'pp' # TODO remove this dependency
+require 'rley'  # Load the gem
+
+# Steps to render a parse tree (of a valid parsed input):
+# 1. Define a grammar
+# 2. Create a tokenizer for the language
+# 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)
+
+########################################
+# Step 1. Define a problematic grammar
+# Grammar Z: A grammar with hidden left recursion and a cycle
+# (based on example 2 in article of Elizabeth Scott, "SPPF-Style Parsing From Earley Recognisers"
+# Electronic Notes in Theoretical Computer Science 203 (2008) 53–67
+# Let's create the grammar step-by-step with the grammar builder:
+builder = Rley::Syntax::GrammarBuilder.new
+builder.add_terminals('b')
+builder.add_production('S' => %w(S S))
+builder.add_production('S' => 'b')
+
+# And now build the grammar...
+grammar_tricky = builder.grammar
+
+
+########################################
+# 2. Create a tokenizer for the language
+# The tokenizer transforms the input into an array of tokens
+def tokenizer(aText, aGrammar)
+  tokens = aText.chars.map do |lexeme|
+    case lexeme
+      when 'b'
+        terminal = aGrammar.name2symbol[lexeme]
+      else
+        msg = "Unknown input text '#{lexeme}'"
+        fail StandardError, msg
+    end
+    Rley::Parser::Token.new(lexeme, terminal)
+  end
+
+  return tokens
+end
+
+########################################
+# Step 3. Create a parser for that grammar
+parser = Rley::Parser::EarleyParser.new(grammar_tricky)
+
+########################################
+# Step 3. Tokenize the input
+valid_input = 'bbb'
+tokens = tokenizer(valid_input, grammar_tricky)
+
+########################################
+# Step 5. Let the parser process the input
+result = parser.parse(tokens)
+puts "Parsing success? #{result.success?}"
+puts "Parsing ambiguous? #{result.ambiguous?}"
+#pp result
+
+result.chart.state_sets.each_with_index do |aStateSet, index|
+  puts "State[#{index}]"
+  puts "========"
+  aStateSet.states.each { |aState| puts aState.to_s }
+end
+
+# End of file

data/examples/parsers/parsing_right_recursive.rb

@@ -0,0 +1,70 @@
+# Purpose: to demonstrate how to build and render a parse tree
+
+require 'pp' # TODO remove this dependency
+require 'rley'  # Load the gem
+
+# Steps to render a parse tree (of a valid parsed input):
+# 1. Define a grammar
+# 2. Create a tokenizer for the language
+# 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)
+
+########################################
+# Step 1. Define a problematic grammar
+# Grammar Z: A grammar with hidden left recursion and a cycle
+# (based on example in book of D. Grune, C JH. Jacobs,
+# "Parsing Techniques: A Practical Guide"
+# Springer, ISBN: 978-1-4419-1901-4, (2010) p. 224
+# Let's create the grammar step-by-step with the grammar builder:
+builder = Rley::Syntax::GrammarBuilder.new
+builder.add_terminals('a')
+builder.add_production('S' => %w(a S))
+builder.add_production('S' => []) # Empty RHS
+
+# And now build the grammar...
+right_recursive_gram = builder.grammar
+
+
+########################################
+# 2. Create a tokenizer for the language
+# The tokenizer transforms the input into an array of tokens
+def tokenizer(aText, aGrammar)
+  tokens = aText.chars.map do |lexeme|
+    case lexeme
+      when 'a'
+        terminal = aGrammar.name2symbol[lexeme]
+      else
+        msg = "Unknown input text '#{lexeme}'"
+        fail StandardError, msg
+    end
+    Rley::Parser::Token.new(lexeme, terminal)
+  end
+
+  return tokens
+end
+
+########################################
+# Step 3. Create a parser for that grammar
+parser = Rley::Parser::EarleyParser.new(right_recursive_gram)
+
+########################################
+# Step 3. Tokenize the input
+valid_input = 'aaaa'
+tokens = tokenizer(valid_input, right_recursive_gram)
+
+########################################
+# Step 5. Let the parser process the input
+result = parser.parse(tokens)
+puts "Parsing success? #{result.success?}"
+#pp result
+
+result.chart.state_sets.each_with_index do |aStateSet, index|
+  puts "State[#{index}]"
+  puts "========"
+  aStateSet.states.each { |aState| puts aState.to_s }
+end
+
+# End of file

data/lib/rley/constants.rb

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

data/lib/rley/gfg/edge.rb

@@ -0,0 +1,19 @@
+module Rley # This module is used as a namespace
+  module GFG # This module is used as a namespace
+    # Abstract class. Represents an edge in a grammar flow graph. 
+    # Responsibilities:
+    # - To know the successor vertex
+    class Edge
+      # The destination vertex of the edge .
+      attr_reader :successor
+      
+      def initialize(thePredecessor, theSuccessor)
+        @successor = theSuccessor
+        thePredecessor.add_edge(self)
+      end
+
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/rley/gfg/end_vertex.rb

@@ -0,0 +1,24 @@
+require_relative 'non_terminal_vertex'
+
+module Rley # This module is used as a namespace
+  module GFG # This module is used as a namespace
+    # TODO: change definition.
+    # Represents a specialized vertex in a grammar flow graph 
+    # that is associated to a given non-terminal symbol.
+    # Responsibilities (in addition to inherited ones):
+    # - Know its related non-terminal symbol
+    class EndVertex < NonTerminalVertex
+      
+      def initialize(aNonTerminal)
+        super(aNonTerminal)
+      end
+      
+      def label()
+        return "#{non_terminal}."
+      end
+
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/rley/gfg/epsilon_edge.rb

@@ -0,0 +1,25 @@
+require_relative 'edge'
+
+module Rley # This module is used as a namespace
+  module GFG # This module is used as a namespace
+    # Represents an edge in a grammar flow graph 
+    # without change of the position in the input stream.
+    # Responsibilities:
+    # - To know the successor vertex
+    class EpsilonEdge < Edge
+      # The destination vertex of the edge .
+      attr_reader :successor
+      
+      def initialize(thePredecessor, theSuccessor)
+        super(thePredecessor, theSuccessor)
+      end
+      
+      def to_s()
+        " --> #{successor.label}"
+      end
+
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/rley/gfg/grm_flow_graph.rb

@@ -0,0 +1,167 @@
+require_relative 'start_vertex'
+require_relative 'end_vertex'
+require_relative 'item_vertex'
+require_relative 'epsilon_edge'
+require_relative 'scan_edge'
+
+module Rley # This module is used as a namespace
+  module GFG # This module is used as a namespace
+    # TODO: add definition
+    class GrmFlowGraph
+        # The set of all vertices in the graph
+        attr_reader :vertices
+
+        # The vertex marked as start node of the graph
+        attr_reader :start_vertex
+
+        # A Hash with pairs of the form: non-terminal symbol => start node
+        attr_reader :start_vertex_for
+
+        # A Hash with pairs of the form: non-terminal symbol => end node
+        attr_reader :end_vertex_for
+
+      def initialize(theDottedItems)
+        @vertices = []
+        @start_vertex_for = {}
+        @end_vertex_for = {}
+
+        build_graph(theDottedItems)
+      end
+
+private
+      def add_vertex(aVertex)
+        # TODO: make setting of start vertex more robust
+        start_vertex = aVertex if vertices.empty?
+        vertices << aVertex
+      end
+
+      def build_graph(theDottedItems)
+        build_all_starts_ends(theDottedItems)
+
+        curr_production = nil
+        theDottedItems.each_with_index do |d_item, index_item|
+          if curr_production.nil? || curr_production != d_item.production
+            # Another production found...
+            curr_production = d_item.production
+            lhs = curr_production.lhs
+            # build_start_end_for(lhs) #Build start/end vertex per non-terminal
+            if curr_production.empty?
+              add_single_item(d_item)
+            else
+              # Add vertices and edges for dotted items of production
+              augment_graph(theDottedItems, index_item)
+            end
+          end
+        end
+      end
+      
+      def build_all_starts_ends(theDottedItems)
+        productions_raw = theDottedItems.map(&:production)
+        productions = productions_raw.uniq
+        productions.each { |prod| build_start_end_for(prod.lhs) }
+      end
+
+      # if there is not yet a start vertex labelled .N in the GFG:
+      #   add a start vertex labelled .N
+      #   add an end vertex labelled N.
+      def build_start_end_for(aNonTerminal)
+        unless start_vertex_for.include?(aNonTerminal)
+          new_start_vertex = StartVertex.new(aNonTerminal)
+          start_vertex_for[aNonTerminal] = new_start_vertex
+          add_vertex(new_start_vertex)
+
+          new_end_vertex = EndVertex.new(aNonTerminal)
+          end_vertex_for[aNonTerminal] = new_end_vertex
+          add_vertex(new_end_vertex)
+        end
+      end
+
+
+      def add_single_item(aDottedItem)
+        new_vertex = ItemVertex.new(aDottedItem)
+        add_vertex(new_vertex)
+        build_entry_edge(new_vertex)
+        build_exit_edge(new_vertex)
+      end
+
+      # Add vertices and edges for dotted items derived from same production
+      # production of the form: N => α[1] ... α[n] (non-empty rhs):
+      # # Rule 3
+      # create n+1 nodes labelled:  N => . α[1] ... α[n], N => α[1] . ... α[n], ..., N => α[1] ... α[n] .
+      # add an epsilon entry edge: .N -> N => . α[1] ... α[n]
+      # add an epsilon exit edge: N => α[1] ... α[n] . -> N.
+      # For each symbol in rhs:
+      #   if it is a terminal, say a:
+      #     Rule 4
+      #     add a scan edge: N => α[1] .a  α[n] -> N => α[1] a. α[n]
+      #   else # non-terminal symbol A in rhs:
+      #     Rule 5
+      #     add a call edge: N => α[1] .A  α[n] -> .A
+      #     add a return edge: A. -> N => α[1] A.  α[n]
+      def augment_graph(theDottedItems, firstItemPos)
+        production = theDottedItems[firstItemPos].production
+        max_index = production.rhs.size + 1
+        (0...max_index).each do |index|
+          current_item = theDottedItems[firstItemPos+index]
+          new_vertex = ItemVertex.new(current_item)
+          add_vertex(new_vertex)
+          build_exit_edge(new_vertex) if current_item.reduce_item? # At end?
+          if current_item.at_start?
+            build_entry_edge(new_vertex)
+          else
+            # At least one symbol before the dot
+            # Retrieve the symbol before the dot...
+            prev_symbol = current_item.prev_symbol
+            if prev_symbol.kind_of?(Syntax::Terminal)
+              build_scan_edge(vertices[-2], new_vertex)
+            else
+              # ...non-terminal
+              build_call_return_edges(vertices[-2], new_vertex)
+            end
+          end
+        end
+      end
+
+      # Create an entry edge for the given vertex
+      def build_entry_edge(theVertex)
+        # Retrieve corresponding start vertex (for lhs non-terminal)
+        start_vertex = start_vertex_for[theVertex.dotted_item.production.lhs]
+
+        # Create an edge start_vertex -> the vertex
+        EpsilonEdge.new(start_vertex, theVertex)
+      end
+
+      # Create an exit edge for the given vertex
+      def build_exit_edge(theVertex)
+        # Retrieve corresponding end vertex (for lhs non-terminal)
+        end_vertex = end_vertex_for[theVertex.dotted_item.production.lhs]
+
+        # Create an edge the vertex -> end_vertex
+        EpsilonEdge.new(theVertex, end_vertex)
+      end
+
+      # Create a scan edge between two vertices.
+      # These two vertices are assumed to correspond to two
+      # consecutive dot positions separated by a terminal symbol
+      def build_scan_edge(fromVertex, toVertex)
+        ScanEdge.new(fromVertex, toVertex, fromVertex.dotted_item.next_symbol)
+      end
+
+      def build_call_return_edges(call_vertex, return_vertex)
+        nt_symbol = call_vertex.dotted_item.next_symbol
+
+        # Retrieve corresponding start vertex
+        start_vertex = start_vertex_for[nt_symbol]
+        # Create an edge call vertex -> start vertex
+        EpsilonEdge.new(call_vertex, start_vertex)
+
+        # Retrieve corresponding end vertex
+        end_vertex = end_vertex_for[nt_symbol]
+        # Create an edge end vertex -> return vertex
+        EpsilonEdge.new(end_vertex, return_vertex)
+      end
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/rley/gfg/item_vertex.rb

@@ -0,0 +1,26 @@
+require_relative 'vertex'
+
+module Rley # This module is used as a namespace
+  module GFG # This module is used as a namespace
+    # TODO: modify definition
+    # Represents a specialized vertex in a grammar flow graph 
+    # that is associated to a given dotted item.
+    # Responsibilities (in addition to inherited ones):
+    # - Know its related non-terminal symbol
+    class ItemVertex < Vertex
+        attr_reader :dotted_item
+      
+      def initialize(aDottedItem)
+        super()
+        @dotted_item = aDottedItem
+      end
+      
+      def label()
+        return "#{dotted_item}"
+      end
+
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/rley/gfg/non_terminal_vertex.rb

@@ -0,0 +1,21 @@
+require_relative 'vertex'
+
+module Rley # This module is used as a namespace
+  module GFG # This module is used as a namespace
+    # Represents a specialized vertex in a grammar flow graph 
+    # that is associated to a given non-terminal symbol.
+    # Responsibilities (in addition to inherited ones):
+    # - Know its related non-terminal symbol
+    class NonTerminalVertex < Vertex
+        attr_reader :non_terminal
+      
+      def initialize(aNonTerminal)
+        super()
+        @non_terminal = aNonTerminal
+      end
+
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/rley/gfg/scan_edge.rb

@@ -0,0 +1,25 @@
+require_relative 'edge'
+
+module Rley # This module is used as a namespace
+  module GFG # This module is used as a namespace
+    # Abstract class. Represents an edge in a grammar flow graph
+    # Responsibilities:
+    # - To know the successor vertex
+    class ScanEdge < Edge
+      # The terminal symbol expected from the input stream
+      attr_reader :terminal
+      
+      def initialize(thePredecessor, theSuccessor, aTerminal)
+        super(thePredecessor, theSuccessor)
+        @terminal = aTerminal
+      end
+      
+      def to_s()
+        " -#{terminal}-> #{successor.label}"
+      end
+
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/rley/gfg/start_vertex.rb

@@ -0,0 +1,24 @@
+require_relative 'non_terminal_vertex'
+
+module Rley # This module is used as a namespace
+  module GFG # This module is used as a namespace
+    # TODO: change definition.
+    # Represents a specialized vertex in a grammar flow graph 
+    # that is associated to a given non-terminal symbol.
+    # Responsibilities (in addition to inherited ones):
+    # - Know its related non-terminal symbol
+    class StartVertex < NonTerminalVertex
+      
+      def initialize(aNonTerminal)
+        super(aNonTerminal)
+      end
+      
+      def label()
+        return ".#{non_terminal}"
+      end
+
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/rley/gfg/vertex.rb

@@ -0,0 +1,24 @@
+module Rley # This module is used as a namespace
+  module GFG # This module is used as a namespace
+    # Abstract class. Represents a vertex in a grammar flow graph
+    # Responsibilities:
+    # - To know its outgoing edges
+    # - To know its label
+    class Vertex
+      # The edges linking the successor vertices to this one.
+      attr_reader :edges
+      
+      def initialize()
+        @edges = []
+      end
+      
+      # Add an graph edge to this vertex
+      def add_edge(anEdge)
+        edges << anEdge
+      end
+
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/rley/parser/earley_parser.rb

@@ -1,12 +1,14 @@
 require_relative '../syntax/grammar'
+require_relative 'grm_items_builder'  # Use mix-in module
 require_relative 'parse_tracer'
-require_relative 'dotted_item'
 require_relative 'parsing'
 
 module Rley # This module is used as a namespace
   module Parser # This module is used as a namespace
     # Implementation of a parser that uses the Earley parsing algorithm.  
     class EarleyParser
+      include GrmItemsBuilder # Mix-in module for created dotted items of given grammar
+      
       # The grammar of the language.
       attr_reader(:grammar)
 
@@ -23,7 +25,7 @@ module Rley # This module is used as a namespace
       
       def initialize(aGrammar)
         @grammar = aGrammar
-        @dotted_items = build_dotted_items(grammar)
+        @dotted_items = build_dotted_items(grammar) # Method from mixin
         @start_mapping = build_start_mapping(dotted_items)
         @next_mapping = build_next_mapping(dotted_items)
       end
@@ -31,8 +33,6 @@ module Rley # This module is used as a namespace
       # Parse a sequence of input tokens.
       # @param aTokenSequence [Array] Array of Tokens objects returned by a 
       # tokenizer/scanner/lexer.
-      # @param aGrammar [Grammar] The grammar of the language 
-      # (to use by the parser).
       # @param aTraceLevel [Fixnum] The specified trace level.
       # The possible values are:
       # 0: No trace output (default case)
@@ -69,20 +69,6 @@ module Rley # This module is used as a namespace
 
       private
 
-      def build_dotted_items(aGrammar)
-        items = []
-        aGrammar.rules.each do |prod|
-          rhs_size = prod.rhs.size
-          if rhs_size == 0
-            items << DottedItem.new(prod, 0)
-          else
-            items += (0..rhs_size).map { |i| DottedItem.new(prod, i) }
-          end
-        end
-
-        return items
-      end
-
       # Create a Hash with pairs of the kind:
       # non-terminal => [start dotted items]
       def build_start_mapping(theDottedItems)

data/lib/rley/parser/grm_items_builder.rb

@@ -0,0 +1,23 @@
+require_relative 'dotted_item'
+
+module Rley # This module is used as a namespace
+  module Parser # This module is used as a namespace
+    # Mix-in module. Builds the dotted items for a given grammar
+    module GrmItemsBuilder
+      # Build an array of dotted items from the productions in passed grammar.
+      def build_dotted_items(aGrammar)
+        items = []
+        aGrammar.rules.each do |prod|
+          rhs_size = prod.rhs.size
+          if rhs_size == 0
+            items << DottedItem.new(prod, 0)
+          else
+            items += (0..rhs_size).map { |i| DottedItem.new(prod, i) }
+          end
+        end
+
+        return items
+      end
+    end # module
+  end # module
+end # module

data/lib/rley/parser/parsing.rb

@@ -11,7 +11,7 @@ module Rley # This module is used as a namespace
       # The sequence of input token to parse
       attr_reader(:tokens)
 
-      # @param aTraceLevel [Fixnum] The specified trace level.
+      # @param aTracer [ParseTracer] An object that traces the parsing.
       # The possible values are:
       # 0: No trace output (default case)
       # 1: Show trace of scanning and completion rules

data/spec/rley/formatter/json_spec.rb

@@ -1,7 +1,6 @@
 require_relative '../../spec_helper'
 require 'stringio'
 
-# require_relative '../../../lib/rley/dynamic_grammar'
 require_relative '../support/grammar_abc_helper'
 require_relative '../../../lib/rley/parser/token'
 require_relative '../../../lib/rley/parser/earley_parser'

data/spec/rley/gfg/edge_spec.rb

@@ -0,0 +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

data/spec/rley/gfg/end_vertex_spec.rb

@@ -0,0 +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
+          allow(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

@@ -0,0 +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

data/spec/rley/gfg/grm_flow_graph_spec.rb

@@ -0,0 +1,139 @@
+require_relative '../../spec_helper'
+require 'pp'
+
+require_relative '../support/grammar_abc_helper'
+require_relative '../../../lib/rley/parser/grm_items_builder'
+
+# Load the module under test
+require_relative '../../../lib/rley/gfg/grm_flow_graph'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module GFG # Open this namespace to avoid module qualifier prefixes
+    describe GrmFlowGraph do
+      include GrammarABCHelper # Mix-in module with builder for grammar abc
+
+      # Helper method. Create an array of dotted items
+      # from the given grammar
+      def build_items_for_grammar(aGrammar)
+        helper = Object.new
+        helper.extend(Parser::GrmItemsBuilder)
+        return helper.build_dotted_items(aGrammar)
+      end
+
+      # Check that the passed graph has exactly the same
+      # vertices and edges as expected
+      def compare_graph_expectations(aGraph, expectations)
+        i = 0
+        aGraph.vertices.each do |vertex|
+          vertex.edges.each do |edge|
+            representation = vertex.label + edge.to_s
+            expect(representation).to eq(expectations[i])
+            i += 1
+          end
+        end
+      end
+
+      # Factory method. Build a production with the given sequence
+      # of symbols as its rhs.
+      let(:grammar_abc) do
+        builder = grammar_abc_builder
+        builder.grammar
+      end
+
+      # Helper method. Create an array of dotted items
+      # from the abc grammar
+      let(:items_from_grammar) { build_items_for_grammar(grammar_abc) }
+
+      # Default instantiation rule
+      subject { GrmFlowGraph.new(items_from_grammar) }
+
+
+      context 'Initialization:' do
+        it 'should be created with an array of dotted items' do
+          expect { GrmFlowGraph.new(items_from_grammar) }.not_to raise_error
+        end
+
+        it 'should have the correct number of vertices' do
+          # Number of vertices = count of dotted items +...
+          #   ... 2 * count of non-terminals
+          count_vertices = 2 * grammar_abc.non_terminals.size
+          count_vertices += items_from_grammar.size
+          expect(subject.vertices.size).to eq(count_vertices)
+        end
+
+        it 'should have for each non-terminal one start and end vertex' do
+          # Iterate over all non-terminals of grammar...
+          grammar_abc.non_terminals.each do |nterm|
+            # ...to each non-terminal there should be a start vertex
+            start_vertex = subject.start_vertex_for[nterm]
+            expect(start_vertex).to be_kind_of(StartVertex)
+            expect(start_vertex.label).to eq(".#{nterm}")
+
+            # ...to each non-terminal there should be an end vertex
+            end_vertex = subject.end_vertex_for[nterm]
+            expect(end_vertex).to be_kind_of(EndVertex)
+            expect(end_vertex.label).to eq("#{nterm}.")
+          end
+        end
+
+        it 'should have one or more entry edges per start vertex' do
+          subject.start_vertex_for.values.each do |a_start|
+            expect(a_start.edges.size >= 1).to be_truthy
+            a_start.edges.each do |edge|
+              expect(edge.successor.dotted_item.at_start?).to be_truthy
+            end
+          end
+        end
+
+        it 'should have the correct graph structure' do
+          # We use the abc grammar
+          expected = [
+            '.S --> S => . A',
+            '.A --> A => . a A c',
+            '.A --> A => . b',
+            'A. --> S => A .',
+            'A. --> A => a A . c',
+            'S => . A --> .A',
+            'S => A . --> S.',
+            'A => . a A c -a-> A => a . A c',
+            'A => a . A c --> .A',
+            'A => a A . c -c-> A => a A c .',
+            'A => a A c . --> A.',
+            'A => . b -b-> A => b .',
+            'A => b . --> A.'
+          ]
+
+          compare_graph_expectations(subject, expected)
+        end
+
+        it 'should handle empty productions' do
+            builder = Rley::Syntax::GrammarBuilder.new
+            builder.add_terminals('a')
+            builder.add_production('S' => 'A')
+            builder.add_production('A' => 'a')
+            builder.add_production('A' => []) # empty rhs
+
+            grammar = builder.grammar
+            items = build_items_for_grammar(grammar)
+
+            graph = GrmFlowGraph.new(items)
+            expected = [
+              '.S --> S => . A',
+              '.A --> A => . a',
+              '.A --> A => .',
+              'A. --> S => A .',
+              'S => . A --> .A',
+              'S => A . --> S.',
+              'A => . a -a-> A => a .',
+              'A => a . --> A.',
+              'A => . --> A.'
+            ]
+            
+            compare_graph_expectations(graph, expected)
+        end
+      end # context
+    end # describe
+  end # module
+end # module
+
+# End of file

data/spec/rley/gfg/item_vertex_spec.rb

@@ -0,0 +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'
+
+# Load the class under test
+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)
+        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(:sample_prod) { build_prod(nt_sentence, t_a, t_b, t_c) }
+      let(:other_prod) {  build_prod(nt_sentence, t_a) }
+      let(:empty_prod) { build_prod(nt_sentence) }
+      let(:sample_item) { Parser::DottedItem.new(sample_prod, 1) }
+      subject { ItemVertex.new(sample_item) }
+
+      context 'Initialization:' do
+        it 'should be created with a dotted item' do
+          expect { ItemVertex.new(sample_item) }.not_to raise_error
+        end
+
+        it 'should know its dotted item' do
+          expect(subject.dotted_item).to eq(sample_item)
+        end
+      end # context
+      
+      context 'Provided services:' do
+        it 'should know its label' do
+          expect(subject.label).to eq(sample_item.to_s)
+        end
+        
+        
+      end # context      
+    end # describe
+  end # module
+end # module
+
+# End of file

data/spec/rley/gfg/non_terminal_vertex_spec.rb

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

data/spec/rley/gfg/scan_edge_spec.rb

@@ -0,0 +1,30 @@
+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

data/spec/rley/gfg/start_vertex_spec.rb

@@ -0,0 +1,26 @@
+require_relative '../../spec_helper'
+
+# Load the class under test
+require_relative '../../../lib/rley/gfg/start_vertex'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module GFG # Open this namespace to avoid module qualifier prefixes
+    describe StartVertex do
+      let(:sample_nt) { double('NT') }
+      subject { StartVertex.new(sample_nt) }
+
+      context 'Initialization:' do
+        it 'should be created with a non-terminal symbol' do
+          expect { StartVertex.new(sample_nt) }.not_to raise_error
+        end
+
+        it 'should know its label' do
+          allow(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/vertex_spec.rb

@@ -0,0 +1,38 @@
+require_relative '../../spec_helper'
+
+# Load the class under test
+require_relative '../../../lib/rley/gfg/vertex'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module GFG # Open this namespace to avoid module qualifier prefixes
+    describe Vertex do
+      subject { Vertex.new() }
+
+      context 'Initialization:' do
+        it 'should be created without argument' do
+          expect { Vertex.new() }.not_to raise_error
+        end
+        
+        it "shouldn't have edges at start" do
+          expect(subject.edges.empty?).to eq(true)
+        end
+      end # context
+      
+      context 'Provided services:' do
+        it 'should accept new edges' do
+          edge1 = double('fake-edge1')
+          edge2 = double('fake-edge2')
+          
+          expect { subject.add_edge(edge1) }.not_to raise_error
+          expect(subject.edges.size).to eq(1)
+          expect(subject.edges.last).to eq(edge1)
+          expect { subject.add_edge(edge2) }.not_to raise_error          
+          expect(subject.edges.size).to eq(2)
+          expect(subject.edges.last).to eq(edge2)
+        end
+      end # context
+    end # describe
+  end # module
+end # module
+
+# End of file

data/spec/rley/parser/grm_items_builder_spec.rb

@@ -0,0 +1,43 @@
+require_relative '../../spec_helper'
+
+require_relative '../support/grammar_abc_helper'
+
+# Load the module under test
+require_relative '../../../lib/rley/parser/grm_items_builder'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module Parser # Open this namespace to avoid module qualifier prefixes
+    describe 'Testing GrmItemsBuilder' do
+      include GrmItemsBuilder # Use mix-in to test
+      include GrammarABCHelper # Mix-in module with builder for grammar abc
+
+      # Factory method. Build a production with the given sequence
+      # of symbols as its rhs.
+      let(:grammar_abc) do
+        builder = grammar_abc_builder
+        builder.grammar
+      end
+
+      context 'Builder pattern behaviour' do
+        it 'should create dotted items for a grammar' do
+          # Next line calls method from mixin module under test
+          items = build_dotted_items(grammar_abc)
+          expect(items.size).to eq(8)
+          expectations = [ 
+            'S => . A',
+            'S => A .',
+            'A => . a A c',
+            'A => a . A c',
+            'A => a A . c',
+            'A => a A c .',
+            'A => . b',
+            'A => b .',
+          ]
+          expect(items.map(&:to_s)).to eq(expectations)
+        end
+      end
+    end # describe
+  end # module
+end # module
+
+# End of file

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.2.14
+  version: 0.2.15
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-26 00:00:00.000000000 Z
+date: 2016-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -139,9 +139,11 @@ files:
 - examples/parsers/parsing_L1.rb
 - examples/parsers/parsing_abc.rb
 - examples/parsers/parsing_ambig.rb
+- examples/parsers/parsing_another.rb
 - examples/parsers/parsing_b_expr.rb
 - examples/parsers/parsing_err_expr.rb
 - examples/parsers/parsing_groucho.rb
+- examples/parsers/parsing_right_recursive.rb
 - examples/parsers/parsing_tricky.rb
 - examples/parsers/tracing_parser.rb
 - examples/recognizers/recognizer_abc.rb
@@ -150,10 +152,20 @@ files:
 - lib/rley/formatter/base_formatter.rb
 - lib/rley/formatter/debug.rb
 - lib/rley/formatter/json.rb
+- lib/rley/gfg/edge.rb
+- lib/rley/gfg/end_vertex.rb
+- lib/rley/gfg/epsilon_edge.rb
+- lib/rley/gfg/grm_flow_graph.rb
+- lib/rley/gfg/item_vertex.rb
+- lib/rley/gfg/non_terminal_vertex.rb
+- lib/rley/gfg/scan_edge.rb
+- lib/rley/gfg/start_vertex.rb
+- lib/rley/gfg/vertex.rb
 - lib/rley/parse_tree_visitor.rb
 - lib/rley/parser/chart.rb
 - lib/rley/parser/dotted_item.rb
 - lib/rley/parser/earley_parser.rb
+- lib/rley/parser/grm_items_builder.rb
 - lib/rley/parser/parse_state.rb
 - lib/rley/parser/parse_state_tracker.rb
 - lib/rley/parser/parse_tracer.rb
@@ -177,10 +189,20 @@ files:
 - lib/rley/syntax/verbatim_symbol.rb
 - spec/rley/formatter/debug_spec.rb
 - spec/rley/formatter/json_spec.rb
+- spec/rley/gfg/edge_spec.rb
+- spec/rley/gfg/end_vertex_spec.rb
+- spec/rley/gfg/epsilon_edge_spec.rb
+- spec/rley/gfg/grm_flow_graph_spec.rb
+- spec/rley/gfg/item_vertex_spec.rb
+- spec/rley/gfg/non_terminal_vertex_spec.rb
+- spec/rley/gfg/scan_edge_spec.rb
+- spec/rley/gfg/start_vertex_spec.rb
+- spec/rley/gfg/vertex_spec.rb
 - spec/rley/parse_tree_visitor_spec.rb
 - spec/rley/parser/chart_spec.rb
 - spec/rley/parser/dotted_item_spec.rb
 - spec/rley/parser/earley_parser_spec.rb
+- spec/rley/parser/grm_items_builder_spec.rb
 - spec/rley/parser/parse_state_spec.rb
 - spec/rley/parser/parse_tracer_spec.rb
 - spec/rley/parser/parse_tree_builder_spec.rb
@@ -236,9 +258,19 @@ summary: Ruby implementation of the Earley's parsing algorithm
 test_files:
 - spec/rley/formatter/debug_spec.rb
 - spec/rley/formatter/json_spec.rb
+- spec/rley/gfg/edge_spec.rb
+- spec/rley/gfg/end_vertex_spec.rb
+- spec/rley/gfg/epsilon_edge_spec.rb
+- spec/rley/gfg/grm_flow_graph_spec.rb
+- spec/rley/gfg/item_vertex_spec.rb
+- spec/rley/gfg/non_terminal_vertex_spec.rb
+- spec/rley/gfg/scan_edge_spec.rb
+- spec/rley/gfg/start_vertex_spec.rb
+- spec/rley/gfg/vertex_spec.rb
 - spec/rley/parser/chart_spec.rb
 - spec/rley/parser/dotted_item_spec.rb
 - spec/rley/parser/earley_parser_spec.rb
+- spec/rley/parser/grm_items_builder_spec.rb
 - spec/rley/parser/parse_state_spec.rb
 - spec/rley/parser/parse_tracer_spec.rb
 - spec/rley/parser/parse_tree_builder_spec.rb