sequitur 0.0.04

data/spec/sequitur/production_spec.rb

@@ -0,0 +1,271 @@
+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 '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
+
+      # Case 2: production with one reference
+      subject.append_symbol(p_a)
+      expect(subject.references).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]) 
+
+      # Case 4: production with multiple distinct references
+      subject.append_symbol(p_bc)
+      expect(subject.references).to eq([p_a, p_a, p_bc])          
+    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 increment the refcount for each production in the rhs' do
+      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 calculate the digrams before appending:' do
+      # Case: empty production
+      expect(subject.calc_append_symbol(:a)).to be_empty
+
+      # Case: single-symbol rhs
+      subject.append_symbol(:a)
+      expect(to_symbols(subject.calc_append_symbol(:b))).to eq([[:a, :b]])
+
+      # Case: two-symbols rhs
+      subject.append_symbol(:b)
+      expectation = [[:a, :b], [:b, :c]]
+      expect(to_symbols(subject.calc_append_symbol(:c))).to eq(expectation)
+    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
+      symbols = [:a, :b, 'c', :d, :e, :f]
+      symbols.each { |symb| subject.append_symbol(symb) }
+      expectation = "#{subject.object_id} : a b 'c' d e f."
+      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.replace_digram(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) }
+      subject.replace_digram(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.backrefs[subject.object_id]).to eq(2)
+    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.replace_digram(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)
+      expect(p_bc.backrefs[subject.object_id]).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.replace_digram(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)
+      expect(p_bc.backrefs[subject.object_id]).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.replace_digram(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)
+      expect(p_bc.backrefs[subject.object_id]).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.replace_production(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) }
+      subject.replace_production(p_bc)
+      expect(subject.rhs.size).to eq(3)
+      expect(subject.rhs).to eq(%w(b c d))
+    end
+
+
+    it 'should replace a production at the end' do
+      ['d', p_bc].each { |symb| subject.append_symbol(symb) }
+      subject.replace_production(p_bc)
+
+      expect(subject.rhs.size).to eq(3)
+      expect(subject.rhs).to eq(%w(d b c))
+    end
+
+    it 'should replace a production as sole symbol' do
+      subject.append_symbol(p_bc)
+      subject.replace_production(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.replace_production(p_bc)
+
+      expect(subject.rhs.size).to eq(4)
+      expect(subject.rhs).to eq(%w(a b c d))
+    end
+
+  end # context
+
+end # describe
+
+end # module
+
+# End of file

data/spec/sequitur/sequitur-grammar_spec.rb

@@ -0,0 +1,213 @@
+require_relative '../spec_helper'
+
+# Load the class under test
+require_relative '../../lib/sequitur/sequitur-grammar'
+
+module Sequitur # Re-open the module to get rid of qualified names
+
+describe SequiturGrammar do
+  # Factory method. Returns an empty enumerator (
+  # i.e. without elements to iterate)
+  def empty_enum()
+    return [].to_enum
+  end
+
+  context 'Creation from an enumeration of tokens:' do
+
+    it 'could be created with an empty enumerator' do
+      expect { SequiturGrammar.new(empty_enum) }.not_to raise_error
+
+      # Creation
+      instance = SequiturGrammar.new(empty_enum)
+
+      # Initialization
+      expect(instance.productions.size).to eq(1)
+      expect(instance.root).to eq(instance.productions.first)
+      expect(instance.root).to be_empty
+    end
+
+    it 'could be created with single token' do
+      # Creation
+      instance = SequiturGrammar.new([:a].to_enum)
+
+      # Initialization
+      expect(instance.productions.size).to eq(1)
+      expect(instance.root).to eq(instance.productions.first)
+      expect(instance.root.rhs).to eq([:a])
+    end
+
+    it 'could be created with multiple unique tokens' do
+      # Creation
+      instance = SequiturGrammar.new([:a, :b, :c, :d].to_enum)
+
+      # Initialization
+      expect(instance.productions.size).to eq(1)
+      expect(instance.root).to eq(instance.productions.first)
+      expect(instance.root.rhs).to eq([:a, :b, :c, :d])
+    end
+
+    it 'could be created with a repeating digram' do
+      instance = SequiturGrammar.new([:a, :b, :a, :b].to_enum)
+
+      # Expectations:
+      # S : A A.
+      # A : a b.
+      expect(instance.productions.size).to eq(2)
+      p_a = instance.productions[1]
+      expect(p_a.rhs).to eq([:a, :b])
+      expect(instance.root.rhs).to eq([p_a, p_a])
+    end
+
+    it 'should enforce the utility rule' do
+      instance = SequiturGrammar.new([:a, :b, :c, :a, :b, :c].to_enum)
+
+      # Expectations without utility rule:
+      # S : B B.
+      # A : a b.
+      # B : A c.
+
+      # Expectations with utility rule:
+      # S : A A.
+      # A : a b c.
+      expect(instance.productions.size).to eq(2)
+      p_a = instance.productions.last
+      expect(p_a.rhs).to eq([:a, :b, :c])
+      expect(instance.root.rhs).to eq([p_a, p_a])
+    end
+
+
+    it 'should cope with the example from presentation' do
+      input = 'bbebeebebebbebee'
+
+      # Creation
+      instance = SequiturGrammar.new(input.chars)
+
+      # Expectations:
+      # S: P3 P2 P3
+      # P1: b e
+      # P2: P1 P1
+      # P3: b P2 e
+      expect(instance.productions.size).to eq(4)
+      (p1, p2, p3) = instance.productions[1..3]
+      expect(instance.root.rhs).to eq([p3, p2, p3])
+      expect(p1.rhs).to eq(%w(b e))
+      expect(p2.rhs).to eq([p1, p1])
+      expect(p3.rhs).to eq(['b', p2, 'e'])
+    end
+
+    it 'should cope with the example from sequitur.info website' do
+      input = 'abcabdabcabd'
+      instance = SequiturGrammar.new(input.chars)
+
+      # Expectations:
+      # 0 → 2 2
+      # 1 → a b
+      # 2 → 1 c 1 d
+
+      expect(instance.productions.size).to eq(3)
+      (p1, p2) = instance.productions[1..2]
+      expect(instance.root.rhs).to eq([p2, p2])
+      expect(p1.rhs).to eq(%w(a b))
+      expect(p2.rhs).to eq([p1, 'c', p1, 'd'])
+    end
+
+    it "should cope with the example from Salomon's book" do
+      input = 'abcdbcabcdbc'
+      instance = SequiturGrammar.new(input.chars)
+
+      # Expectations:
+      # S → CC
+      # A → bc
+      # C → aAdA
+
+      expect(instance.productions.size).to eq(3)
+      (p_a, p_c) = instance.productions[1..2]
+      expect(instance.root.rhs).to eq([p_c, p_c])
+      expect(p_a.rhs).to eq(%w(b c))
+      expect(p_c.rhs).to eq(['a', p_a, 'd', p_a])
+    end
+
+    it 'should cope with the "porridge" example from sequitur.info' do
+      # Another example from sequitur.info website
+      input = <<-SNIPPET
+pease porridge hot,
+pease porridge cold,
+pease porridge in the pot,
+nine days old.
+
+some like it hot,
+some like it cold,
+some like it in the pot,
+nine days old.
+SNIPPET
+      # Expectations (sequitur.org)
+      # 0 → 1 2 3 4 3 5 ↵ 6 2 7 4 7 5
+      # 1 → p e a s 8 r r i d g 9                         pease_porridge_
+      # 2 → h o t                                         hot
+      # 3 → 10 1                                          ,↵pease_porridge_
+      # 4 → c 11                                          cold
+      # 5 → 12 _ t h 8 t 10 n 12 9 d a y s _ 11 . ↵ 
+      #   in_the_pot,↵nine_days_old.↵
+      # 6 → s o m 9 l i k 9 i t _                         some_like_it_
+      # 7 → 10 6                                          ,↵some_like_it_
+      # 8 → 9 p o                                         e_po
+      # 9 → e _                                           e_
+      # 10 → , ↵                                          ,↵
+      # 11 → o l d                                        old
+      # 12 → i n                                          in
+
+      instance = SequiturGrammar.new(input.chars)
+      expect(instance.productions.size).to eq(13)
+      p0 = instance.root
+      expect(p0.rhs.size).to eq(13)
+
+      (p1, p2, p3, p4, p5, p6, p7, p8, p9) = instance.productions[1..9]
+      (p10, p11, p12) = instance.productions[10..12]
+
+      # Note: the productions aren't sorted the same way as
+      # the sequitur.info implementation.
+      p0_expectation = [
+        p2, p8, p3, p10, p3, p12, "\n",
+        p9, p8, p11, p10, p11, p12
+      ]
+      expect(p0.rhs).to eq(p0_expectation)  # Rule 0 above
+      expect(p1.rhs).to eq(['e', ' '])  # Rule 9 above
+      expect(p2.rhs).to eq([%w(p e a s), p4, %w(r r i d g), p1].flatten) # R1
+      expect(p3.rhs).to eq([p5, p2])  # Rule 3 above
+      expect(p4.rhs).to eq([p1, 'p', 'o'])  # Rule 8 above
+      expect(p5.rhs).to eq([',', "\n"])  # Rule 10 above
+      expect(p6.rhs).to eq(%w(i n))  # Rule 12 above
+      expect(p7.rhs).to eq(%w(o l d))  # Rule 11 above
+      expect(p8.rhs).to eq(%w(h o t))  # Rule 2 above
+      p9_expectation = [%w(s o m), p1, %w(l i k), p1, 'i', 't', ' '].flatten
+      expect(p9.rhs).to eq(p9_expectation)  # Rule 6 above
+      expect(p10.rhs).to eq(['c', p7])  # Rule 4 above
+      expect(p11.rhs).to eq([p5, p9])  # Rule 7 above
+      p12_expectation = [
+        p6, ' ', 't', 'h', p4, 't', p5, 'n', p6, p1,
+        %w(d a y s), ' ', p7, '.', "\n"
+      ].flatten
+      expect(p12.rhs).to eq(p12_expectation)  # Rule 5 above
+    end
+  end # context
+
+  context 'Generating a text representation of itself:' do
+
+    it 'should generate a text representation when empty' do
+      instance = SequiturGrammar.new(empty_enum)
+      expectation = "#{instance.root.object_id} : ."
+
+      expect(instance.to_string).to eq(expectation)
+    end
+
+    it 'should generate a text representation of a simple production' do
+      instance = SequiturGrammar.new([:a].to_enum)
+      expectation = "#{instance.root.object_id} : a."
+      expect(instance.to_string).to eq(expectation)
+    end
+  end # context
+
+end # describe
+end # module
+
+# End of file