sequitur 0.1.18 → 0.1.19

data/spec/sequitur/production_spec.rb

@@ -66,7 +66,7 @@ describe Production do
       expect(subject.references).to be_empty
 
       # Case 2: production without references
-      symbols = [:a, :b, :c]
+      symbols = %i[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
@@ -90,14 +90,14 @@ describe Production do
     end
 
     it 'should know the position(s) of a given digram' do
-      sequence1 = [:a, :b, :c, :a, :b, :a, :b, :d]
+      sequence1 = %i[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 = %i[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)
@@ -114,15 +114,15 @@ describe Production do
     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])
+      expect(subject.rhs).to eq(%i[a b])
+      expect(subject.last_digram.symbols).to eq(%i[a b])
     end
 
     it 'should append a symbol when rhs has several symbols' do
-      symbols = [:a, :b, :c, :d, :e, :f]
+      symbols = %i[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])
+      expect(subject.last_digram.symbols).to eq(%i[e f])
     end
 
     it 'should append a production in its rhs' do

data/spec/sequitur/sequitur_grammar_spec.rb

@@ -7,7 +7,7 @@ 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()
+  def empty_enum
     return [].to_enum
   end
 
@@ -36,28 +36,28 @@ describe SequiturGrammar do
 
     it 'could be created with multiple unique tokens' do
       # Creation
-      instance = SequiturGrammar.new([:a, :b, :c, :d].to_enum)
+      instance = SequiturGrammar.new(%i[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])
+      expect(instance.start.rhs).to eq(%i[a b c d])
     end
 
     it 'could be created with a repeating digram' do
-      instance = SequiturGrammar.new([:a, :b, :a, :b].to_enum)
+      instance = SequiturGrammar.new(%i[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(p_a.rhs).to eq(%i[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)
+      instance = SequiturGrammar.new(%i[a b c a b c].to_enum)
 
       # Expectations without utility rule:
       # S : B B.
@@ -69,7 +69,7 @@ describe SequiturGrammar do
       # 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(p_a.rhs).to eq(%i[a b c])
       expect(instance.start.rhs).to eq([p_a, p_a])
     end
 
@@ -124,7 +124,7 @@ describe SequiturGrammar do
       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'
@@ -143,7 +143,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([:b, :e])
+      expect(p1.rhs).to eq(%i[b e])
       expect(p2.rhs).to eq([p1, p1])
       expect(p3.rhs).to eq([:b, p2, :e])
     end
@@ -279,7 +279,7 @@ SNIPPET
       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(p1.rhs).to eq(%i[a b])
       expect(p2.rhs).to eq([p1, :c, p1, :d])
     end
   end # context

data/spec/sequitur/symbol_sequence_spec.rb

@@ -24,7 +24,7 @@ describe SymbolSequence do
 
     subject do
       an_instance = SymbolSequence.new
-      [:a, :b, :c].each { |a_sym| an_instance << a_sym }
+      %i[a b c].each { |a_sym| an_instance << a_sym }
       an_instance
     end
 
@@ -63,7 +63,7 @@ describe SymbolSequence do
       expect(instance).to eq(instance)
 
       expect(subject).not_to eq(instance)
-      [:a, :b, :c].each { |a_sym| instance << a_sym }
+      %i[a b c].each { |a_sym| instance << a_sym }
       expect(subject).to eq(instance)
 
       # Check that element order is relevant
@@ -72,10 +72,10 @@ describe SymbolSequence do
     end
 
     it 'should know whether it is equal to an array' do
-      expect(subject).to eq([:a, :b, :c])
+      expect(subject).to eq(%i[a b c])
 
       # Check that element order is relevant
-      expect(subject).not_to eq([:c, :b, :a])
+      expect(subject).not_to eq(%i[c b a])
     end
 
     it 'should know that is not equal to something else' do

data/spec/spec_helper.rb

@@ -6,10 +6,12 @@ require 'coveralls'
 
 Coveralls.wear!
 
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-  SimpleCov::Formatter::HTMLFormatter,
-  Coveralls::SimpleCov::Formatter
-]
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(
+  [
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+)
 
 
 require 'rspec' # Use the RSpec framework

metadata

@@ -1,108 +1,123 @@
 --- !ruby/object:Gem::Specification
 name: sequitur
 version: !ruby/object:Gem::Version
-  version: 0.1.18
+  version: 0.1.19
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-21 00:00:00.000000000 Z
+date: 2018-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 10.0.0
+        version: '0.7'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 10.0.0
+        version: 0.7.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 10.0.0
+        version: '0.7'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 10.0.0
+        version: 0.7.0
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: 10.0.0
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: 10.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: 10.0.0
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: 10.0.0
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 3.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
-  name: coveralls
+  name: rubygems
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        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: 0.7.0
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
-  name: rubygems
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 0.8.0
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 0.8.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 0.8.0
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0
-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,
-  \nc) generate grammar rules that can represent a given input.\n"
+        version: 0.8.0
+description: |
+  Ruby implementation of the Sequitur algorithm. This algorithm automatically
+  finds repetitions and hierarchical structures in a given sequence of input
+  tokens. It encodes the input into a context-free grammar.
+  The Sequitur algorithm can be used to
+  a) compress a sequence of items,
+  b) discover patterns in an sequence,
+  c) generate grammar rules that can represent a given input.
 email: famished.tiger@yahoo.com
 executables: []
 extensions: []
@@ -173,7 +188,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.7
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Ruby implementation of the Sequitur algorithm