rley 0.4.01 → 0.4.02

data/lib/rley/parser/parse_tree_factory.rb

@@ -0,0 +1,57 @@
+require_relative 'parse_walker_factory'
+require_relative 'parse_tree_builder'
+
+module Rley # This module is used as a namespace
+  module Parser # This module is used as a namespace
+    # Utility class that helps to create a ParseTree from
+    # a given Parsing object.
+    class ParseTreeFactory
+      # Link to Parsing object (= results of recognizer)
+      attr_reader(:parsing)
+
+
+      def initialize(aParsingResult)
+        @parsing = aParsingResult
+      end
+
+      # Factory that produces the parse tree
+      def build_parse_tree()
+        a_walker = walker(parsing)
+        a_builder = builder(parsing)
+
+        begin
+          loop do
+            event = a_walker.next
+            # puts "EVENT #{event[0]} #{event[1]}"
+            a_builder.receive_event(*event)
+          end
+        rescue StopIteration
+          # Do nothing
+        end
+
+        return a_builder.tree
+      end
+
+
+      private
+
+      # Create a Parsing walker, that is, an object
+      # that will iterate over the relevant nodes (= parsing entries)
+      # of a GFGParsing
+      def walker(aParseResult)
+        walker_factory = ParseWalkerFactory.new
+        accept_entry = aParseResult.accepting_entry
+        accept_index = aParseResult.chart.last_index
+        walker_factory.build_walker(accept_entry, accept_index)
+      end
+
+      # Create a Builder, that is, an object
+      # that will create piece by piece the forest
+      def builder(aParseResult)
+        ParseTreeBuilder.new(aParseResult.tokens)
+      end
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/rley/ptree/non_terminal_node.rb

@@ -3,17 +3,18 @@ require_relative 'parse_tree_node' # Load superclass
 module Rley # This module is used as a namespace
   module PTree # This module is used as a namespace
     class NonTerminalNode < ParseTreeNode
-      # Link to the input token
-      attr_reader(:children)
+      # Array of sub-nodes.
+      attr_reader(:subnodes)
 
       def initialize(aSymbol, aRange)
         super(aSymbol, aRange)
-        @children = []
+        @subnodes = []
       end
 
-      # @param aChildNode [ParseTreeNode-like] a child node.
-      def add_child(aChildNode)
-        children << aChildNode
+      # Pre-pend the given subnode in front of the list of subnodes
+      # @param aSubnode [ParseTreeNode-like] a child node.
+      def add_subnode(aSubnode)
+        subnodes.unshift(aSubnode)
       end
       
       # Emit a (formatted) string representation of the node.
@@ -22,11 +23,11 @@ module Rley # This module is used as a namespace
         connector = '+- '
         selfie = super(indentation)
         prefix = "\n" + (' ' * connector.size * indentation) + connector
-        children_repr = children.reduce('') do |sub_result, child|
-          sub_result << prefix + child.to_string(indentation + 1) 
+        subnodes_repr = subnodes.reduce('') do |sub_result, subnode|
+          sub_result << prefix + subnode.to_string(indentation + 1) 
         end
         
-        return selfie + children_repr
+        return selfie + subnodes_repr        
       end
       
       # Part of the 'visitee' role in Visitor design pattern.

data/lib/rley/ptree/parse_tree_node.rb

@@ -1,4 +1,4 @@
-require_relative 'token_range'
+require_relative '../tokens/token_range'
 
 module Rley # This module is used as a namespace
   module PTree # This module is used as a namespace
@@ -11,19 +11,24 @@ module Rley # This module is used as a namespace
 
       def initialize(aSymbol, aRange)
         @symbol = aSymbol
-        @range = TokenRange.new(aRange)
+        @range = Tokens::TokenRange.new(aRange)
       end
-      
+
       def range=(aRange)
         range.assign(aRange)
       end
-      
+
       # Emit a (formatted) string representation of the node.
       # Mainly used for diagnosis/debugging purposes.
       def to_string(indentation)
-        
         return "#{symbol.name}#{range.to_string(indentation)}"
       end
+
+      # Emit a short string representation of the node.
+      # Mainly used for diagnosis/debugging purposes.
+      def to_s()
+        return "#{symbol.name}#{range.to_string(0)}"
+      end
     end # class
   end # module
 end # module

data/lib/rley/ptree/terminal_node.rb

@@ -4,24 +4,32 @@ module Rley # This module is used as a namespace
   module PTree # This module is used as a namespace
     class TerminalNode < ParseTreeNode
       # Link to the input token
-      attr(:token, true)
+      attr_reader(:token)
 
-      def initialize(aTerminalSymbol, aRange)
-        super(aTerminalSymbol, aRange)
+      # aPosition is the position of the token in the input stream.      
+      def initialize(aToken, aPos)
+        range = aPos.kind_of?(Fixnum) ? { low: aPos, high: aPos + 1 } : aPos
+        super(aToken.terminal, range)
+        @token = aToken
       end
 
       # Emit a (formatted) string representation of the node.
       # Mainly used for diagnosis/debugging purposes.
       def to_string(indentation)
-        value = token.nil? ? '(nil)' : token.lexeme
-        super(indentation) + ": '#{value}'"
+        return super + ": '#{token.lexeme}'"
       end
+      
+      # Emit a short string representation of the node.
+      # Mainly used for diagnosis/debugging purposes.
+      def to_s()
+        return super + ": '#{token.lexeme}'"
+      end      
 
       # Part of the 'visitee' role in Visitor design pattern.
       # @param aVisitor[ParseTreeVisitor] the visitor
       def accept(aVisitor)
         aVisitor.visit_terminal(self)
-      end
+      end      
     end # class
   end # module
 end # module

data/lib/rley/sppf/sppf_node.rb

@@ -1,4 +1,4 @@
-require_relative '../ptree/token_range'
+require_relative '../tokens/token_range'
 
 module Rley # This module is used as a namespace
   module SPPF # This module is used as a namespace
@@ -10,7 +10,7 @@ module Rley # This module is used as a namespace
       attr_reader(:range)
       
       def initialize(aRange)
-        @range = PTree::TokenRange.new(aRange)
+        @range = Tokens::TokenRange.new(aRange)
       end
       
       # Return the origin (= lower bound of the range 

data/lib/rley/{parser → tokens}/token.rb

@@ -1,8 +1,5 @@
-require_relative '../syntax/grammar'
-require_relative 'dotted_item'
-
 module Rley # This module is used as a namespace
-  module Parser # This module is used as a namespace
+  module Tokens # This module is used as a namespace
     class Token
       attr_reader(:lexeme)
       attr_reader(:terminal)

data/lib/rley/{ptree → tokens}/token_range.rb

@@ -1,5 +1,5 @@
 module Rley # This module is used as a namespace
-  module PTree # This module is used as a namespace
+  module Tokens # This module is used as a namespace
     # A token range (also called an extent) represents an interval 
     # of token positions that is matched by a given grammar symbol.
     # For instance consider the expression E: 3 + 11,

data/spec/rley/formatter/debug_spec.rb

@@ -2,8 +2,8 @@ require_relative '../../spec_helper'
 require 'stringio'
 
 require_relative '../support/grammar_abc_helper'
-require_relative '../../../lib/rley/parser/token'
-require_relative '../../../lib/rley/parser/earley_parser'
+require_relative '../../../lib/rley/tokens/token'
+require_relative '../../../lib/rley/parser/gfg_earley_parser'
 require_relative '../../../lib/rley/ptree/parse_tree'
 require_relative '../../../lib/rley/parse_tree_visitor'
 # Load the class under test
@@ -30,11 +30,11 @@ module Rley # Re-open the module to get rid of qualified names
       # for the language specified by gramma_abc
       let(:grm_abc_tokens1) do
         [
-          Parser::Token.new('a', a_),
-          Parser::Token.new('a', a_),
-          Parser::Token.new('b', b_),
-          Parser::Token.new('c', c_),
-          Parser::Token.new('c', c_)
+          Tokens::Token.new('a', a_),
+          Tokens::Token.new('a', a_),
+          Tokens::Token.new('b', b_),
+          Tokens::Token.new('c', c_),
+          Tokens::Token.new('c', c_)
         ]
       end
 
@@ -51,7 +51,7 @@ module Rley # Re-open the module to get rid of qualified names
       #    +- c[4,5]
       # Capital letters represent non-terminal nodes
       let(:grm_abc_ptree1) do
-        parser = Parser::EarleyParser.new(grammar_abc)
+        parser = Parser::GFGEarleyParser.new(grammar_abc)
         parse_result = parser.parse(grm_abc_tokens1)
         parse_result.parse_tree
       end
@@ -79,30 +79,30 @@ module Rley # Re-open the module to get rid of qualified names
           expectations = <<-SNIPPET
 before_ptree
   before_non_terminal
-    before_children
+    before_subnodes
       before_non_terminal
-        before_children
+        before_subnodes
           before_terminal
           after_terminal
           before_non_terminal
-            before_children
+            before_subnodes
               before_terminal
               after_terminal
               before_non_terminal
-                before_children
+                before_subnodes
                   before_terminal
                   after_terminal
-                after_children
+                after_subnodes
               after_non_terminal
               before_terminal
               after_terminal
-            after_children
+            after_subnodes
           after_non_terminal
           before_terminal
           after_terminal
-        after_children
+        after_subnodes
       after_non_terminal
-    after_children
+    after_subnodes
   after_non_terminal
 after_ptree
 SNIPPET

data/spec/rley/formatter/json_spec.rb

@@ -2,8 +2,8 @@ require_relative '../../spec_helper'
 require 'stringio'
 
 require_relative '../support/grammar_abc_helper'
-require_relative '../../../lib/rley/parser/token'
-require_relative '../../../lib/rley/parser/earley_parser'
+require_relative '../../../lib/rley/tokens/token'
+require_relative '../../../lib/rley/parser/gfg_earley_parser'
 require_relative '../../../lib/rley/ptree/parse_tree'
 require_relative '../../../lib/rley/parse_tree_visitor'
 # Load the class under test
@@ -30,11 +30,11 @@ module Rley # Re-open the module to get rid of qualified names
       # for the language specified by gramma_abc
       let(:grm_abc_tokens1) do
         [
-          Parser::Token.new('a', a_),
-          Parser::Token.new('a', a_),
-          Parser::Token.new('b', b_),
-          Parser::Token.new('c', c_),
-          Parser::Token.new('c', c_)
+          Tokens::Token.new('a', a_),
+          Tokens::Token.new('a', a_),
+          Tokens::Token.new('b', b_),
+          Tokens::Token.new('c', c_),
+          Tokens::Token.new('c', c_)
         ]
       end
 
@@ -51,7 +51,7 @@ module Rley # Re-open the module to get rid of qualified names
       #    +- c[4,5]
       # Capital letters represent non-terminal nodes
       let(:grm_abc_ptree1) do
-        parser = Parser::EarleyParser.new(grammar_abc)
+        parser = Parser::GFGEarleyParser.new(grammar_abc)
         parse_result = parser.parse(grm_abc_tokens1)
         parse_result.parse_tree
       end

data/spec/rley/parse_forest_visitor_spec.rb

@@ -2,7 +2,7 @@ require_relative '../spec_helper'
 
 require_relative './support/grammar_helper'
 require_relative './support/grammar_sppf_helper'
-require_relative '../../lib/rley/parser/token'
+require_relative '../../lib/rley/tokens/token'
 require_relative '../../lib/rley/parser/gfg_earley_parser'
 require_relative '../../lib/rley/sppf/non_terminal_node'
 require_relative '../../lib/rley/sppf/parse_forest'

data/spec/rley/parse_tree_visitor_spec.rb

@@ -1,8 +1,8 @@
 require_relative '../spec_helper'
 
 require_relative './support/grammar_abc_helper'
-require_relative '../../lib/rley/parser/token'
-require_relative '../../lib/rley/parser/earley_parser'
+require_relative '../../lib/rley/tokens/token'
+require_relative '../../lib/rley/parser/gfg_earley_parser'
 # Load the class under test
 require_relative '../../lib/rley/parse_tree_visitor'
 
@@ -24,11 +24,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
     # for the language specified by gramma_abc
     let(:grm_abc_tokens1) do
       [
-        Parser::Token.new('a', a_),
-        Parser::Token.new('a', a_),
-        Parser::Token.new('b', b_),
-        Parser::Token.new('c', c_),
-        Parser::Token.new('c', c_)
+        Tokens::Token.new('a', a_),
+        Tokens::Token.new('a', a_),
+        Tokens::Token.new('b', b_),
+        Tokens::Token.new('c', c_),
+        Tokens::Token.new('c', c_)
       ]
     end
 
@@ -45,7 +45,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
     #    +- c[4,5]
     # Capital letters represent non-terminal nodes
     let(:grm_abc_ptree1) do
-      parser = Parser::EarleyParser.new(grammar_abc)
+      parser = Parser::GFGEarleyParser.new(grammar_abc)
       parse_result = parser.parse(grm_abc_tokens1)
       parse_result.parse_tree
     end
@@ -110,13 +110,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       # Sample non-terminal node
       let(:nterm_node) do
-        first_big_a = grm_abc_ptree1.root.children[0]
-        second_big_a = first_big_a.children[1]
-        second_big_a.children[1]
+        first_big_a = grm_abc_ptree1.root.subnodes[0]
+        second_big_a = first_big_a.subnodes[1]
+        second_big_a.subnodes[1]
       end
 
       # Sample terminal node
-      let(:term_node) { nterm_node.children[0] }
+      let(:term_node) { nterm_node.subnodes[0] }
 
       it 'should react to the start_visit_ptree message' do
         # Notify subscribers when start the visit of the ptree
@@ -132,13 +132,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       it 'should react to the visit_children message' do
         # Notify subscribers when start the visit of children nodes
-        children = nterm_node.children
+        children = nterm_node.subnodes
         args = [nterm_node, children]
-        expect(listener1).to receive(:before_children).with(*args)
+        expect(listener1).to receive(:before_subnodes).with(*args)
         expect(listener1).to receive(:before_terminal).with(children[0])
         expect(listener1).to receive(:after_terminal).with(children[0])
-        expect(listener1).to receive(:after_children).with(nterm_node, children)
-        subject.send(:traverse_children, nterm_node)
+        expect(listener1).to receive(:after_subnodes).with(nterm_node, children)
+        subject.send(:traverse_subnodes, nterm_node)
       end
 
       it 'should react to the end_visit_nonterminal message' do
@@ -172,37 +172,37 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         #    |  +- c[3,4]
         #    +- c[4,5]
         root = grm_abc_ptree1.root
-        children = root.children
+        children = root.subnodes
         big_a_1 = children[0]
-        big_a_1_children = big_a_1.children
+        big_a_1_children = big_a_1.subnodes
         big_a_2 = big_a_1_children[1]
-        big_a_2_children = big_a_2.children
+        big_a_2_children = big_a_2.subnodes
         big_a_3 = big_a_2_children[1]
-        big_a_3_children = big_a_3.children
+        big_a_3_children = big_a_3.subnodes
         expectations = [
           [:before_ptree, [grm_abc_ptree1]],
           [:before_non_terminal, [root]],
-          [:before_children, [root, children]],
+          [:before_subnodes, [root, children]],
           [:before_non_terminal, [big_a_1]],
-          [:before_children, [big_a_1, big_a_1_children]],
+          [:before_subnodes, [big_a_1, big_a_1_children]],
           [:before_terminal, [big_a_1_children[0]]],
           [:after_terminal, [big_a_1_children[0]]],
           [:before_non_terminal, [big_a_2]],
-          [:before_children, [big_a_2, big_a_2_children]],
+          [:before_subnodes, [big_a_2, big_a_2_children]],
           [:before_terminal, [big_a_2_children[0]]],
           [:after_terminal, [big_a_2_children[0]]],
           [:before_non_terminal, [big_a_3]],
-          [:before_children, [big_a_3, big_a_3_children]],
+          [:before_subnodes, [big_a_3, big_a_3_children]],
           [:before_terminal, [big_a_3_children[0]]],
           [:after_terminal, [big_a_3_children[0]]],
-          [:after_children, [big_a_3, big_a_3_children]],
+          [:after_subnodes, [big_a_3, big_a_3_children]],
           [:before_terminal, [big_a_2_children[2]]],
           [:after_terminal, [big_a_2_children[2]]],
-          [:after_children, [big_a_2, big_a_2_children]],
+          [:after_subnodes, [big_a_2, big_a_2_children]],
           [:before_terminal, [big_a_1_children[2]]],
           [:after_terminal, [big_a_1_children[2]]],
-          [:after_children, [big_a_1, big_a_1_children]],
-          [:after_children, [root, children]],
+          [:after_subnodes, [big_a_1, big_a_1_children]],
+          [:after_subnodes, [root, children]],
           [:after_ptree, [grm_abc_ptree1]]
         ]
         expectations.each do |(msg, args)|