rambling-trie 0.9.3 → 1.0.0

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

@@ -6,49 +6,23 @@ describe Rambling::Trie::Container do
   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
+    it 'uses the provided node as root' do
+      expect(container.root).to be root
     end
 
     context 'with a block' do
       it 'yields the container' do
-        yielded_container = nil
+        yielded = nil
 
-        container = Rambling::Trie::Container.new root do |container|
-          yielded_container = container
+        container = Rambling::Trie::Container.new root, compressor do |container|
+          yielded = container
         end
 
-        expect(yielded_container).to eq container
+        expect(yielded).to be container
       end
     end
   end
 
-  describe '#root' do
-    it 'returns the trie root node' do
-      expect(container.root).to eq root
-    end
-  end
-
   describe '#add' do
     let(:clone) { double :clone }
     let(:word) { double :word, clone: clone }
@@ -470,12 +444,9 @@ describe Rambling::Trie::Container do
   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'
+        %w(hi hello high hell highlight histerical).each do |word|
+          container.add word
+        end
       end
 
       it 'returns an array with the words that match' do
@@ -533,4 +504,122 @@ describe Rambling::Trie::Container do
       end
     end
   end
+
+  describe '#words_within' do
+    before do
+      %w(one word and other words).each do |word|
+        container.add word
+      end
+    end
+
+    context 'phrase does not contain any words' do
+      it 'returns an empty array' do
+        expect(container.words_within 'xyz').to match_array []
+      end
+
+      context 'and the node is compressed' do
+        before do
+          container.compress!
+        end
+
+        it 'returns an empty array' do
+          expect(container.words_within 'xyz').to match_array []
+        end
+      end
+    end
+
+    context 'phrase contains one word at the start of the phrase' do
+      it 'returns an array with the word found in the phrase' do
+        expect(container.words_within 'word').to match_array %w(word)
+        expect(container.words_within 'wordxyz').to match_array %w(word)
+      end
+
+      context 'and the node is compressed' do
+        before do
+          container.compress!
+        end
+
+        it 'returns an array with the word found in the phrase' do
+          expect(container.words_within 'word').to match_array %w(word)
+          expect(container.words_within 'wordxyz').to match_array %w(word)
+        end
+      end
+    end
+
+    context 'phrase contains one word at the end of the phrase' do
+      it 'returns an array with the word found in the phrase' do
+        expect(container.words_within 'xyz word').to match_array %w(word)
+      end
+
+      context 'and the node is compressed' do
+        before do
+          container.compress!
+        end
+
+        it 'returns an array with the word found in the phrase' do
+          expect(container.words_within 'xyz word').to match_array %w(word)
+        end
+      end
+    end
+
+    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)
+      end
+
+      context 'and the node is compressed' do
+        before do
+          container.compress!
+        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)
+        end
+      end
+    end
+  end
+
+  describe '#words_within?' do
+    before do
+      %w(one word and other words).each do |word|
+        container.add word
+      end
+    end
+
+    context 'phrase does not contain any words' do
+      it 'returns false' do
+        expect(container.words_within? 'xyz').to be false
+      end
+    end
+
+    context 'phrase contains any word' do
+      it 'returns true' do
+        expect(container.words_within? 'xyz words').to be true
+        expect(container.words_within? 'xyzone word').to be true
+      end
+    end
+  end
+
+  describe '#==' do
+    context 'when the root nodes are the same' do
+      let(:other_container) { Rambling::Trie::Container.new container.root, compressor }
+
+      it 'returns true' do
+        expect(container).to eq other_container
+      end
+    end
+
+    context 'when the root nodes are not the same' do
+      let(:other_root) { Rambling::Trie::RawNode.new }
+      let(:other_container) do
+        Rambling::Trie::Container.new other_root, compressor do |c|
+          c << 'hola'
+        end
+      end
+
+      it 'returns false' do
+        expect(container).not_to eq other_container
+      end
+    end
+  end
 end

data/spec/lib/rambling/trie/{inspector_spec.rb → inspectable_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Rambling::Trie::Inspector do
+describe Rambling::Trie::Inspectable do
   let(:root) { Rambling::Trie::RawNode.new }
 
   before do
@@ -9,10 +9,12 @@ describe Rambling::Trie::Inspector do
 
   describe '#inspect' do
     let(:node) { root[:o] }
+    let(:terminal_node) { root[:o][:n][:l][:y] }
 
     it 'returns a pretty printed version of the node' do
-      expect(root.inspect).to eq "#<Rambling::Trie::RawNode letter: nil, children: [:o, :t, :w]>"
-      expect(node.inspect).to eq "#<Rambling::Trie::RawNode letter: :o, children: [:n]>"
+      expect(root.inspect).to eq "#<Rambling::Trie::RawNode letter: nil, terminal: nil, children: [:o, :t, :w]>"
+      expect(node.inspect).to eq "#<Rambling::Trie::RawNode letter: :o, terminal: nil, children: [:n]>"
+      expect(terminal_node.inspect).to eq "#<Rambling::Trie::RawNode letter: :y, terminal: true, children: []>"
     end
 
     context 'for a compressed node' do
@@ -21,8 +23,8 @@ describe Rambling::Trie::Inspector do
       let(:compressed_node) { compressed_root[:only] }
 
       it 'returns a pretty printed version of the compressed node' do
-        expect(compressed_root.inspect).to eq "#<Rambling::Trie::CompressedNode letter: nil, children: [:only, :three, :words]>"
-        expect(compressed_node.inspect).to eq "#<Rambling::Trie::CompressedNode letter: :only, children: []>"
+        expect(compressed_root.inspect).to eq "#<Rambling::Trie::CompressedNode letter: nil, terminal: nil, children: [:only, :three, :words]>"
+        expect(compressed_node.inspect).to eq "#<Rambling::Trie::CompressedNode letter: :only, terminal: true, children: []>"
       end
     end
   end

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

@@ -347,61 +347,42 @@ describe Rambling::Trie::RawNode do
     end
   end
 
-  describe '#as_word' do
-    let(:node) { Rambling::Trie::RawNode.new }
-
-    context 'for an empty node' do
-      before do
-        node.add ''
-      end
-
-      it 'returns nil' do
-        expect(node.as_word).to be_empty
-      end
+  describe '#match_prefix' do
+    before do
+      node.letter = :i
+      node.add 'gnite'
+      node.add 'mport'
+      node.add 'mportant'
+      node.add 'mportantly'
     end
 
-    context 'for one letter' do
+    context 'when the node is terminal' do
       before do
-        node.letter = :a
-        node.add ''
+        node.terminal!
       end
 
-      it 'returns the expected one letter word' do
-        expect(node.as_word).to eq 'a'
+      it 'adds itself to the words' do
+        expect(node.match_prefix %w(g n i t e)).to include 'i'
       end
     end
 
-    context 'for a small word' do
-      before do
-        node.letter = :a
-        node.add 'll'
-      end
-
-      it 'returns the expected small word' do
-        expect(node[: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 Rambling::Trie::InvalidOperation
+    context 'when the node is not terminal' do
+      it 'does not add itself to the words' do
+        expect(node.match_prefix %w(g n i t e)).not_to include 'i'
       end
     end
 
-    context 'for a long word' do
-      before do
-        node.letter = :b
-        node.add 'eautiful'
-      end
-
-      it 'returns the expected long word' do
-        expect(node[:e][:a][:u][:t][:i][:f][:u][:l].as_word).to eq 'beautiful'
+    context 'when the first few chars match a terminal node' do
+      it 'adds those terminal nodes to the words' do
+        words = node.match_prefix(%w(m p o r t a n t l y)).to_a
+        expect(words).to include 'import', 'important', 'importantly'
       end
     end
 
-    context 'for a node with nil letter' do
-      let(:node) { Rambling::Trie::RawNode.new nil }
-
-      it 'returns nil' do
-        expect(node.as_word).to be_empty
+    context 'when the first few chars do not match a terminal node' do
+      it 'does not add any other words found' do
+        words = node.match_prefix(%w(m p m p o r t a n t l y)).to_a
+        expect(words).not_to include 'import', 'important', 'importantly'
       end
     end
   end

data/spec/lib/rambling/trie/readers/plain_text_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Rambling::Trie::Readers::PlainText do
+  describe '#each_word' do
+    let(:filepath) { File.join(::SPEC_ROOT, 'assets', 'test_words.en_US.txt') }
+    let(:words) { File.readlines(filepath).map &:chomp }
+
+    it 'yields every word yielded by the file' do
+      yielded = []
+      subject.each_word(filepath) { |word| yielded << word }
+      expect(yielded).to eq words
+    end
+  end
+end

data/spec/lib/rambling/trie/serializers/file_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Rambling::Trie::Serializers::File do
+  let(:serializer) { Rambling::Trie::Serializers::File.new }
+
+  it_behaves_like 'a serializer' do
+    let(:filepath) { File.join ::SPEC_ROOT, 'tmp', 'trie-root.file' }
+    let(:content) { 'a few words to validate that load and dump are working' }
+    let(:formatted_content) { content }
+  end
+end

data/spec/lib/rambling/trie/serializers/marshal_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Rambling::Trie::Serializers::Marshal do
+  let(:serializer) { Rambling::Trie::Serializers::Marshal.new }
+
+  let(:words) { %w(a few words to validate that load and dump are working) }
+  let(:trie) { Rambling::Trie.create { |t| words.each { |w| t << w } } }
+
+  it_behaves_like 'a serializer' do
+    let(:filepath) { File.join ::SPEC_ROOT, 'tmp', 'trie-root.marshal' }
+    let(:content) { trie.root }
+    let(:formatted_content) { Marshal.dump content }
+  end
+end

data/spec/lib/rambling/trie/serializers/yaml_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Rambling::Trie::Serializers::Yaml do
+  let(:serializer) { Rambling::Trie::Serializers::Yaml.new }
+
+  let(:words) { %w(a few words to validate that load and dump are working) }
+  let(:trie) { Rambling::Trie.create { |t| words.each { |w| t << w } } }
+
+  it_behaves_like 'a serializer' do
+    let(:filepath) { File.join ::SPEC_ROOT, 'tmp', 'trie-root.yml' }
+    let(:content) { trie.root }
+    let(:formatted_content) { YAML.dump content }
+  end
+end

data/spec/lib/rambling/trie/serializers/zip_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Rambling::Trie::Serializers::Zip do
+  let(:properties) { Rambling::Trie::Configuration::Properties.new }
+  let(:serializer) { Rambling::Trie::Serializers::Zip.new properties }
+
+  let(:words) { %w(a few words to validate that load and dump are working) }
+  let(:trie) { Rambling::Trie.create { |t| words.each { |w| t << w } } }
+  let(:tmp_path) { File.join ::SPEC_ROOT, 'tmp' }
+
+  before do
+    properties.tmp_path = tmp_path
+  end
+
+  it_behaves_like 'a serializer' do
+    let(:filename) { 'trie-root.marshal' }
+    let(:filepath) { File.join tmp_path, "#{filename}.zip" }
+    let(:content) { trie.root }
+    let(:formatted_content) { zip Marshal.dump content }
+  end
+
+  def zip content
+    io = Zip::OutputStream.write_buffer do |io|
+      io.put_next_entry filename
+      io.write content
+    end
+    io.rewind
+    io.read
+  end
+end

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

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Rambling::Trie::Stringifyable do
+  describe '#as_word' do
+    let(:node) { Rambling::Trie::RawNode.new }
+
+    context 'for an empty node' do
+      before do
+        node.add ''
+      end
+
+      it 'returns nil' do
+        expect(node.as_word).to be_empty
+      end
+    end
+
+    context 'for one letter' do
+      before do
+        node.letter = :a
+        node.add ''
+      end
+
+      it 'returns the expected one letter word' do
+        expect(node.as_word).to eq 'a'
+      end
+    end
+
+    context 'for a small word' do
+      before do
+        node.letter = :a
+        node.add 'll'
+      end
+
+      it 'returns the expected small word' do
+        expect(node[: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 Rambling::Trie::InvalidOperation
+      end
+    end
+
+    context 'for a long word' do
+      before do
+        node.letter = :b
+        node.add 'eautiful'
+      end
+
+      it 'returns the expected long word' do
+        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) { Rambling::Trie::RawNode.new nil }
+
+      it 'returns nil' do
+        expect(node.as_word).to be_empty
+      end
+    end
+
+    context 'for a compressed node' do
+      let(:compressor) { Rambling::Trie::Compressor.new }
+      let(:compressed_node) { compressor.compress node }
+
+      before do
+        node.letter = :a
+        node.add 'm'
+        node.add 'dd'
+      end
+
+      it 'returns the words for the terminal nodes' do
+        expect(compressed_node[:m].as_word).to eq 'am'
+        expect(compressed_node[:dd].as_word).to eq 'add'
+      end
+
+      it 'raise an error for non terminal nodes' do
+        expect { compressed_node.as_word }.to raise_error Rambling::Trie::InvalidOperation
+      end
+    end
+  end
+end