rambling-trie 0.9.3 → 1.0.0

data/lib/rambling/trie/version.rb

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

data/rambling-trie.gemspec

@@ -5,8 +5,8 @@ require 'rambling/trie/version'
 Gem::Specification.new do |gem|
   gem.authors = ['Edgar Gonzalez', 'Lilibeth De La Cruz']
   gem.email = ['edggonzalezg@gmail.com', 'lilibethdlc@gmail.com']
-  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.description = 'The Rambling Trie is a Ruby implementation of the trie data structure, which includes compression abilities and is designed to be very fast to traverse.'
+  gem.summary = 'A Ruby implementation of the trie data structure.'
   gem.homepage = 'http://github.com/gonzedge/rambling-trie'
   gem.date = Time.now.strftime '%Y-%m-%d'
 

data/spec/integration/rambling/trie_spec.rb

@@ -1,55 +1,6 @@
 require 'spec_helper'
 
 describe Rambling::Trie do
-  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 do |word|
-        expect(trie).to include word
-        expect(trie.word? word).to be true
-      end
-    end
-
-    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] }
@@ -79,4 +30,49 @@ describe Rambling::Trie do
       let(:trie) { Rambling::Trie.create filepath }
     end
   end
+
+  describe 'saving and loading full trie from a file' do
+    let(:words_filepath) { File.join ::SPEC_ROOT, 'assets', 'test_words.en_US.txt' }
+    let(:words) { File.readlines(words_filepath).map &:chomp! }
+    let(:trie_to_serialize) { Rambling::Trie.create words_filepath }
+    let(:trie_filename) { File.join ::SPEC_ROOT, '..', 'tmp', 'trie-root' }
+
+    context 'when serialized with Ruby marshal format (default)' do
+      it_behaves_like 'a serializable trie' do
+        let(:trie_filepath) { "#{trie_filename}.marshal" }
+        let(:loaded_trie) { Rambling::Trie.load trie_filepath }
+        let(:serializer) { nil }
+      end
+    end
+
+    context 'when serialized with YAML' do
+      it_behaves_like 'a serializable trie' do
+        let(:trie_filepath) { "#{trie_filename}.yml" }
+        let(:loaded_trie) { Rambling::Trie.load trie_filepath }
+        let(:serializer) { nil }
+      end
+    end
+
+    context 'when serialized with zipped Ruby marshal format' do
+      before do
+        require 'zip'
+        @original_on_exists_proc = ::Zip.on_exists_proc
+        @original_continue_on_exists_proc = ::Zip.continue_on_exists_proc
+        ::Zip.on_exists_proc = true
+        ::Zip.continue_on_exists_proc = true
+      end
+
+      after do
+        require 'zip'
+        ::Zip.on_exists_proc = @original_on_exists_proc
+        ::Zip.continue_on_exists_proc = @original_continue_on_exists_proc
+      end
+
+      it_behaves_like 'a serializable trie' do
+        let(:trie_filepath) { "#{trie_filename}.marshal.zip" }
+        let(:loaded_trie) { Rambling::Trie.load trie_filepath }
+        let(:serializer) { nil }
+      end
+    end
+  end
 end

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

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe Rambling::Trie::Comparable do
+  describe '#==' do
+    let(:node_1) { Rambling::Trie::RawNode.new }
+    let(:node_2) { Rambling::Trie::RawNode.new }
+
+    context 'when the nodes do not have the same letter' do
+      before do
+        node_1.letter = :a
+        node_2.letter = :b
+      end
+
+      it 'returns false' do
+        expect(node_1).not_to eq node_2
+      end
+    end
+
+    context 'when the nodes have the same letter and no children' do
+      before do
+        node_1.letter = :a
+        node_2.letter = :a
+      end
+
+      it 'returns true' do
+        expect(node_1).to eq node_2
+      end
+    end
+
+    context 'when the nodes have the same letter and are terminal' do
+      before do
+        node_1.letter = :a
+        node_1.terminal!
+
+        node_2.letter = :a
+        node_2.terminal!
+      end
+
+      it 'returns true' do
+        expect(node_1).to eq node_2
+      end
+    end
+
+    context 'when the nodes have the same letter and are not terminal' do
+      before do
+        node_1.letter = :a
+        node_2.letter = :a
+      end
+
+      it 'returns true' do
+        expect(node_1).to eq node_2
+      end
+    end
+
+    context 'when the nodes have the same letter but are not both terminal' do
+      before do
+        node_1.letter = :a
+        node_1.terminal!
+
+        node_2.letter = :a
+      end
+      it 'returns false' do
+        expect(node_1).not_to eq node_2
+      end
+    end
+
+    context 'when the nodes have the same letter and the same children' do
+      before do
+        node_1.letter = :t
+        node_1.add 'hese'
+        node_1.add 'hree'
+        node_1.add 'hings'
+
+        node_2.letter = :t
+        node_2.add 'hese'
+        node_2.add 'hree'
+        node_2.add 'hings'
+      end
+
+      it 'returns true' do
+        expect(node_1).to eq node_2
+        expect(node_1[:h][:e][:s][:e]).to eq node_2[:h][:e][:s][:e]
+      end
+    end
+
+    context 'when the nodes have the same letter but different children' do
+      before do
+        node_1.letter = :t
+        node_1.add 'hese'
+        node_1.add 'wo'
+
+        node_2.letter = :t
+        node_2.add 'hese'
+        node_2.add 'hree'
+        node_2.add 'hings'
+      end
+
+      it 'returns false' do
+        expect(node_1).not_to eq node_2
+        expect(node_1[:h][:e][:s][:e]).to eq node_2[:h][:e][:s][:e]
+      end
+    end
+  end
+end

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

@@ -152,4 +152,48 @@ describe Rambling::Trie::CompressedNode do
       end
     end
   end
+
+  describe '#match_prefix' do
+    let(:raw_node) { Rambling::Trie::RawNode.new }
+    let(:compressor) { Rambling::Trie::Compressor.new }
+    let(:node) { compressor.compress raw_node }
+
+    before do
+      raw_node.letter = :i
+      raw_node.add 'gnite'
+      raw_node.add 'mport'
+      raw_node.add 'mportant'
+      raw_node.add 'mportantly'
+    end
+
+    context 'when the node is terminal' do
+      before do
+        raw_node.terminal!
+      end
+
+      it 'adds itself to the words' do
+        expect(node.match_prefix %w(g n i t e)).to include 'i'
+      end
+    end
+
+    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 '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 '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
 end

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

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Rambling::Trie::Configuration::Properties do
+  let(:properties) { Rambling::Trie::Configuration::Properties.new }
+
+  describe '.new' do
+    it 'configures the serializers' do
+      serializers = properties.serializers
+      expect(serializers.keys).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
+      expect(serializers[:yml]).to be_instance_of Rambling::Trie::Serializers::Yaml
+      expect(serializers[:zip]).to be_instance_of Rambling::Trie::Serializers::Zip
+    end
+
+    it 'configures the readers' do
+      readers = properties.readers
+      expect(readers.keys).to match_array %i(txt)
+
+      expect(readers[:txt]).to be_instance_of Rambling::Trie::Readers::PlainText
+    end
+
+    it 'configures the compressor' do
+      expect(properties.compressor).to be_instance_of Rambling::Trie::Compressor
+    end
+
+    it 'configures the root_builder' do
+      expect(properties.root_builder.call).to be_instance_of Rambling::Trie::RawNode
+    end
+  end
+
+  describe '#reset' do
+    before do
+      properties.serializers.add :test, 'test'
+      properties.readers.add :test, 'test'
+    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
+
+      properties.reset
+
+      expect(properties.serializers.keys).not_to include :test
+      expect(properties.readers.keys).not_to include :test
+    end
+  end
+end

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

@@ -0,0 +1,165 @@
+require 'spec_helper'
+
+describe Rambling::Trie::Configuration::ProviderCollection do
+  let(:configured_default) { nil }
+  let(:configured_providers) do
+    { one: first_provider, two: second_provider }
+  end
+
+  let(:first_provider) { double :first_provider }
+  let(:second_provider) { double :second_provider }
+
+  let(:provider_collection) do
+    Rambling::Trie::Configuration::ProviderCollection.new(
+      'provider',
+      configured_providers,
+      configured_default
+    )
+  end
+
+  describe '.new' do
+    it 'has a name' do
+      expect(provider_collection.name).to eq 'provider'
+    end
+
+    it 'has the given providers' do
+      expect(provider_collection.providers)
+        .to eq one: first_provider, two: second_provider
+    end
+
+    it 'has a default provider' do
+      expect(provider_collection.default).to eq first_provider
+    end
+
+    context 'when a default is provided' do
+      let(:configured_default) { second_provider }
+
+      it 'has that as the default provider' do
+        expect(provider_collection.default).to eq second_provider
+      end
+    end
+  end
+
+  describe 'aliases and delegates' do
+    let(:providers) { provider_collection.providers }
+
+    before do
+      allow(providers) .to receive_messages(
+        :[] => nil,
+        :[]= => nil,
+        keys: nil,
+        values: nil,
+      )
+    end
+
+    it 'delegates #[] to providers' do
+      provider_collection[:key]
+      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
+      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
+    let(:provider) { double :provider }
+
+    before do
+      provider_collection.add :three, provider
+    end
+
+    it 'adds a new provider' do
+      expect(provider_collection.providers[:three]).to eq provider
+    end
+  end
+
+  describe '#default=' do
+    let(:other_provider) { double :other_provider }
+
+    context 'when the given value is in the providers list' do
+      it 'changes the default provider' do
+        provider_collection.default = second_provider
+        expect(provider_collection.default).to eq second_provider
+      end
+    end
+
+    context 'when the given value is not in the providers list' do
+      it 'does not change the default provider' do
+        expect do
+          begin
+            provider_collection.default = other_provider
+          rescue
+          end
+        end.not_to change { provider_collection.default }
+      end
+
+      it 'raises an ArgumentError' do
+        expect do
+          provider_collection.default = other_provider
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when the providers list is empty' do
+      let(:configured_providers) do
+        {}
+      end
+
+      it 'accepts nil' do
+        provider_collection.default = nil
+        expect(provider_collection.default).to be_nil
+      end
+
+      it 'raises an ArgumentError for any other provider' do
+        expect do
+          provider_collection.default = other_provider
+        end.to raise_error ArgumentError
+        expect(provider_collection.default).to be_nil
+      end
+    end
+  end
+
+  describe '#resolve' do
+    context 'when the file extension is one of the providers' do
+      it 'returns the corresponding provider' do
+        expect(provider_collection.resolve 'hola.one').to eq first_provider
+        expect(provider_collection.resolve 'hola.two').to eq second_provider
+      end
+    end
+
+    context 'when the file extension is not one of the providers' do
+      it 'returns the default provider' do
+        expect(provider_collection.resolve 'hola.unknown').to eq first_provider
+        expect(provider_collection.resolve 'hola').to eq first_provider
+      end
+    end
+  end
+
+  describe '#reset' do
+    let(:configured_default) { second_provider }
+    let(:provider) { double :provider }
+
+    before do
+      provider_collection.add :three, provider
+      provider_collection.default = provider
+    end
+
+    it 'resets to back to the initially configured values' do
+      provider_collection.reset
+      expect(provider_collection[:three]).to be_nil
+      expect(provider_collection.default).to eq second_provider
+    end
+  end
+end