rley 0.0.18 → 0.1.00

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    N2Y1Yjg4Mzg5ZWI5YjU1NzBkMzYzOWNkNTMzMzA4NGJjYjgwYWE2Yw==
+    MzdkNmMxNWFhMmZjYWY2MzUwM2JhZjUyYzQxYmJjMzdiZmFjMjRhOQ==
   data.tar.gz: !binary |-
-    NDk0ZDFjNTkxZjNjZTE0NTRhNGFkMTc3YzYxNjY3NWExNzI0ZWMzOQ==
+    ODFlMzBlNjNjYjQyODIyNjQwYzY2OTUzMTAyNDI3NGIyMmFkOTcxMg==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    ZGRkMzE5Y2ExNmIwNThkNmZhYmVmZTNmMTc5ZjQxODEyZjU0MTdkZDMyNGVl
-    ZmNlYzc4MjY4ZDJjNTA0NzU2MWUzMTFhNTVjNjAxZWVhYTMxYmM3NDI0MjM1
-    Yjg0MTA3ODkzNTA5MjQ2NTVhNDY2ODdmNWIyMTAxNDlmMmJiMWE=
+    M2EyMDU5MDQ2YzFiYTMyNGU1OWYxYWQ2ODBjNjllZjNhZTUzZjU3NmY0YzE0
+    ODYzMTRiZjZmNzg2ZjZmMTIzZWI2MmNiNzY4M2ZiYjljZTcyN2E4MGNjZDNl
+    ZTQ5YTQ0OWRjMmFlNGIwNTFmMjU2Y2E4YzJkMjFiZGM4NjU4NDI=
   data.tar.gz: !binary |-
-    NGQ4NjBkNGExZTdlNTkxMDEzNDAwYWEyNjE5NTJlZjhlYWI2Mjc0OTdjNjVl
-    YWU2MzJiOWJkZmViNGMyNGJhZTYxM2Q4Y2FkMGJhOTM0YjJkNjczOTExYTgy
-    NjQwNDVhODZiODUwY2EwOTBlMzJhY2JjODc3OTZkY2QwZTQ3MWE=
+    ZTRlMjdhNGM3MTIzZTUyZmQ5MDVjZGMxZjFlNzI0MTI3NTIyZjNlZDBiYmEz
+    ZTU1MDQ4NTBlNzJjYmRiMDRlZTdmODdhYTUwY2NiZDcxMTVlYTM5NjgwZDcz
+    MzM0YTBjZDJiMGI1YWMxMDI0MzYzOGQ4ZDU5ZjIwNWZkZDY2ZWY=

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+### 0.1.00 / 2014-12-05
+* [CHANGE] Bumped version number: it is the first version able to generate a parse tree.
+* [NEW] `Grammar#name2symbol` attribute and accessor. Retrieve a grammar symbol from its name.
+* [NEW] Methods `DottedItem#prev_symbol`, `DottedItem#prev_position` to find symbol on left of dot.
+* [NEW] Method `ParseState#precedes?`, predicate to check whether self is a predecessor of given parse state.
+* [NEW] Method `Parsing#parse_tree` returns a ParseTree object that represents the result of a parse.
+
+
+### 0.0.18 / 2014-11-23
+* [CHANGE] `EarleyParser#parse`: Optimization prevent repeated prediction of same non-terminal for same state set.
+* [CHANGE] File `earley_parser_spec.rb`: Added new test for nullable grammar.
+* [CHANGE] Style refactoring in classes `EarleyParser`, `StateSet`, `Grammar`, `NonTerminal`
+
 ### 0.0.17 / 2014-11-23
 * [CHANGE] File `earley_parser_spec.rb`: Added step-by-step test of ambiguous grammar parsing.
 

data/lib/rley/constants.rb

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

data/lib/rley/parser/dotted_item.rb

@@ -21,7 +21,7 @@ module Rley # This module is used as a namespace
       # Index of the next symbol (from the rhs) after the 'dot'.
       # If the dot is at the end of the rhs (i.e.) there is no next
       # symbol, then the position takes the value -1.
-      # It the rhs is empty, then the postion is -2
+      # It the rhs is empty, then the position is -2
       attr_reader(:position)
 
       # @param aProduction
@@ -64,11 +64,37 @@ module Rley # This module is used as a namespace
         return production.lhs
       end
       
+      # Return the symbol before the dot.
+      # nil is returned if the dot is at the start of the rhs
+      def prev_symbol()
+        before_position = prev_position
+        if before_position.nil?
+          result = nil
+        else
+          result =  production.rhs[before_position]
+        end
+        
+        return result
+      end
+      
       # Return the symbol after the dot.
       # nil is returned if the dot is at the end
       def next_symbol()
         return (position < 0) ? nil : production.rhs[position]
       end
+      
+      # Calculate the position of the dot if were moved by 
+      # one step on the left.
+      def prev_position()
+        case position
+          when -2, 0
+            result = nil
+          when -1
+            result = (production.rhs.size == 1) ? 0 : (production.rhs.size - 1)
+          else
+            result = position-1
+        end
+      end
 
       # An item with the dot in front of a terminal is called a shift item
       def shift_item?()

data/lib/rley/parser/parse_state.rb

@@ -24,18 +24,36 @@ module Rley # This module is used as a namespace
 
         return result
       end
-      
+
       # Returns true if the dot is at the end of the rhs of the production.
       # In other words, the complete rhs matches the input.
       def complete?()
         return dotted_rule.reduce_item?
       end
-      
+
       # Next expected symbol in the production
       def next_symbol()
         return dotted_rule.next_symbol
       end
-      
+
+      # Does this parse state have the 'other' as successor?
+      def precedes?(other)
+        return false if self == other
+
+        return false unless origin == other.origin
+        other_production = other.dotted_rule.production
+        return false unless dotted_rule.production == other_production
+
+        prev_position = other.dotted_rule.prev_position
+        if prev_position.nil?
+          result = false
+        else
+          result = dotted_rule.position == prev_position
+        end
+
+        return result
+      end
+
       # Give a String representation of itself.
       # The format of the text representation is
       # "format of dotted rule" + " | " + origin
@@ -43,13 +61,14 @@ module Rley # This module is used as a namespace
       def to_s()
         return  dotted_rule.to_s + " | #{origin}"
       end
-      
+
+
       private
-      
+
       # Return the validated dotted item(rule)
       def valid_dotted_rule(aDottedRule)
         fail StandardError, 'Dotted item cannot be nil' if aDottedRule.nil?
-        
+
         return aDottedRule
       end
     end # class

data/lib/rley/parser/parsing.rb

@@ -1,4 +1,5 @@
 require_relative 'chart'
+require_relative '../ptree/parse_tree'
 
 module Rley # This module is used as a namespace
   module Parser # This module is used as a namespace
@@ -17,18 +18,61 @@ module Rley # This module is used as a namespace
       # followed the syntax specified by the grammar)
       def success?()
         # Success can be detected as follows:
-        # The last chart entry has a parse state
-        # that involves the start production and
-        # has a dot positioned at the end of its rhs.
-
-        start_dotted_rule = chart.start_dotted_rule
-        start_production = start_dotted_rule.production
-        last_chart_entry = chart.state_sets.last
-        candidate_states = last_chart_entry.states_for(start_production)
-        found = candidate_states.find(&:complete?)
-
+        # The last chart entry has a complete parse state
+        # with the start symbol as lhs
+        found = end_parse_state
         return !found.nil?
       end
+      
+      # Factory method. Builds a ParseTree from the parse result.
+      # @return [ParseTree]
+      # Algorithm:
+      # 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
+        curr_dotted_item = parse_state.dotted_rule
+        full_range = { low: 0, high: state_set_index }
+        ptree = PTree::ParseTree.new(curr_dotted_item.production, full_range)
+        loop do
+          # Look at the symbol on left of the dot
+          curr_symbol = curr_dotted_item.prev_symbol
+          case curr_symbol
+            when Syntax::Terminal
+              state_set_index -= 1
+              ptree.step_back(state_set_index)
+              parse_state = chart[state_set_index].predecessor_state(parse_state)
+              curr_dotted_item = parse_state.dotted_rule
+              
+            when Syntax::NonTerminal
+              # Retrieve complete states
+              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
+              ptree.current_node.range = { low: parse_state.origin }
+              node_range =  ptree.current_node.range
+              ptree.add_children(curr_dotted_item.production, node_range)
+              
+            when NilClass
+              lhs = curr_dotted_item.production.lhs
+              new_states = chart[state_set_index].states_expecting(lhs)
+              break if new_states.empty?
+              # TODO: make this more robust
+              parse_state = new_states[0]
+              curr_dotted_item = parse_state.dotted_rule
+              ptree.step_up(state_set_index)
+              ptree.current_node.range = { low: parse_state.origin }
+              break if ptree.root == ptree.current_node
+            else
+              msg = "Unexpected grammar symbol type #{curr_symbol.class}"
+              raise StandardError, msg
+          end
+        end
+        
+        return ptree
+      end
 
 
       # Push a parse state (dotted item + origin) to the
@@ -91,6 +135,20 @@ module Rley # This module is used as a namespace
       def states_expecting(aTerminal, aPosition)
         return chart[aPosition].states_expecting(aTerminal)
       end
+      
+      private
+      
+      # Retrieve full parse state.
+      # 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()
+        start_dotted_rule = chart.start_dotted_rule
+        start_production = start_dotted_rule.production
+        last_chart_entry = chart.state_sets[-1]
+        candidate_states = last_chart_entry.states_for(start_production)
+        return candidate_states.find(&:complete?)
+      end
     end # class
   end # module
 end # module

data/lib/rley/parser/state_set.rb

@@ -26,10 +26,31 @@ module Rley # This module is used as a namespace
         return states.select { |s| s.dotted_rule.next_symbol == aTerminal }
       end
 
+      # The list of complete ParseState that have the symbol as the lhs of their
+      # production
+      def states_rewriting(aNonTerm)
+        return states.select do |s| 
+          (s.dotted_rule.production.lhs == aNonTerm) && s.complete?
+        end
+      end
+      
       # The list of ParseState that involve the given production
       def states_for(aProduction)
         return states.select { |s| s.dotted_rule.production == aProduction }
       end
+      
+      # Retrieve the parse state that is the predecessor of the given one.
+      def predecessor_state(aParseState)
+        if aParseState.dotted_rule.prev_position.nil?
+          raise StandardError, "#{aParseState}"
+        else
+          prod = aParseState.dotted_rule.production
+          candidate = states.find { |s| s.precedes?(aParseState) }
+        end
+        
+        return candidate
+      end
+      
 
       private
 

data/lib/rley/ptree/non_terminal_node.rb

@@ -0,0 +1,21 @@
+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)
+
+      def initialize(aSymbol, aRange)
+        super(aSymbol, aRange)
+        @children = []
+      end
+
+      # @param aChildNode [ParseTreeNode-like] a child node.
+      def add_child(aChildNode)
+        children << aChildNode
+      end
+    end # class
+  end # module
+end # module
+# End of file

data/lib/rley/ptree/parse_tree.rb

@@ -0,0 +1,95 @@
+require_relative 'terminal_node'
+require_relative 'non_terminal_node'
+
+module Rley # This module is used as a namespace
+  module PTree # This module is used as a namespace
+    class ParseTree
+      # 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)
+      end
+
+      # Return the active node.
+      def current_node()
+        return current_path.last
+      end
+
+
+      def add_children(aProduction, aRange)
+        aProduction.rhs.each do |symb|
+          case symb
+            when Syntax::Terminal
+              new_node = TerminalNode.new(symb,{})
+            when Syntax::NonTerminal
+              new_node = NonTerminalNode.new(symb,{})
+            else
+              fail Standard, "Unknown grammar symbol type #{symb.class}"
+          end
+
+          current_node.add_child(new_node)
+        end
+
+        children = current_node.children
+        children.first.range = low_bound(aRange)
+        children.last.range = high_bound(aRange)
+        unless children.empty?
+          path_increment = [children.size - 1, children.last]
+          @current_path.concat(path_increment)
+        end
+      end
+      
+      # Move the current node to the parent node.
+      # @param tokenPos [Fixnum] position of the matching input token
+      def step_up(tokenPos)
+        (pos, last_node) = current_path.pop(2)
+        #last_node.range = low_bound({low: tokenPos})
+      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})
+
+        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
+      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
+# End of file

data/lib/rley/ptree/parse_tree_node.rb

@@ -0,0 +1,25 @@
+require_relative 'token_range'
+
+module Rley # This module is used as a namespace
+  module PTree # This module is used as a namespace
+    class ParseTreeNode
+      # Link to the grammar symbol
+      attr_reader(:symbol)
+
+      # A range of indices for tokens corresponding to the node.
+      attr_reader(:range)
+
+
+      def initialize(aSymbol, aRange)
+        @symbol = aSymbol
+        @range = TokenRange.new(aRange)
+      end
+      
+      def range=(aRange)
+        range.assign(aRange)
+      end
+
+    end # class
+  end # module
+end # module
+# End of file

data/lib/rley/ptree/terminal_node.rb

@@ -0,0 +1,16 @@
+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 TerminalNode < ParseTreeNode
+      # Link to the input token
+      attr_writer(:token)
+
+      def initialize(aTerminalSymbol, aRange)
+        super(aTerminalSymbol, aRange)
+      end
+
+    end # class
+  end # module
+end # module
+# End of file

data/lib/rley/ptree/token_range.rb

@@ -0,0 +1,61 @@
+module Rley # This module is used as a namespace
+  module PTree # This module is used as a namespace
+    class TokenRange
+      # The index of the lower bound of token range
+      attr_reader(:low)
+
+      # The index of the upper bound of token range
+      attr_reader(:high)
+
+      # @param aRangeRep [Hash]
+      def initialize(aRangeRep)
+        assign_low(aRangeRep)
+        assign_high(aRangeRep)
+      end
+      
+      
+      def ==(other)
+        return true if object_id == other.object_id
+        
+        case other
+          when Hash
+            result = low == other[:low] && high == other[:high]
+          when TokenRange
+            result = low == other.low && high == other.high
+        end
+        
+        return result
+      end
+
+      # true when both bounds aren't nil.
+      def bounded?()
+        return !(low.nil? || high.nil?)
+      end
+      
+      # Conditional assign
+      def assign(aRange)
+        return if bounded?
+        
+        assign_low(aRange) if low.nil?
+        assign_high(aRange) if high.nil?
+      end
+      
+      private
+      def assign_low(aRange)
+        case aRange
+        when Hash then @low = aRange.fetch(:low, nil)
+        when TokenRange then @low = aRange.low
+        end
+      end
+      
+      def assign_high(aRange)
+        case aRange
+        when Hash then @high = aRange.fetch(:high, nil)
+        when TokenRange then @high = aRange.high
+        end
+      end
+
+    end # class
+  end # module
+end # module
+# End of file

data/lib/rley/syntax/grammar.rb

@@ -20,12 +20,16 @@ module Rley # This module is used as a namespace
 
       # The list of grammar symbols in the language.
       attr_reader(:symbols)
+      
+      # A Hash with pairs of the kind: symbol name => grammar symbol
+      attr_reader(:name2symbol)
 
       # @param theProduction [Array of Production] the list of productions
       # of the grammar.
       def initialize(theProductions)
         @rules = []
         @symbols = []
+        @name2symbol = {}
         valid_productions = validate_productions(theProductions)
         # TODO: use topological sorting
         @start_symbol = valid_productions[0].lhs
@@ -50,13 +54,10 @@ module Rley # This module is used as a namespace
       def add_production(aProduction)
         @rules << aProduction
         the_lhs = aProduction.lhs
-        @symbols << the_lhs unless @symbols.include? the_lhs
+        add_symbol(the_lhs)
 
         # TODO: remove quadratic execution time
-        aProduction.rhs.each do |symb|
-          next if symbols.include? symb
-          @symbols << symb
-        end
+        aProduction.rhs.each { |symb| add_symbol(symb) }
       end
 
       
@@ -104,6 +105,16 @@ module Rley # This module is used as a namespace
         
         return nullable
       end
+      
+      private
+      
+      def add_symbol(aSymbol)
+        its_name = aSymbol.name
+        unless name2symbol.include? its_name
+          @symbols << aSymbol
+          @name2symbol[its_name] = aSymbol
+        end
+      end
     end # class
   end # module
 end # module

data/spec/rley/parser/dotted_item_spec.rb

@@ -16,7 +16,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       def build_prod(theLHS, *theRHSSymbols)
         return Syntax::Production.new(theLHS, theRHSSymbols)
       end
-    
+
       let(:t_a) { Syntax::Terminal.new('A') }
       let(:t_b) { Syntax::Terminal.new('B') }
       let(:t_c) { Syntax::Terminal.new('C') }
@@ -43,7 +43,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should know its production' do
           expect(subject.production).to eq(sample_prod)
         end
-        
+
         it 'should know the lhs of the production' do
           expect(subject.lhs).to eq(sample_prod.lhs)
         end
@@ -71,11 +71,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       context 'Provided service:' do
         it 'should whether its dot is at start position' do
           expect(subject).not_to be_at_start
-          
+
           # At start position
           instance1 = DottedItem.new(sample_prod, 0)
           expect(instance1).to be_at_start
-          
+
           # At start/end at the same time (production is empty)
           instance2 = DottedItem.new(build_prod(nt_sentence), 0)
           expect(instance2).to be_at_start
@@ -91,10 +91,38 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(second_instance).to be_reduce_item
         end
 
+        it 'should know the symbol before the dot' do
+          expect(subject.prev_symbol).to eq(t_a)
+          
+          # Case of an empty production
+          instance = DottedItem.new(empty_prod, 0)
+          expect(instance.prev_symbol).to be_nil
+          
+          # Case of a dot at start position
+          instance = DottedItem.new(sample_prod, 0)
+          expect(instance.prev_symbol).to be_nil          
+        end
+
         it 'should know the symbol after the dot' do
           expect(subject.next_symbol).to eq(t_b)
         end
         
+        it 'should calculate the previous position of the dot' do
+          expect(subject.prev_position).to eq(0)
+          
+          # Case of an empty production
+          instance = DottedItem.new(empty_prod, 0)
+          expect(instance.prev_position).to be_nil
+          
+          # Case of a dot at start position
+          instance = DottedItem.new(sample_prod, 0)
+          expect(instance.prev_position).to be_nil 
+
+          # Case of single symbol production
+          instance = DottedItem.new(other_prod, 1)
+          expect(instance.prev_position).to eq(0)           
+        end
+
         it 'should give its text representation' do
           expectation = 'sentence => A . B C'
           expect(subject.to_s).to eq(expectation)

data/spec/rley/parser/parse_state_spec.rb

@@ -91,6 +91,15 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(subject.next_symbol).to eq(t_c)
         end
         
+        it 'should know whether another instance follows this one' do
+          expect(subject.precedes?(subject)).to eq(false)
+          state1 = ParseState.new(DottedItem.new(sample_prod, 1), origin_val)
+          expect(state1.precedes?(subject)).to eq(true)
+          state0 = ParseState.new(DottedItem.new(sample_prod, 0), origin_val)
+          expect(state0.precedes?(state1)).to eq(true)
+          expect(state0.precedes?(subject)).to eq(false)
+        end
+        
         it 'should know its text representation' do
           expected = 'sentence => A B . C | 3'
           expect(subject.to_s).to eq(expected)

data/spec/rley/parser/parsing_spec.rb

@@ -3,8 +3,10 @@ require_relative '../../spec_helper'
 require_relative '../../../lib/rley/syntax/non_terminal'
 require_relative '../../../lib/rley/syntax/verbatim_symbol'
 require_relative '../../../lib/rley/syntax/production'
+require_relative '../../../lib/rley/syntax/grammar_builder'
 require_relative '../../../lib/rley/parser/dotted_item'
 require_relative '../../../lib/rley/parser/token'
+require_relative '../../../lib/rley/parser/earley_parser'
 # Load the class under test
 require_relative '../../../lib/rley/parser/parsing'
 
@@ -48,7 +50,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           tokens = grm1_tokens
           expect { Parsing.new(start_rule, tokens) }.not_to raise_error
         end
-        
+
         it 'should know the input tokens' do
           expect(subject.tokens).to eq(grm1_tokens)
         end
@@ -58,28 +60,28 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
 
       end # context
-      
+
       context 'Parsing:' do
         it 'should push a state to a given chart entry' do
           expect(subject.chart[1]).to be_empty
           item = DottedItem.new(prod_A1, 1)
-          
+
           subject.push_state(item, 1, 1)
           expect(subject.chart[1]).not_to be_empty
           expect(subject.chart[1].first.dotted_rule).to eq(item)
-          
+
           # Pushing twice the same state must be no-op
           subject.push_state(item, 1, 1)
           expect(subject.chart[1].size).to eq(1)
         end
-        
+
         it 'should complain when trying to push a nil dotted item' do
           err = StandardError
           msg = 'Dotted item may not be nil'
           expect { subject.push_state(nil, 1, 1) }.to raise_error(err, msg)
         end
-        
-        
+
+
         it 'should retrieve the parse states that expect a given terminal' do
           item1 = DottedItem.new(prod_A1, 2)
           item2 = DottedItem.new(prod_A1, 1)
@@ -89,27 +91,51 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(states.size).to eq(1)
           expect(states[0].dotted_rule).to eq(item1)
         end
-        
+
         it 'should update the states upon token match' do
           # When a input token matches an expected terminal symbol
           # then new parse states must be pushed to the following chart slot
           expect(subject.chart[1]).to be_empty
-          
+
           item1 = DottedItem.new(prod_A1, 0)
           item2 = DottedItem.new(prod_A2, 0)
           subject.push_state(item1, 0, 0)
           subject.push_state(item2, 0, 0)
           subject.scanning(a_, 0) { |i| i } # Code block is mock
-          
+
           # Expected side effect: a new state at chart[1]
           expect(subject.chart[1].size).to eq(1)
           new_state = subject.chart[1].states[0]
           expect(new_state.dotted_rule).to eq(item1)
           expect(new_state.origin).to eq(0)
         end
-
-      end
-
+        
+      end # context
+      
+      context 'Parse tree building:' do
+        let(:sample_grammar1) do
+          builder = Syntax::GrammarBuilder.new
+          builder.add_terminals('a', 'b', 'c')
+          builder.add_production('S' => ['A'])
+          builder.add_production('A' => %w(a A c))
+          builder.add_production('A' => ['b'])
+          builder.grammar
+        end
+        
+        let(:token_seq1) do
+          %w(a a b c c).map do |letter|
+            Token.new(letter, sample_grammar1.name2symbol[letter])
+          end
+        end
+        
+        
+        it 'should build the parse tree for a non-ambiguous grammar' do
+          parser = EarleyParser.new(sample_grammar1)
+          instance = parser.parse(token_seq1)
+          ptree = instance.parse_tree
+          expect(ptree).to be_kind_of(PTree::ParseTree)
+        end
+      end # context
     end # describe
   end # module
 end # module

data/spec/rley/parser/state_set_spec.rb

@@ -56,6 +56,22 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           allow(dotted_rule2).to receive(:production).and_return(a_prod)
           expect(subject.states_for(a_prod)).to eq([state2])
         end
+        
+        it 'should list the states that rewrite a given non-terminal' do
+          non_term = double('fake-non-terminal')
+          prod1 = double('fake-production1')
+          prod2 = double('fake-production2')
+        
+          # Adding states
+          subject.push_state(state1)
+          subject.push_state(state2)
+          allow(dotted_rule1).to receive(:production).and_return(prod1)
+          allow(prod1).to receive(:lhs).and_return(:dummy)          
+          allow(dotted_rule2).to receive(:production).and_return(prod2)
+          allow(dotted_rule2).to receive(:reduce_item?).and_return(true)
+          allow(prod2).to receive(:lhs).and_return(non_term) 
+          expect(subject.states_rewriting(non_term)).to eq([state2])
+        end
 
       end # context
 

data/spec/rley/ptree/non_terminal_node_spec.rb

@@ -0,0 +1,36 @@
+require_relative '../../spec_helper'
+
+# Load the class under test
+require_relative '../../../lib/rley/ptree/non_terminal_node'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module PTree # Open this namespace to avoid module qualifier prefixes
+    describe NonTerminalNode do
+      let(:sample_symbol) { double('fake-symbol') }
+      let(:sample_range) { double('fake-range') }
+      
+      subject { NonTerminalNode.new(sample_symbol, sample_range) }
+
+      context 'Initialization:' do
+        it "shouldn't have children yet" do
+          expect(subject.children).to be_empty
+        end
+      end # context
+      
+      context 'Provided services:' do
+        it 'should accept children' do
+          child1 = double('first_child')
+          child2 = double('second_child')
+          child3 = double('third_child')
+          expect { subject.add_child(child1) }.not_to raise_error
+          subject.add_child(child2)
+          subject.add_child(child3)
+          expect(subject.children).to eq([child1, child2, child3])
+        end
+      end # context
+
+    end # describe
+  end # module
+end # module
+
+# End of file

data/spec/rley/ptree/parse_tree_node_spec.rb

@@ -0,0 +1,32 @@
+require_relative '../../spec_helper'
+
+# Load the class under test
+require_relative '../../../lib/rley/ptree/parse_tree_node'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module PTree # Open this namespace to avoid module qualifier prefixes
+    describe ParseTreeNode do
+      let(:sample_symbol) { double('fake-symbol') }
+      let(:sample_range) { {low: 0, high: 5}  }
+      
+      subject { ParseTreeNode.new(sample_symbol, sample_range) }
+
+      context 'Initialization:' do
+        it 'should be created with a symbol and a range' do
+          expect { ParseTreeNode.new(sample_symbol, sample_range) }.not_to raise_error
+        end
+
+        it 'should know its symbol' do
+          expect(subject.symbol).to eq(sample_symbol)
+        end
+        
+        it "should know its range" do
+          expect(subject.range).to eq(sample_range)
+        end
+      end # context
+
+    end # describe
+  end # module
+end # module
+
+# End of file

data/spec/rley/ptree/parse_tree_spec.rb

@@ -0,0 +1,95 @@
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/rley/syntax/grammar_builder'
+# Load the class under test
+require_relative '../../../lib/rley/ptree/parse_tree'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module PTree # Open this namespace to avoid module qualifier prefixes
+    describe ParseTree do
+      let(:sample_grammar) do
+        builder = Syntax::GrammarBuilder.new
+        builder.add_terminals('a', 'b', 'c')
+        builder.add_production('S' => ['A'])
+        builder.add_production('A' => %w(a A c))
+        builder.add_production('A' => ['b'])
+        builder.grammar
+      end
+
+      let(:sample_prod) { sample_grammar.rules[0] }
+      let(:sample_range) { {low:0, high:5} }
+      subject { ParseTree.new(sample_prod, sample_range) }
+
+      context 'Initialization:' do
+        it 'should be created with a production and a range' do
+          construction = -> { ParseTreeNode.new(sample_prod, sample_range) }
+          expect(construction).not_to raise_error
+        end
+
+        it 'should know its root node' do
+          its_root = subject.root
+          expect(its_root.symbol.name).to eq('S')
+          expect(its_root.range).to eq(sample_range)
+          expect(its_root.children.size).to eq(1)
+          expect(its_root.children[0].symbol.name).to eq('A')
+          expect(its_root.children[0].range).to eq(sample_range)
+        end
+
+        it 'should know its current path' do
+          path = subject.current_path
+
+          # Given the tree:
+          # S[0,5]
+          # +- A[0,5] <- current node
+          # Expected path: [S[0,5], 0, A[0,5]]
+          expect(path.size).to eq(3)
+          expect(path[0]).to eq(subject.root)
+          expect(path[1]).to eq(0)
+          expect(path[2]).to eq(subject.root.children[0])
+          expect(path[2].range).to eq(sample_range)
+        end
+      end # context
+
+      context 'Provided service:' do
+        it 'should add children to current node' do
+          subject.add_children(sample_grammar.rules[1], sample_range)
+
+          # Given the tree:
+          # S[0,5]
+          # +- A[0,5]
+          #    +-a[0,nil]
+          #    +-A[nil, nil]
+          #    +-c[nil, 5] <- current node
+          # Expected path: [S[0,5], 0, A[0,5], 2, c[nil, 5]]
+          path = subject.current_path
+          expect(path.size).to eq(5)
+          expect(path[3]).to eq(2)
+          expect(path[4].symbol.name).to eq('c')
+          expect(path[4].range.low).to be_nil
+          expect(path[4].range.high).to eq(5)
+        end
+
+        it 'should step back to a previous sibling node' do
+          subject.add_children(sample_grammar.rules[1], sample_range)
+          subject.step_back(4)
+          # Expected tree:
+          # S[0,5]
+          # +- A[0,5]
+          #    +-a[0,nil]
+          #    +-A[nil, 4] <- current node
+          #    +-c[4, 5]
+          # Expected path: [S[0,5], 0, A[0,5], 1, A[nil, 4]]
+          path = subject.current_path
+          expect(path.size).to eq(5)
+          expect(path[3]).to eq(1)
+          expect(path[4].symbol.name).to eq('A')
+          expect(path[4].range.low).to be_nil
+          expect(path[4].range.high).to eq(4)
+        end
+      end
+
+    end # describe
+  end # module
+end # module
+
+# End of file

data/spec/rley/ptree/token_range_spec.rb

@@ -0,0 +1,103 @@
+require_relative '../../spec_helper'
+
+# Load the class under test
+require_relative '../../../lib/rley/ptree/token_range'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module PTree # Open this namespace to avoid module qualifier prefixes
+    describe TokenRange do
+
+      let(:sample_range) { {low: 0, high: 5} }
+
+      # Default instantiation rule
+      subject { TokenRange.new(sample_range) }
+
+      context 'Initialization:' do
+        it 'should be created with a range Hash' do
+          # No bounds provided
+          expect { TokenRange.new({}) }.not_to raise_error
+
+          # Low bound provided
+          expect { TokenRange.new({low: 0}) }.not_to raise_error
+
+          # High bound provided
+          expect { TokenRange.new({high: 5}) }.not_to raise_error
+
+          # Both bounds provided
+          expect { TokenRange.new({low: 0, high: 5}) }.not_to raise_error
+        end
+
+        it 'should know its low bound' do
+          expect(subject.low).to eq(0)
+        end
+
+        it 'should know its low bound' do
+          expect(subject.high).to eq(5)
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should know whether it is bounded or not' do
+          expect(subject).to be_bounded
+
+          # Case: only low bound is set
+          instance = TokenRange.new({low: 0})
+          expect(instance).not_to be_bounded
+
+          # Case: only upper bound is set
+          instance =  TokenRange.new({high: 5})
+          expect(instance).not_to be_bounded
+
+          # No bound is set
+          instance =  TokenRange.new({})
+          expect(instance).not_to be_bounded
+        end
+
+        it 'should assign it open bounds' do
+          some_range = {low: 1, high: 4}
+
+          ###########
+          # Case of bounded token range...
+          subject.assign(some_range)
+
+          # ... should be unchanged
+          expect(subject.low).to eq(sample_range[:low])
+          expect(subject.high).to eq(sample_range[:high])
+
+          ###########
+          # Case: only low bound is set
+          instance = TokenRange.new({low: 0})
+          instance.assign(some_range)
+
+          # Expectation: high is assigned the new value
+          expect(instance).to be_bounded
+          expect(instance.low).to eq(0)
+          expect(instance.high).to eq(4)
+
+          ###########
+          # Case: only high bound is set
+          instance = TokenRange.new({high: 5})
+          instance.assign(some_range)
+
+          # Expectation: low is assigned the new value
+          expect(instance).to be_bounded
+          expect(instance.low).to eq(1)
+          expect(instance.high).to eq(5)
+
+          ###########
+          # Case: no bound is set
+          instance = TokenRange.new({})
+          instance.assign(some_range)
+
+          # Expectation: low is assigned the new value
+          expect(instance).to be_bounded
+          expect(instance.low).to eq(1)
+          expect(instance.high).to eq(4)
+        end
+      end
+
+    end # describe
+  end # module
+end # module
+
+# End of file

data/spec/rley/syntax/grammar_spec.rb

@@ -117,11 +117,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:nominal_prods) { Production}
 =end
 
+      subject do
+        productions = [prod_S, prod_A1, prod_A2]
+        Grammar.new(productions)
+      end
+
       context 'Initialization:' do
-        subject do
-          productions = [prod_S, prod_A1, prod_A2]
-          Grammar.new(productions)
-        end
 
         it 'should be created with a list of productions' do
           expect { Grammar.new([prod_S, prod_A1, prod_A2]) }.not_to raise_error
@@ -144,11 +145,23 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
       end # context
       
-      context 'Non-nullable grammar:' do
-        subject do
-          productions = [prod_S, prod_A1, prod_A2]
-          Grammar.new(productions)
+      # let(:nt_S) { NonTerminal.new('S') }
+      # let(:nt_A) { NonTerminal.new('A') }
+      # let(:a_) { VerbatimSymbol.new('a') }
+      # let(:b_)  { VerbatimSymbol.new('b') }
+      # let(:c_)  { VerbatimSymbol.new('c') }
+      
+      context 'Provided services:' do
+        it 'should retrieve its symbols from their name' do
+          expect(subject.name2symbol['S']).to eq(nt_S)
+          expect(subject.name2symbol['A']).to eq(nt_A)
+          expect(subject.name2symbol['a']).to eq(a_)
+          expect(subject.name2symbol['b']).to eq(b_)
+          expect(subject.name2symbol['c']).to eq(c_)
         end
+      end # context
+      
+      context 'Non-nullable grammar:' do
         
         it 'should mark all its nonterminals as non-nullable' do
           nonterms = subject.non_terminals

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.0.18
+  version: 0.1.00
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-23 00:00:00.000000000 Z
+date: 2014-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -96,6 +96,11 @@ files:
 - lib/rley/parser/parsing.rb
 - lib/rley/parser/state_set.rb
 - lib/rley/parser/token.rb
+- lib/rley/ptree/non_terminal_node.rb
+- lib/rley/ptree/parse_tree.rb
+- lib/rley/ptree/parse_tree_node.rb
+- lib/rley/ptree/terminal_node.rb
+- lib/rley/ptree/token_range.rb
 - lib/rley/syntax/grammar.rb
 - lib/rley/syntax/grammar_builder.rb
 - lib/rley/syntax/grm_symbol.rb
@@ -112,6 +117,10 @@ files:
 - spec/rley/parser/parsing_spec.rb
 - spec/rley/parser/state_set_spec.rb
 - spec/rley/parser/token_spec.rb
+- spec/rley/ptree/non_terminal_node_spec.rb
+- spec/rley/ptree/parse_tree_node_spec.rb
+- spec/rley/ptree/parse_tree_spec.rb
+- spec/rley/ptree/token_range_spec.rb
 - spec/rley/syntax/grammar_builder_spec.rb
 - spec/rley/syntax/grammar_spec.rb
 - spec/rley/syntax/grm_symbol_spec.rb
@@ -161,6 +170,10 @@ test_files:
 - spec/rley/parser/parsing_spec.rb
 - spec/rley/parser/state_set_spec.rb
 - spec/rley/parser/token_spec.rb
+- spec/rley/ptree/non_terminal_node_spec.rb
+- spec/rley/ptree/parse_tree_node_spec.rb
+- spec/rley/ptree/parse_tree_spec.rb
+- spec/rley/ptree/token_range_spec.rb
 - spec/rley/syntax/grammar_builder_spec.rb
 - spec/rley/syntax/grammar_spec.rb
 - spec/rley/syntax/grm_symbol_spec.rb