rambling-trie 0.4.2 → 0.5.0

data/lib/rambling/trie/version.rb

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

data/rambling-trie.gemspec

@@ -8,20 +8,20 @@ Gem::Specification.new do |gem|
   gem.description = 'The Rambling Trie is a custom implementation of the Trie data structure with Ruby, which includes compression abilities and is designed to be very fast to traverse.'
   gem.summary = 'A custom implementation of the trie data structure.'
   gem.homepage = 'http://github.com/ramblinglabs/rambling-trie'
-  gem.date = Time.now.strftime('%Y-%m-%d')
+  gem.date = Time.now.strftime '%Y-%m-%d'
 
-  gem.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
-  gem.files = `git ls-files`.split("\n")
-  gem.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename f }
+  gem.files = `git ls-files`.split "\n"
+  gem.test_files = `git ls-files -- {test,spec,features}/*`.split "\n"
   gem.require_paths = ['lib']
 
   gem.name = 'rambling-trie'
   gem.version = Rambling::Trie::VERSION
   gem.platform = Gem::Platform::RUBY
 
-  gem.add_development_dependency 'rspec', '>=2.0.0'
-  gem.add_development_dependency 'rake', '>=0.9.2'
-  gem.add_development_dependency 'ruby-prof', '>=0.10.8'
-  gem.add_development_dependency 'yard', '>=0.7.5'
-  gem.add_development_dependency 'redcarpet', '>=2.1.0'
+  gem.add_development_dependency 'rspec', '>=2.12.0'
+  gem.add_development_dependency 'rake', '>=10.0.0.1'
+  gem.add_development_dependency 'ruby-prof', '>=0.11.2'
+  gem.add_development_dependency 'yard', '>=0.8.3'
+  gem.add_development_dependency 'redcarpet', '>=2.2.2'
 end

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

@@ -3,48 +3,49 @@ require 'spec_helper'
 module Rambling
   module Trie
     describe Branches do
-      describe '#add_branch_from' do
+      describe '#add' do
         context 'new word for existing branch' do
           let(:node) { Node.new 'back' }
 
-          before :each do
-            node.add_branch_from 'a'
+          before do
+            node.add 'a'
           end
 
           it 'does not increment the child count' do
-            node.should have(1).children
+            expect(node).to have(1).children
           end
 
           it 'marks it as terminal' do
-            node[:a].should be_terminal
+            expect(node[:a]).to be_terminal
+          end
+
+          it 'returns the added node' do
+            expect(node.add('a').letter).to eq :a
           end
         end
 
         context 'old word for existing branch' do
           let(:node) { Node.new 'back' }
 
-          before :each do
-            node.add_branch_from 'ack'
+          before do
+            node.add 'ack'
           end
 
           it 'does not increment any child count' do
-            node.should have(1).children
-            node[:a].should have(1).children
-            node[:a][:c].should have(1).children
-            node[:a][:c][:k].should have(0).children
+            expect(node).to have(1).children
+            expect(node[:a]).to have(1).children
+            expect(node[:a][:c]).to have(1).children
+            expect(node[:a][:c][:k]).to have(0).children
           end
         end
       end
 
       describe '#<<' do
-        let(:root) { Root.new }
+        let(:node) { Node.new }
         let(:word) { 'word' }
 
-        it 'delegates to #add_branch_from' do
-          [true, false].each do |value|
-            root.stub(:add_branch_from).with(word).and_return value
-            root << word
-          end
+        it 'delegates to #add' do
+          expect((node << 'a').letter).to eq :a
         end
       end
     end

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

@@ -20,7 +20,7 @@ module Rambling
 
         it 'defers to the children hash' do
           deferer.children.should_receive(:[]).with(key).and_return value
-          deferer[key].should == value
+          expect(deferer[key]).to eq value
         end
       end
 
@@ -40,7 +40,7 @@ module Rambling
 
         it 'defers to the children hash' do
           deferer.children.should_receive(:delete).with(key).and_return value
-          deferer.delete(key).should == value
+          expect(deferer.delete key).to eq value
         end
       end
 
@@ -50,7 +50,7 @@ module Rambling
         it 'defers to the children hash' do
           [true, false].each do |value|
             deferer.children.should_receive(:has_key?).with(key).and_return value
-            deferer.has_key?(key).should send("be_#{value}")
+            expect(deferer.has_key? key).to eq value
           end
         end
       end

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

@@ -6,31 +6,31 @@ module Rambling
       let(:root) { Root.new }
       let(:words) { %w(add some words and another word) }
 
-      before :each do
+      before do
         words.each { |word| root << word.clone }
       end
 
       describe '#each' do
         it 'returns an enumerator' do
-          root.each.should be_a(Enumerator)
+          expect(root.each).to be_a Enumerator
         end
 
         it 'includes every word contained in the trie' do
-          root.each { |word| words.should include(word) }
-          root.count.should == words.count
+          root.each { |word| expect(words).to include word }
+          expect(root.count).to eq words.count
         end
       end
 
       describe '#size' do
         it 'delegates to #count' do
-          root.size.should == words.size
+          expect(root.size).to eq words.size
         end
       end
 
       it 'includes the core Enumerable module' do
-        root.all? { |word| words.include? word }.should be_true
-        root.any? { |word| word.start_with? 's' }.should be_true
-        root.to_a.should =~ words
+        expect(root.all? { |word| words.include? word }).to be_true
+        expect(root.any? { |word| word.start_with? 's' }).to be_true
+        expect(root.to_a).to match_array words
       end
     end
   end

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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module Rambling
+  module Trie
+    describe Inspector do
+      let(:root) do
+        Root.new do |trie|
+          %w(only three words).each { |word| trie << word }
+        end
+      end
+
+      let(:node) { root[:o] }
+
+      describe '#inspect' do
+        it 'returns a pretty printed version of the node' do
+          expect(root.inspect).to eq("#<Rambling::Trie::Root letter: nil, children: [:o, :t, :w]>")
+          expect(node.inspect).to eq("#<Rambling::Trie::Node letter: :o, children: [:n]>")
+        end
+      end
+    end
+  end
+end

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

@@ -4,27 +4,51 @@ module Rambling
   module Trie
     describe Node do
       describe '.new' do
-        context 'with no letters' do
+        context 'with no word' do
+          let(:node) { Node.new }
+
+          it 'does not have any letter' do
+            expect(node.letter).to be_nil
+          end
+
+          it 'includes no children' do
+            expect(node).to have(0).children
+          end
+
+          it 'is not a terminal node' do
+            expect(node).to_not be_terminal
+          end
+
+          it 'returns empty string as its word' do
+            expect(node.as_word).to be_empty
+          end
+
+          it 'is not compressed' do
+            expect(node).to_not be_compressed
+          end
+        end
+
+        context 'with an empty word' do
           let(:node) { Node.new '' }
 
           it 'does not have any letter' do
-            node.letter.should be_nil
+            expect(node.letter).to be_nil
           end
 
           it 'includes no children' do
-            node.should have(0).children
+            expect(node).to have(0).children
           end
 
           it 'is not a terminal node' do
-            node.should_not be_terminal
+            expect(node).to_not be_terminal
           end
 
           it 'returns empty string as its word' do
-            node.as_word.should be_empty
+            expect(node.as_word).to be_empty
           end
 
           it 'is not compressed' do
-            node.should_not be_compressed
+            expect(node).to_not be_compressed
           end
         end
 
@@ -32,15 +56,15 @@ module Rambling
           let(:node) { Node.new 'a' }
 
           it 'makes it the node letter' do
-            node.letter.should == :a
+            expect(node.letter).to eq :a
           end
 
           it 'includes no children' do
-            node.should have(0).children
+            expect(node).to have(0).children
           end
 
           it 'is a terminal node' do
-            node.should be_terminal
+            expect(node).to be_terminal
           end
         end
 
@@ -48,31 +72,31 @@ module Rambling
           let(:node) { Node.new 'ba' }
 
           it 'takes the first as the node letter' do
-            node.letter.should == :b
+            expect(node.letter).to eq :b
           end
 
           it 'includes one child' do
-            node.should have(1).children
+            expect(node).to have(1).children
           end
 
           it 'includes a child with the expected letter' do
-            node.children.values.first.letter.should == :a
+            expect(node.children.values.first.letter).to eq :a
           end
 
           it 'has the expected letter as a key' do
-            node.has_key?(:a).should be_true
+            expect(node).to have_key(:a)
           end
 
           it 'returns the child corresponding to the key' do
-            node[:a].should == node.children[:a]
+            expect(node[:a]).to eq node.children[:a]
           end
 
           it 'does not mark itself as a terminal node' do
-            node.should_not be_terminal
+            expect(node).to_not be_terminal
           end
 
           it 'marks the first child as a terminal node' do
-            node[:a].should be_terminal
+            expect(node[:a]).to be_terminal
           end
         end
 
@@ -80,17 +104,17 @@ module Rambling
           let(:node) { Node.new 'spaghetti' }
 
           it 'marks the last letter as terminal node' do
-            node[:p][:a][:g][:h][:e][:t][:t][:i].should be_terminal
+            expect(node[:p][:a][:g][:h][:e][:t][:t][:i]).to be_terminal
           end
 
           it 'does not mark any other letter as terminal node' do
-            node[:p][:a][:g][:h][:e][:t][:t].should_not be_terminal
-            node[:p][:a][:g][:h][:e][:t].should_not be_terminal
-            node[:p][:a][:g][:h][:e].should_not be_terminal
-            node[:p][:a][:g][:h].should_not be_terminal
-            node[:p][:a][:g].should_not be_terminal
-            node[:p][:a].should_not be_terminal
-            node[:p].should_not be_terminal
+            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
           end
         end
       end
@@ -100,7 +124,7 @@ module Rambling
           let(:node) { Node.new '' }
 
           it 'returns nil' do
-            node.as_word.should be_empty
+            expect(node.as_word).to be_empty
           end
         end
 
@@ -108,7 +132,7 @@ module Rambling
           let(:node) { Node.new 'a' }
 
           it 'returns the expected one letter word' do
-            node.as_word.should == 'a'
+            expect(node.as_word).to eq 'a'
           end
         end
 
@@ -116,11 +140,11 @@ module Rambling
           let(:node) { Node.new 'all' }
 
           it 'returns the expected small word' do
-            node[:l][:l].as_word.should == 'all'
+            expect(node[:l][:l].as_word).to eq 'all'
           end
 
           it 'raises an error for a non terminal node' do
-            lambda { node[:l].as_word }.should raise_error(InvalidOperation)
+            expect { node[:l].as_word }.to raise_error InvalidOperation
           end
         end
 
@@ -128,14 +152,14 @@ module Rambling
           let(:node) { Node.new 'beautiful' }
 
           it 'returns the expected long word' do
-            node[:e][:a][:u][:t][:i][:f][:u][:l].as_word.should == 'beautiful'
+            expect(node[: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 }
           it 'returns nil' do
-            node.as_word.should be_empty
+            expect(node.as_word).to be_empty
           end
         end
       end
@@ -145,22 +169,22 @@ module Rambling
         let(:node) { Node.new '', root }
 
         context 'parent is compressed' do
-          before :each do
+          before do
             root.stub(:compressed?).and_return true
           end
 
           it 'returns true' do
-            node.should be_compressed
+            expect(node).to be_compressed
           end
         end
 
         context 'parent is not compressed' do
-          before :each do
+          before do
             root.stub(:compressed?).and_return false
           end
 
           it 'returns false' do
-            node.compressed?.should be_false
+            expect(node).to_not be_compressed
           end
         end
       end

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

@@ -6,264 +6,275 @@ module Rambling
       let(:root) { Root.new }
 
       describe '.new' do
-        context 'without filename' do
-          it 'has no letter' do
-            root.letter.should be_nil
-          end
+        it 'has no children' do
+          expect(root).to have(0).children
+        end
 
-          it 'is not a terminal node' do
-            root.should_not be_terminal
-          end
+        it 'has no letter' do
+          expect(root.letter).to be_nil
+        end
 
-          it 'has no children' do
-            root.should have(0).children
-          end
+        it 'is not a terminal node' do
+          expect(root).to_not be_terminal
+        end
 
-          it 'is not a word' do
-            root.is_word?.should be_false
-          end
+        it 'is not a word' do
+          expect(root).to_not be_word
         end
 
-        context 'with a filename' do
-          let(:filename) { File.join(::SPEC_ROOT, 'assets', 'test_words.txt') }
-          let(:root) { Root.new filename }
+        context 'with a block' do
+          let(:root) { Root.new { |root| root << 'test' } }
 
-          it 'has the expected root children' do
-            File.open(filename) do |file|
-              expected_hash = Hash[file.readlines.map { |x| [x.slice(0).to_sym, nil] }]
-              root.should have(expected_hash.length).children
-              root.children.map { |k, v| k }.should =~ expected_hash.map { |k, v| k }
-            end
+          it 'has no letter' do
+            expect(root.letter).to be_nil
           end
 
-          it 'loads every word' do
-            File.open filename do |file|
-              file.readlines.each { |word| root.is_word?(word.chomp).should be_true }
-            end
+          it 'is not a terminal node' do
+            expect(root).to_not be_terminal
           end
 
-          context 'and compressed' do
-            before :each do
-              root.compress!
-            end
-
-            it 'is marked as compressed' do
-              root.should be_compressed
-            end
-
-            it 'compresses the root nodes' do
-              root[:t].letter.should == :t
-              root[:t].children.size.should == 2
-
-              root[:t][:ru].letter.should == :ru
-              root[:t][:ru].children.size.should == 2
+          it 'is not a word' do
+            expect(root).to_not be_word
+          end
 
-              root[:t][:ru][:e].should be_terminal
-              root[:t][:ru][:e].should be_compressed
-            end
+          it 'executes the block' do
+            expect(root).to have(1).children
+            expect(root.word? 'test').to be_true
           end
         end
       end
 
       describe '#compress!' do
-        it 'returns itself marked as compressed' do
-          compressed_root = root.compress!
+        let(:compressed_root) { root.compress! }
 
-          compressed_root.should == root
-          compressed_root.should be_compressed
+        it 'returns itself marked as compressed' do
+          expect(compressed_root).to eq root
+          expect(compressed_root).to be_compressed
         end
 
         context 'after calling #compress! once' do
-          it 'keeps returning itself' do
-            compressed_root = root.compress!.compress!
+          let(:recompressed_root) { compressed_root.compress! }
 
-            compressed_root.should == root
-            compressed_root.should be_compressed
+          it 'keeps returning itself' do
+            expect(recompressed_root).to eq root
+            expect(recompressed_root).to be_compressed
           end
         end
 
         context 'with at least one word' do
           it 'keeps the root letter nil' do
-            root.add_branch_from 'all'
+            root << 'all'
             root.compress!
 
-            root.letter.should be_nil
+            expect(root.letter).to be_nil
           end
         end
 
         context 'with a single word' do
-          before :each do
-            root.add_branch_from 'all'
+          before do
+            root << 'all'
             root.compress!
           end
 
           it 'compresses into a single node without children' do
-            root[:all].letter.should == :all
-            root[:all].should have(0).children
-            root[:all].should be_terminal
-            root[:all].should be_compressed
+            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
           end
         end
 
         context 'with two words' do
-          before :each do
-            root.add_branch_from 'all'
-            root.add_branch_from 'ask'
+          before do
+            root << 'all'
+            root << 'ask'
             root.compress!
           end
 
           it 'compresses into corresponding three nodes' do
-            root[:a].letter.should == :a
-            root[:a].children.size.should == 2
+            expect(root[:a].letter).to eq :a
+            expect(root[:a].children.size).to eq 2
 
-            root[:a][:ll].letter.should == :ll
-            root[:a][:sk].letter.should == :sk
+            expect(root[:a][:ll].letter).to eq :ll
+            expect(root[:a][:sk].letter).to eq :sk
 
-            root[:a][:ll].should have(0).children
-            root[:a][:sk].should have(0).children
+            expect(root[:a][:ll]).to have(0).children
+            expect(root[:a][:sk]).to have(0).children
 
-            root[:a][:ll].should be_terminal
-            root[:a][:sk].should be_terminal
+            expect(root[:a][:ll]).to be_terminal
+            expect(root[:a][:sk]).to be_terminal
 
-            root[:a][:ll].should be_compressed
-            root[:a][:sk].should be_compressed
+            expect(root[:a][:ll]).to be_compressed
+            expect(root[:a][:sk]).to be_compressed
           end
         end
 
         it 'reassigns the parent nodes correctly' do
-          root.add_branch_from 'repay'
-          root.add_branch_from 'rest'
-          root.add_branch_from 'repaint'
+          root << 'repay'
+          root << 'rest'
+          root << 'repaint'
           root.compress!
 
-          root[:re].letter.should == :re
-          root[:re].children.size.should == 2
+          expect(root[:re].letter).to eq :re
+          expect(root[:re].children.size).to eq 2
 
-          root[:re][:pa].letter.should == :pa
-          root[:re][:st].letter.should == :st
+          expect(root[:re][:pa].letter).to eq :pa
+          expect(root[:re][:st].letter).to eq :st
 
-          root[:re][:pa].children.size.should == 2
-          root[:re][:st].should have(0).children
+          expect(root[:re][:pa].children.size).to eq 2
+          expect(root[:re][:st]).to have(0).children
 
-          root[:re][:pa][:y].letter.should == :y
-          root[:re][:pa][:int].letter.should == :int
+          expect(root[:re][:pa][:y].letter).to eq :y
+          expect(root[:re][:pa][:int].letter).to eq :int
 
-          root[:re][:pa][:y].should have(0).children
-          root[:re][:pa][:int].should have(0).children
+          expect(root[:re][:pa][:y]).to have(0).children
+          expect(root[:re][:pa][:int]).to have(0).children
 
-          root[:re][:pa][:y].parent.should == root[:re][:pa]
-          root[:re][:pa][:int].parent.should == root[:re][:pa]
+          expect(root[:re][:pa][:y].parent).to eq root[:re][:pa]
+          expect(root[:re][:pa][:int].parent).to eq root[:re][:pa]
         end
 
         it 'does not compress terminal nodes' do
-          root.add_branch_from 'you'
-          root.add_branch_from 'your'
-          root.add_branch_from 'yours'
+          root << 'you'
+          root << 'your'
+          root << 'yours'
 
           root.compress!
 
-          root[:you].letter.should == :you
+          expect(root[:you].letter).to eq :you
 
-          root[:you][:r].letter.should == :r
-          root[:you][:r].should be_compressed
+          expect(root[:you][:r].letter).to eq :r
+          expect(root[:you][:r]).to be_compressed
 
-          root[:you][:r][:s].letter.should == :s
-          root[:you][:r][:s].should be_compressed
+          expect(root[:you][:r][:s].letter).to eq :s
+          expect(root[:you][:r][:s]).to be_compressed
         end
 
         describe 'and trying to add a branch' do
           it 'raises an error' do
-            root.add_branch_from 'repay'
-            root.add_branch_from 'rest'
-            root.add_branch_from 'repaint'
+            root << 'repay'
+            root << 'rest'
+            root << 'repaint'
             root.compress!
 
-            lambda { root.add_branch_from('restaurant') }.should raise_error(InvalidOperation)
+            expect { root << 'restaurant' }.to raise_error InvalidOperation
           end
         end
       end
 
-      describe '#has_branch_for?' do
+      describe '#word?' do
         context 'word is contained' do
-          shared_examples_for 'word is found' do
-            it 'matches part of the word' do
-              root.should have_branch_for 'hell'
-              root.should have_branch_for 'hig'
-            end
-
-            it 'matches the whole word' do
-              root.is_word?('hello').should be_true
-              root.is_word?('high').should be_true
-            end
+          before do
+            root << 'hello'
+            root << 'high'
           end
 
-          before :each do
-            root.add_branch_from 'hello'
-            root.add_branch_from 'high'
+          it 'matches the whole word' do
+            expect(root.word? 'hello').to be_true
+            expect(root.word? 'high').to be_true
           end
 
-          it_behaves_like 'word is found'
+          it 'is aliased as #include?' do
+            expect(root).to include 'hello'
+            expect(root).to include 'high'
+          end
 
-          context 'and the root been compressed' do
-            before :each do
+          context 'and the root has been compressed' do
+            before do
               root.compress!
             end
 
-            it_behaves_like 'word is found'
+            it 'matches the whole word' do
+              expect(root.word? 'hello').to be_true
+              expect(root.word? 'high').to be_true
+            end
           end
         end
 
         context 'word is not contained' do
-          shared_examples_for 'word not found' do
-            it 'does not match any part of the word' do
-              root.should_not have_branch_for 'ha'
-              root.should_not have_branch_for 'hal'
+          before do
+            root << 'hello'
+          end
+
+          it 'does not match the whole word' do
+            expect(root.word? 'halt').to be_false
+          end
+
+          it 'is aliased as #include?' do
+            expect(root).to_not include 'high'
+          end
+
+          context 'and the root has been compressed' do
+            before do
+              root.compress!
             end
 
             it 'does not match the whole word' do
-              root.is_word?('halt').should be_false
+              expect(root.word? 'halt').to be_false
             end
           end
+        end
+      end
 
-          before :each do
-            root.add_branch_from 'hello'
+      describe '#branch?' do
+        context 'word is contained' do
+          before do
+            root << 'hello'
+            root << 'high'
           end
 
-          it_behaves_like 'word not found'
+          it 'matches part of the word' do
+            expect(root.branch? 'hell').to be_true
+            expect(root.branch? 'hig').to be_true
+          end
 
           context 'and the root has been compressed' do
-            before :each do
+            before do
               root.compress!
             end
 
-            it_behaves_like 'word not found'
+            it 'matches part of the word' do
+              expect(root.branch? 'hell').to be_true
+              expect(root.branch? 'hig').to be_true
+            end
           end
         end
-      end
 
-      describe '#include?' do
-        let(:word) { 'word' }
+        context 'word is not contained' do
+          before do
+            root << 'hello'
+          end
 
-        it 'delegates to #is_word?' do
-          [true, false].each do |value|
-            root.stub(:is_word?).with(word).and_return value
-            root.include?(word).should &method("be_#{value}".to_sym)
+          it 'does not match any part of the word' do
+            expect(root.branch? 'ha').to be_false
+            expect(root.branch? 'hal').to be_false
+          end
+
+          context 'and the root has been compressed' do
+            before do
+              root.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
+            end
           end
         end
       end
 
-      describe '#add_branch_from' do
+      describe '#add' do
         let(:original_word) { 'word' }
         let(:word) { original_word.clone }
 
         it 'does not change the original word' do
-          root.add_branch_from word
-          word.should == original_word
+          root.add word
+          expect(word).to eq original_word
         end
 
         it 'is still aliased as #<<' do
           root << word
-          word.should == original_word
+          expect(word).to eq original_word
         end
       end
     end