sequitur 0.1.13 → 0.1.14

data/spec/sequitur/production_ref_spec.rb

@@ -1,111 +1,102 @@
-require_relative '../spec_helper'
-
-# Load the class under test
-require_relative '../../lib/sequitur/production'
-require_relative '../../lib/sequitur/production_ref'
-
-module Sequitur # Re-open the module to get rid of qualified names
-
-describe ProductionRef do
- 
-  let(:target) { Production.new }
-  let(:another_target) { Production.new }
-  
-  subject { ProductionRef.new(target) }
-
-  context 'Creation & initialization:' do
-
-    it 'should be created with a production argument' do 
-      expect { ProductionRef.new(target) }.not_to raise_error
-      expect(target.refcount).to eq(1)
-    end
-    
-    it 'should clone with reference count incrementing' do
-      expect(target.refcount).to eq(0)
-      expect(subject.production.refcount).to eq(1)
-      klone = subject.clone
-      expect(klone.production.refcount).to eq(2)
-      duplicate = subject.dup
-      expect(duplicate.production.refcount).to eq(3)
-    end
-    
-    it 'should know its referenced production' do   
-      instance = ProductionRef.new(target)
-      expect(instance.production).to eq(target)
-    end
-    
-    
-  end # context
-  
-  context 'Provided services:' do 
-    
-    it 'should render its referenced production' do
-      expect(subject.to_s).to eq(target.object_id.to_s)
-    end
-    
-    it 'should unbind itself from its production' do
-      expect(target.refcount).to eq(0)
-      expect(subject).not_to be_unbound
-      expect(target.refcount).to eq(1)
-      subject.unbind
-      expect(target.refcount).to eq(0)
-      expect(subject.production).to be_nil
-      expect(subject).to be_unbound
-    end
-    
-    it 'should bind to a production' do
-      expect(target.refcount).to eq(0)
-      
-      expect(subject).not_to be_unbound
-      expect(target.refcount).to eq(1)
-      
-      # Case: bind again to same production
-      expect { subject.bind_to(target) }.not_to raise_error
-      expect(target.refcount).to eq(1)
-
-      # Case: bind to another production
-      expect(another_target.refcount).to eq(0)
-      subject.bind_to(another_target)
-      expect(target.refcount).to eq(0)      
-      expect(another_target.refcount).to eq(1)
-    end
-    
-    it 'should complain when binding to something else than production' do
-      subject.bind_to(target)
-      msg = 'Illegal production type String'
-      expect { subject.bind_to('WRONG') }.to raise_error(StandardError, msg)
-    end
-  
-    it 'should compare to other production (reference)' do
-      same = ProductionRef.new(target)
-      expect(subject).to eq(subject)  # Strict identity
-      expect(subject).to eq(same)   # 2 references pointing to same production
-      expect(subject).to eq(target)
-    end
-    
-    it 'should return the hash value of its production' do
-      expectation = target.hash
-      expect(subject.hash).to eq(expectation)
-    end
-    
-    it 'should complain when requested for a hash and unbound' do
-      subject.unbind
-      expect { subject.hash }.to raise_error(StandardError)
-    end
-    
-    it 'should accept a visitor' do
-      # Use a mock visitor
-      fake = double('fake_visitor')
-      
-      # Visitor should receive a visit message
-      expect(fake).to receive(:visit_prod_ref).once
-      expect { subject.accept(fake) }.not_to raise_error
-    end
-    
-  end # context
-
-end # describe
-
-end # module
-
-# End of file
+require_relative '../spec_helper'
+
+# Load the class under test
+require_relative '../../lib/sequitur/production'
+require_relative '../../lib/sequitur/production_ref'
+
+module Sequitur # Re-open the module to get rid of qualified names
+describe ProductionRef do
+  let(:target) { Production.new }
+  let(:another_target) { Production.new }
+
+  subject { ProductionRef.new(target) }
+
+  context 'Creation & initialization:' do
+    it 'should be created with a production argument' do
+      expect { ProductionRef.new(target) }.not_to raise_error
+      expect(target.refcount).to eq(1)
+    end
+
+    it 'should clone with reference count incrementing' do
+      expect(target.refcount).to eq(0)
+      expect(subject.production.refcount).to eq(1)
+      klone = subject.clone
+      expect(klone.production.refcount).to eq(2)
+      duplicate = subject.dup
+      expect(duplicate.production.refcount).to eq(3)
+    end
+
+    it 'should know its referenced production' do
+      instance = ProductionRef.new(target)
+      expect(instance.production).to eq(target)
+    end
+  end # context
+
+  context 'Provided services:' do
+    it 'should render its referenced production' do
+      expect(subject.to_s).to eq(target.object_id.to_s)
+    end
+
+    it 'should unbind itself from its production' do
+      expect(target.refcount).to eq(0)
+      expect(subject).not_to be_unbound
+      expect(target.refcount).to eq(1)
+      subject.unbind
+      expect(target.refcount).to eq(0)
+      expect(subject.production).to be_nil
+      expect(subject).to be_unbound
+    end
+
+    it 'should bind to a production' do
+      expect(target.refcount).to eq(0)
+
+      expect(subject).not_to be_unbound
+      expect(target.refcount).to eq(1)
+
+      # Case: bind again to same production
+      expect { subject.bind_to(target) }.not_to raise_error
+      expect(target.refcount).to eq(1)
+
+      # Case: bind to another production
+      expect(another_target.refcount).to eq(0)
+      subject.bind_to(another_target)
+      expect(target.refcount).to eq(0)
+      expect(another_target.refcount).to eq(1)
+    end
+
+    it 'should complain when binding to something else than production' do
+      subject.bind_to(target)
+      msg = 'Illegal production type String'
+      expect { subject.bind_to('WRONG') }.to raise_error(StandardError, msg)
+    end
+
+    it 'should compare to other production (reference)' do
+      same = ProductionRef.new(target)
+      expect(subject).to eq(subject)  # Strict identity
+      expect(subject).to eq(same)   # 2 references pointing to same production
+      expect(subject).to eq(target)
+    end
+
+    it 'should return the hash value of its production' do
+      expectation = target.hash
+      expect(subject.hash).to eq(expectation)
+    end
+
+    it 'should complain when requested for a hash and unbound' do
+      subject.unbind
+      expect { subject.hash }.to raise_error(StandardError)
+    end
+
+    it 'should accept a visitor' do
+      # Use a mock visitor
+      fake = double('fake_visitor')
+
+      # Visitor should receive a visit message
+      expect(fake).to receive(:visit_prod_ref).once
+      expect { subject.accept(fake) }.not_to raise_error
+    end
+  end # context
+end # describe
+end # module
+
+# End of file

data/spec/sequitur/production_spec.rb

@@ -1,376 +1,361 @@
-require_relative '../spec_helper'
-
-# Load the class under test
-require_relative '../../lib/sequitur/production'
-
-module Sequitur # Re-open the module to get rid of qualified names
-
-describe Production do
-  # Helper method: convert list of digrams into an array
-  # of symbol couples.
-  def to_symbols(theDigrams)
-    return theDigrams.map(&:symbols)
-  end
-
-  let(:p_a) do
-      instance = Production.new
-      instance.append_symbol(:a)
-      instance
-  end
-
-  let(:p_bc) do
-    instance = Production.new
-    instance.append_symbol('b')
-    instance.append_symbol('c')
-    instance
-  end
-
-  context 'Creation & initialization:' do
-    it 'should be created without argument' do
-      expect { Production.new }.not_to raise_error
-    end
-
-    it 'should not referenced yet' do
-      expect(subject.refcount).to eq(0)
-    end
-
-    it 'should be empty at creation' do
-      expect(subject).to be_empty
-    end
-
-    it 'should not have digram' do
-      expect(subject.digrams).to be_empty
-      expect(subject.last_digram).to be_nil
-    end
-  end # context
-  
-  context 'Provided services:' do
-  
-    it 'should compare to another production' do
-      expect(p_a).to eq(p_a)
-      expect(p_a).not_to eq(p_bc)
-    end
-    
-    it 'should compare to a production reference' do
-      ref_a = ProductionRef.new(p_a)
-      expect(p_a).to eq(ref_a) 
-      expect(p_bc).not_to eq(ref_a)
-      
-      ref_bc = ProductionRef.new(p_bc)
-      expect(p_a).not_to eq(ref_bc) 
-      expect(p_bc).to eq(ref_bc)      
-    end
-  end # context
-
-  context 'Knowing its rhs:' do
-
-    it 'should know the productions in its rhs' do
-      # Case 1: empty production
-      expect(subject.references).to be_empty
-
-      # Case 2: production without references
-      symbols = [:a, :b, :c]
-      symbols.each { |symb| subject.append_symbol(symb) }
-      expect(subject.references).to be_empty
-      expect(subject.references_of(p_a)).to be_empty
-
-      # Case 2: production with one reference
-      subject.append_symbol(p_a)
-      expect(subject.references).to eq([p_a])
-      expect(subject.references_of(p_a).map(&:production)).to eq([p_a])
-
-
-      # Case 3: production with repeated references
-      subject.append_symbol(p_a) # second time
-      expect(subject.references).to eq([p_a, p_a])
-      expect(subject.references_of(p_a).map(&:production)).to eq([p_a, p_a])
-
-
-      # Case 4: production with multiple distinct references
-      subject.append_symbol(p_bc)
-      expect(subject.references).to eq([p_a, p_a, p_bc])
-      expect(subject.references_of(p_bc).map(&:production)).to eq([p_bc])
-    end
-
-    it 'should know the position(s) of a given digram' do
-      sequence1 = [:a, :b, :c, :a, :b, :a, :b, :d]
-      sequence1.each { |symb| subject.append_symbol(symb) }
-      positions = [0, 3, 5]
-      expect(subject.positions_of(:a, :b)).to eq(positions)
-
-      subject.clear_rhs
-      # Case of overlapping digrams
-      sequence2 = [:a, :a, :b, :a, :a, :a, :c, :d]
-      sequence2.each { |symb| subject.append_symbol(symb) }
-      positions = [0, 3]
-      expect(subject.positions_of(:a, :a)).to eq(positions)
-    end
-
-  end # context
-
-  context 'Appending a symbol:' do
-
-    it 'should append a symbol when empty' do
-      expect { subject.append_symbol(:a) }.not_to raise_error
-      expect(subject.rhs).to eq([:a])
-      expect(subject.last_digram).to be_nil
-    end
-
-    it 'should append a symbol when has one symbol' do
-      subject.append_symbol(:a)
-      subject.append_symbol(:b)
-      expect(subject.rhs).to eq([:a, :b])
-      expect(subject.last_digram.symbols).to eq([:a, :b])
-    end
-
-    it 'should append a symbol when rhs has several symbols' do
-      symbols = [:a, :b, :c, :d, :e, :f]
-      symbols.each { |symb| subject.append_symbol(symb) }
-      expect(subject.rhs).to eq(symbols)
-      expect(subject.last_digram.symbols).to eq([:e, :f])
-    end
-
-    it 'should append a production in its rhs' do
-      # Side-effect: refcount of production to append is incremented
-      expect(p_a.refcount).to be(0)
-
-      input = [p_a, :b, :c, :d, p_a, :e, :f]  # p_a appears twice
-      input.each { |symb| subject.append_symbol(symb) }
-      expect(p_a.refcount).to be(2)
-    end
-    
-    it 'should append a production ref in its rhs' do
-      # Side-effect: refcount of production to append is incremented
-      ref_a = ProductionRef.new(p_a)
-      expect(p_a.refcount).to be(1)
-      
-      input = [ref_a, :b, :c, :d, ref_a]  # ref_a appears twice
-      input.each { |symb| subject.append_symbol(symb) }
-      
-      # References in rhs should point to p_a...
-      # ...but should be distinct reference objects
-      expect(subject.rhs[0]).to eq(p_a)
-      expect(subject.rhs[0].object_id).not_to eq(ref_a.object_id)
-      expect(subject.rhs[-1]).to eq(p_a)
-      expect(subject.rhs[-1].object_id).not_to eq(ref_a.object_id)
-      
-      # Reference count should be updated
-      expect(p_a.refcount).to be(3)
-    end
-    
-    it 'should complain when appending ref to nil production' do
-      # Side-effect: refcount of production to append is incremented
-      ref_a = ProductionRef.new(p_a)
-      expect(p_a.refcount).to be(1)
-      
-      # Unbind the reference
-      ref_a.unbind
-      
-      expect { subject.append_symbol(ref_a) }.to raise_error(StandardError)
-    end
-
-  end # context
-
-
-  context 'Text representation of a production rule:' do
-
-    it 'should emit minimal text when empty' do
-      expectation = "#{subject.object_id} : ."
-      expect(subject.to_string).to eq(expectation)
-    end
-
-    it 'should emit its text representation' do
-      instance = Production.new
-      symbols = [:a, :b, 'c', :d, :e, 1000, instance]
-      symbols.each { |symb| subject.append_symbol(symb) }
-      expectation = "#{subject.object_id} : " 
-      expectation << "a b 'c' d e 1000 #{instance.object_id}."
-      expect(subject.to_string).to eq(expectation)
-    end
-
-  end # context
-
-  context 'Detecting digram repetition:' do
-    it 'should report no repetition when empty' do
-      expect(subject.repeated_digram?).to be_falsey
-    end
-
-    it 'should report no repetition when rhs has less than 3 symbols' do
-      subject.append_symbol(:a)
-      expect(subject.repeated_digram?).to be_falsey
-
-      subject.append_symbol(:a)
-      expect(subject.repeated_digram?).to be_falsey
-    end
-
-    it 'should detect shortest repetition' do
-      'aaa'.each_char { |symb| subject.append_symbol(symb) }
-      expect(subject.repeated_digram?).to be_truthy
-    end
-
-    it 'should detect any repetition pattern' do
-      # Positive cases
-      cases = %w(abab abcdab abcdcd abcdefcd )
-      cases.each do |word|
-        instance = Production.new
-        word.each_char { |symb| instance.append_symbol(symb) }
-        expect(instance.repeated_digram?).to be_truthy
-      end
-
-      # Negative cases
-      cases = %w(abc abb abba abcdef)
-      cases.each do |word|
-        instance = Production.new
-        word.each_char { |symb| instance.append_symbol(symb) }
-        expect(instance.repeated_digram?).to be_falsey
-      end
-    end
-  end # context
-
-  context 'Replacing a digram by a production:' do
-
-    it 'should have not effect on empty production' do
-      subject.reduce_step(p_bc)
-      expect(subject.rhs).to be_empty
-      expect(p_bc.refcount).to eq(0)
-    end
-
-
-    it 'should replace two-symbol sequence' do
-      %w(a b c d e b c e).each { |symb| subject.append_symbol(symb) }
-      p_bc_before = p_bc.to_string
-      subject.reduce_step(p_bc)
-
-      expect(subject.rhs.size).to eq(6)
-      expect(subject.rhs).to eq(['a', p_bc, 'd', 'e', p_bc, 'e'])
-      expect(p_bc.refcount).to eq(2)
-      expect(p_bc.to_string).to eq(p_bc_before)
-    end
-
-
-    it 'should replace a starting two-symbol sequence' do
-      %w(b c d e b c e).each { |symb| subject.append_symbol(symb) }
-      subject.reduce_step(p_bc)
-
-      expect(subject.rhs.size).to eq(5)
-      expect(subject.rhs).to eq([p_bc, 'd', 'e', p_bc, 'e'])
-      expect(p_bc.refcount).to eq(2)
-    end
-
-
-    it 'should replace an ending two-symbol sequence' do
-      %w(a b c d e b c).each { |symb| subject.append_symbol(symb) }
-      subject.reduce_step(p_bc)
-
-      expect(subject.rhs.size).to eq(5)
-      expect(subject.rhs).to eq(['a', p_bc, 'd', 'e', p_bc])
-      expect(p_bc.refcount).to eq(2)
-    end
-
-    it 'should replace two consecutive two-symbol sequences' do
-      %w(a b c b c d).each { |symb| subject.append_symbol(symb) }
-      subject.reduce_step(p_bc)
-
-      expect(subject.rhs.size).to eq(4)
-      expect(subject.rhs).to eq(['a', p_bc, p_bc, 'd'])
-      expect(p_bc.refcount).to eq(2)
-    end
-
-  end # context
-
-  context 'Replacing a production occurrence by its rhs:' do
-
-    it 'should have not effect on empty production' do
-      subject.derive_step(p_bc)
-      expect(subject.rhs).to be_empty
-    end
-
-    it 'should replace a production at the start' do
-      [p_bc, 'd'].each { |symb| subject.append_symbol(symb) }
-      expect(p_bc.refcount).to eq(1)
-      
-      subject.derive_step(p_bc)
-      expect(subject.rhs.size).to eq(3)
-      expect(subject.rhs).to eq(%w(b c d))
-      expect(p_bc.refcount).to eq(0)
-    end
-
-
-    it 'should replace a production at the end' do
-      ['d', p_bc].each { |symb| subject.append_symbol(symb) }
-      expect(p_bc.refcount).to eq(1)
-      subject.derive_step(p_bc)
-
-      expect(subject.rhs.size).to eq(3)
-      expect(subject.rhs).to eq(%w(d b c))
-      expect(p_bc.refcount).to eq(0)
-    end
-
-    it 'should replace a production as sole symbol' do
-      subject.append_symbol(p_bc)
-      subject.derive_step(p_bc)
-
-      expect(subject.rhs.size).to eq(2)
-      expect(subject.rhs).to eq(%w(b c))
-    end
-
-    it 'should replace a production in the middle' do
-      ['a', p_bc, 'd'].each { |symb| subject.append_symbol(symb) }
-      subject.derive_step(p_bc)
-
-      expect(subject.rhs.size).to eq(4)
-      expect(subject.rhs).to eq(%w(a b c d))
-    end
-
-  end # context
-  
-  context 'Visiting:' do
-    it 'should accept a visitor when its rhs is empty' do
-      # Use a mock visitor
-      fake = double('fake_visitor')
-      
-      # Empty production: visitor will receive a start and end visit messages
-      expect(fake).to receive(:start_visit_production).once.ordered
-      expect(fake).to receive(:start_visit_rhs).once.ordered
-      expect(fake).to receive(:end_visit_rhs).once.ordered
-      expect(fake).to receive(:end_visit_production).once.ordered
-
-      expect { subject.accept(fake) }.not_to raise_error
-    end
-    
-    it 'should accept a visitor when rhs consists of terminals only' do
-      # Use a mock visitor
-      fake = double('fake_visitor')      
-      expect(fake).to receive(:start_visit_production).once.ordered
-      expect(fake).to receive(:start_visit_rhs).once.ordered
-      expect(fake).to receive(:visit_terminal).with('b').ordered
-      expect(fake).to receive(:visit_terminal).with('c').ordered
-      expect(fake).to receive(:end_visit_rhs).once.ordered
-      expect(fake).to receive(:end_visit_production).once.ordered
-
-      expect { p_bc.accept(fake) }.not_to raise_error
-    end
-    
-    it 'should accept a visitor when rhs consists of non-terminals' do
-      # Add two production references (=non-terminals) to RHS of subject
-      subject.append_symbol(p_a)
-      subject.append_symbol(p_bc)
-      
-      fake = double('fake_visitor')      
-      expect(fake).to receive(:start_visit_production).once.ordered
-      expect(fake).to receive(:start_visit_rhs).once.ordered
-      expect(fake).to receive(:visit_prod_ref).with(p_a).ordered
-      expect(fake).to receive(:visit_prod_ref).with(p_bc).ordered
-      expect(fake).to receive(:end_visit_rhs).once.ordered
-      expect(fake).to receive(:end_visit_production).once.ordered
-
-      expect { subject.accept(fake) }.not_to raise_error
-    end
-  
-  end # context
-
-end # describe
-
-end # module
-
-# End of file
+require_relative '../spec_helper'
+
+# Load the class under test
+require_relative '../../lib/sequitur/production'
+
+module Sequitur # Re-open the module to get rid of qualified names
+describe Production do
+  # Helper method: convert list of digrams into an array
+  # of symbol couples.
+  def to_symbols(theDigrams)
+    return theDigrams.map(&:symbols)
+  end
+
+  let(:p_a) do
+      instance = Production.new
+      instance.append_symbol(:a)
+      instance
+  end
+
+  let(:p_bc) do
+    instance = Production.new
+    instance.append_symbol('b')
+    instance.append_symbol('c')
+    instance
+  end
+
+  context 'Creation & initialization:' do
+    it 'should be created without argument' do
+      expect { Production.new }.not_to raise_error
+    end
+
+    it 'should not referenced yet' do
+      expect(subject.refcount).to eq(0)
+    end
+
+    it 'should be empty at creation' do
+      expect(subject).to be_empty
+    end
+
+    it 'should not have digram' do
+      expect(subject.digrams).to be_empty
+      expect(subject.last_digram).to be_nil
+    end
+  end # context
+
+  context 'Provided services:' do
+    it 'should compare to another production' do
+      expect(p_a).to eq(p_a)
+      expect(p_a).not_to eq(p_bc)
+    end
+
+    it 'should compare to a production reference' do
+      ref_a = ProductionRef.new(p_a)
+      expect(p_a).to eq(ref_a)
+      expect(p_bc).not_to eq(ref_a)
+
+      ref_bc = ProductionRef.new(p_bc)
+      expect(p_a).not_to eq(ref_bc)
+      expect(p_bc).to eq(ref_bc)
+    end
+  end # context
+
+  context 'Knowing its rhs:' do
+    it 'should know the productions in its rhs' do
+      # Case 1: empty production
+      expect(subject.references).to be_empty
+
+      # Case 2: production without references
+      symbols = [:a, :b, :c]
+      symbols.each { |symb| subject.append_symbol(symb) }
+      expect(subject.references).to be_empty
+      expect(subject.references_of(p_a)).to be_empty
+
+      # Case 2: production with one reference
+      subject.append_symbol(p_a)
+      expect(subject.references).to eq([p_a])
+      expect(subject.references_of(p_a).map(&:production)).to eq([p_a])
+
+
+      # Case 3: production with repeated references
+      subject.append_symbol(p_a) # second time
+      expect(subject.references).to eq([p_a, p_a])
+      expect(subject.references_of(p_a).map(&:production)).to eq([p_a, p_a])
+
+
+      # Case 4: production with multiple distinct references
+      subject.append_symbol(p_bc)
+      expect(subject.references).to eq([p_a, p_a, p_bc])
+      expect(subject.references_of(p_bc).map(&:production)).to eq([p_bc])
+    end
+
+    it 'should know the position(s) of a given digram' do
+      sequence1 = [:a, :b, :c, :a, :b, :a, :b, :d]
+      sequence1.each { |symb| subject.append_symbol(symb) }
+      positions = [0, 3, 5]
+      expect(subject.positions_of(:a, :b)).to eq(positions)
+
+      subject.clear_rhs
+      # Case of overlapping digrams
+      sequence2 = [:a, :a, :b, :a, :a, :a, :c, :d]
+      sequence2.each { |symb| subject.append_symbol(symb) }
+      positions = [0, 3]
+      expect(subject.positions_of(:a, :a)).to eq(positions)
+    end
+  end # context
+
+  context 'Appending a symbol:' do
+    it 'should append a symbol when empty' do
+      expect { subject.append_symbol(:a) }.not_to raise_error
+      expect(subject.rhs).to eq([:a])
+      expect(subject.last_digram).to be_nil
+    end
+
+    it 'should append a symbol when has one symbol' do
+      subject.append_symbol(:a)
+      subject.append_symbol(:b)
+      expect(subject.rhs).to eq([:a, :b])
+      expect(subject.last_digram.symbols).to eq([:a, :b])
+    end
+
+    it 'should append a symbol when rhs has several symbols' do
+      symbols = [:a, :b, :c, :d, :e, :f]
+      symbols.each { |symb| subject.append_symbol(symb) }
+      expect(subject.rhs).to eq(symbols)
+      expect(subject.last_digram.symbols).to eq([:e, :f])
+    end
+
+    it 'should append a production in its rhs' do
+      # Side-effect: refcount of production to append is incremented
+      expect(p_a.refcount).to be(0)
+
+      input = [p_a, :b, :c, :d, p_a, :e, :f]  # p_a appears twice
+      input.each { |symb| subject.append_symbol(symb) }
+      expect(p_a.refcount).to be(2)
+    end
+
+    it 'should append a production ref in its rhs' do
+      # Side-effect: refcount of production to append is incremented
+      ref_a = ProductionRef.new(p_a)
+      expect(p_a.refcount).to be(1)
+
+      input = [ref_a, :b, :c, :d, ref_a]  # ref_a appears twice
+      input.each { |symb| subject.append_symbol(symb) }
+
+      # References in rhs should point to p_a...
+      # ...but should be distinct reference objects
+      expect(subject.rhs[0]).to eq(p_a)
+      expect(subject.rhs[0].object_id).not_to eq(ref_a.object_id)
+      expect(subject.rhs[-1]).to eq(p_a)
+      expect(subject.rhs[-1].object_id).not_to eq(ref_a.object_id)
+
+      # Reference count should be updated
+      expect(p_a.refcount).to be(3)
+    end
+
+    it 'should complain when appending ref to nil production' do
+      # Side-effect: refcount of production to append is incremented
+      ref_a = ProductionRef.new(p_a)
+      expect(p_a.refcount).to be(1)
+
+      # Unbind the reference
+      ref_a.unbind
+
+      expect { subject.append_symbol(ref_a) }.to raise_error(StandardError)
+    end
+  end # context
+
+
+  context 'Text representation of a production rule:' do
+    it 'should emit minimal text when empty' do
+      expectation = "#{subject.object_id} : ."
+      expect(subject.to_string).to eq(expectation)
+    end
+
+    it 'should emit its text representation' do
+      instance = Production.new
+      symbols = [:a, :b, 'c', :d, :e, 1000, instance]
+      symbols.each { |symb| subject.append_symbol(symb) }
+      expectation = "#{subject.object_id} : "
+      expectation << "a b 'c' d e 1000 #{instance.object_id}."
+      expect(subject.to_string).to eq(expectation)
+    end
+  end # context
+
+  context 'Detecting digram repetition:' do
+    it 'should report no repetition when empty' do
+      expect(subject.repeated_digram?).to be_falsey
+    end
+
+    it 'should report no repetition when rhs has less than 3 symbols' do
+      subject.append_symbol(:a)
+      expect(subject.repeated_digram?).to be_falsey
+
+      subject.append_symbol(:a)
+      expect(subject.repeated_digram?).to be_falsey
+    end
+
+    it 'should detect shortest repetition' do
+      'aaa'.each_char { |symb| subject.append_symbol(symb) }
+      expect(subject.repeated_digram?).to be_truthy
+    end
+
+    it 'should detect any repetition pattern' do
+      # Positive cases
+      cases = %w(abab abcdab abcdcd abcdefcd )
+      cases.each do |word|
+        instance = Production.new
+        word.each_char { |symb| instance.append_symbol(symb) }
+        expect(instance.repeated_digram?).to be_truthy
+      end
+
+      # Negative cases
+      cases = %w(abc abb abba abcdef)
+      cases.each do |word|
+        instance = Production.new
+        word.each_char { |symb| instance.append_symbol(symb) }
+        expect(instance.repeated_digram?).to be_falsey
+      end
+    end
+  end # context
+
+  context 'Replacing a digram by a production:' do
+    it 'should have not effect on empty production' do
+      subject.reduce_step(p_bc)
+      expect(subject.rhs).to be_empty
+      expect(p_bc.refcount).to eq(0)
+    end
+
+
+    it 'should replace two-symbol sequence' do
+      %w(a b c d e b c e).each { |symb| subject.append_symbol(symb) }
+      p_bc_before = p_bc.to_string
+      subject.reduce_step(p_bc)
+
+      expect(subject.rhs.size).to eq(6)
+      expect(subject.rhs).to eq(['a', p_bc, 'd', 'e', p_bc, 'e'])
+      expect(p_bc.refcount).to eq(2)
+      expect(p_bc.to_string).to eq(p_bc_before)
+    end
+
+
+    it 'should replace a starting two-symbol sequence' do
+      %w(b c d e b c e).each { |symb| subject.append_symbol(symb) }
+      subject.reduce_step(p_bc)
+
+      expect(subject.rhs.size).to eq(5)
+      expect(subject.rhs).to eq([p_bc, 'd', 'e', p_bc, 'e'])
+      expect(p_bc.refcount).to eq(2)
+    end
+
+
+    it 'should replace an ending two-symbol sequence' do
+      %w(a b c d e b c).each { |symb| subject.append_symbol(symb) }
+      subject.reduce_step(p_bc)
+
+      expect(subject.rhs.size).to eq(5)
+      expect(subject.rhs).to eq(['a', p_bc, 'd', 'e', p_bc])
+      expect(p_bc.refcount).to eq(2)
+    end
+
+    it 'should replace two consecutive two-symbol sequences' do
+      %w(a b c b c d).each { |symb| subject.append_symbol(symb) }
+      subject.reduce_step(p_bc)
+
+      expect(subject.rhs.size).to eq(4)
+      expect(subject.rhs).to eq(['a', p_bc, p_bc, 'd'])
+      expect(p_bc.refcount).to eq(2)
+    end
+  end # context
+
+  context 'Replacing a production occurrence by its rhs:' do
+    it 'should have not effect on empty production' do
+      subject.derive_step(p_bc)
+      expect(subject.rhs).to be_empty
+    end
+
+    it 'should replace a production at the start' do
+      [p_bc, 'd'].each { |symb| subject.append_symbol(symb) }
+      expect(p_bc.refcount).to eq(1)
+
+      subject.derive_step(p_bc)
+      expect(subject.rhs.size).to eq(3)
+      expect(subject.rhs).to eq(%w(b c d))
+      expect(p_bc.refcount).to eq(0)
+    end
+
+
+    it 'should replace a production at the end' do
+      ['d', p_bc].each { |symb| subject.append_symbol(symb) }
+      expect(p_bc.refcount).to eq(1)
+      subject.derive_step(p_bc)
+
+      expect(subject.rhs.size).to eq(3)
+      expect(subject.rhs).to eq(%w(d b c))
+      expect(p_bc.refcount).to eq(0)
+    end
+
+    it 'should replace a production as sole symbol' do
+      subject.append_symbol(p_bc)
+      subject.derive_step(p_bc)
+
+      expect(subject.rhs.size).to eq(2)
+      expect(subject.rhs).to eq(%w(b c))
+    end
+
+    it 'should replace a production in the middle' do
+      ['a', p_bc, 'd'].each { |symb| subject.append_symbol(symb) }
+      subject.derive_step(p_bc)
+
+      expect(subject.rhs.size).to eq(4)
+      expect(subject.rhs).to eq(%w(a b c d))
+    end
+  end # context
+
+  context 'Visiting:' do
+    it 'should accept a visitor when its rhs is empty' do
+      # Use a mock visitor
+      fake = double('fake_visitor')
+
+      # Empty production: visitor will receive a start and end visit messages
+      expect(fake).to receive(:start_visit_production).once.ordered
+      expect(fake).to receive(:start_visit_rhs).once.ordered
+      expect(fake).to receive(:end_visit_rhs).once.ordered
+      expect(fake).to receive(:end_visit_production).once.ordered
+
+      expect { subject.accept(fake) }.not_to raise_error
+    end
+
+    it 'should accept a visitor when rhs consists of terminals only' do
+      # Use a mock visitor
+      fake = double('fake_visitor')
+      expect(fake).to receive(:start_visit_production).once.ordered
+      expect(fake).to receive(:start_visit_rhs).once.ordered
+      expect(fake).to receive(:visit_terminal).with('b').ordered
+      expect(fake).to receive(:visit_terminal).with('c').ordered
+      expect(fake).to receive(:end_visit_rhs).once.ordered
+      expect(fake).to receive(:end_visit_production).once.ordered
+
+      expect { p_bc.accept(fake) }.not_to raise_error
+    end
+
+    it 'should accept a visitor when rhs consists of non-terminals' do
+      # Add two production references (=non-terminals) to RHS of subject
+      subject.append_symbol(p_a)
+      subject.append_symbol(p_bc)
+
+      fake = double('fake_visitor')
+      expect(fake).to receive(:start_visit_production).once.ordered
+      expect(fake).to receive(:start_visit_rhs).once.ordered
+      expect(fake).to receive(:visit_prod_ref).with(p_a).ordered
+      expect(fake).to receive(:visit_prod_ref).with(p_bc).ordered
+      expect(fake).to receive(:end_visit_rhs).once.ordered
+      expect(fake).to receive(:end_visit_production).once.ordered
+
+      expect { subject.accept(fake) }.not_to raise_error
+    end
+  end # context
+end # describe
+end # module
+
+# End of file