dendroid 0.0.12 → 0.2.00

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', '']

data/spec/dendroid/syntax/grammar_spec.rb

@@ -4,8 +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\choice'
+require_relative '..\..\..\lib\dendroid\syntax\rule'
 require_relative '..\..\..\lib\dendroid\syntax\grammar'
 require_relative '..\..\..\lib\dendroid\grm_dsl\base_grm_builder'
 
@@ -33,19 +32,15 @@ describe Dendroid::Syntax::Grammar do
     Dendroid::Syntax::SymbolSeq.new(symbols)
   end
 
-  def build_production(lhs, symbols)
-    Dendroid::Syntax::Production.new(lhs, build_symbol_seq(symbols))
-  end
-
   def build_choice(lhs, sequences)
-    Dendroid::Syntax::Choice.new(lhs, sequences.map { |arr| build_symbol_seq(arr) })
+    Dendroid::Syntax::Rule.new(lhs, sequences.map { |arr| build_symbol_seq(arr) })
   end
 
   def build_all_rules
-    rule1 = build_production(p_symb, [s_symb]) # p => s
+    rule1 = build_choice(p_symb, [[s_symb]]) # p => s
     rule2 = build_choice(s_symb, [[s_symb, plus_symb, m_symb], [m_symb]]) # s => s + m | m
     rule3 = build_choice(m_symb, [[m_symb, star_symb, t_symb], [t_symb]]) # m => m * t
-    rule4 = build_production(t_symb, [int_symb]) # t => INTEGER
+    rule4 = build_choice(t_symb, [[int_symb]]) # t => INTEGER
     [rule1, rule2, rule3, rule4]
   end
 
@@ -58,8 +53,8 @@ describe Dendroid::Syntax::Grammar do
       expect(subject.symbols).to eq(all_terminals)
     end
 
-    it 'ignores about productions after initialization' do
-      expect(subject.rules).to be_nil
+    it 'does not have rules after initialization' do
+      expect(subject.rules).to be_empty
     end
 
     it 'maps a terminal name to one GrmSymbol object' do
@@ -72,7 +67,7 @@ describe Dendroid::Syntax::Grammar do
 
   context 'Adding productions:' do
     it 'allows the addition of one production rule' do
-      rule = build_production(p_symb, [s_symb])
+      rule = build_choice(p_symb, [[s_symb]])
       expect { subject.add_rule(rule) }.not_to raise_error
       expect(subject.rules.size).to eq(1)
       expect(subject.rules.first).to eq(rule)
@@ -109,14 +104,15 @@ describe Dendroid::Syntax::Grammar do
       end
     end
 
-    it 'maps every non-terminal to its defining productions' do
+    it 'maps every non-terminal to its defining production' do
       rules = build_all_rules
       rules.each { |rl| subject.add_rule(rl) }
       %i[p s m t].each do |symb_name|
         symb = subject.name2symbol[symb_name]
         expected_prods = subject.rules.select { |prd| prd.head == symb }
-        related_prods = subject.nonterm2productions[symb]
-        expect(related_prods).to eq(expected_prods)
+        expect(expected_prods.size).to eq(1)
+        related_prod = subject.nonterm2production[symb]
+        expect(related_prod).to eq(expected_prods[0])
       end
     end
   end # context
@@ -140,10 +136,10 @@ describe Dendroid::Syntax::Grammar do
       nterm_e = build_nonterminal('E')
 
       instance = described_class.new([terminal_a])
-      instance.add_rule(build_production(nterm_s_prime, [nterm_s]))
-      instance.add_rule(build_production(nterm_s, [nterm_a, nterm_a, nterm_a, nterm_a]))
+      instance.add_rule(build_choice(nterm_s_prime, [[nterm_s]]))
+      instance.add_rule(build_choice(nterm_s, [[nterm_a, nterm_a, nterm_a, nterm_a]]))
       instance.add_rule(build_choice(nterm_a, [[terminal_a], [nterm_e]]))
-      instance.add_rule(build_production(nterm_e, []))
+      instance.add_rule(build_choice(nterm_e, [[]]))
 
       instance.complete!
       all_nonterminals = subject.symbols.reject(&:terminal?)
@@ -159,7 +155,7 @@ describe Dendroid::Syntax::Grammar do
       # Let add's unreachable symbols
       zed_symb = build_nonterminal('Z')
       question_symb = build_nonterminal('?')
-      bad_rule = build_production(zed_symb, [zed_symb, question_symb, int_symb]) # Z => Z ? INTEGER
+      bad_rule = build_choice(zed_symb, [[zed_symb, question_symb, int_symb]]) # Z => Z ? INTEGER
       subject.add_rule(bad_rule)
       unreachable = subject.send(:unreachable_symbols)
       expect(unreachable).not_to be_empty
@@ -174,7 +170,7 @@ describe Dendroid::Syntax::Grammar do
       expect(t_symb).to be_productive
       expect(p_symb).to be_productive
 
-      # Grammar with non-productive symbols
+      # # Grammar with non-productive symbols
       term_a = build_terminal('a')
       term_b = build_terminal('b')
       term_c = build_terminal('c')
@@ -190,12 +186,12 @@ describe Dendroid::Syntax::Grammar do
       nterm_S = build_nonterminal('S')
       instance = described_class.new([term_a, term_b, term_c, term_d, term_e, term_f])
       instance.add_rule(build_choice(nterm_S, [[nterm_A, nterm_B], [nterm_D, nterm_E]]))
-      instance.add_rule(build_production(nterm_A, [term_a]))
-      instance.add_rule(build_production(nterm_B, [term_b, nterm_C]))
-      instance.add_rule(build_production(nterm_C, [term_c]))
-      instance.add_rule(build_production(nterm_D, [term_d, nterm_F]))
-      instance.add_rule(build_production(nterm_E, [term_e]))
-      instance.add_rule(build_production(nterm_F, [term_f, nterm_D]))
+      instance.add_rule(build_choice(nterm_A, [[term_a]]))
+      instance.add_rule(build_choice(nterm_B, [[term_b, nterm_C]]))
+      instance.add_rule(build_choice(nterm_C, [[term_c]]))
+      instance.add_rule(build_choice(nterm_D, [[term_d, nterm_F]]))
+      instance.add_rule(build_choice(nterm_E, [[term_e]]))
+      instance.add_rule(build_choice(nterm_F, [[term_f, nterm_D]]))
       nonproductive = instance.send(:mark_non_productive_symbols)
       expect(nonproductive).not_to be_empty
       expect(nonproductive).to eq([nterm_D, nterm_F])
@@ -230,8 +226,7 @@ describe Dendroid::Syntax::Grammar do
         # No terminal symbol explicitly declared => all symbols are non-terminals
 
         rule 'S' => 'A'
-        rule 'A' => 'a A c'
-        rule 'A' => 'b'
+        rule 'A' => ['a A c', 'b']
       end
 
       builder.grammar
@@ -243,8 +238,7 @@ describe Dendroid::Syntax::Grammar do
 
         # # Wrong: terminals 'd' and 'e' never appear in rules
         rule 'S' => 'A'
-        rule 'A' => 'a A c'
-        rule 'A' => 'b'
+        rule 'A' => ['a A c', 'b']
       end
 
       builder.grammar
@@ -282,13 +276,24 @@ describe Dendroid::Syntax::Grammar do
       builder.grammar
     end
 
+    def grm_multiple_defs
+      builder = Dendroid::GrmDSL::BaseGrmBuilder.new do
+        declare_terminals('a b c')
+
+        rule 'A' => %w[a B]
+        rule 'B' => ['b', '']
+        rule 'A' => 'c'
+      end
+
+      builder.grammar
+    end
+
     def duplicate_production
       builder = Dendroid::GrmDSL::BaseGrmBuilder.new do
-        declare_terminals('a', 'b', 'c')
+        declare_terminals('a')
 
         rule 'S' => 'A'
-        rule 'A' => ['a A c', 'b']
-        rule 'S' => 'A' # Duplicate rule
+        rule 'A' => %w[a a] # Duplicate alternatives
       end
 
       builder.grammar
@@ -329,8 +334,13 @@ describe Dendroid::Syntax::Grammar do
       expect { grm_undefined_nterm }.to raise_error(StandardError, err_msg)
     end
 
+    it 'raises an error when a non-terminal is defined multiple times' do
+      err_msg = "Non-terminal 'A' is on left-hand side of more than one rule."
+      expect { grm_multiple_defs }.to raise_error(StandardError, err_msg)
+    end
+
     it 'raises an error when a production is duplicated' do
-      err_msg = "Production rule 'S => A' appears more than once in the grammar."
+      err_msg = 'Duplicate alternatives: A => a'
       expect { duplicate_production }.to raise_error(StandardError, err_msg)
     end