rambling-trie-opal 2.1.1

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+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 }
+
+    context 'when the nodes do not have the same letter' do
+      before do
+        node_1.letter = :a
+        node_2.letter = :b
+      end
+
+      it 'returns false' do
+        expect(node_1).not_to eq node_2
+      end
+    end
+
+    context 'when the nodes have the same letter and no children' do
+      before do
+        node_1.letter = :a
+        node_2.letter = :a
+      end
+
+      it 'returns true' do
+        expect(node_1).to eq node_2
+      end
+    end
+
+    context 'when the nodes have the same letter and are terminal' do
+      before do
+        node_1.letter = :a
+        node_1.terminal!
+
+        node_2.letter = :a
+        node_2.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
+      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_2.letter = :a
+      end
+      it 'returns false' do
+        expect(node_1).not_to eq node_2
+      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_2.letter = :t
+        add_words node_2, %w(hese hree hings)
+      end
+
+      it 'returns true' do
+        expect(node_1).to eq node_2
+      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_2.letter = :t
+        add_words node_2, %w(hese hree hings)
+      end
+
+      it 'returns false' do
+        expect(node_1).not_to eq node_2
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Rambling::Trie::Compressor do
+  let(:compressor) { Rambling::Trie::Compressor.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 do
+        add_words node, %w(all the words)
+      end
+
+      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 do
+        add_word node, 'all'
+      end
+
+      it 'compresses into a single node without children' do
+        compressed = compressor.compress node
+
+        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
+      end
+    end
+
+    context 'with two words' do
+      before do
+        add_words node, %w(all ask)
+      end
+
+      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
+    end
+
+    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
+
+    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
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Rambling::Trie::Configuration::Properties do
+  let(:properties) { Rambling::Trie::Configuration::Properties.new }
+
+  describe '.new' do
+    it 'configures the serializers' do
+      serializers = properties.serializers
+
+      expect(serializers.formats).to match_array %i(marshal yaml yml)
+      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
+
+    it 'configures the readers' do
+      readers = properties.readers
+
+      expect(readers.formats).to match_array %i(txt)
+      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
+
+    it 'resets the serializers and readers 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
+      expect(properties.readers.formats).not_to include :test
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+# 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) { double :first_provider }
+  let(:second_provider) { double :second_provider }
+
+  let(:provider_collection) do
+    Rambling::Trie::Configuration::ProviderCollection.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
+
+    it 'delegates `#[]` to providers' do
+      expect(provider_collection[:key]).to eq 'value'
+      expect(providers).to have_received(:[]).with :key
+    end
+
+    it 'aliases `#formats` to `providers#keys`' do
+      expect(provider_collection.formats).to eq %i(a b)
+      expect(providers).to have_received :keys
+    end
+  end
+
+  describe '#add' do
+    let(:provider) { double :provider }
+
+    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) { double :other_provider }
+
+    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
+
+      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
+    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
+      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
+      end
+    end
+  end
+
+  describe '#reset' do
+    let(:configured_default) { second_provider }
+    let(:provider) { double :provider }
+
+    before do
+      provider_collection.add :three, provider
+      provider_collection.default = provider
+    end
+
+    it 'resets to back to the initially configured values' do
+      provider_collection.reset
+      expect(provider_collection[:three]).to be_nil
+      expect(provider_collection.default).to eq second_provider
+    end
+  end
+end

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

@@ -0,0 +1,591 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Rambling::Trie::Container do
+  let(:container) { Rambling::Trie::Container.new root, compressor }
+  let(:compressor) { Rambling::Trie::Compressor.new }
+  let(:root) { Rambling::Trie::Nodes::Raw.new }
+
+  describe '.new' do
+    it 'uses the provided node as root' do
+      expect(container.root).to be root
+    end
+
+    context 'with a block' do
+      it 'yields the container' do
+        yielded = nil
+
+        container = Rambling::Trie::Container.new root, compressor do |c|
+          yielded = c
+        end
+
+        expect(yielded).to be container
+      end
+    end
+  end
+
+  describe '#add' do
+    it 'adds the word to the root node' do
+      add_word container, 'hello'
+
+      expect(root.children.size).to eq 1
+      expect(root.to_a).to eq %w(hello)
+    end
+  end
+
+  describe '#concat' do
+    it 'adds all the words to the root node' do
+      container.concat %w(other words)
+
+      expect(root.children.size).to eq 2
+      expect(root.to_a).to eq %w(other words)
+    end
+
+    it 'returns all the corresponding nodes' do
+      nodes = container.concat %w(other words)
+
+      expect(nodes.first.letter).to eq :o
+      expect(nodes.last.letter).to eq :w
+    end
+  end
+
+  describe '#compress!' do
+    let(:node) { Rambling::Trie::Nodes::Compressed.new }
+
+    before do
+      allow(compressor).to receive(:compress).and_return node
+
+      add_word root, 'yes'
+      node[:yes] = Rambling::Trie::Nodes::Compressed.new
+    end
+
+    it 'compresses the trie using the compressor' do
+      container.compress!
+
+      expect(compressor).to have_received(:compress).with root
+    end
+
+    it 'changes to the root returned by the compressor' do
+      container.compress!
+
+      expect(container.root).not_to eq root
+      expect(container.root).to eq node
+    end
+
+    it 'returns itself' do
+      expect(container.compress!).to eq container
+    end
+
+    it 'does not compress multiple times' do
+      container.compress!
+      allow(node).to receive(:compressed?).and_return(true)
+
+      container.compress!
+      expect(compressor).to have_received(:compress).once
+    end
+  end
+
+  describe '#compress' do
+    let(:node) { Rambling::Trie::Nodes::Compressed.new }
+
+    before do
+      allow(compressor).to receive(:compress).and_return node
+
+      add_word root, 'yes'
+      node[:yes] = Rambling::Trie::Nodes::Compressed.new
+    end
+
+    it 'compresses the trie using the compressor' do
+      container.compress
+
+      expect(compressor).to have_received(:compress).with root
+    end
+
+    it 'returns a container with the new root' do
+      new_container = container.compress
+
+      expect(new_container.root).not_to eq root
+      expect(new_container.root).to eq node
+    end
+
+    it 'returns a new container' do
+      expect(container.compress).not_to eq container
+    end
+
+    it 'can compress multiple times' do
+      container.compress
+      container.compress
+
+      expect(compressor).to have_received(:compress).twice
+    end
+
+    it 'cannot compress the result' do
+      new_container = container.compress
+      new_container.compress
+
+      expect(compressor).to have_received(:compress).once
+    end
+  end
+
+  describe '#word?' do
+    let(:root) do
+      double :root,
+        compressed?: compressed,
+        word?: nil
+    end
+
+    context 'for an uncompressed root' do
+      let(:compressed) { true }
+
+      it 'calls the root with the word characters' do
+        container.word? 'words'
+        expect(root).to have_received(:word?).with %w(w o r d s)
+      end
+    end
+
+    context 'for a compressed root' do
+      let(:compressed) { false }
+
+      it 'calls the root with the full word' do
+        container.word? 'words'
+        expect(root).to have_received(:word?).with %w(w o r d s)
+      end
+    end
+  end
+
+  describe '#partial_word?' do
+    let(:root) do
+      double :root,
+        compressed?: compressed,
+        partial_word?: nil
+    end
+
+    context 'for an uncompressed root' do
+      let(:compressed) { true }
+
+      it 'calls the root with the word characters' do
+        container.partial_word? 'words'
+        expect(root).to have_received(:partial_word?).with %w(w o r d s)
+      end
+    end
+
+    context 'for a compressed root' do
+      let(:compressed) { false }
+
+      it 'calls the root with the word characters' do
+        container.partial_word? 'words'
+        expect(root).to have_received(:partial_word?).with %w(w o r d s)
+      end
+    end
+  end
+
+  describe 'delegates and aliases' do
+    before do
+      allow(root).to receive_messages(
+        :[] => nil,
+        add: nil,
+        as_word: nil,
+        children: nil,
+        children_tree: nil,
+        compressed?: nil,
+        each: nil,
+        key?: nil,
+        inspect: nil,
+        letter: nil,
+        parent: nil,
+        partial_word?: nil,
+        scan: nil,
+        size: nil,
+        to_s: nil,
+        word?: nil,
+      )
+    end
+
+    it 'aliases `#include?` to `#word?`' do
+      container.include? 'words'
+      expect(root).to have_received(:word?).with %w(w o r d s)
+    end
+
+    it 'aliases `#match?` to `#partial_word?`' do
+      container.match? 'words'
+      expect(root).to have_received(:partial_word?).with %w(w o r d s)
+    end
+
+    it 'aliases `#words` to `#scan`' do
+      container.words 'hig'
+      expect(root).to have_received(:scan).with %w(h i g)
+    end
+
+    it 'aliases `#<<` to `#add`' do
+      container << 'words'
+      expect(root).to have_received(:add).with %i(s d r o w)
+    end
+
+    it 'delegates `#[]` to the root node' do
+      container[:yep]
+      expect(root).to have_received(:[]).with :yep
+    end
+
+    it 'delegates `#children` to the root node' do
+      container.children
+      expect(root).to have_received :children
+    end
+
+    it 'delegates `#children_tree` to the root node' do
+      container.children_tree
+      expect(root).to have_received :children_tree
+    end
+
+    it 'delegates `#compressed?` to the root node' do
+      container.compressed?
+      expect(root).to have_received :compressed?
+    end
+
+    it 'delegates `#key?` to the root node' do
+      container.key? :yup
+      expect(root).to have_received(:key?).with :yup
+    end
+
+    it 'aliases `#has_key?` to `#key?`' do
+      container.has_key? :yup
+      expect(root).to have_received(:key?).with :yup
+    end
+
+    it 'aliases `#has_letter?` to `#has_key?`' do
+      container.has_letter? :yup
+      expect(root).to have_received(:key?).with :yup
+    end
+
+    it 'delegates `#inspect` to the root node' do
+      container.inspect
+      expect(root).to have_received :inspect
+    end
+
+    it 'delegates `#size` to the root node' do
+      container.size
+      expect(root).to have_received :size
+    end
+  end
+
+  describe '#compress!' do
+    it 'gets a new root from the compressor' do
+      container.compress!
+
+      expect(container.root).not_to be root
+      expect(container.root).to be_compressed
+      expect(root).not_to be_compressed
+    end
+
+    it 'generates a new root with the words from the passed root' do
+      words = %w(a few words hello hell)
+
+      add_words container, words
+      container.compress!
+
+      words.each do |word|
+        expect(container).to include word
+      end
+    end
+
+    describe 'and trying to add a word' do
+      it 'raises an error' do
+        add_words container, %w(repay rest repaint)
+        container.compress!
+
+        expect do
+          add_word container, 'restaurant'
+        end.to raise_error Rambling::Trie::InvalidOperation
+      end
+    end
+  end
+
+  describe '#word?' do
+    context 'word is contained' do
+      before do
+        add_words container, %w(hello high)
+      end
+
+      it 'matches the whole word' do
+        expect(container.word? 'hello').to be true
+        expect(container.word? 'high').to be true
+      end
+
+      context 'and the root has been compressed' do
+        before do
+          container.compress!
+        end
+
+        it 'matches the whole word' do
+          expect(container.word? 'hello').to be true
+          expect(container.word? 'high').to be true
+        end
+      end
+    end
+
+    context 'word is not contained' do
+      before do
+        add_word container, 'hello'
+      end
+
+      it 'does not match the whole word' do
+        expect(container.word? 'halt').to be false
+        expect(container.word? 'al').to be false
+      end
+
+      context 'and the root has been compressed' do
+        before do
+          container.compress!
+        end
+
+        it 'does not match the whole word' do
+          expect(container.word? 'halt').to be false
+          expect(container.word? 'al').to be false
+        end
+      end
+    end
+  end
+
+  describe '#partial_word?' do
+    context 'word is contained' do
+      before do
+        add_words container, %w(hello high)
+      end
+
+      it 'matches part of the word' do
+        expect(container.partial_word? 'hell').to be true
+        expect(container.partial_word? 'hig').to be true
+      end
+
+      context 'and the root has been compressed' do
+        before do
+          container.compress!
+        end
+
+        it 'matches part of the word' do
+          expect(container.partial_word? 'h').to be true
+          expect(container.partial_word? 'he').to be true
+          expect(container.partial_word? 'hell').to be true
+          expect(container.partial_word? 'hello').to be true
+          expect(container.partial_word? 'hi').to be true
+          expect(container.partial_word? 'hig').to be true
+          expect(container.partial_word? 'high').to be true
+        end
+      end
+    end
+
+    shared_examples_for 'a non matching tree' 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
+
+    context 'word is not contained' do
+      before do
+        add_word container, 'hello'
+      end
+
+      context 'and the root is uncompressed' do
+        it_behaves_like 'a non matching tree'
+      end
+
+      context 'and the root has been compressed' do
+        it_behaves_like 'a non matching tree'
+      end
+    end
+  end
+
+  describe '#scan' do
+    context 'words that match are not contained' do
+      before do
+        add_words container, %w(hi hello high hell highlight histerical)
+      end
+
+      it 'returns an array with the words that match' do
+        expect(container.scan 'hi').to eq %w(hi high highlight histerical)
+        expect(container.scan 'hig').to eq %w(high highlight)
+      end
+
+      context 'and the root has been compressed' do
+        before do
+          container.compress!
+        end
+
+        it 'returns an array with the words that match' do
+          expect(container.scan 'hi').to eq %w(hi high highlight histerical)
+          expect(container.scan 'hig').to eq %w(high highlight)
+        end
+      end
+    end
+
+    context 'words that match are not contained' do
+      before do
+        add_word container, 'hello'
+      end
+
+      it 'returns an empty array' do
+        expect(container.scan 'hi').to eq %w()
+      end
+
+      context 'and the root has been compressed' do
+        before do
+          container.compress!
+        end
+
+        it 'returns an empty array' do
+          expect(container.scan 'hi').to eq %w()
+        end
+      end
+    end
+  end
+
+  describe '#words_within' do
+    before do
+      add_words container, %w(one word and other words)
+    end
+
+    context 'phrase does not contain any words' do
+      it 'returns an empty array' do
+        expect(container.words_within 'xyz').to match_array []
+      end
+
+      context 'and the node is compressed' do
+        before do
+          container.compress!
+        end
+
+        it 'returns an empty array' do
+          expect(container.words_within 'xyz').to match_array []
+        end
+      end
+    end
+
+    context 'phrase contains one word at the start of the phrase' do
+      it 'returns an array with the word found in the phrase' do
+        expect(container.words_within 'word').to match_array %w(word)
+        expect(container.words_within 'wordxyz').to match_array %w(word)
+      end
+
+      context 'and the node is compressed' do
+        before do
+          container.compress!
+        end
+
+        it 'returns an array with the word found in the phrase' do
+          expect(container.words_within 'word').to match_array %w(word)
+          expect(container.words_within 'wordxyz').to match_array %w(word)
+        end
+      end
+    end
+
+    context 'phrase contains one word at the end of the phrase' do
+      it 'returns an array with the word found in the phrase' do
+        expect(container.words_within 'xyz word').to match_array %w(word)
+      end
+
+      context 'and the node is compressed' do
+        before do
+          container.compress!
+        end
+
+        it 'returns an array with the word found in the phrase' do
+          expect(container.words_within 'xyz word').to match_array %w(word)
+        end
+      end
+    end
+
+    context 'phrase contains a few words' 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
+
+      context 'and the node is compressed' do
+        before do
+          container.compress!
+        end
+
+        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
+    end
+  end
+
+  describe '#words_within?' do
+    before do
+      add_words container, %w(one word and other words)
+    end
+
+    context 'phrase does not contain any words' do
+      it 'returns false' do
+        expect(container.words_within? 'xyz').to be false
+      end
+    end
+
+    context 'phrase contains any word' do
+      it 'returns true' do
+        expect(container.words_within? 'xyz words').to be true
+        expect(container.words_within? 'xyzone word').to be true
+      end
+    end
+  end
+
+  describe '#==' do
+    context 'when the root nodes are the same' do
+      let(:other_container) do
+        Rambling::Trie::Container.new container.root, compressor
+      end
+
+      it 'returns true' do
+        expect(container).to eq other_container
+      end
+    end
+
+    context 'when the root nodes are not the same' do
+      let(:other_root) { Rambling::Trie::Nodes::Raw.new }
+      let(:other_container) do
+        Rambling::Trie::Container.new other_root, compressor
+      end
+
+      before do
+        add_word other_container, 'hola'
+      end
+
+      it 'returns false' do
+        expect(container).not_to eq other_container
+      end
+    end
+  end
+
+  describe '#each' do
+    before do
+      add_words container, %w(yes no why)
+    end
+
+    it 'returns an enumerator when no block is given' do
+      expect(container.each).to be_instance_of Enumerator
+    end
+
+    it 'iterates through all words contained' do
+      expect(container.each.to_a).to eq %w(yes no why)
+    end
+  end
+
+  describe '#inspect' do
+    before do
+      add_words container, %w(a few words hello hell)
+    end
+
+    it 'returns the container class name plus the root inspection' do
+      expect(container.inspect).to eq one_line <<~CONTAINER
+        #<Rambling::Trie::Container root: #<Rambling::Trie::Nodes::Raw letter: nil,
+        terminal: nil,
+        children: [:a, :f, :w, :h]>>
+      CONTAINER
+    end
+  end
+end