rley 0.2.15 → 0.3.00

data/lib/rley/sppf/parse_forest.rb

@@ -0,0 +1,48 @@
+require_relative 'token_node'
+require_relative 'non_terminal_node'
+
+module Rley # This module is used as a namespace
+  module SPPF # This module is used as a namespace
+    # TODO change comment
+    # A parse tree (a.k.a. concrete syntax tree) is a tree-based representation
+    # for the parse that corresponds to the input text. In a parse tree, 
+    # a node corresponds to a grammar symbol used during the parsing:
+    # - a leaf node maps to a terminal symbol occurring in
+    # the input, and
+    # - a intermediate node maps to a non-terminal node reduced
+    # during the parse. 
+    # The root node corresponds to the main/start symbol of the grammar.
+    class ParseForest
+      # The root node of the forest
+      attr_reader(:root)
+      
+      # A Hash with pairs of the kind node key => node
+      attr_reader(:key2node)
+
+      # @param theRootNode [ParseForestNode] The root node of the parse tree.
+      def initialize(theRootNode)
+        @root = theRootNode
+        @key2node = {}
+      end
+      
+      # Returns true if the given node is present in the forest.
+      def include?(aNode)
+        return key2node.include?(aNode)
+      end
+
+
+      # Part of the 'visitee' role in the Visitor design pattern.
+      #   A visitee is expected to accept the visit from a visitor object
+      # @param aVisitor [ParseForestVisitor] the visitor object
+      def accept(aVisitor)
+        aVisitor.start_visit_pforest(self)
+
+        # Let's proceed with the visit of nodes
+        root.accept(aVisitor) if root
+
+        aVisitor.end_visit_pforest(self)
+      end
+    end # class
+  end # module
+end # module
+# End of file

data/lib/rley/sppf/sppf_node.rb

@@ -0,0 +1,24 @@
+require_relative '../ptree/token_range'
+
+module Rley # This module is used as a namespace
+  module SPPF # This module is used as a namespace
+    # Abstract class. The generalization for all kinds of nodes
+    # occurring in a shared packed parse forest.
+    class SPPFNode
+    
+      # A range of indices for tokens matching this node.
+      attr_reader(:range)
+      
+      def initialize(aRange)
+        @range = PTree::TokenRange.new(aRange)
+      end
+      
+      # Return the origin (= lower bound of the range 
+      # = position of first token matched by the symbol)
+      def origin()
+        return range.low
+      end  
+    end # class
+  end # module
+end # module
+# End of file

data/lib/rley/sppf/token_node.rb

@@ -0,0 +1,29 @@
+require_relative 'leaf_node'
+
+module Rley # This module is used as a namespace
+  module SPPF # This module is used as a namespace
+    # A node in a parse forest that matches exactly one
+    # token from the input
+    class TokenNode < LeafNode
+      attr_reader(:token)
+      
+      # aPosition is the position of the token in the input stream.
+      def initialize(aToken, aPosition)
+        range = {low: aPosition, high: aPosition + 1}
+        super(range)
+        @token = aToken
+      end
+      
+      # Emit a (formatted) string representation of the node.
+      # Mainly used for diagnosis/debugging purposes.
+      def to_string(indentation)
+        return "#{token.terminal.name}#{range.to_string(indentation)}"
+      end
+      
+      def key()
+        @key ||= to_string(0)
+      end
+    end # class
+  end # module
+end # module
+# End of file

data/lib/rley/syntax/grammar_builder.rb

@@ -67,21 +67,25 @@ module Rley # This module is used as a namespace
       end
 
       # Given the grammar symbols and productions added to the builder,
-      # build the resulting grammar.
+      # build the resulting grammar (if not yet done).
       def grammar()
-        fail StandardError, 'No symbol found for grammar' if symbols.empty?
-        if productions.empty?
-          fail StandardError, 'No production found for grammar'
+        unless @grammar
+          fail StandardError, 'No symbol found for grammar' if symbols.empty?
+          if productions.empty?
+            fail StandardError, 'No production found for grammar'
+          end
+          
+          # Check that each non-terminal appears at least once in lhs.
+          all_non_terminals = symbols.values.select { |s| s.is_a?(NonTerminal) }
+          all_non_terminals.each do |n_term|
+            next if productions.any? { |prod| n_term == prod.lhs }
+            fail StandardError, "Nonterminal #{n_term.name} not rewritten"
+          end
+
+          @grammar = Grammar.new(productions.dup)
         end
         
-        # Check that each non-terminal appears at least once in lhs.
-        all_non_terminals = symbols.values.select { |s| s.is_a?(NonTerminal) }
-        all_non_terminals.each do |n_term|
-          next if productions.any? { |prod| n_term == prod.lhs }
-          fail StandardError, "Nonterminal #{n_term.name} not rewritten"
-        end
-
-        return Grammar.new(productions.dup)
+        return @grammar
       end
 
       private

data/lib/rley/syntax/grm_symbol.rb

@@ -12,6 +12,12 @@ module Rley # This module is used as a namespace
         @name = aName.dup
       end
       
+      # Return true iff the symbol is a terminal
+      def terminal?()
+        # Default implementation to override if necessary
+        return false
+      end
+      
       # The String representation of the grammar symbol
       # @return [String]
       def to_s()

data/lib/rley/syntax/terminal.rb

@@ -12,6 +12,11 @@ module Rley # This module is used as a namespace
         super(aName)
       end
       
+      # Return true iff the symbol is a terminal
+      def terminal?()
+        return true
+      end
+      
       # @return [false] Return true if the symbol derives
       # the empty string. As terminal symbol corresponds to a input token
       # it is by definition non-nullable.

data/spec/rley/gfg/call_edge_spec.rb

@@ -0,0 +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/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/end_vertex_spec.rb

@@ -18,6 +18,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           allow(sample_nt).to receive(:to_s).and_return('NT')
           expect(subject.label).to eq('NT.')
         end
+        
       end # context
     end # describe
   end # module

data/spec/rley/gfg/grm_flow_graph_spec.rb

@@ -1,5 +1,4 @@
 require_relative '../../spec_helper'
-require 'pp'
 
 require_relative '../support/grammar_abc_helper'
 require_relative '../../../lib/rley/parser/grm_items_builder'
@@ -53,6 +52,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect { GrmFlowGraph.new(items_from_grammar) }.not_to raise_error
         end
 
+        it 'should know its main start vertex' do
+          expect(subject.start_vertex).to eq(subject.vertices.first)
+        end
+
         it 'should have the correct number of vertices' do
           # Number of vertices = count of dotted items +...
           #   ... 2 * count of non-terminals
@@ -128,9 +131,28 @@ module Rley # Open this namespace to avoid module qualifier prefixes
               'A => a . --> A.',
               'A => . --> A.'
             ]
-            
+
             compare_graph_expectations(graph, expected)
         end
+
+        it 'should have shortcut edges' do
+          subject.vertices.each do |a_vertex|
+            next unless a_vertex.kind_of?(ItemVertex)
+            if a_vertex.next_symbol.kind_of?(Syntax::NonTerminal)
+              expect(a_vertex.shortcut).not_to be_nil            
+              my_d_item = a_vertex.dotted_item
+              
+              # Retrieve dotted item of shortcut successor
+              other_d_item = a_vertex.shortcut.successor.dotted_item
+              
+              # Now the checks...
+              expect(my_d_item.production).to eq(other_d_item.production)
+              expect(my_d_item.position).to eq(other_d_item.prev_position)
+            else
+              expect(a_vertex.shortcut).to be_nil
+            end
+          end
+        end
       end # context
     end # describe
   end # module

data/spec/rley/gfg/item_vertex_spec.rb

@@ -3,6 +3,7 @@ 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/shortcut_edge'
 
 # Load the class under test
 require_relative '../../../lib/rley/gfg/item_vertex'
@@ -10,20 +11,25 @@ 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(: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(: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(:empty_prod) { build_prod(nt_sentence) }
       let(:sample_item) { Parser::DottedItem.new(sample_prod, 1) }
+      let(:next_item) { Parser::DottedItem.new(sample_prod, 2) }
       subject { ItemVertex.new(sample_item) }
 
       context 'Initialization:' do
@@ -34,15 +40,78 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should know its dotted item' do
           expect(subject.dotted_item).to eq(sample_item)
         end
+
+        it 'should not have any shortcut edge at start' do
+          expect(subject.shortcut).to be_nil
+        end
       end # context
-      
+
       context 'Provided services:' do
         it 'should know its label' do
           expect(subject.label).to eq(sample_item.to_s)
         end
+
+        it 'should know the lhs of the production' do
+          expect(subject.lhs).to eq(nt_sentence)
+        end
+
+        it 'should know whether it has a dot at the end of the rhs' do
+          # Case: dot not at the end
+          expect(subject).not_to be_complete
+
+          # Case: dot at the end
+          instance1 = ItemVertex.new(Parser::DottedItem.new(sample_prod, 3))
+          expect(instance1).to be_complete
+
+          # Case: empty production
+          instance2 = ItemVertex.new(Parser::DottedItem.new(empty_prod, 0))
+          expect(instance2).to be_complete
+        end
+
+        it 'should know the previous symbol (if any) in the rhs' do
+          # Case: dot is after first symbol
+          instance1 = ItemVertex.new(sample_item)
+          expect(instance1.prev_symbol).to eq(t_a)
+          
+          # Case: dot is after second or later symbol
+          instance2 = ItemVertex.new(next_item)
+          expect(instance2.prev_symbol).to eq(nt_b_sequence)          
+
+          # Case: dot is at begin
+          instance3 = ItemVertex.new(Parser::DottedItem.new(sample_prod, 0))
+          expect(instance3.prev_symbol).to be_nil
+
+          # Case: empty production
+          instance4 = ItemVertex.new(Parser::DottedItem.new(empty_prod, 0))
+          expect(instance4.prev_symbol).to be_nil
+        end
         
         
-      end # context      
+        it 'should know the next symbol (if any) in the rhs' do
+          #Case: dot is not penultimate
+          expect(subject.next_symbol).to eq(nt_b_sequence)
+
+          # Case: dot is penultimate
+          instance1 = ItemVertex.new(next_item)
+          expect(instance1.next_symbol).to eq(t_c)
+
+          # Case: dot is at end
+          instance2 = ItemVertex.new(Parser::DottedItem.new(sample_prod, 3))
+          expect(instance2.next_symbol).to be_nil
+
+          # Case: empty production
+          instance3 = ItemVertex.new(Parser::DottedItem.new(empty_prod, 0))
+          expect(instance3.next_symbol).to be_nil
+        end
+
+        it 'should accept a shortcut edge' do
+          next_vertex = ItemVertex.new(next_item)
+
+          # The ShortcutEdge constructor invokes the shortcut setter
+          shortcut = ShortcutEdge.new(subject, next_vertex)
+          expect(subject.shortcut).to eq(shortcut)
+        end
+      end # context
     end # describe
   end # module
 end # module

data/spec/rley/gfg/non_terminal_vertex_spec.rb

@@ -17,6 +17,20 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should know its non-terminal' do
           expect(subject.non_terminal).to eq(sample_nt)
         end
+        
+
+        it 'should accept at more than one outgoing edge' 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

data/spec/rley/gfg/return_edge_spec.rb

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