dendroid 0.2.02 → 0.2.04

data/lib/dendroid/parsing/parse_node.rb

@@ -1,17 +1,30 @@
 # frozen_string_literal: true
 
 module Dendroid
+  # Namespace for all classes needed for implementing a generic parser.
+  # The goal is to take the output from the Earley recognizer (i.e. a chart object),
+  # visit it and build a data structure (a parse tree or a shared parse forest) that is much
+  # more convenient for subsequent processing (e.g. semantic analysis of a compiler/interpreter).
   module Parsing
+    # An abstract class (i.e. a generalization) for elements forming a parse tree (forest).
+    # A parse tree is a graph data structure that represents the parsed input text into a tree-like hierarchy
+    # of elements constructed by applying syntax rules of the language at hand.
+    # A parse forest is a data structure that merges a number parse trees into one graph.
+    # Contrary to parse trees, a parse forests can represent the results of an ambiguous parsing.
     class ParseNode
-      # @return [Array<Integer>] The range of input tokens that match this node.
+      # @return [Range] The range of indexes of the input tokens that match this node.
       attr_reader :range
 
+      # @param lowerBound [Integer] Rank of first input token that is matched by this node
+      # @param upperBound [Integer] Rank of last input token that is matched by this node
       def initialize(lowerBound, upperBound)
         @range = valid_range(lowerBound, upperBound)
       end
 
-      def to_s
-        "[#{range[0]}, #{range[1]}]"
+      protected
+
+      def range_to_s
+        "[#{range}]"
       end
 
       private
@@ -19,7 +32,7 @@ module Dendroid
       def valid_range(lowerBound, upperBound)
         raise StandardError unless lowerBound.is_a?(Integer) && upperBound.is_a?(Integer)
 
-        [lowerBound, upperBound]
+        lowerBound..upperBound
       end
     end # class
   end # module

data/lib/dendroid/parsing/parse_tree_visitor.rb

@@ -45,7 +45,7 @@ class ParseTreeVisitor
   end
 
   # Visit event. The visitor is about to visit the given non terminal node.
-  # @param aNonTerminalNode [ANDNode] the node to visit.
+  # @param aNonTerminalNode [AndNode] the node to visit.
   def visit_and_node(aNonTerminalNode)
     if @traversal == :post_order
       broadcast(:before_and_node, aNonTerminalNode)

data/lib/dendroid/parsing/terminal_node.rb

@@ -4,6 +4,7 @@ require_relative 'parse_node'
 
 module Dendroid
   module Parsing
+    # A parse tree/forest node that is related to one input token.
     class TerminalNode < ParseNode
       # @return [Dendroid::Syntax::Terminal] Terminal symbol of matching token.
       attr_reader :symbol
@@ -23,9 +24,11 @@ module Dendroid
         aVisitor.visit_terminal(self)
       end
 
+      # Render a String representation of itself
+      # @return [String]
       def to_s
-        display_val = token.is_a?(Dendroid::Lexical::Literal) ? ": #{token.value}" : ''
-        "#{symbol.name}#{display_val} #{super}"
+        display_val = token.literal? ? ": #{token.value}" : ''
+        "#{symbol.name}#{display_val} #{range_to_s}"
       end
     end # class
   end # module

data/lib/dendroid/parsing/walk_progress.rb

@@ -7,16 +7,30 @@ require_relative 'empty_rule_node'
 
 module Dendroid
   module Parsing
+    # This object holds the current state of the visit of a Chart by one
+    # ChartWalker through one single visit path. A path corresponds to a
+    # chain from the current item back to the initial item(s) through the predecessors links.
+    # It is used to construct (part of) the parse tree beginning from the root node.
     class WalkProgress
+      # @return [Symbol] One of: :New, :Running, :Waiting, :Complete, :Forking, :Delegating
       attr_accessor :state
+
+      # @return [Integer] rank of the item set from the chart being visited
       attr_accessor :curr_rank
+
+      # @return [Dendroid::Recognizer::EItem] the chart entry being visited
       attr_reader :curr_item
+
+      # When not nil, override the predecessors links of the current item
+      # @return [Dendroid::Recognizer::EItem|NilClass]
       attr_accessor :predecessor
-      attr_reader :parents
 
-      # rubocop: disable Metrics/CyclomaticComplexity
-      # rubocop: disable Metrics/PerceivedComplexity
+      # @return [Array<Dendroid::Parsing::CompositeParseNode>] The ancestry of current parse node.
+      attr_reader :parents
 
+      # @param start_rank [Integer] Initial rank at the start of the visit
+      # @param start_item [Dendroid::Recognizer::EItem] Initial chart entry to visit
+      # @param parents [Array<Dendroid::Parsing::CompositeParseNode>]
       def initialize(start_rank, start_item, parents)
         @state = :New
         @curr_rank = start_rank
@@ -34,32 +48,46 @@ module Dendroid
         @parents = orig.parents.dup
       end
 
+      # Current item has multiple predecessors: set the state to Forking and
+      # force one of the predecessor to be the next entry to visit.
+      # @param thePredecessor [Dendroid::Recognizer::EItem]
       def fork(thePredecessor)
         @state = :Forking
         @predecessor = thePredecessor
       end
 
+      # Set the current entry being visited to the given one
+      # @param anEntry [Dendroid::Recognizer::EItem]
       def curr_item=(anEntry)
         raise StandardError if anEntry.nil?
 
         @curr_item = anEntry
       end
 
+      # Add a child leaf node for the given chart entry that corresponds
+      # to an empty rule.
+      # @param anEntry [Dendroid::Recognizer::EItem]
+      # @return [Dendroid::Parsing::EmptyRuleNode]
       def add_node_empty(anEntry)
         node_empty = EmptyRuleNode.new(anEntry, curr_rank)
         add_child_node(node_empty)
       end
 
-      # Add a terminal node for terminal at current rank as a child of last parent
+      # Add a leaf terminal node for the token at current rank as a child of last parent.
+      # @param token [Dendroid::Lexical::Token]
+      # @return [Dendroid::Parsing::TerminalNode]
       def add_terminal_node(token)
         @curr_rank -= 1
         term_node = TerminalNode.new(curr_item.prev_symbol, token, curr_rank)
         add_child_node(term_node)
       end
 
-      # Add an AND node for given entry as a child of last parent
+      # Make an AND node for the given entry as a child of last parent and
+      # push this node in the ancestry
+      # @param anEntry [Dendroid::Recognizer::EItem]
+      # @return [Dendroid::Parsing::AndNode]
       def push_and_node(anEntry)
-        node = ANDNode.new(anEntry, curr_rank)
+        node = AndNode.new(anEntry, curr_rank)
         raise StandardError unless anEntry.rule == node.rule # Fails
 
         add_child_node(node)
@@ -68,6 +96,11 @@ module Dendroid
         node
       end
 
+      # Make an OR node as a child of last parent and
+      # push this node in the ancestry.
+      # @param origin [Integer] Start rank
+      # #param arity [Integer] The number of alternative derivations
+      # @return [Dendroid::Parsing::OrNode]
       def push_or_node(origin, arity)
         node = OrNode.new(curr_item.prev_symbol, origin, curr_rank, arity)
         add_child_node(node)
@@ -76,14 +109,22 @@ module Dendroid
         node
       end
 
+      # Add the given node as a child of the last parent node.
+      # @param aNode [Dendroid::Parsing::ParseNode]
+      # @return [Dendroid::Parsing::ParseNode]
       def add_child_node(aNode)
-        parents.last.add_child(aNode, curr_item.position - 1)
+        parents.last.add_child(aNode, curr_item.position - 1) unless parents.empty?
         aNode
       end
 
+      # rubocop: disable Metrics/CyclomaticComplexity
+      # rubocop: disable Metrics/PerceivedComplexity
+
       # Do the given EItems match one of the parent?
       # Matching = corresponds to the same rule and range
-      # @return [Array<EItem>]
+      # @param entries [Dendroid::Recognizer::EItem]
+      # @param stop_at_first [Boolean] Must be true
+      # @return [Array<Array<EItem, Integer>>]
       def match_parent?(entries, stop_at_first)
         matching = []
         min_origin = entries[0].origin
@@ -106,7 +147,7 @@ module Dendroid
           break if stop_at_first && !matching.empty?
 
           # Stop loop when parent.origin < min(entries.origin)
-          break if node.range[0] < min_origin
+          break if node.range.begin < min_origin
 
           offset += 1
         end

data/lib/dendroid/recognizer/e_item.rb

@@ -8,6 +8,7 @@ module Dendroid
     # An Earley item is essentially a pair consisting of a dotted item and the rank of a token.
     # It helps to keep track the progress of an Earley recognizer.
     class EItem
+      # Mix-in module used to forward some method calls to the related dotted item.
       extend Forwardable
 
       # (Weak) reference to the dotted item
@@ -17,7 +18,8 @@ module Dendroid
       # @return [Integer] the rank of the token that correspond to the start of the rule.
       attr_reader :origin
 
-      # TODO: :predictor, :completer, :scanner
+      # Specifies the algorithm with which this entry can be derived from its predecessor(s).
+      # @return [Symbol] of one: :predictor, :completer, :scanner
       attr_accessor :algo
 
       # @return [Array<WeakRef>] predecessors sorted by decreasing origin value

data/lib/dendroid/syntax/rule.rb

@@ -12,7 +12,7 @@ module Dendroid
       # @return [Array<Dendroid::Syntax::SymbolSeq>]
       attr_reader :alternatives
 
-      # Create a Choice instance.
+      # Create a Rule instance.
       # @param theLhs [Dendroid::Syntax::NonTerminal] The left-hand side of the rule.
       # @param alt [Array<Dendroid::Syntax::SymbolSeq>] the alternatives (each as a sequence of symbols).
       def initialize(theLhs, alt)

data/lib/dendroid.rb

@@ -6,10 +6,8 @@
 module Dendroid
 end # module
 
-
 # This file acts as a jumping-off point for loading dependencies expected
 # for a Dendroid client.
-
 require_relative './dendroid/grm_dsl/base_grm_builder'
 require_relative './dendroid/utils/base_tokenizer'
 require_relative './dendroid/recognizer/recognizer'

data/spec/dendroid/lexical/literal_spec.rb

@@ -16,7 +16,11 @@ describe Dendroid::Lexical::Literal do
       expect { described_class.new(ex_source, ex_pos, ex_terminal, ex_value) }.not_to raise_error
     end
 
-    it 'knows its value' do
+    it 'knows it is a token with a literal value attached to it' do
+      expect(subject).to be_literal
+    end
+
+    it 'knows its literal value' do
       expect(subject.value).to eq(ex_value)
     end
   end # context

data/spec/dendroid/lexical/token_spec.rb

@@ -27,5 +27,9 @@ describe Dendroid::Lexical::Token do
     it 'knows the terminal name' do
       expect(subject.terminal).to eq(ex_terminal)
     end
+
+    it 'has no literal value attached to it' do
+      expect(subject).not_to be_literal
+    end
   end # context
 end # describe

data/spec/dendroid/parsing/chart_walker_spec.rb

@@ -5,14 +5,6 @@ require_relative '../support/sample_grammars'
 require_relative '../../../lib/dendroid/recognizer/recognizer'
 require_relative '../../../lib/dendroid/parsing/chart_walker'
 
-# require_relative '../grm_dsl/base_grm_builder'
-# require_relative '../utils/base_tokenizer'
-# require_relative '../recognizer/recognizer'
-# require_relative 'chart_walker'
-# require_relative 'parse_tree_visitor'
-# require_relative '../formatters/bracket_notation'
-# require_relative '../formatters/ascii_tree'
-
 RSpec.describe Dendroid::Parsing::ChartWalker do
   include SampleGrammars
 
@@ -45,37 +37,37 @@ RSpec.describe Dendroid::Parsing::ChartWalker do
       walker = described_class.new(chart)
       root = walker.walk(success_entry(chart, recognizer))
 
-      expect(root.to_s).to eq('p => s [0, 5]')
+      expect(root.to_s).to eq('p => s [0..5]')
       expect(root.children.size).to eq(1)
-      expect(root.children[-1].to_s).to eq('s => s PLUS m [0, 5]')
+      expect(root.children[-1].to_s).to eq('s => s PLUS m [0..5]')
       plus_expr = root.children[-1]
       expect(plus_expr.children.size).to eq(3)
-      expect(plus_expr.children[0].to_s).to eq('s => m [0, 1]')
-      expect(plus_expr.children[1].to_s).to eq('PLUS [1, 2]')
-      expect(plus_expr.children[2].to_s).to eq('m => m STAR t [2, 5]')
+      expect(plus_expr.children[0].to_s).to eq('s => m [0..1]')
+      expect(plus_expr.children[1].to_s).to eq('PLUS [1..2]')
+      expect(plus_expr.children[2].to_s).to eq('m => m STAR t [2..5]')
 
       operand_plus = plus_expr.children[0]
       expect(operand_plus.children.size).to eq(1)
-      expect(operand_plus.children[0].to_s).to eq('m => t [0, 1]')
+      expect(operand_plus.children[0].to_s).to eq('m => t [0..1]')
       expect(operand_plus.children[0].children.size).to eq(1)
-      expect(operand_plus.children[0].children[0].to_s).to eq('t => INTEGER [0, 1]')
-      expect(operand_plus.children[0].children[0].children[0].to_s).to eq('INTEGER: 2 [0, 1]')
+      expect(operand_plus.children[0].children[0].to_s).to eq('t => INTEGER [0..1]')
+      expect(operand_plus.children[0].children[0].children[0].to_s).to eq('INTEGER: 2 [0..1]')
 
-      expect(plus_expr.children[1].to_s).to eq('PLUS [1, 2]')
+      expect(plus_expr.children[1].to_s).to eq('PLUS [1..2]')
 
       star_expr = plus_expr.children[2]
       expect(star_expr.children.size).to eq(3)
-      expect(star_expr.children[0].to_s).to eq('m => t [2, 3]')
-      expect(star_expr.children[1].to_s).to eq('STAR [3, 4]')
-      expect(star_expr.children[2].to_s).to eq('t => INTEGER [4, 5]')
+      expect(star_expr.children[0].to_s).to eq('m => t [2..3]')
+      expect(star_expr.children[1].to_s).to eq('STAR [3..4]')
+      expect(star_expr.children[2].to_s).to eq('t => INTEGER [4..5]')
 
       operand_star = star_expr.children[0]
       expect(operand_star.children.size).to eq(1)
-      expect(operand_star.children[0].to_s).to eq('t => INTEGER [2, 3]')
-      expect(operand_star.children[0].children[0].to_s).to eq('INTEGER: 3 [2, 3]')
+      expect(operand_star.children[0].to_s).to eq('t => INTEGER [2..3]')
+      expect(operand_star.children[0].children[0].to_s).to eq('INTEGER: 3 [2..3]')
 
       expect(star_expr.children[2].children.size).to eq(1)
-      expect(star_expr.children[2].children[0].to_s).to eq('INTEGER: 4 [4, 5]')
+      expect(star_expr.children[2].children[0].to_s).to eq('INTEGER: 4 [4..5]')
     end
 
     it 'generates a parse tree for grammar l10 (with left recursive rule)' do
@@ -84,27 +76,27 @@ RSpec.describe Dendroid::Parsing::ChartWalker do
       walker = described_class.new(chart)
       root = walker.walk(success_entry(chart, recognizer))
 
-      expect(root.to_s).to eq('A => A a [0, 5]')
+      expect(root.to_s).to eq('A => A a [0..5]')
       expect(root.children.size).to eq(2)
-      expect(root.children[0].to_s).to eq('A => A a [0, 4]')
-      expect(root.children[1].to_s).to eq('a [4, 5]')
+      expect(root.children[0].to_s).to eq('A => A a [0..4]')
+      expect(root.children[1].to_s).to eq('a [4..5]')
 
       expect(root.children[0].children.size).to eq(2)
-      expect(root.children[0].children[0].to_s).to eq('A => A a [0, 3]')
-      expect(root.children[0].children[1].to_s).to eq('a [3, 4]')
+      expect(root.children[0].children[0].to_s).to eq('A => A a [0..3]')
+      expect(root.children[0].children[1].to_s).to eq('a [3..4]')
 
       grand_child = root.children[0].children[0]
       expect(grand_child.children.size).to eq(2)
-      expect(grand_child.children[0].to_s).to eq('A => A a [0, 2]')
-      expect(grand_child.children[1].to_s).to eq('a [2, 3]')
+      expect(grand_child.children[0].to_s).to eq('A => A a [0..2]')
+      expect(grand_child.children[1].to_s).to eq('a [2..3]')
 
       expect(grand_child.children[0].children.size).to eq(2)
-      expect(grand_child.children[0].children[0].to_s).to eq('A => A a [0, 1]')
-      expect(grand_child.children[0].children[1].to_s).to eq('a [1, 2]')
+      expect(grand_child.children[0].children[0].to_s).to eq('A => A a [0..1]')
+      expect(grand_child.children[0].children[1].to_s).to eq('a [1..2]')
 
       expect(grand_child.children[0].children[0].children.size).to eq(2)
-      expect(grand_child.children[0].children[0].children[0].to_s).to eq('_ [0, 0]')
-      expect(grand_child.children[0].children[0].children[1].to_s).to eq('a [0, 1]')
+      expect(grand_child.children[0].children[0].children[0].to_s).to eq('_ [0..0]')
+      expect(grand_child.children[0].children[0].children[1].to_s).to eq('a [0..1]')
     end
 
     it 'generates a parse tree for grammar l11 (with right recursive rule)' do
@@ -113,27 +105,27 @@ RSpec.describe Dendroid::Parsing::ChartWalker do
       walker = described_class.new(chart)
       root = walker.walk(success_entry(chart, recognizer))
 
-      expect(root.to_s).to eq('A => a A [0, 5]')
+      expect(root.to_s).to eq('A => a A [0..5]')
       expect(root.children.size).to eq(2)
-      expect(root.children[0].to_s).to eq('a [0, 1]')
-      expect(root.children[1].to_s).to eq('A => a A [1, 5]')
+      expect(root.children[0].to_s).to eq('a [0..1]')
+      expect(root.children[1].to_s).to eq('A => a A [1..5]')
 
       expect(root.children[1].children.size).to eq(2)
-      expect(root.children[1].children[0].to_s).to eq('a [1, 2]')
-      expect(root.children[1].children[1].to_s).to eq('A => a A [2, 5]')
+      expect(root.children[1].children[0].to_s).to eq('a [1..2]')
+      expect(root.children[1].children[1].to_s).to eq('A => a A [2..5]')
 
       grand_child = root.children[1].children[1]
       expect(grand_child.children.size).to eq(2)
-      expect(grand_child.children[0].to_s).to eq('a [2, 3]')
-      expect(grand_child.children[1].to_s).to eq('A => a A [3, 5]')
+      expect(grand_child.children[0].to_s).to eq('a [2..3]')
+      expect(grand_child.children[1].to_s).to eq('A => a A [3..5]')
 
       expect(grand_child.children[1].children.size).to eq(2)
-      expect(grand_child.children[1].children[0].to_s).to eq('a [3, 4]')
-      expect(grand_child.children[1].children[1].to_s).to eq('A => a A [4, 5]')
+      expect(grand_child.children[1].children[0].to_s).to eq('a [3..4]')
+      expect(grand_child.children[1].children[1].to_s).to eq('A => a A [4..5]')
 
       expect(grand_child.children[1].children[1].children.size).to eq(2)
-      expect(grand_child.children[1].children[1].children[0].to_s).to eq('a [4, 5]')
-      expect(grand_child.children[1].children[1].children[1].to_s).to eq('_ [5, 5]')
+      expect(grand_child.children[1].children[1].children[0].to_s).to eq('a [4..5]')
+      expect(grand_child.children[1].children[1].children[1].to_s).to eq('_ [5..5]')
     end
   end # context
 
@@ -144,78 +136,78 @@ RSpec.describe Dendroid::Parsing::ChartWalker do
       walker = described_class.new(chart)
       root = walker.walk(success_entry(chart, recognizer))
 
-      expect(root.to_s).to eq('OR: S [0, 4]')
+      expect(root.to_s).to eq('OR: S [0..4]')
       expect(root.children.size).to eq(3)
       root.children.each do |child|
         expect(child.children.size).to eq(2)
-        expect(child.to_s).to eq('S => S S [0, 4]')
+        expect(child.to_s).to eq('S => S S [0..4]')
       end
       (a, b, c) = root.children
 
       # Test structure of tree a
       (child_a_0, child_a_1) = a.children
-      expect(child_a_0.to_s).to eq('S => S S [0, 2]')
-      expect(child_a_1.to_s).to eq('S => S S [2, 4]')
+      expect(child_a_0.to_s).to eq('S => S S [0..2]')
+      expect(child_a_1.to_s).to eq('S => S S [2..4]')
       expect(child_a_0.children.size).to eq(2)
       (child_a_0_0, child_a_0_1) = child_a_0.children
-      expect(child_a_0_0.to_s).to eq('S => x [0, 1]')
-      expect(child_a_0_1.to_s).to eq('S => x [1, 2]')
-      expect(child_a_0_0.children[0].to_s).to eq('x [0, 1]')
-      expect(child_a_0_1.children[0].to_s).to eq('x [1, 2]')
+      expect(child_a_0_0.to_s).to eq('S => x [0..1]')
+      expect(child_a_0_1.to_s).to eq('S => x [1..2]')
+      expect(child_a_0_0.children[0].to_s).to eq('x [0..1]')
+      expect(child_a_0_1.children[0].to_s).to eq('x [1..2]')
 
       expect(child_a_1.children.size).to eq(2)
       (child_a_1_0, child_a_1_1) = child_a_1.children
-      expect(child_a_1_0.to_s).to eq('S => x [2, 3]')
-      expect(child_a_1_1.to_s).to eq('S => x [3, 4]')
-      expect(child_a_1_0.children[0].to_s).to eq('x [2, 3]')
-      expect(child_a_1_1.children[0].to_s).to eq('x [3, 4]')
+      expect(child_a_1_0.to_s).to eq('S => x [2..3]')
+      expect(child_a_1_1.to_s).to eq('S => x [3..4]')
+      expect(child_a_1_0.children[0].to_s).to eq('x [2..3]')
+      expect(child_a_1_1.children[0].to_s).to eq('x [3..4]')
 
       # Test structure of forest b
       (child_b_0, child_b_1) = b.children
-      expect(child_b_0.to_s).to eq('OR: S [0, 3]')
-      expect(child_b_1.to_s).to eq('S => x [3, 4]')
+      expect(child_b_0.to_s).to eq('OR: S [0..3]')
+      expect(child_b_1.to_s).to eq('S => x [3..4]')
       expect(child_b_1.equal?(child_a_1_1)).to be_truthy # Sharing
       expect(child_b_0.children.size).to eq(2)
       (child_b_0_0, child_b_0_1) = child_b_0.children
-      expect(child_b_0_0.to_s).to eq('S => S S [0, 3]')
-      expect(child_b_0_1.to_s).to eq('S => S S [0, 3]')
+      expect(child_b_0_0.to_s).to eq('S => S S [0..3]')
+      expect(child_b_0_1.to_s).to eq('S => S S [0..3]')
       expect(child_b_0_0.children.size).to eq(2)
       (child_b_0_0_0, child_b_0_0_1) = child_b_0_0.children
-      expect(child_b_0_0_0.to_s).to eq('S => x [0, 1]')
+      expect(child_b_0_0_0.to_s).to eq('S => x [0..1]')
       expect(child_b_0_0_0.equal?(child_a_0_0)).to be_truthy # Sharing
-      expect(child_b_0_0_1.to_s).to eq('S => S S [1, 3]')
+      expect(child_b_0_0_1.to_s).to eq('S => S S [1..3]')
       expect(child_b_0_0_1.children.size).to eq(2)
-      expect(child_b_0_0_1.children[0].to_s).to eq('S => x [1, 2]')
+      expect(child_b_0_0_1.children[0].to_s).to eq('S => x [1..2]')
       expect(child_b_0_0_1.children[0].equal?(child_a_0_1)).to be_truthy # Sharing
-      expect(child_b_0_0_1.children[1].to_s).to eq('S => x [2, 3]')
+      expect(child_b_0_0_1.children[1].to_s).to eq('S => x [2..3]')
       expect(child_b_0_0_1.children[1].equal?(child_a_1_0)).to be_truthy # Sharing
 
       expect(child_b_0_1.children.size).to eq(2)
       (child_b_0_1_0, child_b_0_1_1) = child_b_0_1.children
-      expect(child_b_0_1_0.to_s).to eq('S => S S [0, 2]')
+      expect(child_b_0_1_0.to_s).to eq('S => S S [0..2]')
       expect(child_b_0_1_0.equal?(child_a_0)).to be_truthy # Sharing
-      expect(child_b_0_1_1.to_s).to eq('S => x [2, 3]')
+      expect(child_b_0_1_1.to_s).to eq('S => x [2..3]')
       expect(child_b_0_1_1.equal?(child_a_1_0)).to be_truthy # Sharing
 
       # Test structure of forest c
       (child_c_0, child_c_1) = c.children
-      expect(child_c_0.to_s).to eq('S => x [0, 1]')
+      expect(child_c_0.to_s).to eq('S => x [0..1]')
       expect(child_c_0.equal?(child_a_0_0)).to be_truthy # Sharing
-      expect(child_c_1.to_s).to eq('OR: S [1, 4]')
+      expect(child_c_1.to_s).to eq('OR: S [1..4]')
       expect(child_c_1.children.size).to eq(2)
       (child_c_1_0, child_c_1_1) = child_c_1.children
-      expect(child_c_1_0.to_s).to eq('S => S S [1, 4]')
-      expect(child_c_1_1.to_s).to eq('S => S S [1, 4]')
+      expect(child_c_1_0.to_s).to eq('S => S S [1..4]')
+      expect(child_c_1_1.to_s).to eq('S => S S [1..4]')
       expect(child_c_1_0.children.size).to eq(2)
       (child_c_1_0_0, child_c_1_0_1) = child_c_1_0.children
-      expect(child_c_1_0_0.to_s).to eq('S => x [1, 2]')
+      expect(child_c_1_0_0.to_s).to eq('S => x [1..2]')
       expect(child_c_1_0_0.equal?(child_a_0_1)).to be_truthy # Sharing
-      expect(child_c_1_0_1.to_s).to eq('S => S S [2, 4]')
+      expect(child_c_1_0_1.to_s).to eq('S => S S [2..4]')
       expect(child_c_1_0_1.equal?(child_a_1)).to be_truthy # Sharing
       (child_c_1_1_0, child_c_1_1_1) = child_c_1_1.children
-      expect(child_c_1_1_0.to_s).to eq('S => S S [1, 3]')
+      expect(child_c_1_1_0.to_s).to eq('S => S S [1..3]')
       expect(child_c_1_1_0.equal?(child_b_0_0_1)).to be_truthy # Sharing
-      expect(child_c_1_1_1.to_s).to eq('S => x [3, 4]')
+      expect(child_c_1_1_1.to_s).to eq('S => x [3..4]')
       expect(child_c_1_1_1.equal?(child_b_1)).to be_truthy # Sharing
     end
 
@@ -225,24 +217,24 @@ RSpec.describe Dendroid::Parsing::ChartWalker do
       walker = described_class.new(chart)
       root = walker.walk(success_entry(chart, recognizer))
 
-      expect(root.to_s).to eq('OR: S [0, 2]')
+      expect(root.to_s).to eq('OR: S [0..2]')
       expect(root.children.size).to eq(2)
       root.children.each do |ch|
-        expect(ch.to_s).to eq('S => S T [0, 2]')
+        expect(ch.to_s).to eq('S => S T [0..2]')
         expect(ch.children.size).to eq(2)
       end
       (child_0_0, child_0_1) = root.children[0].children
-      expect(child_0_0.to_s).to eq('S => a [0, 1]')
-      expect(child_0_1.to_s).to eq('T => a B [1, 2]')
+      expect(child_0_0.to_s).to eq('S => a [0..1]')
+      expect(child_0_1.to_s).to eq('T => a B [1..2]')
       expect(child_0_1.children.size).to eq(2)
-      expect(child_0_1.children[0].to_s).to eq('a [1, 2]')
-      expect(child_0_1.children[1].to_s).to eq('_ [2, 2]')
+      expect(child_0_1.children[0].to_s).to eq('a [1..2]')
+      expect(child_0_1.children[1].to_s).to eq('_ [2..2]')
 
       (child_1_0, child_1_1) = root.children[1].children
-      expect(child_1_0.to_s).to eq('S => a [0, 1]')
-      expect(child_1_1.to_s).to eq('T => a [1, 2]')
+      expect(child_1_0.to_s).to eq('S => a [0..1]')
+      expect(child_1_1.to_s).to eq('T => a [1..2]')
       expect(child_1_0.equal?(child_0_0)).to be_truthy # Sharing
-      expect(child_1_1.children[0].to_s).to eq('a [1, 2]')
+      expect(child_1_1.children[0].to_s).to eq('a [1..2]')
       expect(child_1_1.children[0].equal?(child_0_1.children[0])).to be_truthy # Sharing
     end
   end # context

data/spec/dendroid/parsing/composite_parse_node_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/dendroid/parsing/composite_parse_node'
+
+RSpec.describe Dendroid::Parsing::CompositeParseNode do
+  let(:sample_range) { 3..5 }
+  let(:sample_child_count) { 7 }
+  subject { described_class.new(sample_range.begin, sample_range.end, sample_child_count) }
+
+  context 'Initialization:' do
+    it 'should be initialized with two token positions and a child count' do
+      expect { described_class.new(sample_range.begin, sample_range.end, sample_child_count) }.not_to raise_error
+    end
+
+    it 'has its children array filled with nils' do
+      # Check number of elements...
+      expect(subject.children.size).to eq(sample_child_count)
+
+      # All elements are nil
+      expect(subject.children.all?(&:nil?)).to be_truthy
+    end
+  end # context
+
+  context 'provided services:' do
+    it 'adds a child node at a specific slot' do
+      child3 = Dendroid::Parsing::ParseNode.new(3, 4)
+      child5 = Dendroid::Parsing::ParseNode.new(5, 6)
+      subject.add_child(child3, 3)
+      subject.add_child(child5, 5)
+      expect(subject.children.reject(&:nil?).size).to eq(2)
+      expect(subject.children[3]).to eq(child3)
+      expect(subject.children[5]).to eq(child5)
+    end
+  end # context
+end # describe

data/spec/dendroid/parsing/empty_rule_node_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper'
+require_relative '../../../lib/dendroid/grm_dsl/base_grm_builder'
+require_relative '../../../lib/dendroid/grm_analysis/dotted_item'
+require_relative '../../../lib/dendroid/recognizer/e_item'
+require_relative '../../../lib/dendroid/parsing/empty_rule_node'
+
+RSpec.describe Dendroid::Parsing::EmptyRuleNode do
+  let(:sample_rule) { sample_grammar.rules[0] }
+  let(:sample_dotted_item) { Dendroid::GrmAnalysis::DottedItem.new(sample_rule, 0, 1) }
+  let(:sample_entry) { Dendroid::Recognizer::EItem.new(sample_dotted_item, 5) }
+
+  subject { described_class.new(sample_entry, 5) }
+
+  let(:sample_grammar) do
+    builder = Dendroid::GrmDSL::BaseGrmBuilder.new do
+      declare_terminals('INTEGER')
+
+      rule('s' => ['INTEGER', ''])
+    end
+
+    builder.grammar
+  end
+
+  context 'Initialization:' do
+    it 'should be initialized with a chart entry and an end rank number' do
+      expect { described_class.new(sample_entry, 5) }.not_to raise_error
+    end
+
+    it 'knows the rule it is related to' do
+      expect(subject.rule).to eq(sample_grammar.rules[0])
+    end
+
+    it 'knows the alternative index it is related to' do
+      expect(subject.alt_index).to eq(1)
+    end
+
+    it 'knows its origin and end positions' do
+      expect(subject.range.begin).to eq(subject.range.end)
+      expect(subject.range.begin).to eq(5)
+    end
+  end # context
+
+  context 'Provided services:' do
+    it 'renders a String representation of its range' do
+      expect(subject.to_s).to eq('_ [5..5]')
+    end
+  end # context
+end # describe