rambling-trie 0.8.1 → 0.9.0

data/lib/rambling/trie/tasks/performance/profile/memory.rb

@@ -0,0 +1,116 @@
+require_relative '../../helpers/path'
+require_relative '../../helpers/time'
+
+namespace :performance do
+  namespace :profile do
+    include Helpers::Path
+    include Helpers::Time
+
+    def with_gc_stats
+      puts "Live objects before - #{GC.stat[:heap_live_slots]}"
+      yield
+      puts "Live objects after  - #{GC.stat[:heap_live_slots]}"
+    end
+
+    def memory_profile name
+      puts
+      puts name
+
+      result = MemoryProfiler.report allow_files: 'lib/rambling/trie', ignore_files: 'tasks/performance' do
+        yield
+      end
+
+      dir = path 'reports', Rambling::Trie::VERSION, 'memory', time
+      FileUtils.mkdir_p dir
+      result.pretty_print to_file: File.join(dir, name)
+    end
+
+    def dictionary
+      dictionary = path 'assets', 'dictionaries', 'words_with_friends.txt'
+    end
+
+    namespace :memory do
+      task creation: ['performance:directory'] do
+        puts 'Generating memory profiling reports for creation...'
+
+        trie = nil
+
+        memory_profile "memory-profile-new-trie" do
+          with_gc_stats { trie = Rambling::Trie.create dictionary }
+        end
+      end
+
+      task compression: ['performance:directory'] do
+        trie = Rambling::Trie.create dictionary
+
+        memory_profile "memory-profile-trie-and-compress" do
+          with_gc_stats { trie.compress! }
+        end
+
+        with_gc_stats { GC.start }
+      end
+
+      task lookups: ['performance:directory'] do
+        trie = Rambling::Trie.create dictionary
+        words = %w(hi help beautiful impressionism anthropological)
+
+        tries = [ trie, trie.clone.compress! ]
+
+        tries.each do |trie|
+          times = 10
+
+          name = "memory-profile-searching-#{trie.compressed? ? 'compressed' : 'uncompressed'}-trie-word"
+          memory_profile name do
+            with_gc_stats do
+              words.each do |word|
+                times.times do
+                  trie.word? word
+                end
+              end
+            end
+          end
+
+          name = "memory-profile-searching-#{trie.compressed? ? 'compressed' : 'uncompressed'}-trie-partial-word"
+          memory_profile name do
+            with_gc_stats do
+              words.each do |word|
+                times.times do
+                  trie.partial_word? word
+                end
+              end
+            end
+          end
+        end
+      end
+
+      task scans: ['performance:directory'] do
+        words = {
+          hi: 1,
+          help: 100,
+          beautiful: 100,
+          impressionism: 200,
+          anthropological: 200,
+        }
+
+        trie = Rambling::Trie.create dictionary
+        [ trie, trie.clone.compress! ].each do |trie|
+          name = "memory-profile-#{trie.compressed? ? 'compressed' : 'uncompressed'}-trie-scan"
+          memory_profile name do
+            words.each do |word, times|
+              times.times do
+                trie.scan(word.to_s).size
+              end
+            end
+          end
+        end
+      end
+
+      task all: [
+        'performance:profile:memory:creation',
+        'performance:profile:memory:compression',
+        'performance:profile:memory:lookups',
+        'performance:profile:memory:scans'
+      ]
+    end
+  end
+end

data/lib/rambling/trie/version.rb

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

data/rambling-trie.gemspec

@@ -20,9 +20,11 @@ Gem::Specification.new do |gem|
   gem.version = Rambling::Trie::VERSION
   gem.platform = Gem::Platform::RUBY
 
-  gem.add_development_dependency 'rspec', '~> 3.4'
-  gem.add_development_dependency 'rake', '~> 10.5'
-  gem.add_development_dependency 'ruby-prof', '~> 0.15.2'
-  gem.add_development_dependency 'yard', '~> 0.8.7'
+  gem.add_development_dependency 'rspec', '~> 3.5'
+  gem.add_development_dependency 'rake', '~> 12.0'
+  gem.add_development_dependency 'ruby-prof', '~> 0.16.2'
+  gem.add_development_dependency 'memory_profiler', '~> 0.9.7'
+  gem.add_development_dependency 'benchmark-ips', '~> 2.7.2'
+  gem.add_development_dependency 'yard', '~> 0.9.5'
   gem.add_development_dependency 'redcarpet', '~> 3.3.4'
 end

data/spec/integration/rambling/trie_spec.rb

@@ -1,20 +1,74 @@
 require 'spec_helper'
 
 describe Rambling::Trie do
-  describe 'when a filepath is provided' do
-    let(:filepath) { File.join ::SPEC_ROOT, 'assets', 'test_words.txt' }
-    let(:words) { File.readlines(filepath).map &:chomp }
-    subject { Rambling::Trie.create filepath }
+  shared_examples_for 'a compressable trie' do
+    context 'and the trie is not compressed' do
+      it_behaves_like 'a trie data structure'
 
+      it 'does not alter the input' do
+        word = 'string'
+        trie.add word
+
+        expect(word).to eq 'string'
+      end
+
+      it 'is marked as not compressed' do
+        expect(trie).not_to be_compressed
+      end
+    end
+
+    context 'and the trie is compressed' do
+      before { trie.compress! }
+
+      it_behaves_like 'a trie data structure'
+
+      it 'is marked as compressed' do
+        expect(trie).to be_compressed
+      end
+    end
+  end
+
+  shared_examples_for 'a trie data structure' do
     it 'contains all the words from the file' do
-      words.each { |word| expect(subject).to include word }
+      words.each do |word|
+        expect(trie).to include word
+        expect(trie.word? word).to be true
+      end
     end
 
-    describe 'and the trie is compressed' do
-      it 'still contains all the words from the file' do
-        subject.compress!
-        words.each { |word| expect(subject).to include word }
+    it 'matches the start of all the words from the file' do
+      words.each do |word|
+        expect(trie.match? word).to be true
+        expect(trie.match? word[0..-2]).to be true
+        expect(trie.partial_word? word).to be true
+        expect(trie.partial_word? word[0..-2]).to be true
       end
     end
+
+    it 'allows iterating over all the words' do
+      expect(trie.to_a.sort).to eq words.sort
+    end
+  end
+
+  describe 'with words provided directly' do
+    it_behaves_like 'a compressable trie' do
+      let(:words) { %w[a couple of words for our full trie integration test] }
+      let(:trie) { Rambling::Trie.create }
+
+      before do
+        words.each do |word|
+          trie << word
+          trie.add word
+        end
+      end
+    end
+  end
+
+  describe 'with words from a file' do
+    it_behaves_like 'a compressable trie' do
+      let(:filepath) { File.join ::SPEC_ROOT, 'assets', 'test_words.txt' }
+      let(:words) { File.readlines(filepath).map &:chomp }
+      let(:trie) { Rambling::Trie.create filepath }
+    end
   end
 end

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

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Rambling::Trie::CompressedNode do
+  let(:node) { Rambling::Trie::CompressedNode.new }
+
+  describe '#compressed?' do
+    it 'returns true' do
+      expect(node).to be_compressed
+    end
+  end
+
+  describe '.new' do
+    context 'with no parent' do
+      let(:node) { Rambling::Trie::CompressedNode.new }
+
+      it 'is marked as root' do
+        expect(node).to be_root
+      end
+    end
+
+    context 'with a specified' do
+      let(:node) { Rambling::Trie::CompressedNode.new double(:root) }
+
+      it 'is not marked as root' do
+        expect(node).not_to be_root
+      end
+    end
+  end
+
+  describe '#add' do
+    it 'raises an error' do
+      expect { node.add 'restaurant' }.to raise_error Rambling::Trie::InvalidOperation
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Rambling::Trie::Compressor do
+  let(:compressor) { Rambling::Trie::Compressor.new }
+
+  describe '#compress' do
+    let(:words) { %w(a few words hello hell) }
+    let(:root) do
+      Rambling::Trie::RawNode.new
+    end
+
+    before do
+      words.each { |w| root.add w.clone }
+    end
+
+    it 'generates a new root with the words from the passed root' do
+      new_root = compressor.compress root
+
+      expect(words).not_to be_empty
+      words.each do |word|
+        expect(new_root).to include word
+      end
+    end
+
+    it 'compresses the new root' do
+      new_root = compressor.compress root
+
+      expect(new_root.children_tree.keys).to eq %i(a few words hell)
+    end
+  end
+end

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

@@ -0,0 +1,470 @@
+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 }
+
+  describe '.new' do
+    context 'without a specified root' do
+      before do
+        allow(Rambling::Trie::RawNode).to receive(:new)
+          .and_return root
+      end
+
+      it 'initializes an empty trie root node' do
+        Rambling::Trie::Container.new
+        expect(Rambling::Trie::RawNode).to have_received :new
+      end
+    end
+
+    context 'without a specified compressor' do
+      before do
+        allow(Rambling::Trie::Compressor).to receive(:new)
+          .and_return compressor
+      end
+
+      it 'initializes a compressor' do
+        Rambling::Trie::Container.new
+        expect(Rambling::Trie::Compressor).to have_received :new
+      end
+    end
+
+    context 'with a block' do
+      it 'yields the container' do
+        yielded_container = nil
+
+        container = Rambling::Trie::Container.new root do |container|
+          yielded_container = container
+        end
+
+        expect(yielded_container).to eq container
+      end
+    end
+  end
+
+  describe '#add' do
+    let(:clone) { double :clone }
+    let(:word) { double :word, clone: clone }
+
+    before do
+      allow(root).to receive(:add)
+    end
+
+    it 'clones the original word' do
+      container.add word
+      expect(root).to have_received(:add).with clone
+    end
+  end
+
+  describe '#compress!' do
+    let(:node) { double :node, add: nil, compressed?: false }
+
+    before do
+      allow(compressor).to receive(:compress).and_return node
+      allow(root).to receive(:add)
+    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!
+      container.add 'word'
+
+      expect(root).not_to have_received :add
+      expect(node).to have_received :add
+    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 '#word?' do
+    context 'for an uncompressed root' do
+      let(:root) do
+        double :root,
+          compressed?: false,
+          word?: nil
+      end
+
+      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(:root) do
+        double :root,
+          compressed?: true,
+          word?: nil
+      end
+
+      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
+    context 'for an uncompressed root' do
+      let(:root) do
+        double :root,
+          compressed?: false,
+          partial_word?: nil
+      end
+
+      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(:root) do
+        double :root,
+          compressed?: true,
+          partial_word?: nil
+      end
+
+      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(
+        word?: nil,
+        partial_word?: nil,
+        scan: nil,
+        add: nil,
+        each: nil,
+        compressed?: 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 'words'
+    end
+
+    it 'delegates `#each` to the root node' do
+      container.each
+      expect(root).to have_received :each
+    end
+
+    it 'delegates `#compressed?` to the root node' do
+      container.compressed?
+      expect(root).to have_received :compressed?
+    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'
+      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]
+    end
+
+    it 'does not compress terminal nodes' do
+      container.add 'you'
+      container.add 'your'
+      container.add 'yours'
+
+      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
+    end
+
+    describe 'and trying to add a word' do
+      it 'raises an error' do
+        container.add 'repay'
+        container.add 'rest'
+        container.add 'repaint'
+        container.compress!
+
+        expect { container.add 'restaurant' }.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'
+      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
+        container.add '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
+        container.add 'hello'
+        container.add '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
+
+    context 'word is not contained' do
+      before do
+        container.add '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
+      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
+      end
+    end
+  end
+
+  describe '#scan' do
+    context 'words that match are not contained' do
+      before do
+        container.add 'hi'
+        container.add 'hello'
+        container.add 'high'
+        container.add 'hell'
+        container.add 'highlight'
+        container.add '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'
+        ]
+      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 [
+            'hi',
+            'high',
+            'highlight',
+            'histerical'
+          ]
+
+          expect(container.scan 'hig').to eq [
+            'high',
+            'highlight'
+          ]
+        end
+      end
+    end
+
+    context 'words that match are not contained' do
+      before do
+        container.add 'hello'
+      end
+
+      it 'returns an empty array' do
+        expect(container.scan 'hi').to eq []
+      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 []
+        end
+      end
+    end
+  end
+end