rambling-trie 2.4.0 → 2.5.0

data/spec/lib/rambling/trie/nodes/raw_spec.rb

@@ -1,184 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Nodes::Raw do
-  let(:node) { described_class.new }
-
-  describe '#new' do
-    it 'is not a word' do
-      expect(node).not_to be_word
-    end
-  end
-
-  it_behaves_like 'a trie node implementation' do
-    def add_word_to_tree word
-      add_word node, word
-    end
-
-    def add_words_to_tree words
-      add_words node, words
-    end
-
-    def assign_letter letter
-      node.letter = letter
-    end
-  end
-
-  describe '#compressed?' do
-    it 'returns false' do
-      expect(node).not_to be_compressed
-    end
-  end
-
-  describe '#add' do
-    context 'when the node has no branches' do
-      before { add_word node, 'abc' }
-
-      it 'adds only one child' do
-        expect(node.children.size).to eq 1
-      end
-
-      # rubocop:disable RSpec/MultipleExpectations
-      it 'adds the full subtree' do
-        expect(node[:a]).not_to be_nil
-        expect(node[:a][:b]).not_to be_nil
-        expect(node[:a][:b][:c]).not_to be_nil
-      end
-      # rubocop:enable RSpec/MultipleExpectations
-
-      # rubocop:disable RSpec/MultipleExpectations
-      it 'marks only the last child as terminal' do
-        expect(node).not_to be_terminal
-        expect(node[:a]).not_to be_terminal
-        expect(node[:a][:b]).not_to be_terminal
-        expect(node[:a][:b][:c]).to be_terminal
-      end
-      # rubocop:enable RSpec/MultipleExpectations
-    end
-
-    context 'when a word is added more than once' do
-      before do
-        add_word node, 'ack'
-        add_word node, 'ack'
-      end
-
-      # rubocop:disable RSpec/MultipleExpectations
-      it 'only counts it once' do
-        expect(node.children.size).to eq 1
-        expect(node[:a].children.size).to eq 1
-        expect(node[:a][:c].children.size).to eq 1
-        expect(node[:a][:c][:k].children.size).to eq 0
-      end
-      # rubocop:enable RSpec/MultipleExpectations
-
-      # rubocop:disable RSpec/MultipleExpectations
-      it 'does not change the terminal nodes in the tree' do
-        expect(node).not_to be_terminal
-        expect(node[:a]).not_to be_terminal
-        expect(node[:a][:c]).not_to be_terminal
-        expect(node[:a][:c][:k]).to be_terminal
-      end
-      # rubocop:enable RSpec/MultipleExpectations
-
-      it 'still returns the "added" node' do
-        child = add_word node, 'ack'
-        expect(child.letter).to eq :a
-      end
-    end
-
-    context 'when the word does not exist in the tree but the letters do' do
-      before { add_words node, %w(ack a) }
-
-      it 'does not add another branch' do
-        expect(node.children.size).to eq 1
-      end
-
-      # rubocop:disable RSpec/MultipleExpectations
-      it 'marks the corresponding node as terminal' do
-        expect(node).not_to be_terminal
-        expect(node[:a]).to be_terminal
-        expect(node[:a][:c]).not_to be_terminal
-        expect(node[:a][:c][:k]).to be_terminal
-      end
-      # rubocop:enable RSpec/MultipleExpectations
-
-      it 'returns the added node' do
-        child = add_word node, 'a'
-        expect(child.letter).to eq :a
-      end
-    end
-
-    context 'when the node has a letter and a parent' do
-      let(:parent) { described_class.new }
-      let(:node) { described_class.new :a, parent }
-
-      context 'when adding an empty string' do
-        before { add_word node, '' }
-
-        it 'does not alter the node letter' do
-          expect(node.letter).to eq :a
-        end
-
-        it 'does not change the node children' do
-          expect(node.children.size).to eq 0
-        end
-
-        it 'changes the node to terminal' do
-          expect(node).to be_terminal
-        end
-      end
-
-      context 'when adding a one letter word' do
-        before { add_word node, 'b' }
-
-        it 'does not alter the node letter' do
-          expect(node.letter).to eq :a
-        end
-
-        # rubocop:disable RSpec/MultipleExpectations
-        it 'adds a child with the expected letter' do
-          expect(node.children.size).to eq 1
-          expect(node.children.first.letter).to eq :b
-        end
-        # rubocop:enable RSpec/MultipleExpectations
-
-        it 'reports it has the expected letter a key' do
-          expect(node).to have_key(:b)
-        end
-
-        it 'returns the child corresponding to the key' do
-          expect(node[:b]).to eq node.children_tree[:b]
-        end
-
-        it 'does not mark itself as terminal' do
-          expect(node).not_to be_terminal
-        end
-
-        it 'marks the first child as terminal' do
-          expect(node[:b]).to be_terminal
-        end
-      end
-
-      context 'when adding a large word' do
-        before { add_word node, 'mplified' }
-
-        it 'marks the last letter as terminal' do
-          expect(node[:m][:p][:l][:i][:f][:i][:e][:d]).to be_terminal
-        end
-
-        # rubocop:disable RSpec/ExampleLength, RSpec/MultipleExpectations
-        it 'does not mark any other letter as terminal' do
-          expect(node[:m][:p][:l][:i][:f][:i][:e]).not_to be_terminal
-          expect(node[:m][:p][:l][:i][:f][:i]).not_to be_terminal
-          expect(node[:m][:p][:l][:i][:f]).not_to be_terminal
-          expect(node[:m][:p][:l][:i]).not_to be_terminal
-          expect(node[:m][:p][:l]).not_to be_terminal
-          expect(node[:m][:p]).not_to be_terminal
-          expect(node[:m]).not_to be_terminal
-        end
-        # rubocop:enable RSpec/ExampleLength, RSpec/MultipleExpectations
-      end
-    end
-  end
-end

data/spec/lib/rambling/trie/readers/plain_text_spec.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Readers::PlainText do
-  subject(:reader) { described_class.new }
-
-  describe '#each_word' do
-    let(:filepath) { File.join(::SPEC_ROOT, 'assets', 'test_words.en_US.txt') }
-    let(:words) { File.readlines(filepath).map(&:chomp) }
-
-    it 'yields every word yielded by the file' do
-      yielded = []
-      reader.each_word(filepath) { |word| yielded << word }
-      expect(yielded).to eq words
-    end
-
-    it 'returns an enumerator when no block is given' do
-      expect(reader.each_word filepath).to be_an Enumerator
-    end
-
-    it 'returns the enumerable when a block is given' do
-      expect(reader.each_word(filepath) { |_| }).to eq reader
-    end
-  end
-end

data/spec/lib/rambling/trie/readers/reader_spec.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Readers::Reader do
-  subject(:reader) { described_class.new }
-
-  describe '#load' do
-    it 'is an abstract method that raises NotImplementedError' do
-      expect { reader.each_word('any-file.zip') }
-        .to raise_exception NotImplementedError
-    end
-  end
-end

data/spec/lib/rambling/trie/serializers/file_spec.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Serializers::File do
-  it_behaves_like 'a serializer' do
-    let(:file_format) { :file }
-    let(:content) { trie.to_a.join ' ' }
-    let(:format_content) { ->(content) { content } }
-  end
-end

data/spec/lib/rambling/trie/serializers/marshal_spec.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Serializers::Marshal do
-  it_behaves_like 'a serializer' do
-    let(:file_format) { :marshal }
-    let(:format_content) { Marshal.method(:dump) }
-  end
-end

data/spec/lib/rambling/trie/serializers/serializer_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Serializers::Serializer do
-  subject(:serializer) { described_class.new }
-
-  describe '#load' do
-    it 'is an abstract method that raises NotImplementedError' do
-      expect { serializer.load('any-file.zip') }
-        .to raise_exception NotImplementedError
-    end
-  end
-
-  describe '#dump' do
-    it 'is an abstract method that raises NotImplementedError' do
-      expect { serializer.dump('any contents', 'any-file.zip') }
-        .to raise_exception NotImplementedError
-    end
-  end
-end

data/spec/lib/rambling/trie/serializers/yaml_spec.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Serializers::Yaml do
-  it_behaves_like 'a serializer' do
-    let(:file_format) { :yml }
-    let(:format_content) { YAML.method(:dump) }
-  end
-end

data/spec/lib/rambling/trie/serializers/zip_spec.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Serializers::Zip do
-  {
-    yaml: YAML.method(:dump),
-    yml: YAML.method(:dump),
-    marshal: Marshal.method(:dump),
-    file: Marshal.method(:dump),
-  }.each do |file_format, dump_method|
-    context "with '.#{file_format}'" do
-      it_behaves_like 'a serializer' do
-        let(:properties) { Rambling::Trie::Configuration::Properties.new }
-        let(:serializer) { described_class.new properties }
-        let(:file_format) { :zip }
-
-        let(:filepath) { File.join tmp_path, "trie-root.#{file_format}.zip" }
-        let(:format_content) { ->(content) { zip dump_method.call content } }
-        let(:filename) { File.basename(filepath).gsub %r{\.zip}, '' }
-
-        before { properties.tmp_path = tmp_path }
-      end
-    end
-  end
-
-  def zip content
-    cursor = Zip::OutputStream.write_buffer do |io|
-      io.put_next_entry filename
-      io.write content
-    end
-
-    cursor.rewind
-    cursor.read
-  end
-end

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

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Stringifyable do
-  describe '#as_word' do
-    let(:node) { Rambling::Trie::Nodes::Raw.new }
-
-    context 'with an empty node' do
-      before { add_word node, '' }
-
-      it 'returns nil' do
-        expect(node.as_word).to be_empty
-      end
-    end
-
-    context 'with one letter' do
-      before do
-        node.letter = :a
-        add_word node, ''
-      end
-
-      it 'returns the expected one letter word' do
-        expect(node.as_word).to eq 'a'
-      end
-    end
-
-    context 'with a small word' do
-      before do
-        node.letter = :a
-        add_word node, 'll'
-      end
-
-      it 'returns the expected small word' do
-        expect(node[:l][:l].as_word).to eq 'all'
-      end
-
-      it 'raises an error for a non terminal node' do
-        expect { node[:l].as_word }
-          .to raise_error Rambling::Trie::InvalidOperation
-      end
-    end
-
-    context 'with a long word' do
-      before do
-        node.letter = :b
-        add_word node, 'eautiful'
-      end
-
-      it 'returns the expected long word' do
-        expect(node[:e][:a][:u][:t][:i][:f][:u][:l].as_word).to eq 'beautiful'
-      end
-    end
-
-    context 'with a node with nil letter' do
-      let(:node) { Rambling::Trie::Nodes::Raw.new nil }
-
-      it 'returns nil' do
-        expect(node.as_word).to be_empty
-      end
-    end
-
-    context 'with a compressed node' do
-      let(:compressor) { Rambling::Trie::Compressor.new }
-      let(:compressed_node) { compressor.compress node }
-
-      before do
-        node.letter = :a
-        add_words node, %w(m dd)
-      end
-
-      [
-        [:m, 'am'],
-        [:d, 'add'],
-      ].each do |test_params|
-        key, expected = test_params
-
-        it "returns the words for terminal nodes (#{key} => #{expected})" do
-          expect(compressed_node[key].as_word).to eq expected
-        end
-      end
-
-      it 'raises an error for non terminal nodes' do
-        expect { compressed_node.as_word }
-          .to raise_error Rambling::Trie::InvalidOperation
-      end
-    end
-  end
-end

data/spec/lib/rambling/trie_spec.rb

@@ -1,244 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie do
-  describe '.create' do
-    let(:root) { Rambling::Trie::Nodes::Raw.new }
-    let(:compressor) { Rambling::Trie::Compressor.new }
-    let!(:container) { Rambling::Trie::Container.new root, compressor }
-
-    before do
-      allow(Rambling::Trie::Container).to receive(:new)
-        .and_yield(container)
-        .and_return container
-    end
-
-    it 'returns a new instance of the trie container' do
-      expect(described_class.create).to eq container
-    end
-
-    context 'with a block' do
-      it 'yields the new container' do
-        yielded = nil
-        described_class.create { |trie| yielded = trie }
-        expect(yielded).to eq container
-      end
-    end
-
-    context 'with a filepath' do
-      let(:filepath) { 'a test filepath' }
-      let :reader do
-        instance_double 'Rambling::Trie::Readers::PlainText', :reader
-      end
-      let(:words) { %w(a couple of test words over here) }
-
-      before do
-        receive_and_yield = receive(:each_word)
-        words.inject receive_and_yield do |yielder, word|
-          yielder.and_yield word
-        end
-
-        allow(reader).to receive_and_yield
-        allow(container).to receive :<<
-      end
-
-      it 'loads every word' do
-        described_class.create filepath, reader
-
-        words.each do |word|
-          expect(container).to have_received(:<<).with word
-        end
-      end
-    end
-
-    context 'without any reader' do
-      let(:filepath) { 'a test filepath' }
-      let :reader do
-        instance_double(
-          'Rambling::Trie::Readers::PlainText',
-          :reader,
-          each_word: nil,
-        )
-      end
-
-      before do
-        described_class.config do |c|
-          c.readers.add :default, reader
-          c.readers.default = reader
-        end
-      end
-
-      it 'defaults to a plain text reader' do
-        described_class.create filepath, nil
-
-        expect(reader).to have_received(:each_word).with filepath
-      end
-    end
-  end
-
-  describe '.load' do
-    let(:filepath) { 'a path to a file' }
-    let(:root) { Rambling::Trie::Nodes::Raw.new }
-    let(:compressor) { Rambling::Trie::Compressor.new }
-    let(:container) { Rambling::Trie::Container.new root, compressor }
-    let :serializer do
-      instance_double(
-        'Rambling::True::Serializers::File',
-        :serializer,
-        load: root,
-      )
-    end
-
-    it 'returns a new container with the loaded root node' do
-      trie = described_class.load filepath, serializer
-      expect(trie).to eq container
-    end
-
-    it 'uses the serializer to load the root node from the given filepath' do
-      described_class.load filepath, serializer
-      expect(serializer).to have_received(:load).with filepath
-    end
-
-    context 'without a serializer' do
-      let :marshal_serializer do
-        instance_double(
-          'Rambling::Trie::Serializers::Marshal',
-          :marshal_serializer,
-          load: nil,
-        )
-      end
-      let :default_serializer do
-        instance_double(
-          'Rambling::Trie::Serializers::File',
-          :default_serializer,
-          load: nil,
-        )
-      end
-      let :yaml_serializer do
-        instance_double(
-          'Rambling::Trie::Serializers::Yaml',
-          :yaml_serializer,
-          load: nil,
-        )
-      end
-
-      before do
-        described_class.config do |c|
-          c.serializers.add :default, default_serializer
-          c.serializers.add :marshal, marshal_serializer
-          c.serializers.add :yml, yaml_serializer
-          c.serializers.add :yaml, yaml_serializer
-
-          c.serializers.default = default_serializer
-        end
-      end
-
-      [
-        ['.marshal', :marshal_serializer],
-        ['.yml', :yaml_serializer],
-        ['.yaml', :yaml_serializer],
-        ['', :default_serializer],
-      ].each do |test_params|
-        extension, serializer = test_params
-        filepath = "test#{extension}"
-
-        it "uses extension-based serializer (#{filepath} -> #{serializer})" do
-          serializer_instance = public_send serializer
-
-          described_class.load filepath
-          expect(serializer_instance).to have_received(:load).with filepath
-        end
-      end
-    end
-
-    context 'with a block' do
-      it 'yields the new container' do
-        yielded = nil
-
-        described_class.load filepath, serializer do |trie|
-          yielded = trie
-        end
-
-        expect(yielded).to eq container
-      end
-    end
-  end
-
-  describe '.dump' do
-    let(:filename) { 'a trie' }
-    let(:root) { instance_double 'Rambling::Trie::Serializers::Marshal', :root }
-    let :compressor do
-      instance_double 'Rambling::Trie::Serializers::Marshal', :compressor
-    end
-    let(:trie) { Rambling::Trie::Container.new root, compressor }
-
-    let :marshal_serializer do
-      instance_double(
-        'Rambling::Trie::Serializers::Marshal',
-        :marshal_serializer,
-        dump: nil,
-      )
-    end
-    let :yaml_serializer do
-      instance_double(
-        'Rambling::Trie::Serializers::Yaml',
-        :yaml_serializer,
-        dump: nil,
-      )
-    end
-    let :default_serializer do
-      instance_double(
-        'Rambling::Trie::Serializers::File',
-        :default_serializer,
-        dump: nil,
-      )
-    end
-
-    before do
-      described_class.config do |c|
-        c.serializers.add :default, default_serializer
-        c.serializers.add :marshal, marshal_serializer
-        c.serializers.add :yml, yaml_serializer
-
-        c.serializers.default = default_serializer
-      end
-    end
-
-    it 'uses the configured default serializer by default' do
-      described_class.dump trie, filename
-      expect(default_serializer).to have_received(:dump).with root, filename
-    end
-
-    context 'when provided with a format' do
-      [
-        ['.marshal', :marshal_serializer],
-        ['.yml', :yaml_serializer],
-        ['', :default_serializer],
-      ].each do |test_params|
-        extension, serializer = test_params
-
-        it 'uses the corresponding serializer' do
-          filepath = "#{filename}#{extension}"
-          serializer_instance = public_send serializer
-
-          described_class.dump trie, filepath
-          expect(serializer_instance).to have_received(:dump)
-            .with root, filepath
-        end
-      end
-    end
-  end
-
-  describe '.config' do
-    it 'returns the properties' do
-      expect(described_class.config).to eq described_class.send :properties
-    end
-
-    it 'yields the properties' do
-      yielded = nil
-      described_class.config { |c| yielded = c }
-      expect(yielded).to eq described_class.send :properties
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-require 'simplecov'
-
-COVERAGE_FILTER = %r{/spec/}.freeze
-
-if ENV.key? 'COVERALLS_REPO_TOKEN'
-  require 'coveralls'
-
-  SimpleCov.formatters = [
-    SimpleCov::Formatter::HTMLFormatter,
-    Coveralls::SimpleCov::Formatter,
-  ]
-
-  Coveralls.wear! { add_filter COVERAGE_FILTER }
-else
-  SimpleCov.start { add_filter COVERAGE_FILTER }
-end
-
-require 'rspec'
-require 'rambling-trie'
-::SPEC_ROOT = File.dirname __FILE__
-
-RSpec.configure do |config|
-  config.color = true
-  config.tty = true
-  config.formatter = :documentation
-  config.order = :random
-  config.filter_run_when_matching :focus
-  config.raise_errors_for_deprecations!
-end
-
-require 'support/config'
-
-%w(
-  a_compressible_trie a_serializable_trie a_serializer a_trie_data_structure
-  a_trie_node a_trie_node_implementation a_container_scan a_container_word
-  a_container_partial_word a_container_words_within
-).each do |name|
-  require File.join('support', 'shared_examples', name)
-end