rambling-trie 2.4.0 → 2.5.1

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

data/spec/support/config.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helpers/add_word'
-require_relative 'helpers/one_line_heredoc'
-
-RSpec.configure do |c|
-  c.before do
-    Rambling::Trie.config.reset
-  end
-
-  c.include Support::Helpers::AddWord
-  c.include Support::Helpers::OneLineHeredoc
-
-  RSpec::Matchers.define_negated_matcher :not_change, :change
-end

data/spec/support/helpers/add_word.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Support
-  module Helpers
-    module AddWord
-      def add_words node, words
-        words.each { |word| add_word node, word }
-      end
-
-      def add_word node, word
-        case node
-        when Rambling::Trie::Container
-          node.add word
-        else
-          node.add word.chars.reverse.map(&:to_sym)
-        end
-      end
-    end
-  end
-end

data/spec/support/helpers/one_line_heredoc.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Support
-  module Helpers
-    module OneLineHeredoc
-      def one_line heredoc
-        heredoc.strip.tr "\n", ' '
-      end
-    end
-  end
-end

data/spec/support/shared_examples/a_compressible_trie.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-shared_examples_for 'a compressible trie' do
-  context 'with an uncompressed trie' do
-    it_behaves_like 'a trie data structure'
-
-    it 'does not alter the input' do
-      word = 'string'
-      add_word trie, word
-
-      expect(word).to eq 'string'
-    end
-
-    it 'is marked as not compressed' do
-      expect(trie).not_to be_compressed
-    end
-  end
-
-  context 'with an compressed trie' do
-    let!(:original_root) { trie.root }
-    let!(:original_keys) { original_root.children_tree.keys }
-    let!(:original_values) { original_root.children_tree.values }
-
-    before do
-      trie.compress!
-    end
-
-    it_behaves_like 'a trie data structure'
-
-    it 'is marked as compressed' do
-      expect(trie).to be_compressed
-    end
-
-    it 'leaves the original root keys intact' do
-      expect(original_root.children_tree.keys).to eq original_keys
-    end
-
-    it 'leaves the original trie keys intact' do
-      expect(trie.children_tree.keys).to eq original_keys
-    end
-
-    it 'leaves the original trie values intact' do
-      expect(trie.children_tree.values).not_to eq original_values
-    end
-  end
-end

data/spec/support/shared_examples/a_container_partial_word.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-shared_examples_for 'a matching container#partial_word' do
-  %w(h he hell hello hi hig high).each do |prefix|
-    it 'matches part of the word' do
-      expect(container.partial_word? prefix).to be true
-    end
-  end
-end
-
-shared_examples_for 'a non-matching container#partial_word' do
-  it 'does not match any part of the word' do
-    %w(ha hal al).each do |word|
-      expect(container.partial_word? word).to be false
-    end
-  end
-end

data/spec/support/shared_examples/a_container_scan.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-shared_examples_for 'a matching container#scan' do
-  [
-    ['hi', %w(hi high highlight histerical)],
-    ['hig', %w(high highlight)],
-  ].each do |test_params|
-    prefix, expected = test_params
-
-    it "returns an array with the words that match '#{prefix}'" do
-      expect(container.scan prefix).to eq expected
-    end
-  end
-end

data/spec/support/shared_examples/a_container_word.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-shared_examples_for 'a matching container#word' do
-  %w(hello high).each do |word|
-    it 'matches the whole word' do
-      expect(container.word? word).to be true
-    end
-  end
-end
-
-shared_examples_for 'a non-matching container#word' do
-  %w(halt al).each do |word|
-    it 'does not match the whole word' do
-      expect(container.word? word).to be false
-    end
-  end
-end
-
-shared_examples_for 'a propagating node' do
-  [
-    [true, 'Rambling::Trie::Nodes::Compressed'],
-    [false, 'Rambling::Trie::Nodes::Raw'],
-  ].each do |test_params|
-    compressed_value, instance_double_class = test_params
-
-    context "when root has compressed=#{compressed_value}" do
-      let :root do
-        instance_double(
-          instance_double_class,
-          :root,
-          compressed?: compressed_value,
-          word?: nil,
-          partial_word?: nil,
-        )
-      end
-
-      it 'calls the root with the word characters' do
-        container.public_send method_name, 'words'
-        expect(root).to have_received(method_name).with %w(w o r d s)
-      end
-    end
-  end
-end

data/spec/support/shared_examples/a_container_words_within.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-shared_examples_for 'a matching container#words_within' do
-  [
-    ['word', %w(word)],
-    ['wordxyz', %w(word)],
-  ].each do |test_params|
-    phrase, expected = test_params
-
-    it "returns an array with the word found in the phrase '#{phrase}'" do
-      expect(container.words_within phrase).to match_array expected
-    end
-  end
-end
-
-shared_examples_for 'a non-matching container#words_within' do
-  it 'returns an array with all words found in the phrase' do
-    expect(container.words_within 'xyzword otherzxyone')
-      .to match_array %w(word other one)
-  end
-end
-
-shared_examples_for 'a matching container#words_within?' do
-  context 'when phrase does not contain any words' do
-    it 'returns false' do
-      expect(container.words_within? 'xyz').to be false
-    end
-  end
-
-  context 'when phrase contains any word' do
-    ['xyz words', 'xyzone word'].each do |phrase|
-      it "returns true for '#{phrase}'" do
-        expect(container.words_within? phrase).to be true
-      end
-    end
-  end
-end
-
-shared_examples_for 'a non-matching container#words_within?' do
-  it 'returns an array with all words found in the phrase' do
-    expect(container.words_within 'xyzword otherzxyone')
-      .to match_array %w(word other one)
-  end
-end

data/spec/support/shared_examples/a_serializable_trie.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-shared_examples_for 'a serializable trie' do
-  let(:tmp_path) { File.join ::SPEC_ROOT, 'tmp' }
-  let(:filepath) { File.join tmp_path, "trie-root.#{file_format}" }
-
-  context 'with an uncompressed trie' do
-    before { Rambling::Trie.dump trie_to_serialize, filepath }
-
-    it_behaves_like 'a compressible trie' do
-      let(:trie) { Rambling::Trie.load filepath }
-    end
-  end
-
-  context 'with an compressed trie' do
-    let(:trie) { Rambling::Trie.load filepath }
-
-    before { Rambling::Trie.dump trie_to_serialize.compress!, filepath }
-
-    it_behaves_like 'a trie data structure'
-
-    it 'is marked as compressed' do
-      expect(trie).to be_compressed
-    end
-  end
-end

data/spec/support/shared_examples/a_serializer.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-shared_examples_for 'a serializer' do
-  subject(:serializer) { described_class.new }
-
-  let(:trie) { Rambling::Trie.create }
-  let(:tmp_path) { File.join ::SPEC_ROOT, 'tmp' }
-  let(:filepath) { File.join tmp_path, "trie-root.#{file_format}" }
-  let(:content) { trie.root }
-
-  before do
-    trie.concat %w(a few words to validate that load and dump are working)
-    FileUtils.rm_f filepath
-  end
-
-  describe '#dump' do
-    [true, false].each do |compress_value|
-      context "with compressed=#{compress_value} trie" do
-        let(:formatted_content) { format_content.call content }
-
-        before { trie.compress! if compress_value }
-
-        it 'returns the size in bytes of the file dumped' do
-          total_bytes = serializer.dump content, filepath
-          expect(total_bytes).to be_within(20).of formatted_content.size
-        end
-
-        it 'creates the file with the provided path' do
-          serializer.dump content, filepath
-          expect(File.exist? filepath).to be true
-        end
-
-        it 'converts the contents to the appropriate format' do
-          serializer.dump content, filepath
-          expect(File.size filepath).to be_within(20).of formatted_content.size
-        end
-      end
-    end
-  end
-
-  describe '#load' do
-    [true, false].each do |compress_value|
-      context "with compressed=#{compress_value} trie" do
-        before do
-          trie.compress! if compress_value
-          serializer.dump content, filepath
-        end
-
-        it 'loads the dumped object back into memory' do
-          expect(serializer.load filepath).to eq content
-        end
-
-        it "loads a compressed=#{compress_value} object" do
-          loaded = serializer.load filepath
-          expect(loaded.compressed?).to be compress_value unless :file == file_format
-        end
-      end
-    end
-  end
-end

data/spec/support/shared_examples/a_trie_data_structure.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-shared_examples_for 'a trie data structure' do
-  it 'contains all the words previously provided' do
-    words.each { |word| expect(trie).to include word }
-  end
-
-  it 'returns true for #word? for all words previously provided' do
-    words.each { |word| expect(trie.word? word).to be true }
-  end
-
-  it 'matches the full word for all words in file' do
-    words.each { |word| expect(trie.match? word).to be true }
-  end
-
-  it 'matches the start of all the words in file' do
-    words.each { |word| expect(trie.match? word[0..-2]).to be true }
-  end
-
-  it 'returns true for #partial_word? with full word for all words in file' do
-    words.each { |word| expect(trie.partial_word? word).to be true }
-  end
-
-  it 'returns true for #partial_word? with the start of all words in file' do
-    words.each { |word| expect(trie.partial_word? word[0..-2]).to be true }
-  end
-
-  it 'extracts words within larger strings' do
-    words.each do |word|
-      phrase = "x#{word}y"
-      expect(trie.words_within phrase).to include word
-    end
-  end
-
-  it 'identifies words within larger strings' do
-    words.each do |word|
-      phrase = "x#{word}y"
-      expect(trie.words_within? phrase).to be true
-    end
-  end
-
-  it 'allows iterating over all the words' do
-    expect(trie.to_a.sort).to eq words.sort
-  end
-end