rambling-trie 2.3.0 → 2.4.0

data/spec/integration/rambling/trie_spec.rb

@@ -6,32 +6,60 @@ require 'zip'
 describe Rambling::Trie do
   let(:assets_path) { File.join ::SPEC_ROOT, 'assets' }
 
+  describe '::VERSION' do
+    let(:root_path) { File.join ::SPEC_ROOT, '..' }
+    let(:readme_path) { File.join root_path, 'README.md' }
+    let(:readme) { File.read readme_path }
+    let(:changelog_path) { File.join root_path, 'CHANGELOG.md' }
+    let(:changelog) { File.read changelog_path }
+
+    let(:changelog_versions) do
+      matches = []
+      changelog.scan %r{^## (\d+\.\d+\.\d+)} do |match|
+        matches << match[0]
+      end
+      matches
+    end
+
+    it 'matches with the version in the README badge' do
+      match = %r{\?version=(?<version>.*)$}.match readme
+      expect(match['version']).to eq Rambling::Trie::VERSION
+    end
+
+    it 'is the version before the one at the top of the CHANGELOG' do
+      changelog_version = Gem::Version.new changelog_versions.first
+      lib_version = Gem::Version.new "#{Rambling::Trie::VERSION}.0"
+      expect(changelog_version).to eq lib_version.bump
+    end
+
+    it 'is included in the CHANGELOG diffs' do
+      changelog_versions.shift
+      expect(changelog_versions.first).to eq Rambling::Trie::VERSION
+    end
+  end
+
   context 'when providing words directly' do
     it_behaves_like 'a compressible trie' do
-      let(:trie) { Rambling::Trie.create }
+      let(:trie) { described_class.create }
       let(:words) { %w(a couple of words for our full trie integration test) }
 
-      before do
-        trie.concat words
-      end
+      before { trie.concat words }
     end
   end
 
   context 'when provided with words with unicode characters' do
     it_behaves_like 'a compressible trie' do
-      let(:trie) { Rambling::Trie.create }
-      let(:words) do
+      let(:trie) { described_class.create }
+      let :words do
         %w(poquísimas palabras para nuestra prueba de integración completa 🙃)
       end
 
-      before do
-        trie.concat words
-      end
+      before { trie.concat words }
     end
   end
 
   context 'when provided with a filepath' do
-    let(:trie) { Rambling::Trie.create filepath }
+    let(:trie) { described_class.create filepath }
     let(:words) { File.readlines(filepath).map(&:chomp) }
 
     context 'with english words' do
@@ -53,34 +81,35 @@ describe Rambling::Trie do
 
     context 'when serialized with Ruby marshal format (default)' do
       it_behaves_like 'a serializable trie' do
-        let(:trie_to_serialize) { Rambling::Trie.create words_filepath }
-        let(:format) { :marshal }
+        let(:trie_to_serialize) { described_class.create words_filepath }
+        let(:file_format) { :marshal }
       end
     end
 
     context 'when serialized with YAML' do
       it_behaves_like 'a serializable trie' do
-        let(:trie_to_serialize) { Rambling::Trie.create words_filepath }
-        let(:format) { :yml }
+        let(:trie_to_serialize) { described_class.create words_filepath }
+        let(:file_format) { :yml }
       end
     end
 
     context 'when serialized with zipped Ruby marshal format' do
+      let!(:original_on_exists_proc) { ::Zip.on_exists_proc }
+      let!(:original_continue_on_exists_proc) { ::Zip.continue_on_exists_proc }
+
       before do
-        @original_on_exists_proc = ::Zip.on_exists_proc
-        @original_continue_on_exists_proc = ::Zip.continue_on_exists_proc
         ::Zip.on_exists_proc = true
         ::Zip.continue_on_exists_proc = true
       end
 
       after do
-        ::Zip.on_exists_proc = @original_on_exists_proc
-        ::Zip.continue_on_exists_proc = @original_continue_on_exists_proc
+        ::Zip.on_exists_proc = original_on_exists_proc
+        ::Zip.continue_on_exists_proc = original_continue_on_exists_proc
       end
 
       it_behaves_like 'a serializable trie' do
-        let(:trie_to_serialize) { Rambling::Trie.create words_filepath }
-        let(:format) { 'marshal.zip' }
+        let(:trie_to_serialize) { described_class.create words_filepath }
+        let(:file_format) { 'marshal.zip' }
       end
     end
   end

data/spec/lib/rambling/trie/comparable_spec.rb

@@ -4,93 +4,83 @@ require 'spec_helper'
 
 describe Rambling::Trie::Comparable do
   describe '#==' do
-    let(:node_1) { Rambling::Trie::Nodes::Raw.new }
-    let(:node_2) { Rambling::Trie::Nodes::Raw.new }
+    let(:node_one) { Rambling::Trie::Nodes::Raw.new }
+    let(:node_two) { Rambling::Trie::Nodes::Raw.new }
 
     context 'when the nodes do not have the same letter' do
       before do
-        node_1.letter = :a
-        node_2.letter = :b
+        node_one.letter = :a
+        node_two.letter = :b
       end
 
       it 'returns false' do
-        expect(node_1).not_to eq node_2
+        expect(node_one).not_to eq node_two
       end
     end
 
-    context 'when the nodes have the same letter and no children' do
+    context 'when nodes have same letter, not terminal and no children' do
       before do
-        node_1.letter = :a
-        node_2.letter = :a
+        node_one.letter = :a
+        node_two.letter = :a
       end
 
       it 'returns true' do
-        expect(node_1).to eq node_2
+        expect(node_one).to eq node_two
       end
     end
 
     context 'when the nodes have the same letter and are terminal' do
       before do
-        node_1.letter = :a
-        node_1.terminal!
+        node_one.letter = :a
+        node_one.terminal!
 
-        node_2.letter = :a
-        node_2.terminal!
+        node_two.letter = :a
+        node_two.terminal!
       end
 
       it 'returns true' do
-        expect(node_1).to eq node_2
-      end
-    end
-
-    context 'when the nodes have the same letter and are not terminal' do
-      before do
-        node_1.letter = :a
-        node_2.letter = :a
-      end
-
-      it 'returns true' do
-        expect(node_1).to eq node_2
+        expect(node_one).to eq node_two
       end
     end
 
     context 'when the nodes have the same letter but are not both terminal' do
       before do
-        node_1.letter = :a
-        node_1.terminal!
+        node_one.letter = :a
+        node_one.terminal!
 
-        node_2.letter = :a
+        node_two.letter = :a
       end
+
       it 'returns false' do
-        expect(node_1).not_to eq node_2
+        expect(node_one).not_to eq node_two
       end
     end
 
     context 'when the nodes have the same letter and the same children' do
       before do
-        node_1.letter = :t
-        add_words node_1, %w(hese hree hings)
+        node_one.letter = :t
+        add_words node_one, %w(hese hree hings)
 
-        node_2.letter = :t
-        add_words node_2, %w(hese hree hings)
+        node_two.letter = :t
+        add_words node_two, %w(hese hree hings)
       end
 
       it 'returns true' do
-        expect(node_1).to eq node_2
+        expect(node_one).to eq node_two
       end
     end
 
     context 'when the nodes have the same letter but different children' do
       before do
-        node_1.letter = :t
-        add_words node_1, %w(hese wo)
+        node_one.letter = :t
+        add_words node_one, %w(hese wo)
 
-        node_2.letter = :t
-        add_words node_2, %w(hese hree hings)
+        node_two.letter = :t
+        add_words node_two, %w(hese hree hings)
       end
 
       it 'returns false' do
-        expect(node_1).not_to eq node_2
+        expect(node_one).not_to eq node_two
       end
     end
   end

data/spec/lib/rambling/trie/compressor_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 describe Rambling::Trie::Compressor do
-  let(:compressor) { Rambling::Trie::Compressor.new }
+  let(:compressor) { described_class.new }
 
   describe '#compress' do
     let(:node) { Rambling::Trie::Nodes::Raw.new }
@@ -16,9 +16,7 @@ describe Rambling::Trie::Compressor do
     end
 
     context 'with at least one word' do
-      before do
-        add_words node, %w(all the words)
-      end
+      before { add_words node, %w(all the words) }
 
       it 'keeps the node letter nil' do
         compressed = compressor.compress node
@@ -28,25 +26,25 @@ describe Rambling::Trie::Compressor do
     end
 
     context 'with a single word' do
-      before do
-        add_word node, 'all'
-      end
+      before { add_word node, 'all' }
 
+      # rubocop:disable RSpec/ExampleLength, RSpec/MultipleExpectations
       it 'compresses into a single node without children' do
         compressed = compressor.compress node
+        compressed_node_a = compressed[:a]
 
-        expect(compressed[:a].letter).to eq :all
-        expect(compressed[:a].children.size).to eq 0
-        expect(compressed[:a]).to be_terminal
-        expect(compressed[:a]).to be_compressed
+        expect(compressed_node_a.letter).to eq :all
+        expect(compressed_node_a.children.size).to eq 0
+        expect(compressed_node_a).to be_terminal
+        expect(compressed_node_a).to be_compressed
       end
+      # rubocop:enable RSpec/ExampleLength, RSpec/MultipleExpectations
     end
 
     context 'with two words' do
-      before do
-        add_words node, %w(all ask)
-      end
+      before { add_words node, %w(all ask) }
 
+      # rubocop:disable RSpec/ExampleLength, RSpec/MultipleExpectations
       it 'compresses into corresponding three nodes' do
         compressed = compressor.compress node
 
@@ -65,8 +63,10 @@ describe Rambling::Trie::Compressor do
         expect(compressed[:a][:l]).to be_compressed
         expect(compressed[:a][:s]).to be_compressed
       end
+      # rubocop:enable RSpec/ExampleLength, RSpec/MultipleExpectations
     end
 
+    # rubocop:disable RSpec/ExampleLength, RSpec/MultipleExpectations
     it 'reassigns the parent nodes correctly' do
       add_words node, %w(repay rest repaint)
       compressed = compressor.compress node
@@ -91,7 +91,9 @@ describe Rambling::Trie::Compressor do
       expect(compressed[:r][:p][:i].parent).to eq compressed[:r][:p]
       expect(compressed[:r][:p][:i].children.size).to eq 0
     end
+    # rubocop:enable RSpec/ExampleLength, RSpec/MultipleExpectations
 
+    # rubocop:disable RSpec/ExampleLength, RSpec/MultipleExpectations
     it 'does not compress terminal nodes' do
       add_words node, %w(you your yours)
       compressed = compressor.compress node
@@ -104,5 +106,6 @@ describe Rambling::Trie::Compressor do
       expect(compressed[:y][:r][:s].letter).to eq :s
       expect(compressed[:y][:r][:s]).to be_compressed
     end
+    # rubocop:enable RSpec/ExampleLength, RSpec/MultipleExpectations
   end
 end

data/spec/lib/rambling/trie/configuration/properties_spec.rb

@@ -3,13 +3,17 @@
 require 'spec_helper'
 
 describe Rambling::Trie::Configuration::Properties do
-  let(:properties) { Rambling::Trie::Configuration::Properties.new }
+  let(:properties) { described_class.new }
 
   describe '.new' do
-    it 'configures the serializers' do
+    it 'configures the serializer formats' do
       serializers = properties.serializers
-
       expect(serializers.formats).to match_array %i(marshal yaml yml zip)
+    end
+
+    # rubocop:disable RSpec/ExampleLength
+    it 'configures the serializer providers' do
+      serializers = properties.serializers
       expect(serializers.providers.to_a).to match_array [
         [:marshal, Rambling::Trie::Serializers::Marshal],
         [:yaml, Rambling::Trie::Serializers::Yaml],
@@ -17,11 +21,15 @@ describe Rambling::Trie::Configuration::Properties do
         [:zip, Rambling::Trie::Serializers::Zip],
       ]
     end
+    # rubocop:enable RSpec/ExampleLength
 
-    it 'configures the readers' do
+    it 'configures the reader formats' do
       readers = properties.readers
-
       expect(readers.formats).to match_array %i(txt)
+    end
+
+    it 'configures the reader providers' do
+      readers = properties.readers
       expect(readers.providers.to_a).to match_array [
         [:txt, Rambling::Trie::Readers::PlainText],
       ]
@@ -44,14 +52,24 @@ describe Rambling::Trie::Configuration::Properties do
       properties.readers.add :test, 'test'
     end
 
-    it 'resets the serializers and readers to initial values' do
+    # rubocop:disable RSpec/MultipleExpectations
+    it 'resets the serializers to initial values' do
       expect(properties.serializers.formats).to include :test
-      expect(properties.readers.formats).to include :test
 
       properties.reset
 
       expect(properties.serializers.formats).not_to include :test
+    end
+    # rubocop:enable RSpec/MultipleExpectations
+
+    # rubocop:disable RSpec/MultipleExpectations
+    it 'resets the readers to initial values' do
+      expect(properties.readers.formats).to include :test
+
+      properties.reset
+
       expect(properties.readers.formats).not_to include :test
     end
+    # rubocop:enable RSpec/MultipleExpectations
   end
 end

data/spec/lib/rambling/trie/configuration/provider_collection_spec.rb

@@ -4,15 +4,19 @@ require 'spec_helper'
 
 describe Rambling::Trie::Configuration::ProviderCollection do
   let(:configured_default) { nil }
-  let(:configured_providers) do
+  let :configured_providers do
     { one: first_provider, two: second_provider }
   end
 
-  let(:first_provider) { double :first_provider }
-  let(:second_provider) { double :second_provider }
+  let :first_provider do
+    instance_double 'Rambling::Trie::Serializers::Marshal', :first_provider
+  end
+  let :second_provider do
+    instance_double 'Rambling::Trie::Serializers::Marshal', :second_provider
+  end
 
-  let(:provider_collection) do
-    Rambling::Trie::Configuration::ProviderCollection.new(
+  let :provider_collection do
+    described_class.new(
       :provider,
       configured_providers,
       configured_default,
@@ -46,25 +50,31 @@ describe Rambling::Trie::Configuration::ProviderCollection do
     let(:providers) { provider_collection.providers }
 
     before do
-      allow(providers) .to receive_messages(
+      allow(providers).to receive_messages(
         :[] => 'value',
         keys: %i(a b),
       )
     end
 
+    # rubocop:disable RSpec/MultipleExpectations
     it 'delegates `#[]` to providers' do
       expect(provider_collection[:key]).to eq 'value'
       expect(providers).to have_received(:[]).with :key
     end
+    # rubocop:enable RSpec/MultipleExpectations
 
+    # rubocop:disable RSpec/MultipleExpectations
     it 'aliases `#formats` to `providers#keys`' do
       expect(provider_collection.formats).to eq %i(a b)
       expect(providers).to have_received :keys
     end
+    # rubocop:enable RSpec/MultipleExpectations
   end
 
   describe '#add' do
-    let(:provider) { double :provider }
+    let :provider do
+      instance_double 'Rambling::Trie::Serializers::Marshal', :provider
+    end
 
     before do
       provider_collection.add :three, provider
@@ -76,7 +86,9 @@ describe Rambling::Trie::Configuration::ProviderCollection do
   end
 
   describe '#default=' do
-    let(:other_provider) { double :other_provider }
+    let :other_provider do
+      instance_double 'Rambling::Trie::Serializers::Marshal', :other_provider
+    end
 
     context 'when the given value is in the providers list' do
       it 'changes the default provider' do
@@ -106,43 +118,59 @@ describe Rambling::Trie::Configuration::ProviderCollection do
         expect(provider_collection.default).to be_nil
       end
 
+      # rubocop:disable RSpec/MultipleExpectations
       it 'raises an ArgumentError for any other provider' do
         expect do
           provider_collection.default = other_provider
         end.to raise_error ArgumentError
         expect(provider_collection.default).to be_nil
       end
+      # rubocop:enable RSpec/MultipleExpectations
     end
   end
 
   describe '#resolve' do
     context 'when the file extension is one of the providers' do
-      it 'returns the corresponding provider' do
-        expect(provider_collection.resolve 'hola.one').to eq first_provider
-        expect(provider_collection.resolve 'hola.two').to eq second_provider
+      [
+        ['hola.one', :first_provider],
+        ['hola.two', :second_provider],
+      ].each do |test_params|
+        filepath, provider = test_params
+
+        it 'returns the corresponding provider' do
+          provider_instance = public_send provider
+          expect(provider_collection.resolve filepath).to eq provider_instance
+        end
       end
     end
 
     context 'when the file extension is not one of the providers' do
-      it 'returns the default provider' do
-        expect(provider_collection.resolve 'hola.unknown').to eq first_provider
-        expect(provider_collection.resolve 'hola').to eq first_provider
+      %w(hola.unknown hola).each do |filepath|
+        it 'returns the default provider' do
+          expect(provider_collection.resolve filepath).to eq first_provider
+        end
       end
     end
   end
 
   describe '#reset' do
     let(:configured_default) { second_provider }
-    let(:provider) { double :provider }
+    let :provider do
+      instance_double 'Rambling::Trie::Serializers::Marshal', :provider
+    end
 
     before do
       provider_collection.add :three, provider
       provider_collection.default = provider
     end
 
-    it 'resets to back to the initially configured values' do
+    it 'resets to back to the initially configured values (:three => nil)' do
       provider_collection.reset
       expect(provider_collection[:three]).to be_nil
+    end
+
+    it 'resets to back to the initially configured default' do
+      provider_collection.reset
       expect(provider_collection.default).to eq second_provider
     end
   end