dendroid 0.1.00 → 0.2.00

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,223 @@
+# 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
+
+  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
+  end # context
+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

data/spec/dendroid/recognizer/recognizer_spec.rb

@@ -51,7 +51,7 @@ describe Dendroid::Recognizer::Recognizer do
         'm => t . @ 0',
         's => m . @ 0',
         # 'm => m . STAR t @ 0',
-        'p => s . @ 0',
+        'p => s . @ 0', # Can be ruled out (next token != eos)
         's => s . PLUS m @ 0'
       ]
       set2 = [ # 2 + . 3 * 4'
@@ -65,7 +65,7 @@ describe Dendroid::Recognizer::Recognizer do
         'm => t . @ 2',
         's => s PLUS m . @ 0',
         'm => m . STAR t @ 2',
-        'p => s . @ 0'
+        'p => s . @ 0' # Can be ruled out (next token != eos)
         # 's => s . PLUS m @ 0'
       ]
       set4 = [ # 2 + 3 * . 4'
@@ -422,6 +422,55 @@ describe Dendroid::Recognizer::Recognizer do
       comp_expected_actuals(chart, expectations)
     end
 
+
+    it 'accepts an input with multiple levels of ambiguity' do
+      recognizer = described_class.new(grammar_l8, tokenizer_l8)
+      chart = recognizer.run('x x x x')
+      expect(chart).to be_successful
+
+      set0 = [ # . x x x x
+        'S => . S S @ 0',
+        'S => . x @ 0'
+      ]
+      set1 = [ # x . x x x
+        'S => x . @ 0',
+        'S => S . S @ 0',
+        'S => . S S @ 1',
+        'S => . x @ 1'
+      ]
+      set2 = [ # x x . x x
+        'S => x . @ 1',
+        'S => S S . @ 0',
+        'S => S . S @ 1',
+        'S => S . S @ 0',
+        'S => . S S @ 2',
+        'S => . x @ 2'
+      ]
+      set3 = [ # x x x . x
+        'S => x . @ 2',
+        'S => S S . @ 1',
+        'S => S S . @ 0',
+        'S => S . S @ 2',
+        'S => S . S @ 1',
+        'S => S . S @ 0',
+        'S => . S S @ 3',
+        'S => . x @ 3'
+      ]
+      set4 = [ # x x x x .
+        'S => x . @ 3',
+        'S => S S . @ 2',
+        'S => S S . @ 1',
+        'S => S S . @ 0', # Success entry
+        'S => S . S @ 3',
+        'S => S . S @ 2',
+        'S => S . S @ 1',
+        'S => S . S @ 0',
+        'S => . S S @ 4'
+      ]
+      expectations = [set0, set1, set2, set3, set4]
+      comp_expected_actuals(chart, expectations)
+    end
+
     it 'swallows the input from an infinite ambiguity grammar' do
       recognizer = described_class.new(grammar_l9, tokenizer_l9)
       chart = recognizer.run('x x x')
@@ -441,7 +490,8 @@ describe Dendroid::Recognizer::Recognizer do
         'S => . S S @ 1',
         'S => . @ 1',
         'S => . x @ 1',
-        'S => S . S @ 1'
+        'S => S . S @ 1',
+        'S => S S . @ 1'
       ]
       set2 = [ # x x . x
         'S => x . @ 1',
@@ -452,7 +502,8 @@ describe Dendroid::Recognizer::Recognizer do
         'S => . S S @ 2',
         'S => . @ 2',
         'S => . x @ 2',
-        'S => S . S @ 2'
+        'S => S . S @ 2',
+        'S => S S . @ 2'
       ]
       set3 = [ # x x x .
         'S => x . @ 2',
@@ -465,7 +516,8 @@ describe Dendroid::Recognizer::Recognizer do
         'S => . S S @ 3',
         'S => . @ 3',
         # 'S => . x @ 3',
-        'S => S . S @ 3'
+        'S => S . S @ 3',
+        'S => S S . @ 3'
       ]
       expectations = [set0, set1, set2, set3]
       comp_expected_actuals(chart, expectations)

data/spec/dendroid/support/sample_grammars.rb

@@ -211,6 +211,7 @@ module SampleGrammars
   end
 
   def grammar_l10
+    # Grammar with left recursive rule
     builder = Dendroid::GrmDSL::BaseGrmBuilder.new do
       declare_terminals('a')
 
@@ -230,6 +231,7 @@ module SampleGrammars
 
   def grammar_l11
     builder = Dendroid::GrmDSL::BaseGrmBuilder.new do
+      # Grammar with right-recursive rule
       declare_terminals('a')
 
       rule 'A' => ['a A', '']