sequitur 0.1.15 → 0.1.16

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ODUxYjgzNjcxM2M5ZWQxZDgxNmE0NjJiM2E5Njc5MzBlY2Q1NDc2Mg==
-  data.tar.gz: !binary |-
-    MjRjY2Q2MmRmOWEyZGE2NDI1NWQ2ZDJhZjdlMjE5YzdiMDhkOWI4YQ==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    NDI0YzNmOWI4ZTBlZGNjNDkxNmNmNTRhNDJjZDMzMDY4OWE4YmU5YmRjZmJl
-    NzI5MjViMjhhNGYyODkyNGQzNGMyMGFhMjRkNjMyMDBlOTFlN2ZhNzgzYzk1
-    MTgxNjYzYTA4YmFkZWE1ZDlmOTc0MDdkMzJmOGQzMTFiYmEzYWQ=
-  data.tar.gz: !binary |-
-    OGI1NWI4NDBlMjhhYzQ3NWUyNDI1MmFkZmI0ZTgzYWRlZWQ1OTZlZWM4Yzg1
-    OTIxMDc4Zjc2NmY1MDExNzQ5OWYyZTkwY2EyZjgwMTczZGFkOGE2YzJkMjAx
-    NGQxMWY2NDBkOTBlNTM1M2I2YWNiNDA1M2U1MjZlMWFjY2RjZTI=
+SHA1:
+  metadata.gz: b1af553fad3ecc43dc57cc44e040b01d855caf01
+  data.tar.gz: 541cc47ff348f3886a95bde5eba649c1f1a91913
+SHA512:
+  metadata.gz: db612a6216a109a99a216e2cfaca23feaf20243c121fd404956bc76109f5926e67af4cb26c29f747040f93348768ab2f40e1db3070d096fd96dc687d290a3bf9
+  data.tar.gz: 21ae7581e271eb66e7f8a4578ae451e994670cc138afe341f18722cfbf7cd8625a559748281f2986ce121ba10da2a58438c12f1c04b8db0dd6f3e084e0e2d186

data/.ruby-version

@@ -1 +1 @@
-1.9.3
+2.2.3

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+### 0.1.16 / 2015-09-05
+* [CHANGE] Minor. Code re-formatted to please Rubocop 0.34.0
+* [FIX] File `sequitur.gemspec`: updated gem version in development dependencies
+
 ### 0.1.15 / 2015-06-16
 * [CHANGE] Code re-formatted to please Rubocop 0.32.0
 * [FIX] File `.rubocop.yml`: change some cop settings.

data/Gemfile

@@ -3,8 +3,9 @@ source 'https://rubygems.org'
 
 
 group :development do
-  gem 'rake',  '>= 0.8.0' 
-  gem 'rspec', '>= 3.0.0'
-  gem 'simplecov', '>= 0.5.0'
+  gem 'rake', '>= 10.0.0' 
+  gem 'rspec', '>= 2.1.0'
+  gem 'simplecov', '>= 0.8.0'
   gem 'coveralls', '>= 0.7.0'
 end
+

data/lib/sequitur/constants.rb

@@ -3,7 +3,7 @@
 
 module Sequitur # Module used as a namespace
   # The version number of the gem.
-  Version = '0.1.15'
+  Version = '0.1.16'
 
   # Brief description of the gem.
   Description = 'Ruby implementation of the Sequitur algorithm'

data/lib/sequitur/sequitur_grammar.rb

@@ -121,7 +121,7 @@ class SequiturGrammar < DynamicGrammar
   # And delete P
   def restore_utility(prod_index)
     # Retrieve useless prod from its index
-    useless_prod =  productions[prod_index]
+    useless_prod = productions[prod_index]
 
     # Retrieve production referencing useless one
     referencing = nil

data/spec/sequitur/dynamic_grammar_spec.rb

@@ -71,7 +71,7 @@ describe DynamicGrammar do
       expect(p_b.refcount).to eq(1)
       expect(p_c.refcount).to eq(1)
 
-      subject.remove_production(1)  # 1 => p_a
+      subject.remove_production(1) # 1 => p_a
       expect(subject.productions.size).to eq(4)
       expect(p_b.refcount).to eq(1)
       expect(p_c.refcount).to eq(1)

data/spec/sequitur/formatter/base_text_spec.rb

@@ -60,7 +60,7 @@ SNIPPET
 
     it 'should support visit events with an explicit visitor' do
       instance = BaseText.new(destination)
-      a_visitor = sample_grammar.visitor  # Use visitor explicitly
+      a_visitor = sample_grammar.visitor # Use visitor explicitly
       instance.render(a_visitor)
       expectations = <<-SNIPPET
 start :.

data/spec/sequitur/production_ref_spec.rb

@@ -72,8 +72,8 @@ describe ProductionRef do
 
     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(subject) # Strict identity
+      expect(subject).to eq(same) # 2 references pointing to same production
       expect(subject).to eq(target)
     end
 

data/spec/sequitur/production_spec.rb

@@ -129,7 +129,7 @@ describe Production 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 = [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
@@ -139,7 +139,7 @@ describe Production do
       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 = [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...

data/spec/sequitur/sequitur_grammar_spec.rb

@@ -1,304 +1,304 @@
-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.start).to eq(instance.productions.first)
-      expect(instance.start).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.start).to eq(instance.productions.first)
-      expect(instance.start.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.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
-      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.start.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.start.rhs).to eq([p_a, p_a])
-    end
-
-    it 'should cope with a pattern that caused an exception' do
-      input = 'aaac'  # This sequence raised an exception
-
-      # Creation
-      expect { SequiturGrammar.new(input.chars) }.not_to raise_error
-    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.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'])
-    end
-
-    it 'should work with strings instead of single char input tokens' do
-      # Raw input is sequence of chars
-      raw_input = 'bbebeebebebbebee'
-
-      # Convert them into multichar strings
-      input = raw_input.chars.map do |ch|
-        'letter_' + ch
-      end
-
-      # Creation
-      instance = SequiturGrammar.new(input.to_enum)
-
-      # 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.start.rhs).to eq([p3, p2, p3])
-      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
-    
-    it 'should work with Symbol instead of single char input tokens' do
-      # Raw input is sequence of single characters
-      raw_input = 'bbebeebebebbebee'
-
-      # Convert them into symbols
-      input = raw_input.chars.map(&:to_sym)
-
-      # Creation
-      instance = SequiturGrammar.new(input.to_enum)
-
-      # 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.start.rhs).to eq([p3, p2, p3])
-      expect(p1.rhs).to eq([:b, :e])
-      expect(p2.rhs).to eq([p1, p1])
-      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
-      input = raw_input.chars.map { |ch| ch.to_i(16) }
-
-      # Creation
-      instance = SequiturGrammar.new(input.to_enum)
-
-      # 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.start.rhs).to eq([p3, p2, p3])
-      expect(p1.rhs).to eq([0xb, 0xe])
-      expect(p2.rhs).to eq([p1, p1])
-      expect(p3.rhs).to eq([0xb, p2, 0xe])
-    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.start.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.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
-
-    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.start
-      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
-
-    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.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.start.object_id} : a."
-      expect(instance.to_string).to eq(expectation)
-    end
-  end # context
-end # describe
-end # module
-
-# End of file
+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.start).to eq(instance.productions.first)
+      expect(instance.start).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.start).to eq(instance.productions.first)
+      expect(instance.start.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.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
+      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.start.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.start.rhs).to eq([p_a, p_a])
+    end
+
+    it 'should cope with a pattern that caused an exception' do
+      input = 'aaac' # This sequence raised an exception
+
+      # Creation
+      expect { SequiturGrammar.new(input.chars) }.not_to raise_error
+    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.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'])
+    end
+
+    it 'should work with strings instead of single char input tokens' do
+      # Raw input is sequence of chars
+      raw_input = 'bbebeebebebbebee'
+
+      # Convert them into multichar strings
+      input = raw_input.chars.map do |ch|
+        'letter_' + ch
+      end
+
+      # Creation
+      instance = SequiturGrammar.new(input.to_enum)
+
+      # 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.start.rhs).to eq([p3, p2, p3])
+      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
+    
+    it 'should work with Symbol instead of single char input tokens' do
+      # Raw input is sequence of single characters
+      raw_input = 'bbebeebebebbebee'
+
+      # Convert them into symbols
+      input = raw_input.chars.map(&:to_sym)
+
+      # Creation
+      instance = SequiturGrammar.new(input.to_enum)
+
+      # 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.start.rhs).to eq([p3, p2, p3])
+      expect(p1.rhs).to eq([:b, :e])
+      expect(p2.rhs).to eq([p1, p1])
+      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
+      input = raw_input.chars.map { |ch| ch.to_i(16) }
+
+      # Creation
+      instance = SequiturGrammar.new(input.to_enum)
+
+      # 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.start.rhs).to eq([p3, p2, p3])
+      expect(p1.rhs).to eq([0xb, 0xe])
+      expect(p2.rhs).to eq([p1, p1])
+      expect(p3.rhs).to eq([0xb, p2, 0xe])
+    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.start.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.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
+
+    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.start
+      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
+
+    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.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.start.object_id} : a."
+      expect(instance.to_string).to eq(expectation)
+    end
+  end # context
+end # describe
+end # module
+
+# End of file

metadata

@@ -1,86 +1,104 @@
 --- !ruby/object:Gem::Specification
 name: sequitur
 version: !ruby/object:Gem::Version
-  version: 0.1.15
+  version: 0.1.16
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-16 00:00:00.000000000 Z
+date: 2015-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 10.0.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 10.0.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.0.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 2.1.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 2.1.0
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.8.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.8.0
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.7.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.7.0
 - !ruby/object:Gem::Dependency
   name: rubygems
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.0.0
-description: ! "Ruby implementation of the Sequitur algorithm. This algorithm automatically
+description: "Ruby implementation of the Sequitur algorithm. This algorithm automatically
   \nfinds repetitions and hierarchical structures in a given sequence of input \ntokens.
   It encodes the input into a context-free grammar. \nThe Sequitur algorithm can be
   used to \na) compress a sequence of items,\nb) discover patterns in an sequence,
@@ -91,18 +109,23 @@ extensions: []
 extra_rdoc_files:
 - README.md
 files:
-- .rubocop.yml
-- .rspec
-- .ruby-gemset
-- .ruby-version
-- .simplecov
-- .travis.yml
-- .yardopts
-- Gemfile
-- Rakefile
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".simplecov"
+- ".travis.yml"
+- ".yardopts"
 - CHANGELOG.md
+- Gemfile
 - LICENSE.txt
 - README.md
+- Rakefile
+- examples/integer_sample.rb
+- examples/porridge.rb
+- examples/simple_case.rb
+- examples/symbol_sample.rb
+- examples/word_sample.rb
 - lib/sequitur.rb
 - lib/sequitur/constants.rb
 - lib/sequitur/digram.rb
@@ -125,39 +148,31 @@ files:
 - spec/sequitur/sequitur_grammar_spec.rb
 - spec/sequitur/symbol_sequence_spec.rb
 - spec/spec_helper.rb
-- examples/integer_sample.rb
-- examples/porridge.rb
-- examples/simple_case.rb
-- examples/symbol_sample.rb
-- examples/word_sample.rb
 homepage: https://github.com/famished-tiger/Sequitur
 licenses:
 - MIT
 metadata: {}
-post_install_message: ! '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
+post_install_message: |
+  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   Thank you for installing Sequitur...
-
   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-'
 rdoc_options:
 - --charset=UTF-8 --exclude="examples|features|spec"
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.1
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Ruby implementation of the Sequitur algorithm