rley 0.1.12 → 0.2.00

data/lib/rley/parser/parsing.rb

@@ -1,5 +1,6 @@
 require_relative 'chart'
-require_relative '../ptree/parse_tree'
+require_relative 'parse_state_tracker'
+require_relative 'parse_tree_builder'
 
 
 module Rley # This module is used as a namespace
@@ -9,7 +10,7 @@ module Rley # This module is used as a namespace
 
       # The sequence of input token to parse
       attr_reader(:tokens)
-
+      
       def initialize(startDottedRule, theTokens)
         @tokens = theTokens.dup
         @chart = Chart.new(startDottedRule, tokens.size)
@@ -31,49 +32,32 @@ module Rley # This module is used as a namespace
       # set state_set_index = index of last state set in chart
       # Search the completed parse state that corresponds to the full parse
       def parse_tree()
-        state_set_index = chart.state_sets.size - 1
-        parse_state = end_parse_state
-        full_range = { low: 0, high: state_set_index }
-        start_production = chart.start_dotted_rule.production
-        ptree = PTree::ParseTree.new(start_production, full_range)
-        return ptree if parse_state.nil?
+        state_tracker = new_state_tracker
+        builder = tree_builder(state_tracker.state_set_index)
+        
         loop do
-          curr_dotted_item = parse_state.dotted_rule
           # Look at the symbol on left of the dot
-          curr_symbol = curr_dotted_item.prev_symbol
+          curr_symbol = state_tracker.symbol_on_left
+          
           case curr_symbol
             when Syntax::Terminal
-              state_set_index -= 1
-              parse_state = predecessor_state_terminal(ptree, state_set_index, 
-                parse_state)
-              
+              state_tracker.to_prev_state_set
+              predecessor_state_terminal(curr_symbol, state_tracker, builder)
+
             when Syntax::NonTerminal
-              # Retrieve complete states with curr_symbol as lhs
-              new_states = chart[state_set_index].states_rewriting(curr_symbol)
-              # TODO: make this more robust
-              parse_state = new_states[0]
-              curr_dotted_item = parse_state.dotted_rule
-              # Additional check
-              if ptree.current_node.symbol != curr_dotted_item.production.lhs
-                ptree.step_back(state_set_index)
-              end
-              ptree.current_node.range = { low: parse_state.origin }
-              node_range =  ptree.current_node.range
-              ptree.add_children(curr_dotted_item.production, node_range)
-              link_node_to_token(ptree, state_set_index - 1)
-              
+              completed_state_for(curr_symbol, state_tracker, builder)
+
             when NilClass # No symbol on the left of dot
-              lhs = curr_dotted_item.production.lhs
-              new_states = states_expecting(lhs, state_set_index, true)
+              # Retrieve all parse states that expect the lhs
+              new_states = states_expecting_lhs(state_tracker)
               break if new_states.empty?
-              # TODO: make this more robust
-              parse_state = new_states[0]
-              ptree.step_up(state_set_index)
-              ptree.current_node.range = { low: parse_state.origin }
-              break if ptree.root == ptree.current_node
+              
+              select_expecting_state(new_states, state_tracker, builder)
+              break if builder.root == builder.current_node
           end
         end
-        return ptree
+
+        return builder.parse_tree
       end
 
 
@@ -102,7 +86,7 @@ module Rley # This module is used as a namespace
       def scanning(aTerminal, aPosition, &nextMapping)
         curr_token = tokens[aPosition]
         return unless curr_token.terminal == aTerminal
-        
+
         states = states_expecting(aTerminal, aPosition, false)
         states.each do |s|
           next_item = nextMapping.call(s.dotted_rule)
@@ -114,9 +98,9 @@ module Rley # This module is used as a namespace
 
       # This method is called when a parse state at chart entry reaches the end
       # of a production.
-      # For every state in chart[aPosition] that is complete 
+      # For every state in chart[aPosition] that is complete
       #  (i.e. of the form: { dotted_rule: X -> γ •, origin: j}),
-      # Find states s in chart[j] of the form 
+      # Find states 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 state of the form
@@ -137,22 +121,20 @@ module Rley # This module is used as a namespace
       def states_expecting(aTerminal, aPosition, toSort)
         expecting = chart[aPosition].states_expecting(aTerminal)
         return expecting if !toSort || expecting.size < 2
-        
+
         # Put predicted states ahead
         (predicted, others) = expecting.partition { |state| state.predicted? }
-        
+
         # Sort state 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
-      
-      private
-      
-      # Retrieve full parse state.
-      # After a successful parse, the last chart entry 
+
+      # Retrieve the parse state that represents a complete, successful parse
+      # After a successful parse, the last chart entry
       # has a parse state that involves the start production and
       # has a dot positioned at the end of its rhs.
       def end_parse_state()
@@ -162,25 +144,80 @@ module Rley # This module is used as a namespace
         candidate_states = last_chart_entry.states_for(start_production)
         return candidate_states.find(&:complete?)
       end
+
+      private
+      
+      # Factory method. Creates and initializes a ParseStateTracker instance.
+      def new_state_tracker()
+        instance = ParseStateTracker.new(chart.last_index)
+        instance.parse_state = end_parse_state
+
+        return instance
+      end
+      
       
+      # A terminal symbol is on the left of dot.
       # Go to the predecessor state for the given terminal
-      def predecessor_state_terminal(aParseTree, aStateSetIndex, current_state)
-        aParseTree.step_back(aStateSetIndex)
-        link_node_to_token(aParseTree, aStateSetIndex)
-        state_set = chart[aStateSetIndex]
-        state_set.predecessor_state(current_state)
+      def predecessor_state_terminal(a_symb, aStateTracker, aTreeBuilder)
+        aTreeBuilder.current_node.range = { low: aStateTracker.state_set_index }
+        link_node_to_token(aTreeBuilder, aStateTracker.state_set_index)
+        unless aTreeBuilder.current_node.is_a?(PTree::TerminalNode)
+          pp aTreeBuilder.root
+          pp aTreeBuilder.current_node
+          fail StandardError, "Expected terminal node"
+        end
+        aTreeBuilder.move_back
+        state_set = chart[aStateTracker.state_set_index]
+        previous_state = state_set.predecessor_state(aStateTracker.parse_state)
+        aStateTracker.parse_state = previous_state
       end
+      
+      
+      # Retrieve a complete state with given symbol as lhs.
+      def completed_state_for(a_symb, aStateTracker, aTreeBuilder)
+        new_states = chart[aStateTracker.state_set_index].states_rewriting(a_symb)
+        aStateTracker.select_state(new_states) 
+        aTreeBuilder.range = { high: aStateTracker.state_set_index }
+        aTreeBuilder.use_complete_state(aStateTracker.parse_state)
+        link_node_to_token(aTreeBuilder, aStateTracker.state_set_index - 1)
+        aTreeBuilder.move_down
+      end
+      
+      
+      def states_expecting_lhs(aStateTracker)
+        lhs = aStateTracker.curr_dotted_item.production.lhs
+        new_states = states_expecting(lhs, aStateTracker.state_set_index, true)
 
+        return new_states
+      end
       
+      def select_expecting_state(theStates, aStateTracker, aTreeBuilder)
+        # Select an unused parse state
+        aStateTracker.select_state(theStates) 
+        
+        aTreeBuilder.range = { low: aStateTracker.state_set_index }
+        aTreeBuilder.move_back
+        aTreeBuilder.range = { low: aStateTracker.parse_state.origin }
+      end
+
+
       # If the current node is a terminal node
       # then link the token to that node
-      def link_node_to_token(aParseTree, aStateSetIndex)
-        if aParseTree.current_node.is_a?(PTree::TerminalNode)
-          a_node = aParseTree.current_node
+      def link_node_to_token(aTreeBuilder, aStateSetIndex)
+        if aTreeBuilder.current_node.is_a?(PTree::TerminalNode)
+          a_node = aTreeBuilder.current_node
           a_node.token = tokens[aStateSetIndex] unless a_node.token
         end
       end
+
+      # Factory method. Initializes a ParseTreeBuilder object
+      def tree_builder(anIndex)
+        full_range = { low: 0, high: anIndex }
+        start_production = chart.start_dotted_rule.production
+        return ParseTreeBuilder.new(start_production, full_range)
+      end
       
+
     end # class
   end # module
 end # module

data/lib/rley/ptree/parse_tree.rb

@@ -7,19 +7,11 @@ module Rley # This module is used as a namespace
       # The root node of the tree
       attr_reader(:root)
 
-      # The path to current node
-      attr_reader(:current_path)
-
-      def initialize(aProduction, aRange)
-        @root = NonTerminalNode.new(aProduction.lhs, aRange)
-        @current_path = [ @root ]
-        add_children(aProduction, aRange)
+      # @param theRootNode [ParseTreeNode] The root node of the parse tree.
+      def initialize(theRootNode)
+        @root = theRootNode
       end
 
-      # Return the active node.
-      def current_node()
-        return current_path.last
-      end
 
       # Part of the 'visitee' role in the Visitor design pattern.
       #   A visitee is expected to accept the visit from a visitor object
@@ -33,81 +25,6 @@ module Rley # This module is used as a namespace
         aVisitor.end_visit_ptree(self)
       end
 
-      # Add children to the current node.
-      # The children nodes correspond to the rhs of the production.
-      # Update the range in the children given the passed range object.
-      # Pre-condition: the current node refers to the same (non-terminal)
-      # symbol of the lhs of the given produiction.
-      # @param aProduction [Production] A production rule
-      # @param aRange [TokenRange]
-      def add_children(aProduction, aRange)
-        if aProduction.lhs != current_node.symbol
-          msg = "Internal error. Expected symbol was #{aProduction.lhs} but current node is #{current_node.symbol}"
-          fail StandardError, msg
-        end
-        
-        aProduction.rhs.each do |symb|
-          case symb
-            when Syntax::Terminal
-              new_node = TerminalNode.new(symb, {})
-            when Syntax::NonTerminal
-              new_node = NonTerminalNode.new(symb, {})
-          end
-
-          current_node.add_child(new_node)
-        end
-
-        children = current_node.children
-        children.first.range = low_bound(aRange)
-        children.last.range = high_bound(aRange)
-        return if children.empty?
-
-        path_increment = [children.size - 1, children.last]
-        @current_path.concat(path_increment)
-      end
-
-      # Move the current node to the parent node.
-      # @param _tokenPos [Fixnum] position of the matching input token
-      def step_up(_tokenPos)
-        current_path.pop(2)
-      end
-
-
-
-      # Move the current node to the previous sibling node.
-      # @param tokenPos [Fixnum] position of the matching input token
-      def step_back(tokenPos)
-        (pos, last_node) = current_path[-2, 2]
-        last_node.range = low_bound(low: tokenPos)
-
-        return if pos <= 0
-        current_path.pop(2)
-        new_pos = pos - 1
-        new_curr_node = current_path.last.children[new_pos]
-        current_path << new_pos
-        current_path << new_curr_node
-        new_curr_node.range = high_bound(high: tokenPos)
-      end
-
-      private
-
-      def low_bound(aRange)
-        result = case aRange
-          when Hash then aRange[:low]
-          when TokenRange then aRange.low
-        end
-
-        return { low: result }
-      end
-
-      def high_bound(aRange)
-        result = case aRange
-          when Hash then aRange[:high]
-          when TokenRange then aRange.high
-        end
-
-        return { high: result }
-      end
     end # class
   end # module
 end # module

data/lib/rley/ptree/token_range.rb

@@ -22,6 +22,8 @@ module Rley # This module is used as a namespace
             result = low == other[:low] && high == other[:high]
           when TokenRange
             result = low == other.low && high == other.high
+          when Array
+            result = low == other[0] && high == other[1]
         end
 
         return result

data/lib/rley/syntax/grammar.rb

@@ -41,6 +41,12 @@ module Rley # This module is used as a namespace
       def non_terminals()
         return symbols.select { |s| s.kind_of?(NonTerminal) }
       end
+      
+      # @return [Production] The start production of the grammar (i.e.
+      #   the rule that specifies the syntax for the start symbol.
+      def start_production()
+        return rules[0]
+      end
 
       private
 

data/lib/rley/syntax/grammar_builder.rb

@@ -6,7 +6,7 @@ require_relative 'grammar'
 
 module Rley # This module is used as a namespace
   module Syntax # This module is used as a namespace
-    # Builder pattern. Builder pattern builds a complex object
+    # Builder GoF pattern. Builder pattern builds a complex object
     # (say, a grammar) from simpler objects (terminals and productions)
     # and using a step by step approach.
     class GrammarBuilder

data/spec/rley/formatter/json_spec.rb

@@ -43,9 +43,9 @@ module Rley # Re-open the module to get rid of qualified names
       # Generated tree has the following structure:
       # S[0,5]
       # +- A[0,5]
-      #    +- a[0,0]
+      #    +- a[0,1]
       #    +- A[1,4]
-      #    |  +- a[1,1]
+      #    |  +- a[1,2]
       #    |  +- A[2,3]
       #    |  |  +- b[2,3]
       #    |  +- c[3,4]

data/spec/rley/parser/chart_spec.rb

@@ -30,9 +30,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(subject.state_sets.size).to eq(count_token + 1)
         end
 
-        it 'should the start dotted rule' do
+        it 'should know the start dotted rule' do
           expect(subject.start_dotted_rule).to eq(dotted_rule)
         end
+        
+        it 'should have at least one non-empty state set' do
+          expect(subject.last_index).to eq(0)
+        end
       end # context
     end # describe
   end # module

data/spec/rley/parser/parse_tree_builder_spec.rb

@@ -0,0 +1,179 @@
+require_relative '../../spec_helper'
+require_relative '../../../lib/rley/parser/token'
+require_relative '../../../lib/rley/parser/earley_parser'
+require_relative '../../../lib/rley/parser/parsing'
+# Load the class under test
+require_relative '../../../lib/rley/parser/parse_tree_builder'
+require_relative '../support/grammar_abc_helper'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module Parser # Open this namespace to avoid module qualifier prefixes
+    describe ParseTreeBuilder do
+      include GrammarABCHelper  # Mix-in module with builder for grammar abc
+
+      let(:grammar_abc) do
+        builder = grammar_abc_builder
+        builder.grammar
+      end
+
+      let(:capital_a) { grammar_abc.name2symbol['A'] }
+      let(:capital_s) { grammar_abc.name2symbol['S'] }
+      let(:small_a) { grammar_abc.name2symbol['a'] }
+      let(:small_b) { grammar_abc.name2symbol['b'] }
+      let(:small_c) { grammar_abc.name2symbol['c'] }
+      
+      let(:start_prod) { grammar_abc.start_production } 
+
+      let(:tokens_abc) do
+        %w(a a b c c).map do |letter|
+          Token.new(letter, grammar_abc.name2symbol[letter])
+        end
+      end
+
+      let(:sample_parsing) do
+        parser = EarleyParser.new(grammar_abc)
+        result = parser.parse(tokens_abc)
+      end
+      
+      subject { ParseTreeBuilder.new(start_prod, {low: 0, high: 5}) }
+
+      context 'Initialization:' do
+        it 'should be created with a proposition and a range' do
+          expect { ParseTreeBuilder.new(start_prod, {}) }.not_to raise_error
+        end
+
+        it 'should have a root node at start' do
+            expect(subject.root.symbol).to eq(capital_s)
+        end
+
+        it "should have current path at start" do
+            expect(subject.current_path).not_to be_empty
+        end
+
+        it "should have current node at start" do
+            expect(subject.current_node.symbol).to eq(capital_a)
+        end
+      end # context
+
+      context 'Adding nodes to parse tree:' do
+        it 'should process parse state for a non-terminal node' do
+          # Expectation:
+          # S[0, 5]
+          # +- A[0,5]
+          expect(subject.root.symbol).to eq(capital_s)
+          expect(subject.root.children.size).to eq(1)
+          child1 = subject.root.children[0]
+          expect(child1.symbol).to eq(capital_a)
+          expect(child1.range.low).to eq(0)
+          expect(child1.range.high).to eq(5)
+          expect(subject.current_node).to eq(child1)
+
+          # Add children to A
+          other_state = sample_parsing.chart.state_sets.last.states.first
+          subject.use_complete_state(other_state)
+          
+          # Tree is:
+          # S[0,5]
+          # +- A[0,5]
+          #    +- a[0, ?]
+          #    +- A[?, ?]
+          #    +- c[?, 5]
+          expect(child1.children.size).to eq(3) # a A c
+          %w(a A c).each_with_index do |letter, i|
+            grm_symbol = grammar_abc.name2symbol[letter]
+            expect(child1.children[i].symbol).to eq(grm_symbol)
+          end
+          expect(child1.children[0].range.low).to eq(0)
+          expect(child1.children[-1].range.high).to eq(5)
+          
+          subject.move_down # ... to c
+          subject.range = {low: 4}
+          expect(child1.children[-1].range.low).to eq(4)
+          expect(child1.children.last).to eq(subject.current_node)
+          subject.move_back # ... to A
+          expect(subject.current_node).to eq(child1.children[1])
+          grand_child_A = subject.current_node
+
+          other_state = sample_parsing.chart.state_sets[4].first
+          subject.use_complete_state(other_state)
+          expect(grand_child_A.children.size).to eq(3) # a A c
+          %w(a A c).each_with_index do |letter, i|
+            grm_symbol = grammar_abc.name2symbol[letter]
+            expect(grand_child_A.children[i].symbol).to eq(grm_symbol)
+          end
+        end
+      end # context
+
+      context 'Moving the current node:' do
+        it 'should move down to last child' do
+          # Tree is:
+          # S[0,?]
+          # +- A[0,?]
+
+          # Add children to A
+          parse_state = sample_parsing.chart.state_sets.last.states.first
+          subject.use_complete_state(parse_state)
+
+          # Tree is:
+          # S[0,?]
+          # +- A[0,?]
+          #    +- a[0, ?]
+          #    +- A[?, ?]
+          #    +- c[?, ?]
+          subject.move_down # ...to grand-child c
+          expect(subject.current_node.symbol).to eq(small_c)
+
+
+          subject.move_back # ...to grand-child A
+          expect(subject.current_node.symbol).to eq(capital_a)
+
+          # Add more children
+          other_state = sample_parsing.chart.state_sets[4].states.first
+          subject.use_complete_state(other_state)
+
+          # Tree is:
+          # S[0,?]
+          # +- A[0,?]
+          #    +- a[0, ?]
+          #    +- A[?, ?]
+          #       +- a[?, ?]
+          #       +- A[?, ?]
+          #       +- c [?, ?]
+          #    +- c[?, ?]
+
+          subject.move_down # ...to grand-grand-child c
+          expect(subject.current_node.symbol).to eq(small_c)
+
+          subject.move_back # ...to grand-grand-child A
+          expect(subject.current_node.symbol).to eq(capital_a)
+
+          subject.move_back # ...to grand-grand-child a
+          expect(subject.current_node.symbol).to eq(small_a)
+
+          subject.move_back # ...to grand-child A
+          expect(subject.current_node.symbol).to eq(capital_a)
+          
+          subject.move_back # ...to grand-child a
+          expect(subject.current_node.symbol).to eq(small_a)
+
+          subject.move_back # ...to child A
+          expect(subject.current_node.symbol).to eq(capital_a)
+
+          subject.move_back # ...to S
+          expect(subject.current_node.symbol).to eq(capital_s)           
+        end
+      end # context
+      
+      context 'Parse tree building:' do       
+        it 'should build a parse tree' do
+          expect(subject.parse_tree).to be_kind_of(PTree::ParseTree)
+          actual = subject.parse_tree
+          expect(actual.root).to eq(subject.root)
+        end
+      end # context
+      
+    end # describe
+  end # module
+end # module
+
+# End of file