rambling-trie 0.5.2 → 0.6.0

data/lib/rambling/trie/version.rb

@@ -1,6 +1,6 @@
 module Rambling
   module Trie
     # Current version of the rambling-trie.
-    VERSION = '0.5.2'
+    VERSION = '0.6.0'
   end
 end

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

@@ -3,170 +3,205 @@ require 'spec_helper'
 module Rambling
   module Trie
     describe Node do
+      it 'delegates `#[]` to its children tree' do
+        subject.children_tree.should_receive(:[]).with(:key).and_return('value')
+        expect(subject[:key]).to eq 'value'
+      end
+
+      it 'delegates `#[]=` to its children tree' do
+        subject.children_tree.should_receive(:[]=).with(:key, 'value')
+        subject[:key] = 'value'
+      end
+
+      it 'delegates `#delete` to its children tree' do
+        subject.children_tree.should_receive(:delete).with(:key).and_return('value')
+        expect(subject.delete :key).to eq 'value'
+      end
+
+      it 'delegates `#has_key?` to its children tree' do
+        subject.children_tree.should_receive(:has_key?).with(:present_key).and_return(true)
+        expect(subject).to have_key(:present_key)
+
+        subject.children_tree.should_receive(:has_key?).with(:absent_key).and_return(false)
+        expect(subject).not_to have_key(:absent_key)
+      end
+
+      it 'delegates `#children` to its children tree values' do
+        children = [double('child 1'), double('child 2')]
+        subject.children_tree.should_receive(:values).and_return(children)
+        expect(subject.children).to eq children
+      end
+
+      describe '#root?' do
+        it 'returns false' do
+          expect(subject).to_not be_root
+        end
+      end
+
       describe '.new' do
         context 'with no word' do
-          let(:node) { Node.new }
+          subject { Node.new }
 
           it 'does not have any letter' do
-            expect(node.letter).to be_nil
+            expect(subject.letter).to be_nil
           end
 
           it 'includes no children' do
-            expect(node).to have(0).children
+            expect(subject).to have(0).children
           end
 
           it 'is not a terminal node' do
-            expect(node).to_not be_terminal
+            expect(subject).to_not be_terminal
           end
 
           it 'returns empty string as its word' do
-            expect(node.as_word).to be_empty
+            expect(subject.as_word).to be_empty
           end
 
           it 'is not compressed' do
-            expect(node).to_not be_compressed
+            expect(subject).to_not be_compressed
           end
         end
 
         context 'with an empty word' do
-          let(:node) { Node.new '' }
+          subject { Node.new '' }
 
           it 'does not have any letter' do
-            expect(node.letter).to be_nil
+            expect(subject.letter).to be_nil
           end
 
           it 'includes no children' do
-            expect(node).to have(0).children
+            expect(subject).to have(0).children
           end
 
           it 'is not a terminal node' do
-            expect(node).to_not be_terminal
+            expect(subject).to_not be_terminal
           end
 
           it 'returns empty string as its word' do
-            expect(node.as_word).to be_empty
+            expect(subject.as_word).to be_empty
           end
 
           it 'is not compressed' do
-            expect(node).to_not be_compressed
+            expect(subject).to_not be_compressed
           end
         end
 
         context 'with one letter' do
-          let(:node) { Node.new 'a' }
+          subject { Node.new 'a' }
 
           it 'makes it the node letter' do
-            expect(node.letter).to eq :a
+            expect(subject.letter).to eq :a
           end
 
           it 'includes no children' do
-            expect(node).to have(0).children
+            expect(subject).to have(0).children
           end
 
           it 'is a terminal node' do
-            expect(node).to be_terminal
+            expect(subject).to be_terminal
           end
         end
 
         context 'with two letters' do
-          let(:node) { Node.new 'ba' }
+          subject { Node.new 'ba' }
 
           it 'takes the first as the node letter' do
-            expect(node.letter).to eq :b
+            expect(subject.letter).to eq :b
           end
 
           it 'includes one child' do
-            expect(node).to have(1).children
+            expect(subject).to have(1).children
           end
 
           it 'includes a child with the expected letter' do
-            expect(node.children.values.first.letter).to eq :a
+            expect(subject.children.first.letter).to eq :a
           end
 
           it 'has the expected letter as a key' do
-            expect(node).to have_key(:a)
+            expect(subject).to have_key(:a)
           end
 
           it 'returns the child corresponding to the key' do
-            expect(node[:a]).to eq node.children[:a]
+            expect(subject[:a]).to eq subject.children_tree[:a]
           end
 
           it 'does not mark itself as a terminal node' do
-            expect(node).to_not be_terminal
+            expect(subject).to_not be_terminal
           end
 
           it 'marks the first child as a terminal node' do
-            expect(node[:a]).to be_terminal
+            expect(subject[:a]).to be_terminal
           end
         end
 
         context 'with a large word' do
-          let(:node) { Node.new 'spaghetti' }
+          subject { Node.new 'spaghetti' }
 
           it 'marks the last letter as terminal node' do
-            expect(node[:p][:a][:g][:h][:e][:t][:t][:i]).to be_terminal
+            expect(subject[:p][:a][:g][:h][:e][:t][:t][:i]).to be_terminal
           end
 
           it 'does not mark any other letter as terminal node' do
-            expect(node[:p][:a][:g][:h][:e][:t][:t]).to_not be_terminal
-            expect(node[:p][:a][:g][:h][:e][:t]).to_not be_terminal
-            expect(node[:p][:a][:g][:h][:e]).to_not be_terminal
-            expect(node[:p][:a][:g][:h]).to_not be_terminal
-            expect(node[:p][:a][:g]).to_not be_terminal
-            expect(node[:p][:a]).to_not be_terminal
-            expect(node[:p]).to_not be_terminal
+            expect(subject[:p][:a][:g][:h][:e][:t][:t]).to_not be_terminal
+            expect(subject[:p][:a][:g][:h][:e][:t]).to_not be_terminal
+            expect(subject[:p][:a][:g][:h][:e]).to_not be_terminal
+            expect(subject[:p][:a][:g][:h]).to_not be_terminal
+            expect(subject[:p][:a][:g]).to_not be_terminal
+            expect(subject[:p][:a]).to_not be_terminal
+            expect(subject[:p]).to_not be_terminal
           end
         end
       end
 
       describe '#as_word' do
         context 'for an empty node' do
-          let(:node) { Node.new '' }
+          subject { Node.new '' }
 
           it 'returns nil' do
-            expect(node.as_word).to be_empty
+            expect(subject.as_word).to be_empty
           end
         end
 
         context 'for one letter' do
-          let(:node) { Node.new 'a' }
+          subject { Node.new 'a' }
 
           it 'returns the expected one letter word' do
-            expect(node.as_word).to eq 'a'
+            expect(subject.as_word).to eq 'a'
           end
         end
 
         context 'for a small word' do
-          let(:node) { Node.new 'all' }
+          subject { Node.new 'all' }
 
           it 'returns the expected small word' do
-            expect(node[:l][:l].as_word).to eq 'all'
+            expect(subject[:l][:l].as_word).to eq 'all'
           end
 
           it 'raises an error for a non terminal node' do
-            expect { node[:l].as_word }.to raise_error InvalidOperation
+            expect { subject[:l].as_word }.to raise_error InvalidOperation
           end
         end
 
         context 'for a long word' do
-          let(:node) { Node.new 'beautiful' }
+          subject { Node.new 'beautiful' }
 
           it 'returns the expected long word' do
-            expect(node[:e][:a][:u][:t][:i][:f][:u][:l].as_word).to eq 'beautiful'
+            expect(subject[:e][:a][:u][:t][:i][:f][:u][:l].as_word).to eq 'beautiful'
           end
         end
 
         context 'for a node with nil letter' do
-          let(:node) { Node.new nil }
+          subject { Node.new nil }
           it 'returns nil' do
-            expect(node.as_word).to be_empty
+            expect(subject.as_word).to be_empty
           end
         end
       end
 
       describe '#compressed?' do
         let(:root) { double 'Root' }
-        let(:node) { Node.new '', root }
+        subject { Node.new '', root }
 
         context 'parent is compressed' do
           before do
@@ -174,7 +209,7 @@ module Rambling
           end
 
           it 'returns true' do
-            expect(node).to be_compressed
+            expect(subject).to be_compressed
           end
         end
 
@@ -184,7 +219,7 @@ module Rambling
           end
 
           it 'returns false' do
-            expect(node).to_not be_compressed
+            expect(subject).to_not be_compressed
           end
         end
       end

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

@@ -3,52 +3,56 @@ require 'spec_helper'
 module Rambling
   module Trie
     describe Root do
-      let(:root) { Root.new }
+      describe '#root?' do
+        it 'returns true' do
+          expect(subject).to be_root
+        end
+      end
 
       describe '.new' do
         it 'has no children' do
-          expect(root).to have(0).children
+          expect(subject).to have(0).children
         end
 
         it 'has no letter' do
-          expect(root.letter).to be_nil
+          expect(subject.letter).to be_nil
         end
 
         it 'is not a terminal node' do
-          expect(root).to_not be_terminal
+          expect(subject).to_not be_terminal
         end
 
         it 'is not a word' do
-          expect(root).to_not be_word
+          expect(subject).to_not be_word
         end
 
         context 'with a block' do
-          let(:root) { Root.new { |root| root << 'test' } }
+          subject { Root.new { |root| root << 'test' } }
 
           it 'has no letter' do
-            expect(root.letter).to be_nil
+            expect(subject.letter).to be_nil
           end
 
           it 'is not a terminal node' do
-            expect(root).to_not be_terminal
+            expect(subject).to_not be_terminal
           end
 
           it 'is not a word' do
-            expect(root).to_not be_word
+            expect(subject).to_not be_word
           end
 
           it 'executes the block' do
-            expect(root).to have(1).children
-            expect(root.word? 'test').to be_true
+            expect(subject).to have(1).children
+            expect(subject.word? 'test').to be_true
           end
         end
       end
 
       describe '#compress!' do
-        let(:compressed_root) { root.compress! }
+        let(:compressed_root) { subject.compress! }
 
         it 'returns itself marked as compressed' do
-          expect(compressed_root).to eq root
+          expect(compressed_root).to eq subject
           expect(compressed_root).to be_compressed
         end
 
@@ -56,108 +60,108 @@ module Rambling
           let(:recompressed_root) { compressed_root.compress! }
 
           it 'keeps returning itself' do
-            expect(recompressed_root).to eq root
+            expect(recompressed_root).to eq subject
             expect(recompressed_root).to be_compressed
           end
         end
 
         context 'with at least one word' do
           it 'keeps the root letter nil' do
-            root << 'all'
-            root.compress!
+            subject << 'all'
+            subject.compress!
 
-            expect(root.letter).to be_nil
+            expect(subject.letter).to be_nil
           end
         end
 
         context 'with a single word' do
           before do
-            root << 'all'
-            root.compress!
+            subject << 'all'
+            subject.compress!
           end
 
           it 'compresses into a single node without children' do
-            expect(root[:all].letter).to eq :all
-            expect(root[:all]).to have(0).children
-            expect(root[:all]).to be_terminal
-            expect(root[:all]).to be_compressed
+            expect(subject[:all].letter).to eq :all
+            expect(subject[:all]).to have(0).children
+            expect(subject[:all]).to be_terminal
+            expect(subject[:all]).to be_compressed
           end
         end
 
         context 'with two words' do
           before do
-            root << 'all'
-            root << 'ask'
-            root.compress!
+            subject << 'all'
+            subject << 'ask'
+            subject.compress!
           end
 
           it 'compresses into corresponding three nodes' do
-            expect(root[:a].letter).to eq :a
-            expect(root[:a].children.size).to eq 2
+            expect(subject[:a].letter).to eq :a
+            expect(subject[:a]).to have(2).children
 
-            expect(root[:a][:ll].letter).to eq :ll
-            expect(root[:a][:sk].letter).to eq :sk
+            expect(subject[:a][:ll].letter).to eq :ll
+            expect(subject[:a][:sk].letter).to eq :sk
 
-            expect(root[:a][:ll]).to have(0).children
-            expect(root[:a][:sk]).to have(0).children
+            expect(subject[:a][:ll]).to have(0).children
+            expect(subject[:a][:sk]).to have(0).children
 
-            expect(root[:a][:ll]).to be_terminal
-            expect(root[:a][:sk]).to be_terminal
+            expect(subject[:a][:ll]).to be_terminal
+            expect(subject[:a][:sk]).to be_terminal
 
-            expect(root[:a][:ll]).to be_compressed
-            expect(root[:a][:sk]).to be_compressed
+            expect(subject[:a][:ll]).to be_compressed
+            expect(subject[:a][:sk]).to be_compressed
           end
         end
 
         it 'reassigns the parent nodes correctly' do
-          root << 'repay'
-          root << 'rest'
-          root << 'repaint'
-          root.compress!
+          subject << 'repay'
+          subject << 'rest'
+          subject << 'repaint'
+          subject.compress!
 
-          expect(root[:re].letter).to eq :re
-          expect(root[:re].children.size).to eq 2
+          expect(subject[:re].letter).to eq :re
+          expect(subject[:re]).to have(2).children
 
-          expect(root[:re][:pa].letter).to eq :pa
-          expect(root[:re][:st].letter).to eq :st
+          expect(subject[:re][:pa].letter).to eq :pa
+          expect(subject[:re][:st].letter).to eq :st
 
-          expect(root[:re][:pa].children.size).to eq 2
-          expect(root[:re][:st]).to have(0).children
+          expect(subject[:re][:pa]).to have(2).children
+          expect(subject[:re][:st]).to have(0).children
 
-          expect(root[:re][:pa][:y].letter).to eq :y
-          expect(root[:re][:pa][:int].letter).to eq :int
+          expect(subject[:re][:pa][:y].letter).to eq :y
+          expect(subject[:re][:pa][:int].letter).to eq :int
 
-          expect(root[:re][:pa][:y]).to have(0).children
-          expect(root[:re][:pa][:int]).to have(0).children
+          expect(subject[:re][:pa][:y]).to have(0).children
+          expect(subject[:re][:pa][:int]).to have(0).children
 
-          expect(root[:re][:pa][:y].parent).to eq root[:re][:pa]
-          expect(root[:re][:pa][:int].parent).to eq root[:re][:pa]
+          expect(subject[:re][:pa][:y].parent).to eq subject[:re][:pa]
+          expect(subject[:re][:pa][:int].parent).to eq subject[:re][:pa]
         end
 
         it 'does not compress terminal nodes' do
-          root << 'you'
-          root << 'your'
-          root << 'yours'
+          subject << 'you'
+          subject << 'your'
+          subject << 'yours'
 
-          root.compress!
+          subject.compress!
 
-          expect(root[:you].letter).to eq :you
+          expect(subject[:you].letter).to eq :you
 
-          expect(root[:you][:r].letter).to eq :r
-          expect(root[:you][:r]).to be_compressed
+          expect(subject[:you][:r].letter).to eq :r
+          expect(subject[:you][:r]).to be_compressed
 
-          expect(root[:you][:r][:s].letter).to eq :s
-          expect(root[:you][:r][:s]).to be_compressed
+          expect(subject[:you][:r][:s].letter).to eq :s
+          expect(subject[:you][:r][:s]).to be_compressed
         end
 
-        describe 'and trying to add a branch' do
+        describe 'and trying to add a word' do
           it 'raises an error' do
-            root << 'repay'
-            root << 'rest'
-            root << 'repaint'
-            root.compress!
+            subject << 'repay'
+            subject << 'rest'
+            subject << 'repaint'
+            subject.compress!
 
-            expect { root << 'restaurant' }.to raise_error InvalidOperation
+            expect { subject << 'restaurant' }.to raise_error InvalidOperation
           end
         end
       end
@@ -165,99 +169,119 @@ module Rambling
       describe '#word?' do
         context 'word is contained' do
           before do
-            root << 'hello'
-            root << 'high'
+            subject << 'hello'
+            subject << 'high'
           end
 
           it 'matches the whole word' do
-            expect(root.word? 'hello').to be_true
-            expect(root.word? 'high').to be_true
+            expect(subject.word? 'hello').to be_true
+            expect(subject.word? 'high').to be_true
           end
 
           it 'is aliased as #include?' do
-            expect(root).to include 'hello'
-            expect(root).to include 'high'
+            expect(subject).to include 'hello'
+            expect(subject).to include 'high'
           end
 
           context 'and the root has been compressed' do
             before do
-              root.compress!
+              subject.compress!
             end
 
             it 'matches the whole word' do
-              expect(root.word? 'hello').to be_true
-              expect(root.word? 'high').to be_true
+              expect(subject.word? 'hello').to be_true
+              expect(subject.word? 'high').to be_true
             end
           end
         end
 
         context 'word is not contained' do
           before do
-            root << 'hello'
+            subject << 'hello'
           end
 
           it 'does not match the whole word' do
-            expect(root.word? 'halt').to be_false
+            expect(subject.word? 'halt').to be_false
           end
 
           it 'is aliased as #include?' do
-            expect(root).to_not include 'high'
+            expect(subject).to_not include 'high'
           end
 
           context 'and the root has been compressed' do
             before do
-              root.compress!
+              subject.compress!
             end
 
             it 'does not match the whole word' do
-              expect(root.word? 'halt').to be_false
+              expect(subject.word? 'halt').to be_false
             end
           end
         end
       end
 
-      describe '#branch?' do
+      describe '#partial_word?' do
+        it 'is aliased as #match?' do
+          subject << 'hello'
+          subject << 'high'
+          expect(subject.match? 'hel').to be_true
+          expect(subject.match? 'hig').to be_true
+        end
+
+        it 'is aliased as #branch?, but with a warning' do
+          subject << 'hello'
+          subject << 'high'
+          subject.should_receive(:warn).with('The `#branch?` method will be deprecated, please use `#partial_word?` instead.').twice
+          expect(subject.branch? 'hel').to be_true
+          expect(subject.branch? 'hig').to be_true
+        end
+
         context 'word is contained' do
           before do
-            root << 'hello'
-            root << 'high'
+            subject << 'hello'
+            subject << 'high'
           end
 
           it 'matches part of the word' do
-            expect(root.branch? 'hell').to be_true
-            expect(root.branch? 'hig').to be_true
+            expect(subject.partial_word? 'hell').to be_true
+            expect(subject.partial_word? 'hig').to be_true
           end
 
           context 'and the root has been compressed' do
             before do
-              root.compress!
+              subject.compress!
             end
 
             it 'matches part of the word' do
-              expect(root.branch? 'hell').to be_true
-              expect(root.branch? 'hig').to be_true
+              expect(subject.partial_word? 'h').to be_true
+              expect(subject.partial_word? 'he').to be_true
+              expect(subject.partial_word? 'hell').to be_true
+              expect(subject.partial_word? 'hello').to be_true
+              expect(subject.partial_word? 'hi').to be_true
+              expect(subject.partial_word? 'hig').to be_true
+              expect(subject.partial_word? 'high').to be_true
             end
           end
         end
 
         context 'word is not contained' do
           before do
-            root << 'hello'
+            subject << 'hello'
           end
 
           it 'does not match any part of the word' do
-            expect(root.branch? 'ha').to be_false
-            expect(root.branch? 'hal').to be_false
+            expect(subject.partial_word? 'ha').to be_false
+            expect(subject.partial_word? 'hal').to be_false
           end
 
           context 'and the root has been compressed' do
             before do
-              root.compress!
+              subject.compress!
             end
 
             it 'does not match any part of the word' do
-              expect(root.branch? 'ha').to be_false
-              expect(root.branch? 'hal').to be_false
+              expect(subject.partial_word? 'ha').to be_false
+              expect(subject.partial_word? 'hal').to be_false
             end
           end
         end
@@ -268,12 +292,12 @@ module Rambling
         let(:word) { original_word.clone }
 
         it 'does not change the original word' do
-          root.add word
+          subject.add word
           expect(word).to eq original_word
         end
 
         it 'is still aliased as #<<' do
-          root << word
+          subject << word
           expect(word).to eq original_word
         end
       end