rambling-trie 1.0.2 → 2.2.0

data/lib/rambling/trie/stringifyable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rambling
   module Trie
     # Provides the String representation behavior for the trie data structure.
@@ -6,14 +8,18 @@ module Rambling
       # @return [String] the string representation of the current node.
       # @raise [InvalidOperation] if node is not terminal or is root.
       def as_word
-        raise Rambling::Trie::InvalidOperation, 'Cannot represent branch as a word' if letter && !terminal?
+        if letter && !terminal?
+          raise Rambling::Trie::InvalidOperation,
+            'Cannot represent branch as a word'
+        end
+
         to_s
       end
 
       # String representation of the current node.
       # @return [String] the string representation of the current node.
       def to_s
-        parent.to_s << letter.to_s
+        parent.to_s + letter.to_s
       end
     end
   end

data/lib/rambling/trie/version.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module Rambling
   module Trie
     # Current version of the rambling-trie.
-    VERSION = '1.0.2'.freeze
+    VERSION = '2.2.0'
   end
 end

data/rambling-trie.gemspec

@@ -1,26 +1,37 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
 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 Ruby implementation of the trie data structure, which includes compression abilities and is designed to be very fast to traverse.'
+
+  gem.description = <<~DESCRIPTION.gsub(%r{\s+}, ' ')
+    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.
+  DESCRIPTION
+
   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'
 
-  gem.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename f }
-  gem.files = `git ls-files -- {lib,*file,*.gemspec,LICENSE*,README*}`.split "\n"
-  gem.test_files = `git ls-files -- {test,spec,features}/*`.split "\n"
-  gem.require_paths = ['lib']
+  executables = `git ls-files -- bin/*`.split "\n"
+  files = `git ls-files -- {lib,*file,*.gemspec,LICENSE*,README*}`.split "\n"
+  test_files = `git ls-files -- {test,spec,features}/*`.split "\n"
+
+  gem.executables = executables.map { |f| File.basename f }
+  gem.files = files
+  gem.test_files = test_files
+  gem.require_paths = %w(lib)
 
   gem.name = 'rambling-trie'
   gem.license = 'MIT'
   gem.version = Rambling::Trie::VERSION
   gem.platform = Gem::Platform::RUBY
+  gem.required_ruby_version = '>= 2.5', '<= 3.0.0'
 
-  gem.add_development_dependency 'rspec', '~> 3.5'
-  gem.add_development_dependency 'rake', '~> 12.0'
-  gem.add_development_dependency 'yard', '~> 0.9.5'
+  gem.add_development_dependency 'rake', '~> 13.0'
+  gem.add_development_dependency 'rspec', '~> 3.9'
+  gem.add_development_dependency 'yard', '~> 0.9.25'
 end

data/spec/assets/test_words.es_DO.txt

@@ -21,3 +21,4 @@ tus
 tuyos
 verdad
 verdadero
+🙃

data/spec/integration/rambling/trie_spec.rb

@@ -1,61 +1,72 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
+require 'zip'
 
 describe Rambling::Trie do
-  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 { |t| words.each { |w| t << w } } }
+  let(:assets_path) { File.join ::SPEC_ROOT, 'assets' }
+
+  context 'when providing words directly' do
+    it_behaves_like 'a compressible trie' do
+      let(:trie) { Rambling::Trie.create }
+      let(:words) { %w(a couple of words for our full trie integration test) }
+
+      before do
+        trie.concat words
+      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.en_US.txt' }
-      let(:words) { File.readlines(filepath).map &:chomp! }
-      let(:trie) { Rambling::Trie.create filepath }
+  context 'when provided with words with unicode characters' do
+    it_behaves_like 'a compressible trie' do
+      let(:trie) { Rambling::Trie.create }
+      let(:words) do
+        %w(poquísimas palabras para nuestra prueba de integración completa 🙃)
+      end
+
+      before do
+        trie.concat words
+      end
     end
   end
 
-  describe 'with words with unicode characters' do
-    it_behaves_like 'a compressable trie' do
-      let(:words) { %w[poquísimas palabras para nuestra prueba de integración completa] }
-      let(:trie) { Rambling::Trie.create { |t| words.each { |w| t << w } } }
+  context 'when provided with a filepath' do
+    let(:trie) { Rambling::Trie.create filepath }
+    let(:words) { File.readlines(filepath).map(&:chomp) }
+
+    context 'with english words' do
+      it_behaves_like 'a compressible trie' do
+        let(:filepath) { File.join assets_path, 'test_words.en_US.txt' }
+      end
     end
-  end
 
-  describe 'with words with unicode characters from a file' do
-    it_behaves_like 'a compressable trie' do
-      let(:filepath) { File.join ::SPEC_ROOT, 'assets', 'test_words.en_US.txt' }
-      let(:words) { File.readlines(filepath).map &:chomp! }
-      let(:trie) { Rambling::Trie.create filepath }
+    context 'with unicode characters' do
+      it_behaves_like 'a compressible trie' do
+        let(:filepath) { File.join assets_path, 'test_words.es_DO.txt' }
+      end
     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' }
+  describe 'dump and load' do
+    let(:words_filepath) { File.join assets_path, 'test_words.en_US.txt' }
+    let(:words) { File.readlines(words_filepath).map(&:chomp) }
 
     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 }
+        let(:trie_to_serialize) { Rambling::Trie.create words_filepath }
+        let(:format) { :marshal }
       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 }
+        let(:trie_to_serialize) { Rambling::Trie.create words_filepath }
+        let(:format) { :yml }
       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
@@ -63,15 +74,13 @@ describe Rambling::Trie do
       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 }
+        let(:trie_to_serialize) { Rambling::Trie.create words_filepath }
+        let(:format) { 'marshal.zip' }
       end
     end
   end

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

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Rambling::Trie::Comparable do
   describe '#==' do
-    let(:node_1) { Rambling::Trie::RawNode.new }
-    let(:node_2) { Rambling::Trie::RawNode.new }
+    let(:node_1) { Rambling::Trie::Nodes::Raw.new }
+    let(:node_2) { Rambling::Trie::Nodes::Raw.new }
 
     context 'when the nodes do not have the same letter' do
       before do
@@ -67,37 +69,28 @@ describe Rambling::Trie::Comparable do
     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'
+        add_words node_1, %w(hese hree hings)
 
         node_2.letter = :t
-        node_2.add 'hese'
-        node_2.add 'hree'
-        node_2.add 'hings'
+        add_words node_2, %w(hese hree 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'
+        add_words node_1, %w(hese wo)
 
         node_2.letter = :t
-        node_2.add 'hese'
-        node_2.add 'hree'
-        node_2.add 'hings'
+        add_words node_2, %w(hese hree 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

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

@@ -1,31 +1,108 @@
+# frozen_string_literal: true
+
 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
+    let(:node) { Rambling::Trie::Nodes::Raw.new }
+
+    it 'compresses the node' do
+      add_words node, %w(a few words hello hell)
+      compressed = compressor.compress node
+
+      expect(compressed.children_tree.keys).to eq %i(a f w h)
+    end
+
+    context 'with at least one word' do
+      before do
+        add_words node, %w(all the words)
+      end
+
+      it 'keeps the node letter nil' do
+        compressed = compressor.compress node
+
+        expect(compressed.letter).to be_nil
+      end
     end
 
-    before do
-      words.each { |w| root.add w.clone }
+    context 'with a single word' do
+      before do
+        add_word node, 'all'
+      end
+
+      it 'compresses into a single node without children' do
+        compressed = compressor.compress node
+
+        expect(compressed[:a].letter).to eq :all
+        expect(compressed[:a].children.size).to eq 0
+        expect(compressed[:a]).to be_terminal
+        expect(compressed[:a]).to be_compressed
+      end
     end
 
-    it 'generates a new root with the words from the passed root' do
-      new_root = compressor.compress root
+    context 'with two words' do
+      before do
+        add_words node, %w(all ask)
+      end
+
+      it 'compresses into corresponding three nodes' do
+        compressed = compressor.compress node
+
+        expect(compressed[:a].letter).to eq :a
+        expect(compressed[:a].children.size).to eq 2
+
+        expect(compressed[:a][:l].letter).to eq :ll
+        expect(compressed[:a][:s].letter).to eq :sk
+
+        expect(compressed[:a][:l].children.size).to eq 0
+        expect(compressed[:a][:s].children.size).to eq 0
 
-      expect(words).not_to be_empty
-      words.each do |word|
-        expect(new_root).to include word
+        expect(compressed[:a][:l]).to be_terminal
+        expect(compressed[:a][:s]).to be_terminal
+
+        expect(compressed[:a][:l]).to be_compressed
+        expect(compressed[:a][:s]).to be_compressed
       end
     end
 
-    it 'compresses the new root' do
-      new_root = compressor.compress root
+    it 'reassigns the parent nodes correctly' do
+      add_words node, %w(repay rest repaint)
+      compressed = compressor.compress node
+
+      expect(compressed[:r].letter).to eq :re
+      expect(compressed[:r].parent).to eq compressed
+      expect(compressed[:r].children.size).to eq 2
+
+      expect(compressed[:r][:p].letter).to eq :pa
+      expect(compressed[:r][:p].parent).to eq compressed[:r]
+      expect(compressed[:r][:p].children.size).to eq 2
+
+      expect(compressed[:r][:s].letter).to eq :st
+      expect(compressed[:r][:s].parent).to eq compressed[:r]
+      expect(compressed[:r][:s].children.size).to eq 0
+
+      expect(compressed[:r][:p][:y].letter).to eq :y
+      expect(compressed[:r][:p][:y].parent).to eq compressed[:r][:p]
+      expect(compressed[:r][:p][:y].children.size).to eq 0
+
+      expect(compressed[:r][:p][:i].letter).to eq :int
+      expect(compressed[:r][:p][:i].parent).to eq compressed[:r][:p]
+      expect(compressed[:r][:p][:i].children.size).to eq 0
+    end
+
+    it 'does not compress terminal nodes' do
+      add_words node, %w(you your yours)
+      compressed = compressor.compress node
+
+      expect(compressed[:y].letter).to eq :you
+
+      expect(compressed[:y][:r].letter).to eq :r
+      expect(compressed[:y][:r]).to be_compressed
 
-      expect(new_root.children_tree.keys).to eq %i(a few words hell)
+      expect(compressed[:y][:r][:s].letter).to eq :s
+      expect(compressed[:y][:r][:s]).to be_compressed
     end
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Rambling::Trie::Configuration::Properties do
@@ -6,27 +8,33 @@ describe Rambling::Trie::Configuration::Properties do
   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
+      expect(serializers.formats).to match_array %i(marshal yaml yml zip)
+      expect(serializers.providers.to_a).to match_array [
+        [:marshal, Rambling::Trie::Serializers::Marshal],
+        [:yaml, Rambling::Trie::Serializers::Yaml],
+        [:yml, Rambling::Trie::Serializers::Yaml],
+        [:zip, 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
+      expect(readers.formats).to match_array %i(txt)
+      expect(readers.providers.to_a).to match_array [
+        [:txt, Rambling::Trie::Readers::PlainText],
+      ]
     end
 
     it 'configures the compressor' do
-      expect(properties.compressor).to be_instance_of Rambling::Trie::Compressor
+      compressor = properties.compressor
+      expect(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
+      root = properties.root_builder.call
+      expect(root).to be_instance_of Rambling::Trie::Nodes::Raw
     end
   end
 
@@ -37,13 +45,13 @@ describe Rambling::Trie::Configuration::Properties do
     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
+      expect(properties.serializers.formats).to include :test
+      expect(properties.readers.formats).to include :test
 
       properties.reset
 
-      expect(properties.serializers.keys).not_to include :test
-      expect(properties.readers.keys).not_to include :test
+      expect(properties.serializers.formats).not_to include :test
+      expect(properties.readers.formats).not_to include :test
     end
   end
 end