sequitur 0.1.23 → 0.1.24

data/spec/sequitur/production_ref_spec.rb

@@ -7,98 +7,98 @@ 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
+  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

@@ -5,22 +5,26 @@ 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
+describe Sequitur::Production do
+  # Factory method. Returns a Sequitur::Production
+  def make_production
+    Sequitur::Production.new
+  end
+
   # Helper method: convert list of digrams into an array
   # of symbol couples.
-  def to_symbols(theDigrams)
-    return theDigrams.map(&:symbols)
+  def to_symbols(digrams)
+    digrams.map(&:symbols)
   end
 
   let(:p_a) do
-      instance = Production.new
-      instance.append_symbol(:a)
-      instance
+    instance = make_production
+    instance.append_symbol(:a)
+    instance
   end
 
   let(:p_bc) do
-    instance = Production.new
+    instance = make_production
     instance.append_symbol('b')
     instance.append_symbol('c')
     instance
@@ -28,7 +32,7 @@ describe Production do
 
   context 'Creation & initialization:' do
     it 'should be created without argument' do
-      expect { Production.new }.not_to raise_error
+      expect { make_production }.not_to raise_error
     end
 
     it 'should not referenced yet' do
@@ -52,11 +56,11 @@ describe Production do
     end
 
     it 'should compare to a production reference' do
-      ref_a = ProductionRef.new(p_a)
+      ref_a = Sequitur::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)
+      ref_bc = Sequitur::ProductionRef.new(p_bc)
       expect(p_a).not_to eq(ref_bc)
       expect(p_bc).to eq(ref_bc)
     end
@@ -78,13 +82,11 @@ describe Production do
       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])
@@ -138,7 +140,7 @@ describe Production do
 
     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)
+      ref_a = Sequitur::ProductionRef.new(p_a)
       expect(p_a.refcount).to be(1)
 
       input = [ref_a, :b, :c, :d, ref_a] # ref_a appears twice
@@ -157,7 +159,7 @@ describe Production do
 
     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)
+      ref_a = Sequitur::ProductionRef.new(p_a)
       expect(p_a.refcount).to be(1)
 
       # Unbind the reference
@@ -167,7 +169,6 @@ describe Production do
     end
   end # context
 
-
   context 'Text representation of a production rule:' do
     it 'should emit minimal text when empty' do
       expectation = "#{subject.object_id} : ."
@@ -175,7 +176,7 @@ describe Production do
     end
 
     it 'should emit its text representation' do
-      instance = Production.new
+      instance = make_production
       symbols = [:a, :b, 'c', :d, :e, 1000, instance]
       symbols.each { |symb| subject.append_symbol(symb) }
       expectation = +"#{subject.object_id} : "
@@ -204,17 +205,17 @@ describe Production do
 
     it 'should detect any repetition pattern' do
       # Positive cases
-      cases = %w(abab abcdab abcdcd abcdefcd)
+      cases = %w[abab abcdab abcdcd abcdefcd]
       cases.each do |word|
-        instance = Production.new
+        instance = make_production
         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 = %w[abc abb abba abcdef]
       cases.each do |word|
-        instance = Production.new
+        instance = make_production
         word.each_char { |symb| instance.append_symbol(symb) }
         expect(instance.repeated_digram?).to be_falsey
       end
@@ -228,9 +229,8 @@ describe Production do
       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) }
+      %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)
 
@@ -240,9 +240,8 @@ describe Production do
       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) }
+      %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)
@@ -250,9 +249,8 @@ describe Production do
       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) }
+      %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)
@@ -261,7 +259,7 @@ describe Production do
     end
 
     it 'should replace two consecutive two-symbol sequences' do
-      %w(a b c b c d).each { |symb| subject.append_symbol(symb) }
+      %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)
@@ -282,18 +280,17 @@ describe Production do
 
       subject.derive_step(p_bc)
       expect(subject.rhs.size).to eq(3)
-      expect(subject.rhs).to eq(%w(b c d))
+      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(subject.rhs).to eq(%w[d b c])
       expect(p_bc.refcount).to eq(0)
     end
 
@@ -302,7 +299,7 @@ describe Production do
       subject.derive_step(p_bc)
 
       expect(subject.rhs.size).to eq(2)
-      expect(subject.rhs).to eq(%w(b c))
+      expect(subject.rhs).to eq(%w[b c])
     end
 
     it 'should replace a production in the middle' do
@@ -310,7 +307,7 @@ describe Production do
       subject.derive_step(p_bc)
 
       expect(subject.rhs.size).to eq(4)
-      expect(subject.rhs).to eq(%w(a b c d))
+      expect(subject.rhs).to eq(%w[a b c d])
     end
   end # context
 
@@ -358,6 +355,5 @@ describe Production do
     end
   end # context
 end # describe
-end # module
 
 # End of file

data/spec/sequitur/sequitur_grammar_spec.rb

@@ -5,20 +5,24 @@ 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
+describe Sequitur::SequiturGrammar do
+  # Factory method. Returns a SequiturGrammar
+  def sequitur_grammar(enumerator)
+    Sequitur::SequiturGrammar.new(enumerator)
+  end
+
   # Factory method. Returns an empty enumerator (
   # i.e. without elements to iterate)
   def empty_enum
-    return [].to_enum
+    [].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
+      expect { sequitur_grammar(empty_enum) }.not_to raise_error
 
       # Creation
-      instance = SequiturGrammar.new(empty_enum)
+      instance = sequitur_grammar(empty_enum)
 
       # Initialization
       expect(instance.productions.size).to eq(1)
@@ -28,7 +32,7 @@ describe SequiturGrammar do
 
     it 'could be created with single token' do
       # Creation
-      instance = SequiturGrammar.new([:a].to_enum)
+      instance = sequitur_grammar([:a].to_enum)
 
       # Initialization
       expect(instance.productions.size).to eq(1)
@@ -38,7 +42,7 @@ describe SequiturGrammar do
 
     it 'could be created with multiple unique tokens' do
       # Creation
-      instance = SequiturGrammar.new(%i[a b c d].to_enum)
+      instance = sequitur_grammar(%i[a b c d].to_enum)
 
       # Initialization
       expect(instance.productions.size).to eq(1)
@@ -47,7 +51,7 @@ describe SequiturGrammar do
     end
 
     it 'could be created with a repeating digram' do
-      instance = SequiturGrammar.new(%i[a b a b].to_enum)
+      instance = sequitur_grammar(%i[a b a b].to_enum)
 
       # Expectations:
       # S : A A.
@@ -59,7 +63,7 @@ describe SequiturGrammar do
     end
 
     it 'should enforce the utility rule' do
-      instance = SequiturGrammar.new(%i[a b c a b c].to_enum)
+      instance = sequitur_grammar(%i[a b c a b c].to_enum)
 
       # Expectations without utility rule:
       # S : B B.
@@ -79,15 +83,14 @@ describe SequiturGrammar do
       input = 'aaac' # This sequence raised an exception
 
       # Creation
-      expect { SequiturGrammar.new(input.chars) }.not_to raise_error
+      expect { sequitur_grammar(input.chars) }.not_to raise_error
     end
 
-
     it 'should cope with the example from presentation' do
       input = 'bbebeebebebbebee'
 
       # Creation
-      instance = SequiturGrammar.new(input.chars)
+      instance = sequitur_grammar(input.chars)
 
       # Expectations:
       # S: P3 P2 P3
@@ -97,7 +100,7 @@ describe SequiturGrammar do
       expect(instance.productions.size).to eq(4)
       (p1, p2, p3) = instance.productions[1..3]
       expect(instance.start.rhs).to eq([p3, p2, p3])
-      expect(p1.rhs).to eq(%w(b e))
+      expect(p1.rhs).to eq(%w[b e])
       expect(p2.rhs).to eq([p1, p1])
       expect(p3.rhs).to eq(['b', p2, 'e'])
     end
@@ -110,7 +113,7 @@ describe SequiturGrammar do
       input = raw_input.chars.map { |ch| "letter_#{ch}" }
 
       # Creation
-      instance = SequiturGrammar.new(input.to_enum)
+      instance = sequitur_grammar(input.to_enum)
 
       # Expectations:
       # S: P3 P2 P3
@@ -120,7 +123,7 @@ describe SequiturGrammar do
       expect(instance.productions.size).to eq(4)
       (p1, p2, p3) = instance.productions[1..3]
       expect(instance.start.rhs).to eq([p3, p2, p3])
-      expect(p1.rhs).to eq(%w(letter_b letter_e))
+      expect(p1.rhs).to eq(%w[letter_b letter_e])
       expect(p2.rhs).to eq([p1, p1])
       expect(p3.rhs).to eq(['letter_b', p2, 'letter_e'])
     end
@@ -133,7 +136,7 @@ describe SequiturGrammar do
       input = raw_input.chars.map(&:to_sym)
 
       # Creation
-      instance = SequiturGrammar.new(input.to_enum)
+      instance = sequitur_grammar(input.to_enum)
 
       # Expectations:
       # S: P3 P2 P3
@@ -148,16 +151,15 @@ describe SequiturGrammar do
       expect(p3.rhs).to eq([:b, p2, :e])
     end
 
-
     it 'should work with integer values as input tokens' do
       # Raw input is sequence of hex digits
       raw_input = 'bbebeebebebbebee'
 
-      # Convert them into Fixnums
+      # Convert them into Integers
       input = raw_input.chars.map { |ch| ch.to_i(16) }
 
       # Creation
-      instance = SequiturGrammar.new(input.to_enum)
+      instance = sequitur_grammar(input.to_enum)
 
       # Expectations:
       # S: P3 P2 P3
@@ -174,7 +176,7 @@ describe SequiturGrammar do
 
     it 'should cope with the example from sequitur.info website' do
       input = 'abcabdabcabd'
-      instance = SequiturGrammar.new(input.chars)
+      instance = sequitur_grammar(input.chars)
 
       # Expectations:
       # 0 → 2 2
@@ -184,13 +186,13 @@ describe SequiturGrammar do
       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(%w(a b))
+      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)
+      instance = sequitur_grammar(input.chars)
 
       # Expectations:
       # S → CC
@@ -200,23 +202,23 @@ describe SequiturGrammar do
       expect(instance.productions.size).to eq(3)
       (p_a, p_c) = instance.productions[1..2]
       expect(instance.start.rhs).to eq([p_c, p_c])
-      expect(p_a.rhs).to eq(%w(b 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
+      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_
@@ -233,7 +235,7 @@ SNIPPET
       # 11 → o l d                                        old
       # 12 → i n                                          in
 
-      instance = SequiturGrammar.new(input.chars)
+      instance = sequitur_grammar(input.chars)
       expect(instance.productions.size).to eq(13)
       p0 = instance.start
       expect(p0.rhs.size).to eq(13)
@@ -241,7 +243,7 @@ SNIPPET
       (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
+      # NOTE: the productions aren't sorted the same way as
       # the sequitur.info implementation.
       p0_expectation = [
         p2, p8, p3, p10, p3, p12, "\n",
@@ -249,27 +251,27 @@ SNIPPET
       ]
       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(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(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"
+        %w[d a y s], ' ', p7, '.', "\n"
       ].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)
+      instance = sequitur_grammar(input.to_enum)
 
       # Expectations:
       # start : P2 P2.
@@ -286,19 +288,18 @@ SNIPPET
 
   context 'Generating a text representation of itself:' do
     it 'should generate a text representation when empty' do
-      instance = SequiturGrammar.new(empty_enum)
+      instance = sequitur_grammar(empty_enum)
       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)
+      instance = sequitur_grammar([:a].to_enum)
       expectation = "#{instance.start.object_id} : a."
       expect(instance.to_string).to eq(expectation)
     end
   end # context
 end # describe
-end # module
 
 # End of file