sequitur 0.1.03 → 0.1.05

data/spec/sequitur/dynamic_grammar_spec.rb

@@ -26,8 +26,8 @@ describe DynamicGrammar do
       expect { DynamicGrammar.new }.not_to raise_error
     end
 
-    it 'should have an empty root/start production' do
-      expect(subject.root).to be_empty
+    it 'should have an empty start/start production' do
+      expect(subject.start).to be_empty
       expect(subject.productions.size).to eq(1)
       expect(subject.productions.first).to be_empty
     end
@@ -60,15 +60,6 @@ describe DynamicGrammar do
       expect(subject.productions.last).to eq(p_bc)
     end
 
-    it 'should complain when rhs refers to unknown production' do
-      subject.add_production(p_a)
-      subject.add_production(p_b)
-      # Test fails because of Production#references
-      msg = "Production #{p_bc.object_id} refers to production #{p_c.object_id}"
-      msg << ' that is not part of the grammar.'
-      expect { subject.add_production(p_bc) }.to raise_error(StandardError, msg)
-
-    end
   end # context
 
 
@@ -117,10 +108,10 @@ describe DynamicGrammar do
       a_visitor.subscribe(fake_formatter)
 
       expect(fake_formatter).to receive(:before_grammar).with(subject).ordered
-      expect(fake_formatter).to receive(:before_production).with(subject.root)
+      expect(fake_formatter).to receive(:before_production).with(subject.start)
       expect(fake_formatter).to receive(:before_rhs).with([]).ordered
       expect(fake_formatter).to receive(:after_rhs).with([]).ordered
-      expect(fake_formatter).to receive(:after_production).with(subject.root)
+      expect(fake_formatter).to receive(:after_production).with(subject.start)
       expect(fake_formatter).to receive(:before_production).with(p_a)
       expect(fake_formatter).to receive(:before_rhs).with(p_a.rhs)
       expect(fake_formatter).to receive(:after_rhs).with(p_a.rhs)
@@ -146,13 +137,13 @@ describe DynamicGrammar do
   context 'Generating a text representation of itself:' do
 
     it 'should generate a text representation when empty' do
-      expectation = "#{subject.root.object_id} : ."
+      expectation = "#{subject.start.object_id} : ."
       expect(subject.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."
+    #   expectation = "#{instance.start.object_id} : a."
     #   expect(instance.to_string).to eq(expectation)
     # end
 

data/spec/sequitur/production_spec.rb

@@ -229,7 +229,7 @@ describe Production do
   context 'Replacing a digram by a production:' do
 
     it 'should have not effect on empty production' do
-      subject.replace_digram(p_bc)
+      subject.reduce_step(p_bc)
       expect(subject.rhs).to be_empty
       expect(p_bc.refcount).to eq(0)
     end
@@ -238,7 +238,7 @@ describe Production do
     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.replace_digram(p_bc)
+      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'])
@@ -249,7 +249,7 @@ describe Production do
 
     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)
+      subject.reduce_step(p_bc)
 
       expect(subject.rhs.size).to eq(5)
       expect(subject.rhs).to eq([p_bc, 'd', 'e', p_bc, 'e'])
@@ -259,7 +259,7 @@ describe Production do
 
     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)
+      subject.reduce_step(p_bc)
 
       expect(subject.rhs.size).to eq(5)
       expect(subject.rhs).to eq(['a', p_bc, 'd', 'e', p_bc])
@@ -268,7 +268,7 @@ describe Production do
 
     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)
+      subject.reduce_step(p_bc)
 
       expect(subject.rhs.size).to eq(4)
       expect(subject.rhs).to eq(['a', p_bc, p_bc, 'd'])
@@ -280,7 +280,7 @@ describe Production do
   context 'Replacing a production occurrence by its rhs:' do
 
     it 'should have not effect on empty production' do
-      subject.replace_production(p_bc)
+      subject.derive_step(p_bc)
       expect(subject.rhs).to be_empty
     end
 
@@ -288,7 +288,7 @@ describe Production do
       [p_bc, 'd'].each { |symb| subject.append_symbol(symb) }
       expect(p_bc.refcount).to eq(1)
       
-      subject.replace_production(p_bc)
+      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)
@@ -298,7 +298,7 @@ describe Production do
     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.replace_production(p_bc)
+      subject.derive_step(p_bc)
 
       expect(subject.rhs.size).to eq(3)
       expect(subject.rhs).to eq(%w(d b c))
@@ -307,7 +307,7 @@ describe Production do
 
     it 'should replace a production as sole symbol' do
       subject.append_symbol(p_bc)
-      subject.replace_production(p_bc)
+      subject.derive_step(p_bc)
 
       expect(subject.rhs.size).to eq(2)
       expect(subject.rhs).to eq(%w(b c))
@@ -315,7 +315,7 @@ describe Production do
 
     it 'should replace a production in the middle' do
       ['a', p_bc, 'd'].each { |symb| subject.append_symbol(symb) }
-      subject.replace_production(p_bc)
+      subject.derive_step(p_bc)
 
       expect(subject.rhs.size).to eq(4)
       expect(subject.rhs).to eq(%w(a b c d))

data/spec/sequitur/sequitur_grammar_spec.rb

@@ -22,8 +22,8 @@ describe SequiturGrammar do
 
       # Initialization
       expect(instance.productions.size).to eq(1)
-      expect(instance.root).to eq(instance.productions.first)
-      expect(instance.root).to be_empty
+      expect(instance.start).to eq(instance.productions.first)
+      expect(instance.start).to be_empty
     end
 
     it 'could be created with single token' do
@@ -32,8 +32,8 @@ describe SequiturGrammar do
 
       # Initialization
       expect(instance.productions.size).to eq(1)
-      expect(instance.root).to eq(instance.productions.first)
-      expect(instance.root.rhs).to eq([:a])
+      expect(instance.start).to eq(instance.productions.first)
+      expect(instance.start.rhs).to eq([:a])
     end
 
     it 'could be created with multiple unique tokens' do
@@ -42,8 +42,8 @@ describe SequiturGrammar do
 
       # 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])
+      expect(instance.start).to eq(instance.productions.first)
+      expect(instance.start.rhs).to eq([:a, :b, :c, :d])
     end
 
     it 'could be created with a repeating digram' do
@@ -55,7 +55,7 @@ describe SequiturGrammar do
       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])
+      expect(instance.start.rhs).to eq([p_a, p_a])
     end
 
     it 'should enforce the utility rule' do
@@ -72,7 +72,7 @@ describe SequiturGrammar do
       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])
+      expect(instance.start.rhs).to eq([p_a, p_a])
     end
     
     it 'should cope with a pattern that caused an exception' do
@@ -96,7 +96,7 @@ describe SequiturGrammar do
       # 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(instance.start.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'])
@@ -113,7 +113,7 @@ describe SequiturGrammar do
 
       expect(instance.productions.size).to eq(3)
       (p1, p2) = instance.productions[1..2]
-      expect(instance.root.rhs).to eq([p2, p2])
+      expect(instance.start.rhs).to eq([p2, p2])
       expect(p1.rhs).to eq(%w(a b))
       expect(p2.rhs).to eq([p1, 'c', p1, 'd'])
     end
@@ -129,7 +129,7 @@ describe SequiturGrammar do
 
       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(instance.start.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
@@ -165,7 +165,7 @@ SNIPPET
 
       instance = SequiturGrammar.new(input.chars)
       expect(instance.productions.size).to eq(13)
-      p0 = instance.root
+      p0 = instance.start
       expect(p0.rhs.size).to eq(13)
 
       (p1, p2, p3, p4, p5, p6, p7, p8, p9) = instance.productions[1..9]
@@ -196,20 +196,36 @@ SNIPPET
       ].flatten
       expect(p12.rhs).to eq(p12_expectation)  # Rule 5 above
     end
+    
+    it 'should work with a sequence of Ruby Symbols' do
+      input = 'abcabdabcabd'.chars.map(&:to_sym)
+      instance = SequiturGrammar.new(input.to_enum)
+
+      # Expectations:
+      # start : P2 P2.
+      # P1 : :a :b
+      # P2 : P1 :c P1 :d.
+
+      expect(instance.productions.size).to eq(3)
+      (p1, p2) = instance.productions[1..2]
+      expect(instance.start.rhs).to eq([p2, p2])
+      expect(p1.rhs).to eq([:a, :b])
+      expect(p2.rhs).to eq([p1, :c, p1, :d])
+    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} : ."
+      expectation = "#{instance.start.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."
+      expectation = "#{instance.start.object_id} : a."
       expect(instance.to_string).to eq(expectation)
     end
   end # context

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequitur
 version: !ruby/object:Gem::Version
-  version: 0.1.03
+  version: 0.1.05
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-21 00:00:00.000000000 Z
+date: 2014-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake