rambling-trie 1.0.2 → 1.0.3

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

@@ -6,7 +6,7 @@ describe Rambling::Trie::Configuration::Properties do
   describe '.new' do
     it 'configures the serializers' do
       serializers = properties.serializers
-      expect(serializers.keys).to match_array %i(marshal yaml yml zip)
+      expect(serializers.formats).to match_array %i(marshal yaml yml zip)
 
       expect(serializers[:marshal]).to be_instance_of Rambling::Trie::Serializers::Marshal
       expect(serializers[:yaml]).to be_instance_of Rambling::Trie::Serializers::Yaml
@@ -16,7 +16,7 @@ describe Rambling::Trie::Configuration::Properties do
 
     it 'configures the readers' do
       readers = properties.readers
-      expect(readers.keys).to match_array %i(txt)
+      expect(readers.formats).to match_array %i(txt)
 
       expect(readers[:txt]).to be_instance_of Rambling::Trie::Readers::PlainText
     end
@@ -26,7 +26,7 @@ describe Rambling::Trie::Configuration::Properties do
     end
 
     it 'configures the root_builder' do
-      expect(properties.root_builder.call).to be_instance_of Rambling::Trie::RawNode
+      expect(properties.root_builder.call).to be_instance_of Rambling::Trie::Nodes::Raw
     end
   end
 
@@ -37,13 +37,13 @@ describe Rambling::Trie::Configuration::Properties do
     end
 
     it 'resets the serializers and readers to initial values' do
-      expect(properties.serializers.keys).to include :test
-      expect(properties.readers.keys).to include :test
+      expect(properties.serializers.formats).to include :test
+      expect(properties.readers.formats).to include :test
 
       properties.reset
 
-      expect(properties.serializers.keys).not_to include :test
-      expect(properties.readers.keys).not_to include :test
+      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

@@ -11,7 +11,7 @@ describe Rambling::Trie::Configuration::ProviderCollection do
 
   let(:provider_collection) do
     Rambling::Trie::Configuration::ProviderCollection.new(
-      'provider',
+      :provider,
       configured_providers,
       configured_default
     )
@@ -19,7 +19,7 @@ describe Rambling::Trie::Configuration::ProviderCollection do
 
   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 +45,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

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

@@ -3,7 +3,7 @@ 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
@@ -24,40 +24,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
 
-    it 'clones the original word' do
-      container.add word
-      expect(root).to have_received(:add).with clone
+  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) { 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 +84,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 +143,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 +153,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 +169,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'
@@ -168,12 +217,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 :[]
+      container[:yep]
+      expect(root).to have_received(:[]).with :yep
     end
 
     it 'delegates `#as_word` to the root node' do
@@ -196,14 +245,14 @@ 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 `#has_key?` to the root node' do
+      container.has_key? :yup
+      expect(root).to have_received(:has_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_letter?` to `#has_key?`' do
+      container.has_letter? :yup
+      expect(root).to have_received(:has_key?).with :yup
     end
 
     it 'delegates `#inspect` to the root node' do
@@ -233,118 +282,41 @@ describe Rambling::Trie::Container do
   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 +338,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 +362,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 +387,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,9 +413,7 @@ 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
@@ -486,7 +453,7 @@ describe Rambling::Trie::Container do
 
     context 'words that match are not contained' do
       before do
-        container.add 'hello'
+        add_word container, 'hello'
       end
 
       it 'returns an empty array' do
@@ -507,9 +474,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
@@ -581,9 +546,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 +565,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 +575,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 +589,28 @@ 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 '#<Rambling::Trie::Container root: #<Rambling::Trie::Nodes::Raw letter: nil, terminal: nil, children: [:a, :f, :w, :h]>>'
+    end
+  end
 end