rambling-trie 2.4.0 → 2.5.0

data/spec/integration/rambling/trie_spec.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-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) { described_class.create }
-      let(:words) { %w(a couple of words for our full trie integration test) }
-
-      before { trie.concat words }
-    end
-  end
-
-  context 'when provided with words with unicode characters' do
-    it_behaves_like 'a compressible trie' do
-      let(:trie) { described_class.create }
-      let :words do
-        %w(poquísimas palabras para nuestra prueba de integración completa 🙃)
-      end
-
-      before { trie.concat words }
-    end
-  end
-
-  context 'when provided with a filepath' do
-    let(:trie) { described_class.create filepath }
-    let(:words) { File.readlines(filepath).map(&:chomp) }
-
-    context 'with english words' do
-      it_behaves_like 'a compressible trie' do
-        let(:filepath) { File.join assets_path, 'test_words.en_US.txt' }
-      end
-    end
-
-    context 'with unicode characters' do
-      it_behaves_like 'a compressible trie' do
-        let(:filepath) { File.join assets_path, 'test_words.es_DO.txt' }
-      end
-    end
-  end
-
-  describe 'dump and load' do
-    let(:words_filepath) { File.join assets_path, 'test_words.en_US.txt' }
-    let(:words) { File.readlines(words_filepath).map(&:chomp) }
-
-    context 'when serialized with Ruby marshal format (default)' do
-      it_behaves_like 'a serializable trie' do
-        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) { 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
-        ::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
-      end
-
-      it_behaves_like 'a serializable trie' do
-        let(:trie_to_serialize) { described_class.create words_filepath }
-        let(:file_format) { 'marshal.zip' }
-      end
-    end
-  end
-end

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

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Comparable do
-  describe '#==' do
-    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_one.letter = :a
-        node_two.letter = :b
-      end
-
-      it 'returns false' do
-        expect(node_one).not_to eq node_two
-      end
-    end
-
-    context 'when nodes have same letter, not terminal and no children' do
-      before do
-        node_one.letter = :a
-        node_two.letter = :a
-      end
-
-      it 'returns true' do
-        expect(node_one).to eq node_two
-      end
-    end
-
-    context 'when the nodes have the same letter and are terminal' do
-      before do
-        node_one.letter = :a
-        node_one.terminal!
-
-        node_two.letter = :a
-        node_two.terminal!
-      end
-
-      it 'returns true' do
-        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_one.letter = :a
-        node_one.terminal!
-
-        node_two.letter = :a
-      end
-
-      it 'returns false' do
-        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_one.letter = :t
-        add_words node_one, %w(hese hree hings)
-
-        node_two.letter = :t
-        add_words node_two, %w(hese hree hings)
-      end
-
-      it 'returns true' do
-        expect(node_one).to eq node_two
-      end
-    end
-
-    context 'when the nodes have the same letter but different children' do
-      before do
-        node_one.letter = :t
-        add_words node_one, %w(hese wo)
-
-        node_two.letter = :t
-        add_words node_two, %w(hese hree hings)
-      end
-
-      it 'returns false' do
-        expect(node_one).not_to eq node_two
-      end
-    end
-  end
-end

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

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Compressor do
-  let(:compressor) { described_class.new }
-
-  describe '#compress' do
-    let(:node) { Rambling::Trie::Nodes::Raw.new }
-
-    it 'compresses the node' do
-      add_words node, %w(a few words hello hell)
-      compressed = compressor.compress node
-
-      expect(compressed.children_tree.keys).to eq %i(a f w h)
-    end
-
-    context 'with at least one word' do
-      before { add_words node, %w(all the words) }
-
-      it 'keeps the node letter nil' do
-        compressed = compressor.compress node
-
-        expect(compressed.letter).to be_nil
-      end
-    end
-
-    context 'with a single word' do
-      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_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 { add_words node, %w(all ask) }
-
-      # rubocop:disable RSpec/ExampleLength, RSpec/MultipleExpectations
-      it 'compresses into corresponding three nodes' do
-        compressed = compressor.compress node
-
-        expect(compressed[:a].letter).to eq :a
-        expect(compressed[:a].children.size).to eq 2
-
-        expect(compressed[:a][:l].letter).to eq :ll
-        expect(compressed[:a][:s].letter).to eq :sk
-
-        expect(compressed[:a][:l].children.size).to eq 0
-        expect(compressed[:a][:s].children.size).to eq 0
-
-        expect(compressed[:a][:l]).to be_terminal
-        expect(compressed[:a][:s]).to be_terminal
-
-        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
-
-      expect(compressed[:r].letter).to eq :re
-      expect(compressed[:r].parent).to eq compressed
-      expect(compressed[:r].children.size).to eq 2
-
-      expect(compressed[:r][:p].letter).to eq :pa
-      expect(compressed[:r][:p].parent).to eq compressed[:r]
-      expect(compressed[:r][:p].children.size).to eq 2
-
-      expect(compressed[:r][:s].letter).to eq :st
-      expect(compressed[:r][:s].parent).to eq compressed[:r]
-      expect(compressed[:r][:s].children.size).to eq 0
-
-      expect(compressed[:r][:p][:y].letter).to eq :y
-      expect(compressed[:r][:p][:y].parent).to eq compressed[:r][:p]
-      expect(compressed[:r][:p][:y].children.size).to eq 0
-
-      expect(compressed[:r][:p][:i].letter).to eq :int
-      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
-
-      expect(compressed[:y].letter).to eq :you
-
-      expect(compressed[:y][:r].letter).to eq :r
-      expect(compressed[:y][:r]).to be_compressed
-
-      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

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Configuration::Properties do
-  let(:properties) { described_class.new }
-
-  describe '.new' 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],
-        [:yml, Rambling::Trie::Serializers::Yaml],
-        [:zip, Rambling::Trie::Serializers::Zip],
-      ]
-    end
-    # rubocop:enable RSpec/ExampleLength
-
-    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],
-      ]
-    end
-
-    it 'configures the compressor' do
-      compressor = properties.compressor
-      expect(compressor).to be_instance_of Rambling::Trie::Compressor
-    end
-
-    it 'configures the root_builder' do
-      root = properties.root_builder.call
-      expect(root).to be_instance_of Rambling::Trie::Nodes::Raw
-    end
-  end
-
-  describe '#reset' do
-    before do
-      properties.serializers.add :test, 'test'
-      properties.readers.add :test, 'test'
-    end
-
-    # rubocop:disable RSpec/MultipleExpectations
-    it 'resets the serializers to initial values' do
-      expect(properties.serializers.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

@@ -1,177 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Configuration::ProviderCollection do
-  let(:configured_default) { nil }
-  let :configured_providers do
-    { one: first_provider, two: second_provider }
-  end
-
-  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
-    described_class.new(
-      :provider,
-      configured_providers,
-      configured_default,
-    )
-  end
-
-  describe '.new' do
-    it 'has a name' do
-      expect(provider_collection.name).to eq :provider
-    end
-
-    it 'has the given providers' do
-      expect(provider_collection.providers)
-        .to eq one: first_provider, two: second_provider
-    end
-
-    it 'has a default provider' do
-      expect(provider_collection.default).to eq first_provider
-    end
-
-    context 'when a default is provided' do
-      let(:configured_default) { second_provider }
-
-      it 'has that as the default provider' do
-        expect(provider_collection.default).to eq second_provider
-      end
-    end
-  end
-
-  describe 'aliases and delegates' do
-    let(:providers) { provider_collection.providers }
-
-    before do
-      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 do
-      instance_double 'Rambling::Trie::Serializers::Marshal', :provider
-    end
-
-    before do
-      provider_collection.add :three, provider
-    end
-
-    it 'adds a new provider' do
-      expect(provider_collection.providers[:three]).to eq provider
-    end
-  end
-
-  describe '#default=' do
-    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
-        provider_collection.default = second_provider
-        expect(provider_collection.default).to eq second_provider
-      end
-    end
-
-    context 'when the given value is not in the providers list' do
-      it 'raises an error and keeps the default provider' do
-        expect { provider_collection.default = other_provider }
-          .to raise_error(ArgumentError)
-          .and(not_change { provider_collection.default })
-      end
-
-      it 'raises an ArgumentError' do
-        expect { provider_collection.default = other_provider }
-          .to raise_error ArgumentError
-      end
-    end
-
-    context 'when the providers list is empty' do
-      let(:configured_providers) { {} }
-
-      it 'accepts nil' do
-        provider_collection.default = nil
-        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
-      [
-        ['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
-      %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 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 (: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
-end