rambling-trie 2.4.0 → 2.5.0

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

data/spec/support/shared_examples/a_trie_node.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-shared_examples_for 'a trie node' do
-  let(:node_class) { node.class }
-
-  describe '.new' do
-    it 'has no letter' do
-      expect(node.letter).to be_nil
-    end
-
-    it 'has no children' do
-      expect(node.children.size).to eq 0
-    end
-
-    it 'is not terminal' do
-      expect(node).not_to be_terminal
-    end
-
-    it 'returns empty string as its word' do
-      expect(node.as_word).to be_empty
-    end
-
-    context 'with a letter and a parent' do
-      let(:parent) { node_class.new }
-      # noinspection RubyArgCount
-      let(:node_with_parent) { node_class.new :a, parent }
-
-      it 'does not have any letter' do
-        expect(node_with_parent.letter).to eq :a
-      end
-
-      it 'has no children' do
-        expect(node_with_parent.children.size).to eq 0
-      end
-
-      it 'is not terminal' do
-        expect(node_with_parent).not_to be_terminal
-      end
-    end
-  end
-
-  describe '#root?' do
-    context 'when the node has a parent' do
-      before { node.parent = node }
-
-      it 'returns false' do
-        expect(node).not_to be_root
-      end
-    end
-
-    context 'when the node does not have a parent' do
-      before { node.parent = nil }
-
-      it 'returns true' do
-        expect(node).to be_root
-      end
-    end
-  end
-
-  describe '#terminal!' do
-    # rubocop:disable RSpec/MultipleExpectations
-    it 'forces the node to be terminal' do
-      expect(node).not_to be_terminal
-      node.terminal!
-      expect(node).to be_terminal
-    end
-    # rubocop:enable RSpec/MultipleExpectations
-
-    it 'returns the node' do
-      expect(node.terminal!).to eq node
-    end
-  end
-
-  describe 'delegates and aliases' do
-    let :children_tree do
-      instance_double(
-        'Hash',
-        :children_tree,
-        :[] => 'value',
-        :[]= => nil,
-        key?: false,
-        delete: true,
-      )
-    end
-
-    before { node.children_tree = children_tree }
-
-    # rubocop:disable RSpec/MultipleExpectations
-    it 'delegates `#[]` to its children tree' do
-      expect(node[:key]).to eq 'value'
-      expect(children_tree).to have_received(:[]).with :key
-    end
-    # rubocop:enable RSpec/MultipleExpectations
-
-    it 'delegates `#[]=` to its children tree' do
-      node[:key] = 'value'
-      expect(children_tree).to have_received(:[]=).with(:key, 'value')
-    end
-
-    # rubocop:disable RSpec/MultipleExpectations
-    it 'delegates `#key?` to its children tree' do
-      allow(children_tree).to receive(:key?)
-        .with(:present_key)
-        .and_return true
-
-      expect(node).to have_key(:present_key)
-      expect(node).not_to have_key(:absent_key)
-    end
-    # rubocop:enable RSpec/MultipleExpectations
-
-    # rubocop:disable RSpec/MultipleExpectations
-    it 'delegates `#delete` to its children tree' do
-      expect(node.delete :key).to be true
-      expect(children_tree).to have_received(:delete).with :key
-    end
-    # rubocop:enable RSpec/MultipleExpectations
-
-    # rubocop:disable RSpec/ExampleLength
-    it 'delegates `#children` to its children tree values' do
-      children = [
-        instance_double('Rambling::Trie::Nodes::Node', :child_one),
-        instance_double('Rambling::Trie::Nodes::Node', :child_two),
-      ]
-      allow(children_tree).to receive(:values).and_return children
-
-      expect(node.children).to eq children
-    end
-    # rubocop:enable RSpec/ExampleLength
-
-    it 'aliases `#has_key?` to `#key?`' do
-      node.has_key? :nope
-      expect(children_tree).to have_received(:key?).with :nope
-    end
-  end
-end

data/spec/support/shared_examples/a_trie_node_implementation.rb

@@ -1,149 +0,0 @@
-# frozen_string_literal: true
-
-shared_examples_for 'a trie node implementation' do
-  it_behaves_like 'a trie node'
-
-  describe '#partial_word?' do
-    context 'when the chars array is empty' do
-      it 'returns true' do
-        expect(node.partial_word? []).to be true
-      end
-    end
-
-    context 'when the chars array is not empty' do
-      context 'when the node has a tree that matches the characters' do
-        before { add_word_to_tree 'abc' }
-
-        [%w(a), %w(a b), %w(a b c)].each do |letters|
-          it "returns true for '#{letters}'" do
-            expect(node.partial_word? letters).to be true
-          end
-        end
-      end
-
-      context 'when the node has a tree that does not match the characters' do
-        before { add_word_to_tree 'cba' }
-
-        [%w(a), %w(a b), %w(a b c)].each do |letters|
-          it "returns false for '#{letters}'" do
-            expect(node.partial_word? letters).to be false
-          end
-        end
-      end
-    end
-  end
-
-  describe '#word?' do
-    context 'when the chars array is empty' do
-      context 'when the node is terminal' do
-        before { node.terminal! }
-
-        it 'returns true' do
-          expect(node.word? []).to be true
-        end
-      end
-
-      context 'when the node is not terminal' do
-        it 'returns false' do
-          expect(node.word? []).to be false
-        end
-      end
-    end
-
-    context 'when the chars array is not empty' do
-      context 'when the node has a tree that matches all the characters' do
-        before { add_word_to_tree 'abc' }
-
-        it 'returns true' do
-          expect(node.word? %w(a b c).map(&:dup)).to be true
-        end
-      end
-
-      context 'when the node subtree does not match all the characters' do
-        before { add_word_to_tree 'abc' }
-
-        [%w(a), %w(a b)].each do |letters|
-          it "returns false for '#{letters}'" do
-            expect(node.word? letters.map(&:dup)).to be false
-          end
-        end
-      end
-    end
-  end
-
-  describe '#scan' do
-    context 'when the chars array is empty' do
-      it 'returns itself' do
-        expect(node.scan []).to eq node
-      end
-    end
-
-    context 'when the chars array is not empty' do
-      before { add_words_to_tree %w(cba ccab) }
-
-      context 'when the chars are found' do
-        [
-          [%w(c), %w(cba ccab)],
-          [%w(c b), %w(cba)],
-          [%w(c b a), %w(cba)],
-        ].each do |test_params|
-          letters, expected = test_params
-
-          it "returns the corresponding children (#{letters} => #{expected})" do
-            expect(node.scan letters).to match_array expected
-          end
-        end
-      end
-
-      context 'when the chars are not found' do
-        [
-          %w(a),
-          %w(a b),
-          %w(a b c),
-          %w(c a),
-          %w(c c b),
-          %w(c b a d),
-        ].each do |letters|
-          it "returns a Nodes::Missing for '#{letters}'" do
-            expect(node.scan letters).to be_a Rambling::Trie::Nodes::Missing
-          end
-        end
-      end
-    end
-  end
-
-  describe '#match_prefix' do
-    before do
-      assign_letter :i
-      add_words_to_tree %w(gnite mport mportant mportantly)
-    end
-
-    context 'when the node is terminal' do
-      before { node.terminal! }
-
-      it 'adds itself to the words' do
-        expect(node.match_prefix %w(g n i t e)).to include 'i'
-      end
-    end
-
-    context 'when the node is not terminal' do
-      it 'does not add itself to the words' do
-        expect(node.match_prefix %w(g n i t e)).not_to include 'i'
-      end
-    end
-
-    context 'when the first few chars match a terminal node' do
-      it 'adds those terminal nodes to the words' do
-        words = node.match_prefix(%w(m p o r t a n t l y)).to_a
-        expect(words).to include 'import', 'important', 'importantly'
-      end
-    end
-
-    context 'when the first few chars do not match a terminal node' do
-      it 'does not add any other words found' do
-        words = node.match_prefix(%w(m p m p o r t a n t l y)).to_a
-        expect(words).not_to include 'import', 'important', 'importantly'
-      end
-    end
-  end
-end