dendroid 0.1.00 → 0.2.01

data/lib/dendroid/syntax/rule.rb

@@ -2,28 +2,60 @@
 
 module Dendroid
   module Syntax
-    # In a context-free grammar, a rule has its left-hand side (LHS)
-    # that consists solely of one non-terminal symbol.
-    # and the right-hand side (RHS) consists of one or more sequence of symbols.
-    # The symbols in RHS can be either terminal or non-terminal symbols.
-    # The rule stipulates that the LHS is equivalent to the RHS,
-    # in other words every occurrence of the LHS can be substituted to
-    # corresponding RHS.
+    # A specialization of the Rule class.
+    # A choice is a rule with multiple rhs
     class Rule
       # @return [Dendroid::Syntax::NonTerminal] The left-hand side of the rule.
       attr_reader :head
       alias lhs head
 
-      # Create a Rule instance.
-      # @param lhs [Dendroid::Syntax::NonTerminal] The left-hand side of the rule.
-      def initialize(lhs)
-        @head = valid_head(lhs)
+      # @return [Array<Dendroid::Syntax::SymbolSeq>]
+      attr_reader :alternatives
+
+      # Create a Choice 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)
+        @head = valid_head(theLhs)
+        @alternatives = valid_alternatives(alt)
       end
 
-      # Return the text representation of the rule
+      # Return the text representation of the choice
       # @return [String]
       def to_s
-        head.to_s
+        "#{head} => #{alternatives.join(' | ')}"
+      end
+
+      # Predicate method to check whether the choice rule body is productive.
+      # It is productive when at least one of its alternative is productive.
+      # @return [Boolean]
+      def productive?
+        productive_alts = alternatives.select(&:productive?)
+        return false if productive_alts.empty?
+
+        @productive = Set.new(productive_alts)
+        head.productive = true
+      end
+
+      # Predicate method to check whether the rule has at least one empty alternative.
+      # @return [Boolean]
+      def empty?
+        alternatives.any?(&:empty?)
+      end
+
+      # Returns an array with the symbol sequence of its alternatives
+      # @return [Array<Dendroid::Syntax::SymbolSeq>]
+      def rhs
+        alternatives
+      end
+
+      # Equality operator
+      # Two production rules are equal when their head and alternatives are equal.
+      # @return [Boolean]
+      def ==(other)
+        return true if equal?(other)
+
+        (head == other.head) && (alternatives == other.alternatives)
       end
 
       # The set of all grammar symbols that occur in the rhs.
@@ -70,6 +102,32 @@ module Dendroid
 
         lhs
       end
+
+      def valid_alternatives(alt)
+        raise StandardError, "Expecting an Array, found a #{rhs.class} instead." unless alt.is_a?(Array)
+
+        if alt.empty?
+          # A choice must have at least two alternatives
+          raise StandardError, "The choice for `#{head}` must have at least one alternative."
+        end
+
+        # Verify that each array element is a valid symbol sequence
+        alt.each { |elem| valid_sequence(elem) }
+
+        # Fail when duplicate rhs found
+        alt_texts = alt.map(&:to_s)
+        no_duplicate = alt_texts.uniq
+        if alt_texts.size > no_duplicate.size
+          alt_texts.each_with_index do |str, i|
+            next if str == no_duplicate[i]
+
+            err_msg = "Duplicate alternatives: #{head} => #{alt_texts[i]}"
+            raise StandardError, err_msg
+          end
+        end
+
+        alt
+      end
     end # class
   end # module
 end # module

data/spec/dendroid/grm_analysis/dotted_item_spec.rb

@@ -4,28 +4,29 @@ require_relative '..\..\spec_helper'
 require_relative '..\..\..\lib\dendroid\syntax\terminal'
 require_relative '..\..\..\lib\dendroid\syntax\non_terminal'
 require_relative '..\..\..\lib\dendroid\syntax\symbol_seq'
-require_relative '..\..\..\lib\dendroid\syntax\production'
+require_relative '..\..\..\lib\dendroid\syntax\rule'
 require_relative '..\..\..\lib\dendroid\grm_analysis\dotted_item'
 
 describe Dendroid::GrmAnalysis::DottedItem do
   let(:num_symb) { Dendroid::Syntax::Terminal.new('NUMBER') }
   let(:plus_symb) { Dendroid::Syntax::Terminal.new('PLUS') }
+  let(:minus_symb) { Dendroid::Syntax::Terminal.new('MINUS') }
   let(:expr_symb) { Dendroid::Syntax::NonTerminal.new('expression') }
-  let(:rhs) { Dendroid::Syntax::SymbolSeq.new([num_symb, plus_symb, num_symb]) }
+  let(:rhs1) { Dendroid::Syntax::SymbolSeq.new([num_symb, plus_symb, num_symb]) }
+  let(:rhs2) { Dendroid::Syntax::SymbolSeq.new([num_symb, minus_symb, num_symb]) }
   let(:empty_body) { Dendroid::Syntax::SymbolSeq.new([]) }
-  let(:prod) { Dendroid::Syntax::Production.new(expr_symb, rhs) }
-  let(:empty_prod) { Dendroid::Syntax::Production.new(expr_symb, empty_body) }
+  let(:choice) { Dendroid::Syntax::Rule.new(expr_symb, [rhs1, rhs2, empty_body]) }
 
-  # Implements a dotted item: expression => NUMBER . PLUS NUMBER
-  subject { described_class.new(prod, 1) }
+  # Implements a dotted item: expression => NUMBER . MINUS NUMBER
+  subject { described_class.new(choice, 1, 1) }
 
   context 'Initialization:' do
     it 'is initialized with a production and a dot position' do
-      expect { described_class.new(prod, 1) }.not_to raise_error
+      expect { described_class.new(choice, 1, 1) }.not_to raise_error
     end
 
     it 'knows its related production' do
-      expect(subject.rule).to eq(prod)
+      expect(subject.rule).to eq(choice)
     end
 
     it 'knows its position' do
@@ -35,67 +36,78 @@ describe Dendroid::GrmAnalysis::DottedItem do
 
   context 'Provided services:' do
     it 'renders a String representation of itself' do
-      expect(subject.to_s).to eq('expression => NUMBER . PLUS NUMBER')
+      expect(subject.to_s).to eq('expression => NUMBER . MINUS NUMBER')
     end
 
     it 'knows its state' do
-      expect(described_class.new(prod, 0).state).to eq(:initial)
-      expect(described_class.new(prod, 1).state).to eq(:partial)
-      expect(described_class.new(prod, 3).state).to eq(:completed)
+      expect(described_class.new(choice, 0, 1).state).to eq(:initial)
+      expect(described_class.new(choice, 1, 1).state).to eq(:partial)
+      expect(described_class.new(choice, 3, 1).state).to eq(:completed)
 
-      # Case of an empty production
-      expect(described_class.new(empty_prod, 0).state).to eq(:initial_and_completed)
+      # Case of an empty alternative
+      expect(described_class.new(choice, 0, 2).state).to eq(:initial_and_completed)
     end
 
     it 'knows whether it is in the initial position' do
-      expect(described_class.new(prod, 0)).to be_initial_pos
-      expect(described_class.new(prod, 2)).not_to be_initial_pos
-      expect(described_class.new(prod, 3)).not_to be_initial_pos
+      expect(described_class.new(choice, 0, 0)).to be_initial_pos
+      expect(described_class.new(choice, 2, 0)).not_to be_initial_pos
+      expect(described_class.new(choice, 3, 0)).not_to be_initial_pos
 
-      # Case of an empty production
-      expect(described_class.new(empty_prod, 0)).to be_initial_pos
+      # Case of an empty alternative
+      expect(described_class.new(choice, 0, 2)).to be_initial_pos
     end
 
     it 'knows whether it is in the final position' do
-      expect(described_class.new(prod, 0)).not_to be_final_pos
-      expect(described_class.new(prod, 2)).not_to be_final_pos
-      expect(described_class.new(prod, 3)).to be_final_pos
-      expect(described_class.new(prod, 3)).to be_completed
+      expect(described_class.new(choice, 0, 1)).not_to be_final_pos
+      expect(described_class.new(choice, 2, 1)).not_to be_final_pos
+      expect(described_class.new(choice, 3, 1)).to be_final_pos
+      expect(described_class.new(choice, 3, 1)).to be_completed
 
-      # Case of an empty production
-      expect(described_class.new(empty_prod, 0)).to be_final_pos
+      # Case of an empty alternative
+      expect(described_class.new(choice, 0, 2)).to be_final_pos
     end
 
     it 'knows whether it is in an intermediate position' do
-      expect(described_class.new(prod, 0)).not_to be_intermediate_pos
-      expect(described_class.new(prod, 2)).to be_intermediate_pos
-      expect(described_class.new(prod, 3)).not_to be_intermediate_pos
+      expect(described_class.new(choice, 0, 0)).not_to be_intermediate_pos
+      expect(described_class.new(choice, 2, 0)).to be_intermediate_pos
+      expect(described_class.new(choice, 3, 0)).not_to be_intermediate_pos
 
-      # Case of an empty production
-      expect(described_class.new(empty_prod, 0)).not_to be_intermediate_pos
+      # Case of an empty alternative
+      expect(described_class.new(choice, 0, 2)).not_to be_intermediate_pos
     end
 
     it 'knows the symbol after the dot (if any)' do
-      expect(described_class.new(prod, 0).next_symbol.name).to eq(:NUMBER)
-      expect(described_class.new(prod, 1).next_symbol.name).to eq(:PLUS)
-      expect(described_class.new(prod, 2).next_symbol.name).to eq(:NUMBER)
-      expect(described_class.new(prod, 3).next_symbol).to be_nil
+      expect(described_class.new(choice, 0, 1).next_symbol.name).to eq(:NUMBER)
+      expect(described_class.new(choice, 1, 1).next_symbol.name).to eq(:MINUS)
+      expect(described_class.new(choice, 2, 1).next_symbol.name).to eq(:NUMBER)
+      expect(described_class.new(choice, 3, 1).next_symbol).to be_nil
 
-      # Case of an empty production
-      expect(described_class.new(empty_prod, 0).next_symbol).to be_nil
+      # Case of an empty alternative
+      expect(described_class.new(choice, 0, 2).next_symbol).to be_nil
     end
 
-    it 'can compare a given symbol to the expected one' do
-      expect(described_class.new(prod, 0)).to be_expecting(num_symb)
-      expect(described_class.new(prod, 0)).not_to be_expecting(plus_symb)
-      expect(described_class.new(prod, 1)).to be_expecting(plus_symb)
-      expect(described_class.new(prod, 2)).to be_expecting(num_symb)
-      expect(described_class.new(prod, 3)).not_to be_expecting(num_symb)
-      expect(described_class.new(prod, 3)).not_to be_expecting(plus_symb)
-
-      # Case of an empty production
-      expect(described_class.new(empty_prod, 0)).not_to be_expecting(num_symb)
-      expect(described_class.new(empty_prod, 0)).not_to be_expecting(plus_symb)
+    it 'knows the symbol before the dot (if any)' do
+      expect(described_class.new(choice, 0, 1).prev_symbol).to be_nil
+      expect(described_class.new(choice, 1, 1).prev_symbol.name).to eq(:NUMBER)
+      expect(described_class.new(choice, 2, 1).prev_symbol.name).to eq(:MINUS)
+      expect(described_class.new(choice, 3, 1).prev_symbol.name).to eq(:NUMBER)
+
+      # Case of an empty alternative
+      expect(described_class.new(choice, 0, 1).prev_symbol).to be_nil
+    end
+
+    it 'can compare a given symbol to the one expected' do
+      expect(described_class.new(choice, 0, 1)).to be_expecting(num_symb)
+      expect(described_class.new(choice, 0, 1)).not_to be_expecting(plus_symb)
+      expect(described_class.new(choice, 1, 0)).to be_expecting(plus_symb)
+      expect(described_class.new(choice, 1, 1)).to be_expecting(minus_symb)
+      expect(described_class.new(choice, 2, 0)).to be_expecting(num_symb)
+      expect(described_class.new(choice, 3, 1)).not_to be_expecting(num_symb)
+      expect(described_class.new(choice, 3, 1)).not_to be_expecting(plus_symb)
+
+      # Case of an empty alternative
+      expect(described_class.new(choice, 0, 2)).not_to be_expecting(num_symb)
+      expect(described_class.new(choice, 0, 2)).not_to be_expecting(plus_symb)
     end
   end # context
 end # describe

data/spec/dendroid/grm_analysis/{choice_items_spec.rb → rule_items_spec.rb}

@@ -4,11 +4,10 @@ require_relative '..\..\spec_helper'
 require_relative '..\..\..\lib\dendroid\syntax\terminal'
 require_relative '..\..\..\lib\dendroid\syntax\non_terminal'
 require_relative '..\..\..\lib\dendroid\syntax\symbol_seq'
-require_relative '..\..\..\lib\dendroid\syntax\choice'
-# require_relative '..\..\..\lib\dendroid\grm_analysis\alternative_item'
-require_relative '..\..\..\lib\dendroid\grm_analysis\choice_items'
+require_relative '..\..\..\lib\dendroid\syntax\rule'
+require_relative '..\..\..\lib\dendroid\grm_analysis\rule_items'
 
-describe Dendroid::GrmAnalysis::ChoiceItems do
+describe Dendroid::GrmAnalysis::RuleItems do
   let(:num_symb) { Dendroid::Syntax::Terminal.new('NUMBER') }
   let(:plus_symb) { Dendroid::Syntax::Terminal.new('PLUS') }
   let(:star_symb) { Dendroid::Syntax::Terminal.new('STAR') }
@@ -17,8 +16,8 @@ describe Dendroid::GrmAnalysis::ChoiceItems do
   let(:alt2) { Dendroid::Syntax::SymbolSeq.new([num_symb, star_symb, num_symb]) }
   let(:alt3) { Dendroid::Syntax::SymbolSeq.new([]) }
   subject do
-    choice = Dendroid::Syntax::Choice.new(expr_symb, [alt1, alt2, alt3])
-    choice.extend(Dendroid::GrmAnalysis::ChoiceItems)
+    choice = Dendroid::Syntax::Rule.new(expr_symb, [alt1, alt2, alt3])
+    choice.extend(Dendroid::GrmAnalysis::RuleItems)
     choice.build_items
     choice
   end

data/spec/dendroid/parsing/chart_walker_spec.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper'
+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
+
+  def retrieve_success_item(chart, grammar)
+    last_item_set = chart.item_sets.last
+    result = nil
+    last_item_set.items.reverse_each do |itm|
+      if itm.origin.zero? && itm.dotted_item.completed? && itm.dotted_item.rule.lhs == grammar.start_symbol
+        result = itm
+        break
+      end
+    end
+
+    result
+  end
+
+  def recognizer_for(grammar, tokenizer)
+    Dendroid::Recognizer::Recognizer.new(grammar, tokenizer)
+  end
+
+  def success_entry(chart, recognizer)
+    retrieve_success_item(chart, recognizer.grm_analysis.grammar)
+  end
+
+  # rubocop: disable Naming/VariableNumber
+  context 'Parsing non-ambiguous grammars' do
+    it 'generates a parse tree for the example from Wikipedia' do
+      recognizer = recognizer_for(grammar_l1, tokenizer_l1)
+      chart = recognizer.run('2 + 3 * 4')
+      walker = described_class.new(chart)
+      root = walker.walk(success_entry(chart, recognizer))
+
+      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]')
+      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]')
+
+      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].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(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]')
+
+      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(star_expr.children[2].children.size).to eq(1)
+      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
+      recognizer = recognizer_for(grammar_l10, tokenizer_l10)
+      chart = recognizer.run('a a a a a')
+      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.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].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]')
+
+      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].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].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]')
+    end
+
+    it 'generates a parse tree for grammar l11 (with right recursive rule)' do
+      recognizer = recognizer_for(grammar_l11, tokenizer_l11)
+      chart = recognizer.run('a a a a a')
+      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.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[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]')
+
+      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[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[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]')
+    end
+  end # context
+
+  context 'Parsing ambiguous grammars' do
+    it "generates a parse forest for the G2 grammar that choked Earley's parsing algorithm" do
+      recognizer = recognizer_for(grammar_l8, tokenizer_l8)
+      chart = recognizer.run('x x x x')
+      walker = described_class.new(chart)
+      root = walker.walk(success_entry(chart, recognizer))
+
+      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]')
+      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.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_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]')
+
+      # 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_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.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.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.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].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].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.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.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.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.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.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.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.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.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.equal?(child_b_1)).to be_truthy # Sharing
+    end
+
+    it "generates a parse forest for example 3 in paper 'SPPF-Style Parsing From Earley Recognisers'" do
+      recognizer = recognizer_for(grammar_l7, tokenizer_l7)
+      chart = recognizer.run('a a')
+      walker = described_class.new(chart)
+      root = walker.walk(success_entry(chart, recognizer))
+
+      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.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_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]')
+
+      (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.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].equal?(child_0_1.children[0])).to be_truthy # Sharing
+    end
+  end # context
+  # rubocop: enable Naming/VariableNumber
+end # describe

data/spec/dendroid/parsing/terminal_node_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper'
+require_relative '../../../lib\dendroid/syntax/terminal'
+require_relative '../../../lib/dendroid/lexical/token_position'
+require_relative '../../../lib/dendroid/lexical/literal'
+require_relative '../../../lib/dendroid/parsing/terminal_node'
+
+RSpec.describe Dendroid::Parsing::TerminalNode do
+  let(:ex_source) { '+' }
+  let(:ex_pos) { Dendroid::Lexical::TokenPosition.new(2, 5) }
+  let(:ex_terminal) { Dendroid::Syntax::Terminal.new('PLUS') }
+  let(:plus_token) { Dendroid::Lexical::Token.new(ex_source, ex_pos, ex_terminal) }
+  let(:plus_node) { described_class.new(ex_terminal, plus_token, 3) }
+
+  let(:int_source) { '2' }
+  let(:int_symbol) { Dendroid::Syntax::Terminal.new('INTEGER') }
+  let(:int_token)  { Dendroid::Lexical::Literal.new(int_source, ex_pos, int_symbol, 2) }
+  let(:int_node) { described_class.new(int_symbol, int_token, 5) }
+
+  context 'Initialization:' do
+    it 'should be initialized with a symbol, terminal and a rank' do
+      expect { described_class.new(ex_terminal, plus_token, 3) }.not_to raise_error
+    end
+  end
+
+  context 'provided services' do
+    it 'renders a String representation of itself' do
+      expect(plus_node.to_s).to eq('PLUS [3, 4]')
+    end
+
+    it 'renders also the token value (if any)' do
+      expect(int_node.to_s).to eq('INTEGER: 2 [5, 6]')
+    end
+  end
+end

data/spec/dendroid/recognizer/e_item_spec.rb

@@ -4,7 +4,7 @@ require_relative '../../spec_helper'
 require_relative '../../../lib/dendroid/syntax/terminal'
 require_relative '../../../lib/dendroid/syntax/non_terminal'
 require_relative '../../../lib/dendroid/syntax/symbol_seq'
-require_relative '../../../lib/dendroid/syntax/production'
+require_relative '../../../lib/dendroid/syntax/rule'
 require_relative '../../../lib/dendroid/grm_analysis/dotted_item'
 require_relative '../../../lib/dendroid/recognizer/e_item'
 
@@ -14,10 +14,10 @@ describe Dendroid::Recognizer::EItem do
   let(:expr_symb) { Dendroid::Syntax::NonTerminal.new('expression') }
   let(:rhs) { Dendroid::Syntax::SymbolSeq.new([num_symb, plus_symb, num_symb]) }
   let(:empty_body) { Dendroid::Syntax::SymbolSeq.new([]) }
-  let(:prod) { Dendroid::Syntax::Production.new(expr_symb, rhs) }
-  let(:empty_prod) { Dendroid::Syntax::Production.new(expr_symb, empty_body) }
-  let(:sample_dotted) { Dendroid::GrmAnalysis::DottedItem.new(prod, 1) }
-  let(:other_dotted) { Dendroid::GrmAnalysis::DottedItem.new(empty_prod, 0) }
+  let(:prod) { Dendroid::Syntax::Rule.new(expr_symb, [rhs]) }
+  let(:empty_prod) { Dendroid::Syntax::Rule.new(expr_symb, [empty_body]) }
+  let(:sample_dotted) { Dendroid::GrmAnalysis::DottedItem.new(prod, 1, 0) }
+  let(:other_dotted) { Dendroid::GrmAnalysis::DottedItem.new(empty_prod, 0, 0) }
   let(:sample_origin) { 3 }
 
   subject { described_class.new(sample_dotted, sample_origin) }

data/spec/dendroid/recognizer/item_set_spec.rb

@@ -4,7 +4,7 @@ require_relative '../../spec_helper'
 require_relative '../../../lib/dendroid/syntax/terminal'
 require_relative '../../../lib/dendroid/syntax/non_terminal'
 require_relative '../../../lib/dendroid/syntax/symbol_seq'
-require_relative '../../../lib/dendroid/syntax/production'
+require_relative '../../../lib/dendroid/syntax/rule'
 require_relative '../../../lib/dendroid/grm_analysis/dotted_item'
 require_relative '../../../lib/dendroid/recognizer/e_item'
 require_relative '../../../lib/dendroid/recognizer/item_set'
@@ -15,11 +15,11 @@ describe Dendroid::Recognizer::ItemSet do
   let(:expr_symb) { Dendroid::Syntax::NonTerminal.new('expression') }
   let(:rhs) { Dendroid::Syntax::SymbolSeq.new([num_symb, plus_symb, num_symb]) }
   let(:empty_body) { Dendroid::Syntax::SymbolSeq.new([]) }
-  let(:prod) { Dendroid::Syntax::Production.new(expr_symb, rhs) }
-  let(:empty_prod) { Dendroid::Syntax::Production.new(expr_symb, empty_body) }
-  let(:sample_dotted) { Dendroid::GrmAnalysis::DottedItem.new(prod, 1) }
+  let(:prod) { Dendroid::Syntax::Rule.new(expr_symb, [rhs]) }
+  let(:empty_prod) { Dendroid::Syntax::Rule.new(expr_symb, [empty_body]) }
+  let(:sample_dotted) { Dendroid::GrmAnalysis::DottedItem.new(prod, 1, 0) }
   let(:sample_origin) { 3 }
-  let(:other_dotted) { Dendroid::GrmAnalysis::DottedItem.new(empty_prod, 0) }
+  let(:other_dotted) { Dendroid::GrmAnalysis::DottedItem.new(empty_prod, 0, 0) }
   let(:first_element) { Dendroid::Recognizer::EItem.new(sample_dotted, sample_origin) }
   let(:second_element) { Dendroid::Recognizer::EItem.new(other_dotted, 5) }
 
@@ -37,15 +37,23 @@ describe Dendroid::Recognizer::ItemSet do
 
   context 'Provided services:' do
     it 'adds a new element' do
-      subject.add_item(first_element)
+      added = subject.add_item(first_element)
       expect(subject.size).to eq(1)
+      expect(added).to eq(first_element)
 
-      # Trying a second time, doesn't change the set
+      # Trying a second time with itentical item, doesn't change the set
       subject.add_item(first_element)
       expect(subject.size).to eq(1)
 
-      subject.add_item(second_element)
+      # Trying a third time with equal item, doesn't change the set
+      similar = first_element.dup
+      added = subject.add_item(similar)
+      expect(subject.size).to eq(1)
+      expect(added).to eq(first_element)
+
+      added = subject.add_item(second_element)
       expect(subject.size).to eq(2)
+      expect(added).to eq(second_element)
     end
 
     it 'can render a String representation of itself' do