rambling-trie 1.0.1 → 2.1.1

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Rambling::Trie::Configuration::ProviderCollection do
@@ -11,15 +13,15 @@ describe Rambling::Trie::Configuration::ProviderCollection do
 
   let(:provider_collection) do
     Rambling::Trie::Configuration::ProviderCollection.new(
-      'provider',
+      :provider,
       configured_providers,
-      configured_default
+      configured_default,
     )
   end
 
   describe '.new' do
     it 'has a name' do
-      expect(provider_collection.name).to eq 'provider'
+      expect(provider_collection.name).to eq :provider
     end
 
     it 'has the given providers' do
@@ -45,32 +47,20 @@ describe Rambling::Trie::Configuration::ProviderCollection do
 
     before do
       allow(providers) .to receive_messages(
-        :[] => nil,
-        :[]= => nil,
-        keys: nil,
-        values: nil,
+        :[] => 'value',
+        keys: %i(a b),
       )
     end
 
-    it 'delegates #[] to providers' do
-      provider_collection[:key]
+    it 'delegates `#[]` to providers' do
+      expect(provider_collection[:key]).to eq 'value'
       expect(providers).to have_received(:[]).with :key
     end
 
-    it 'delegates #[]= to providers' do
-      provider_collection[:key] = 'hello'
-      expect(providers).to have_received(:[]=).with :key, 'hello'
-    end
-
-    it 'delegates #keys to providers' do
-      provider_collection.keys
+    it 'aliases `#formats` to `providers#keys`' do
+      expect(provider_collection.formats).to eq %i(a b)
       expect(providers).to have_received :keys
     end
-
-    it 'delegates #values to providers' do
-      provider_collection.values
-      expect(providers).to have_received :values
-    end
   end
 
   describe '#add' do
@@ -96,26 +86,20 @@ describe Rambling::Trie::Configuration::ProviderCollection do
     end
 
     context 'when the given value is not in the providers list' do
-      it 'does not change the default provider' do
-        expect do
-          begin
-            provider_collection.default = other_provider
-          rescue
-          end
-        end.not_to change { provider_collection.default }
+      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 do
-          provider_collection.default = other_provider
-        end.to raise_error ArgumentError
+        expect { provider_collection.default = other_provider }
+          .to raise_error ArgumentError
       end
     end
 
     context 'when the providers list is empty' do
-      let(:configured_providers) do
-        {}
-      end
+      let(:configured_providers) { {} }
 
       it 'accepts nil' do
         provider_collection.default = nil

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

@@ -1,9 +1,11 @@
+# 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::RawNode.new }
+  let(:root) { Rambling::Trie::Nodes::Raw.new }
 
   describe '.new' do
     it 'uses the provided node as root' do
@@ -14,8 +16,8 @@ describe Rambling::Trie::Container do
       it 'yields the container' do
         yielded = nil
 
-        container = Rambling::Trie::Container.new root, compressor do |container|
-          yielded = container
+        container = Rambling::Trie::Container.new root, compressor do |c|
+          yielded = c
         end
 
         expect(yielded).to be container
@@ -24,40 +26,51 @@ describe Rambling::Trie::Container do
   end
 
   describe '#add' do
-    let(:clone) { double :clone }
-    let(:word) { double :word, clone: clone }
+    it 'adds the word to the root node' do
+      add_word container, 'hello'
 
-    before do
-      allow(root).to receive(:add)
+      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 'clones the original word' do
-      container.add word
-      expect(root).to have_received(:add).with clone
+    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) { double :node, add: nil, compressed?: false }
+    let(:node) { Rambling::Trie::Nodes::Compressed.new }
 
     before do
       allow(compressor).to receive(:compress).and_return node
-      allow(root).to receive(:add)
+
+      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
+      expect(compressor).to have_received(:compress).with root
     end
 
     it 'changes to the root returned by the compressor' do
       container.compress!
-      container.add 'word'
 
-      expect(root).not_to have_received :add
-      expect(node).to have_received :add
+      expect(container.root).not_to eq root
+      expect(container.root).to eq node
     end
 
     it 'returns itself' do
@@ -73,13 +86,57 @@ describe Rambling::Trie::Container do
     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(:root) do
-        double :root,
-          compressed?: false,
-          word?: nil
-      end
+      let(:compressed) { true }
 
       it 'calls the root with the word characters' do
         container.word? 'words'
@@ -88,11 +145,7 @@ describe Rambling::Trie::Container do
     end
 
     context 'for a compressed root' do
-      let(:root) do
-        double :root,
-          compressed?: true,
-          word?: nil
-      end
+      let(:compressed) { false }
 
       it 'calls the root with the full word' do
         container.word? 'words'
@@ -102,12 +155,14 @@ describe Rambling::Trie::Container do
   end
 
   describe '#partial_word?' do
+    let(:root) do
+      double :root,
+        compressed?: compressed,
+        partial_word?: nil
+    end
+
     context 'for an uncompressed root' do
-      let(:root) do
-        double :root,
-          compressed?: false,
-          partial_word?: nil
-      end
+      let(:compressed) { true }
 
       it 'calls the root with the word characters' do
         container.partial_word? 'words'
@@ -116,11 +171,7 @@ describe Rambling::Trie::Container do
     end
 
     context 'for a compressed root' do
-      let(:root) do
-        double :root,
-          compressed?: true,
-          partial_word?: nil
-      end
+      let(:compressed) { false }
 
       it 'calls the root with the word characters' do
         container.partial_word? 'words'
@@ -139,7 +190,7 @@ describe Rambling::Trie::Container do
         children_tree: nil,
         compressed?: nil,
         each: nil,
-        has_key?: nil,
+        key?: nil,
         inspect: nil,
         letter: nil,
         parent: nil,
@@ -168,17 +219,12 @@ describe Rambling::Trie::Container do
 
     it 'aliases `#<<` to `#add`' do
       container << 'words'
-      expect(root).to have_received(:add).with 'words'
+      expect(root).to have_received(:add).with %i(s d r o w)
     end
 
     it 'delegates `#[]` to the root node' do
-      container.[]
-      expect(root).to have_received :[]
-    end
-
-    it 'delegates `#as_word` to the root node' do
-      container.as_word
-      expect(root).to have_received :as_word
+      container[:yep]
+      expect(root).to have_received(:[]).with :yep
     end
 
     it 'delegates `#children` to the root node' do
@@ -196,14 +242,19 @@ describe Rambling::Trie::Container do
       expect(root).to have_received :compressed?
     end
 
-    it 'delegates `#each` to the root node' do
-      container.each
-      expect(root).to have_received :each
+    it 'delegates `#key?` to the root node' do
+      container.key? :yup
+      expect(root).to have_received(:key?).with :yup
     end
 
-    it 'delegates `#has_key?` to the root node' do
-      container.has_key?
-      expect(root).to have_received :has_key?
+    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
@@ -211,140 +262,48 @@ describe Rambling::Trie::Container do
       expect(root).to have_received :inspect
     end
 
-    it 'delegates `#letter` to the root node' do
-      container.letter
-      expect(root).to have_received :letter
-    end
-
-    it 'delegates `#parent` to the root node' do
-      container.parent
-      expect(root).to have_received :parent
-    end
-
     it 'delegates `#size` to the root node' do
       container.size
       expect(root).to have_received :size
     end
-
-    it 'delegates `#to_s` to the root node' do
-      container.to_s
-      expect(root).to have_received :to_s
-    end
   end
 
   describe '#compress!' do
-    let(:compressor) { Rambling::Trie::Compressor.new }
-    let(:root) { Rambling::Trie::RawNode.new }
-
-    context 'with at least one word' do
-      it 'keeps the root letter nil' do
-        container.add 'all'
-        container.compress!
-
-        expect(container.letter).to be_nil
-      end
-    end
-
-    context 'with a single word' do
-      before do
-        container.add 'all'
-        container.compress!
-      end
-
-      it 'compresses into a single node without children' do
-        expect(container[:all].letter).to eq :all
-        expect(container[:all].children.size).to eq 0
-        expect(container[:all]).to be_terminal
-        expect(container[:all]).to be_compressed
-      end
-    end
-
-    context 'with two words' do
-      before do
-        container.add 'all'
-        container.add 'ask'
-        container.compress!
-      end
-
-      it 'compresses into corresponding three nodes' do
-        expect(container[:a].letter).to eq :a
-        expect(container[:a].children.size).to eq 2
-
-        expect(container[:a][:ll].letter).to eq :ll
-        expect(container[:a][:sk].letter).to eq :sk
-
-        expect(container[:a][:ll].children.size).to eq 0
-        expect(container[:a][:sk].children.size).to eq 0
-
-        expect(container[:a][:ll]).to be_terminal
-        expect(container[:a][:sk]).to be_terminal
-
-        expect(container[:a][:ll]).to be_compressed
-        expect(container[:a][:sk]).to be_compressed
-      end
-    end
-
-    it 'reassigns the parent nodes correctly' do
-      container.add 'repay'
-      container.add 'rest'
-      container.add 'repaint'
+    it 'gets a new root from the compressor' do
       container.compress!
 
-      expect(container[:re].letter).to eq :re
-      expect(container[:re].children.size).to eq 2
-
-      expect(container[:re][:pa].letter).to eq :pa
-      expect(container[:re][:st].letter).to eq :st
-
-      expect(container[:re][:pa].children.size).to eq 2
-      expect(container[:re][:st].children.size).to eq 0
-
-      expect(container[:re][:pa][:y].letter).to eq :y
-      expect(container[:re][:pa][:int].letter).to eq :int
-
-      expect(container[:re][:pa][:y].children.size).to eq 0
-      expect(container[:re][:pa][:int].children.size).to eq 0
-
-      expect(container[:re][:pa][:y].parent).to eq container[:re][:pa]
-      expect(container[:re][:pa][:int].parent).to eq container[:re][:pa]
+      expect(container.root).not_to be root
+      expect(container.root).to be_compressed
+      expect(root).not_to be_compressed
     end
 
-    it 'does not compress terminal nodes' do
-      container.add 'you'
-      container.add 'your'
-      container.add 'yours'
+    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!
 
-      expect(container[:you].letter).to eq :you
-
-      expect(container[:you][:r].letter).to eq :r
-      expect(container[:you][:r]).to be_compressed
-
-      expect(container[:you][:r][:s].letter).to eq :s
-      expect(container[:you][:r][:s]).to be_compressed
+      words.each do |word|
+        expect(container).to include word
+      end
     end
 
     describe 'and trying to add a word' do
       it 'raises an error' do
-        container.add 'repay'
-        container.add 'rest'
-        container.add 'repaint'
+        add_words container, %w(repay rest repaint)
         container.compress!
 
-        expect { container.add 'restaurant' }.to raise_error Rambling::Trie::InvalidOperation
+        expect do
+          add_word container, 'restaurant'
+        end.to raise_error Rambling::Trie::InvalidOperation
       end
     end
   end
 
   describe '#word?' do
-    let(:compressor) { Rambling::Trie::Compressor.new }
-    let(:root) { Rambling::Trie::RawNode.new }
-
     context 'word is contained' do
       before do
-        container.add 'hello'
-        container.add 'high'
+        add_words container, %w(hello high)
       end
 
       it 'matches the whole word' do
@@ -366,7 +325,7 @@ describe Rambling::Trie::Container do
 
     context 'word is not contained' do
       before do
-        container.add 'hello'
+        add_word container, 'hello'
       end
 
       it 'does not match the whole word' do
@@ -390,8 +349,7 @@ describe Rambling::Trie::Container do
   describe '#partial_word?' do
     context 'word is contained' do
       before do
-        container.add 'hello'
-        container.add 'high'
+        add_words container, %w(hello high)
       end
 
       it 'matches part of the word' do
@@ -416,27 +374,25 @@ describe Rambling::Trie::Container do
       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
-        container.add 'hello'
+        add_word container, 'hello'
       end
 
-      it 'does not match any part of the word' do
-        expect(container.partial_word? 'ha').to be false
-        expect(container.partial_word? 'hal').to be false
-        expect(container.partial_word? 'al').to be false
+      context 'and the root is uncompressed' do
+        it_behaves_like 'a non matching tree'
       end
 
       context 'and the root has been compressed' do
-        before do
-          container.compress!
-        end
-
-        it 'does not match any part of the word' do
-          expect(container.partial_word? 'ha').to be false
-          expect(container.partial_word? 'hal').to be false
-          expect(container.partial_word? 'al').to be false
-        end
+        it_behaves_like 'a non matching tree'
       end
     end
   end
@@ -444,23 +400,12 @@ describe Rambling::Trie::Container do
   describe '#scan' do
     context 'words that match are not contained' do
       before do
-        %w(hi hello high hell highlight histerical).each do |word|
-          container.add word
-        end
+        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 [
-          'hi',
-          'high',
-          'highlight',
-          'histerical'
-        ]
-
-        expect(container.scan 'hig').to eq [
-          'high',
-          'highlight'
-        ]
+        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
@@ -469,28 +414,19 @@ describe Rambling::Trie::Container do
         end
 
         it 'returns an array with the words that match' do
-          expect(container.scan 'hi').to eq [
-            'hi',
-            'high',
-            'highlight',
-            'histerical'
-          ]
-
-          expect(container.scan 'hig').to eq [
-            'high',
-            'highlight'
-          ]
+          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
-        container.add 'hello'
+        add_word container, 'hello'
       end
 
       it 'returns an empty array' do
-        expect(container.scan 'hi').to eq []
+        expect(container.scan 'hi').to eq %w()
       end
 
       context 'and the root has been compressed' do
@@ -499,7 +435,7 @@ describe Rambling::Trie::Container do
         end
 
         it 'returns an empty array' do
-          expect(container.scan 'hi').to eq []
+          expect(container.scan 'hi').to eq %w()
         end
       end
     end
@@ -507,9 +443,7 @@ describe Rambling::Trie::Container do
 
   describe '#words_within' do
     before do
-      %w(one word and other words).each do |word|
-        container.add word
-      end
+      add_words container, %w(one word and other words)
     end
 
     context 'phrase does not contain any words' do
@@ -564,7 +498,8 @@ describe Rambling::Trie::Container do
 
     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)
+        expect(container.words_within 'xyzword otherzxyone')
+          .to match_array %w(word other one)
       end
 
       context 'and the node is compressed' do
@@ -573,7 +508,8 @@ describe Rambling::Trie::Container do
         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)
+          expect(container.words_within 'xyzword otherzxyone')
+            .to match_array %w(word other one)
         end
       end
     end
@@ -581,9 +517,7 @@ describe Rambling::Trie::Container do
 
   describe '#words_within?' do
     before do
-      %w(one word and other words).each do |word|
-        container.add word
-      end
+      add_words container, %w(one word and other words)
     end
 
     context 'phrase does not contain any words' do
@@ -602,7 +536,9 @@ describe Rambling::Trie::Container do
 
   describe '#==' do
     context 'when the root nodes are the same' do
-      let(:other_container) { Rambling::Trie::Container.new container.root, compressor }
+      let(:other_container) do
+        Rambling::Trie::Container.new container.root, compressor
+      end
 
       it 'returns true' do
         expect(container).to eq other_container
@@ -610,11 +546,13 @@ describe Rambling::Trie::Container do
     end
 
     context 'when the root nodes are not the same' do
-      let(:other_root) { Rambling::Trie::RawNode.new }
+      let(:other_root) { Rambling::Trie::Nodes::Raw.new }
       let(:other_container) do
-        Rambling::Trie::Container.new other_root, compressor do |c|
-          c << 'hola'
-        end
+        Rambling::Trie::Container.new other_root, compressor
+      end
+
+      before do
+        add_word other_container, 'hola'
       end
 
       it 'returns false' do
@@ -622,4 +560,32 @@ describe Rambling::Trie::Container do
       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