rley 0.2.00 → 0.2.01

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZTAxMjk3Yzc3YTFjZmUxY2Q2OGI1MDFhZjMxMTk5M2Q1YmMzZWMwNw==
+    NzlkNmE1NzA2OWEzMzVlNTNjOTBkNDI3ZGQ1MDljYTI4M2I3ZmNhNQ==
   data.tar.gz: !binary |-
-    ODMxNDQ0ODZjYmI0YWRlYTE5NWQwZjE3Njg2ZGI2MzBjMjc5ZmVlMQ==
+    NGNlMGZhM2UyNjNiYmMwZTBjMGFiNmEwM2U3NWI2MjUxMzFlYmY5YQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    NmVkNTY4MzE3ZWNhMDhlNWI5OTJlODBkM2ZmOTg1Y2RjODViOThiMzAyYmUy
-    ZTY5N2RhN2EyNzFhMmY3MjhlNmJkNjI4MGVlOTBjZDgwYmM4ZTY0ZjhlNjE2
-    OGU5ZTRlNzAzOGRiOTlmMmZkZDg0NzcyMGQwZDFlYjVmYjAwMzI=
+    MjA1YjJmYjRiNjFjZTViNmFhMDk4ZjA3MDVkOWJjNDBhMjExYjhkMDg5MTUy
+    ZTJkNzhjN2I1NjY5M2I2MWY5NzEyZmJkMjJiZTIwYjEyNTk2MzFmN2ViZWU2
+    YTYzYzkzNTUxYWE1MjU3NGI5NTk3YzAzNmI0MGNkNGExYmEyMDE=
   data.tar.gz: !binary |-
-    N2E0OGJhNjVjOWM3YTMzMzk5YjdjZDdiY2IzMGE5N2RkNTJkNDlkMDcyYTI3
-    YzY5Y2YzZTE4NjcxYjFlNzhhMmM4NDExYzk0NGEzMTE1ZmMwNDUzNzExMTA5
-    OGI3MDFlMzFkYWQ2Y2UzNmI1MGQ5ZGEwNGYyNTg4N2MzMTk3NTk=
+    N2U4Y2I5MjA0YWQyMWZmMmU4MDM0N2ZlNGU1NzA5MzViMDAxZGI1YTc5Zjcy
+    M2MzMDFmOWU5ZGI1NjllODliZTkwNjE2MmMyOTQzZjRkODBjNzUwNDg2MDJl
+    NmExN2FiMjA4ZjBhNTdkNDE4YWUxMzgxZTQ1Y2M4ZDE0OTE4NGY=

data/.rubocop.yml

@@ -5,7 +5,11 @@ AllCops:
     - 'gems/**/*'
     - 'refs/**/*'
 
-# This is disabled because some demos use UTF-8
+AbcSize:
+  Max: 45
+  Enabled: true
+    
+    # This is disabled because some demos use UTF-8
 AsciiComments:
   Enabled: false
   

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+### 0.2.01 / 2015-01-03
+* [CHANGE] File `.rubocop.yml`: AbcMetric setting relaxed.
+* [CHANGE] Fixed most style offenses reported by Rubocop.
+
 ### 0.2.00 / 2015-01-03  
 Version number bump: major re-design of the parse tree generation.
 * [NEW] Class `ParseTreeBuilder`: builder for creating parse tree.

data/examples/parsers/parsing_L0.rb

@@ -109,7 +109,6 @@ puts "Parsing success? #{result.success?}"
 ########################################
 # Step 6. Generate a parse tree from the parse result
 ptree = result.parse_tree
-pp ptree
 
 ########################################
 # Step 7. Render the parse tree (in JSON)

data/lib/rley/constants.rb

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

data/lib/rley/formatter/base_formatter.rb

@@ -1,5 +1,4 @@
 module Rley # This module is used as a namespace
-
   # Namespace dedicated to parse tree formatters.
   module Formatter
     # Superclass for parse tree formatters.

data/lib/rley/parser/chart.rb

@@ -27,7 +27,7 @@ module Rley # This module is used as a namespace
       
       # Return the index value of the last non-empty state set.
       def last_index()
-        first_empty =  state_sets.find_index { |set| set.empty? }
+        first_empty =  state_sets.find_index(&:empty?)
         if first_empty.nil?
           index = state_sets.size - 1
         else

data/lib/rley/parser/parse_state_tracker.rb

@@ -26,12 +26,12 @@ module Rley # This module is used as a namespace
       # Write accessor. Set the given parse state as the current one.
       def parse_state=(aParseState)
         @parse_state = aParseState
-        self.processed_states[parse_state] = true
+        processed_states[parse_state] = true
       end
       
       # Take the first provided state that wasn't processed yet.
       def select_state(theStates)
-        a_state = theStates.find { |st| ! processed_states.include?(st) }
+        a_state = theStates.find { |st| !processed_states.include?(st) }
         self.parse_state = a_state
       end
       
@@ -46,7 +46,7 @@ module Rley # This module is used as a namespace
       
       # Notification that one begins with the previous state set
       def to_prev_state_set()
-        self.state_set_index = self.state_set_index - 1
+        self.state_set_index = state_set_index - 1
       end
     end # class
   end # module

data/lib/rley/parser/parse_tree_builder.rb

@@ -1,181 +1,178 @@
-require 'ostruct' # TODO delete this
-require_relative '../ptree/terminal_node'
-require_relative '../ptree/non_terminal_node'
-require_relative '../ptree/parse_tree'
-
-
-module Rley # This module is used as a namespace
-  module Parser # This module is used as a namespace
-    # Builder GoF pattern. Builder pattern builds a complex object
-    # (say, a parse tree) from simpler objects (terminal and non-terminal
-    # nodes) and using a step by step approach.
-    class ParseTreeBuilder
-      attr_reader(:root)
-      attr_reader(:current_path)
-
-      def initialize(aStartProduction, aRange)
-        @current_path = []
-        start_symbol = aStartProduction.lhs
-        add_node(start_symbol, aRange)
-        use_production(aStartProduction, aRange)
-        move_down
-      end
-
-      # Return the active node.
-      def current_node()
-        return current_path.last
-      end
-      
-      # Factory method.
-      def parse_tree()
-        return PTree::ParseTree.new(root)
-      end
-
-
-      # Given that the current node is also lhs of the production
-      # associated with the complete parse state,
-      # Then add the rhs constituents as child nodes of the current node.
-      # Assumption: current node is lhs of the production association
-      # with the parse state.
-      # @param aCompleteState [ParseState] A complete parse state
-      # (dot is at end of rhs)
-      def use_complete_state(aCompleteState)
-        prod = aCompleteState.dotted_rule.production
-        use_production(prod, {low: aCompleteState.origin})
-      end
-
-      # Given that the current node is a non-terminal
-      # Make its last child node the current node.
-      def move_down()
-        curr_node = current_node
-        unless curr_node.is_a?(PTree::NonTerminalNode)
-          msg = "Current node isn't a non-terminal node #{curr_node.class}"
-          fail StandardError, msg
-        end
-        children = curr_node.children
-        path_increment = [children.size - 1, children.last]
-        @current_path.concat(path_increment)
-      end
-
-
-      # Make the predecessor of current node the
-      # new current node.
-      def move_back()   
-        begin
-          if current_path.length == 1
-            msg = 'Cannot move further back'
-            fail StandardError, msg
-          end
-          (parent, pos, child_node) = current_path[-3, 3]
-          current_path.pop(2)
-          if pos > 0
-            new_pos = pos - 1
-            new_curr_node = parent.children[new_pos]
-            current_path << new_pos
-            current_path << new_curr_node
-            range = high_bound(child_node.range.low)
-          end
-        end while pos == 0 && new_curr_node.is_a?(PTree::NonTerminalNode)
-      end
-
-
-      # Add a child node to the current node.
-      def add_node(aSymbol, aRange)
-        # Create the node
-        a_node = new_node(aSymbol, aRange)
-
-        # Add it to the current node
-        add_child(a_node)
-      end
-
-      # Set unbound endpoints of current node range
-      # to the given range.
-      def range=(aRange)
-        curr_node = current_node
-        return if curr_node.nil?
-        lower = low_bound(aRange)
-        unless lower.nil?
-          current_node.range = lower
-          if curr_node.is_a?(PTree::TerminalNode)
-            current_node.range = high_bound(lower[:low] + 1)
-          end
-        end  
-        upper = high_bound(aRange)
-        current_node.range = upper unless upper.nil?
-      end
-
-      private
-
-      def new_node(aSymbol, aRange)
-        case aSymbol
-          when Syntax::Terminal
-            new_node = PTree::TerminalNode.new(aSymbol, aRange)
-          when Syntax::NonTerminal
-            new_node = PTree::NonTerminalNode.new(aSymbol, aRange)
-        end
-
-        return new_node
-      end
-
-      # Add children nodes to current one.
-      # The children correspond to the members of the rhs of the production.
-      def use_production(aProduction, aRange)
-        prod = aProduction
-        curr_node = current_node
-
-        if curr_node.symbol != prod.lhs
-          msg = "Current node is a #{curr_node.symbol} instead of #{prod.lhs}"
-          fail StandardError, msg
-        end
-        self.range = aRange
-        prod.rhs.each { |symb| add_node(symb, {}) }
-
-        unless curr_node.children.empty?
-          curr_node.children.first.range.assign({ low: curr_node.range.low })
-          curr_node.children.last.range.assign({ high: curr_node.range.high })
-        end
-      end      
-
-      # Add the given node as child node of current node
-      def add_child(aNode)
-        curr_node = current_node
-
-        if curr_node.nil?
-          self.root = aNode
-        else
-          curr_node.children << aNode
-        end
-      end
-
-      # Set the root node of the tree.
-      def root=(aNode)
-        @root = aNode
-        @current_path = [ @root ]
-        root.range = low_bound(0)
-      end
-
-
-      def low_bound(aRange)
-        result = case aRange
-          when Fixnum then aRange
-          when Hash then aRange[:low]
-          when PTree::TokenRange then aRange.low
-        end
-
-        return { low: result }
-      end
-
-      def high_bound(aRange)
-        result = case aRange
-          when Fixnum then aRange
-          when Hash then aRange[:high]
-          when PTree::TokenRange then aRange.high
-        end
-
-        return { high: result }
-      end
-    end # class
-  end # module
-end # module
-
-# End of file
+require_relative '../ptree/terminal_node'
+require_relative '../ptree/non_terminal_node'
+require_relative '../ptree/parse_tree'
+
+
+module Rley # This module is used as a namespace
+  module Parser # This module is used as a namespace
+    # Builder GoF pattern. Builder pattern builds a complex object
+    # (say, a parse tree) from simpler objects (terminal and non-terminal
+    # nodes) and using a step by step approach.
+    class ParseTreeBuilder
+      attr_reader(:root)
+      attr_reader(:current_path)
+
+      def initialize(aStartProduction, aRange)
+        @current_path = []
+        start_symbol = aStartProduction.lhs
+        add_node(start_symbol, aRange)
+        use_production(aStartProduction, aRange)
+        move_down
+      end
+
+      # Return the active node.
+      def current_node()
+        return current_path.last
+      end
+      
+      # Factory method.
+      def parse_tree()
+        return PTree::ParseTree.new(root)
+      end
+
+
+      # Given that the current node is also lhs of the production
+      # associated with the complete parse state,
+      # Then add the rhs constituents as child nodes of the current node.
+      # Assumption: current node is lhs of the production association
+      # with the parse state.
+      # @param aCompleteState [ParseState] A complete parse state
+      # (dot is at end of rhs)
+      def use_complete_state(aCompleteState)
+        prod = aCompleteState.dotted_rule.production
+        use_production(prod, { low: aCompleteState.origin })
+      end
+
+      # Given that the current node is a non-terminal
+      # Make its last child node the current node.
+      def move_down()
+        curr_node = current_node
+        unless curr_node.is_a?(PTree::NonTerminalNode)
+          msg = "Current node isn't a non-terminal node #{curr_node.class}"
+          fail StandardError, msg
+        end
+        children = curr_node.children
+        path_increment = [children.size - 1, children.last]
+        @current_path.concat(path_increment)
+      end
+
+
+      # Make the predecessor of current node the
+      # new current node.
+      def move_back()   
+        begin
+          if current_path.length == 1
+            msg = 'Cannot move further back'
+            fail StandardError, msg
+          end
+          (parent, pos) = current_path[-3, 2]
+          current_path.pop(2)
+          if pos > 0
+            new_pos = pos - 1
+            new_curr_node = parent.children[new_pos]
+            current_path << new_pos
+            current_path << new_curr_node
+          end
+        end while pos == 0 && new_curr_node.is_a?(PTree::NonTerminalNode)
+      end
+
+
+      # Add a child node to the current node.
+      def add_node(aSymbol, aRange)
+        # Create the node
+        a_node = new_node(aSymbol, aRange)
+
+        # Add it to the current node
+        add_child(a_node)
+      end
+
+      # Set unbound endpoints of current node range
+      # to the given range.
+      def range=(aRange)
+        curr_node = current_node
+        return if curr_node.nil?
+        lower = low_bound(aRange)
+        unless lower.nil?
+          current_node.range = lower
+          if curr_node.is_a?(PTree::TerminalNode)
+            current_node.range = high_bound(lower[:low] + 1)
+          end
+        end  
+        upper = high_bound(aRange)
+        current_node.range = upper unless upper.nil?
+      end
+
+      private
+
+      def new_node(aSymbol, aRange)
+        case aSymbol
+          when Syntax::Terminal
+            new_node = PTree::TerminalNode.new(aSymbol, aRange)
+          when Syntax::NonTerminal
+            new_node = PTree::NonTerminalNode.new(aSymbol, aRange)
+        end
+
+        return new_node
+      end
+
+      # Add children nodes to current one.
+      # The children correspond to the members of the rhs of the production.
+      def use_production(aProduction, aRange)
+        prod = aProduction
+        curr_node = current_node
+
+        if curr_node.symbol != prod.lhs
+          msg = "Current node is a #{curr_node.symbol} instead of #{prod.lhs}"
+          fail StandardError, msg
+        end
+        self.range = aRange
+        prod.rhs.each { |symb| add_node(symb, {}) }
+
+        return if curr_node.children.empty?
+        curr_node.children.first.range.assign(low: curr_node.range.low)
+        curr_node.children.last.range.assign(high: curr_node.range.high)
+      end      
+
+      # Add the given node as child node of current node
+      def add_child(aNode)
+        curr_node = current_node
+
+        if curr_node.nil?
+          self.root = aNode
+        else
+          curr_node.children << aNode
+        end
+      end
+
+      # Set the root node of the tree.
+      def root=(aNode)
+        @root = aNode
+        @current_path = [ @root ]
+        root.range = low_bound(0)
+      end
+
+
+      def low_bound(aRange)
+        result = case aRange
+          when Fixnum then aRange
+          when Hash then aRange[:low]
+          when PTree::TokenRange then aRange.low
+        end
+
+        return { low: result }
+      end
+
+      def high_bound(aRange)
+        result = case aRange
+          when Fixnum then aRange
+          when Hash then aRange[:high]
+          when PTree::TokenRange then aRange.high
+        end
+
+        return { high: result }
+      end
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/rley/parser/parsing.rb

@@ -123,11 +123,11 @@ module Rley # This module is used as a namespace
         return expecting if !toSort || expecting.size < 2
 
         # Put predicted states ahead
-        (predicted, others) = expecting.partition { |state| state.predicted? }
+        (predicted, others) = expecting.partition(&:predicted?)
 
         # Sort state in reverse order of their origin value
         [predicted, others].each do |set|
-          set.sort! { |a,b| b.origin <=> a.origin }
+          set.sort! { |a, b| b.origin <=> a.origin }
         end
 
         return predicted + others
@@ -158,13 +158,13 @@ module Rley # This module is used as a namespace
       
       # A terminal symbol is on the left of dot.
       # Go to the predecessor state for the given terminal
-      def predecessor_state_terminal(a_symb, aStateTracker, aTreeBuilder)
+      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"
+          fail StandardError, 'Expected terminal node'
         end
         aTreeBuilder.move_back
         state_set = chart[aStateTracker.state_set_index]
@@ -174,12 +174,12 @@ module Rley # This module is used as a namespace
       
       
       # 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)
+      def completed_state_for(a_symb, aTracker, aTreeBuilder)
+        new_states = chart[aTracker.state_set_index].states_rewriting(a_symb)
+        aTracker.select_state(new_states) 
+        aTreeBuilder.range = { high: aTracker.state_set_index }
+        aTreeBuilder.use_complete_state(aTracker.parse_state)
+        link_node_to_token(aTreeBuilder, aTracker.state_set_index - 1)
         aTreeBuilder.move_down
       end
       
@@ -204,10 +204,10 @@ module Rley # This module is used as a namespace
       # If the current node is a terminal node
       # then link the token to that 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
+        return unless aTreeBuilder.current_node.is_a?(PTree::TerminalNode)
+
+        a_node = aTreeBuilder.current_node
+        a_node.token = tokens[aStateSetIndex] unless a_node.token
       end
 
       # Factory method. Initializes a ParseTreeBuilder object
@@ -216,8 +216,6 @@ module Rley # This module is used as a namespace
         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

@@ -24,7 +24,6 @@ module Rley # This module is used as a namespace
 
         aVisitor.end_visit_ptree(self)
       end
-
     end # class
   end # module
 end # module

data/lib/rley/syntax/grammar.rb

@@ -20,7 +20,7 @@ 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)
 
@@ -41,7 +41,7 @@ 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()
@@ -66,17 +66,17 @@ module Rley # This module is used as a namespace
         aProduction.rhs.each { |symb| add_symbol(symb) }
       end
 
-      
+
       # For each non-terminal determine whether it is nullable or not.
       # A nullable nonterminal is a nonterminal that can match an empty string.
       def compute_nullable()
         non_terminals.each { |nterm| nterm.nullable = false }
         nullable_sets = [ direct_nullable ]
-        
+
         # Drop productions with one terminal in rhs or with a nullable lhs
         filtered_rules = rules.reject do |prod|
-          prod.lhs.nullable? || prod.rhs.find do |symb| 
-            symb.kind_of?(Terminal) 
+          prod.lhs.nullable? || prod.rhs.find do |symb|
+            symb.kind_of?(Terminal)
           end
         end
 
@@ -96,8 +96,8 @@ module Rley # This module is used as a namespace
           nullable_sets[i] = nullable_sets[i - 1].merge(new_nullables)
         end
       end
-        
-        
+
+
       # Return the set of nonterminals which have one of their
       # production rules empty
       def direct_nullable()
@@ -108,18 +108,18 @@ module Rley # This module is used as a namespace
           prod.lhs.nullable = true
           nullable << prod.lhs
         end
-        
+
         return nullable
       end
-      
+
       private
-      
+
       def add_symbol(aSymbol)
         its_name = aSymbol.name
-        unless name2symbol.include? its_name
-          @symbols << aSymbol
-          @name2symbol[its_name] = aSymbol
-        end
+        return if name2symbol.include? its_name
+
+        @symbols << aSymbol
+        @name2symbol[its_name] = aSymbol
       end
     end # class
   end # module

data/spec/rley/parser/parse_tree_builder_spec.rb

@@ -1,179 +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
+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)
+        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

data/spec/rley/parser/parsing_spec.rb

@@ -116,7 +116,6 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(new_state.dotted_rule).to eq(item1)
           expect(new_state.origin).to eq(0)
         end
-
       end # context
 
       context 'Parse tree building:' do
@@ -175,13 +174,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
           (node_s, node_plus, node_m) = node.children
           expect(node_s.symbol).to eq(grm_symbol('S'))
-          expect(node_s.range).to eq({low: 0, high: 1})
+          expect(node_s.range).to eq(low: 0, high: 1)
           expect(node_s.children.size).to eq(1)
           expect(node_plus.symbol).to eq(grm_symbol('+'))
-          expect(node_plus.range).to eq({low: 0, high: 1})  # TODO: fix this
+          expect(node_plus.range).to eq(low: 0, high: 1)  # TODO: fix this
           expect(node_plus.token.lexeme). to eq('+')
           expect(node_m.symbol).to eq(grm_symbol('M'))
-          expect(node_m.range).to eq({low: 2, high: 5})
+          expect(node_m.range).to eq(low: 2, high: 5)
           expect(node_m.children.size).to eq(3)
           
           node = node_s.children[0] # M

data/spec/rley/support/grammar_b_expr_helper.rb

@@ -21,19 +21,19 @@ module GrammarBExprHelper
   
   # Basic expression tokenizer
   def expr_tokenizer(aText, aGrammar)
-  tokens = aText.scan(/\S+/).map do |lexeme|
-    case lexeme
-      when '+', '*'
-        terminal = aGrammar.name2symbol[lexeme]
-      when /^[-+]?\d+$/
-        terminal = aGrammar.name2symbol['integer']
-      else
-        msg = "Unknown input text '#{lexeme}'"
-        fail StandardError, msg
+    tokens = aText.scan(/\S+/).map do |lexeme|
+      case lexeme
+        when '+', '*'
+          terminal = aGrammar.name2symbol[lexeme]
+        when /^[-+]?\d+$/
+          terminal = aGrammar.name2symbol['integer']
+        else
+          msg = "Unknown input text '#{lexeme}'"
+          fail StandardError, msg
+      end
+      Rley::Parser::Token.new(lexeme, terminal)
     end
-    Rley::Parser::Token.new(lexeme, terminal)
+    
+    return tokens
   end
-  
-  return tokens
-end
 end # module

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.2.00
+  version: 0.2.01
 platform: ruby
 authors:
 - Dimitri Geshef