rambling-trie 1.0.2 → 1.0.3

data/lib/rambling/trie/nodes/raw.rb

@@ -0,0 +1,89 @@
+module Rambling
+  module Trie
+    module Nodes
+      # A representation of a node in an uncompressed trie data structure.
+      class Raw < Rambling::Trie::Nodes::Node
+        # Adds a word to the current raw (uncompressed) trie node.
+        # @param [Array<Symbol>] chars the char array to add to the trie.
+        # @return [Raw] the added/modified node based on the word added.
+        # @note This method clears the contents of the chars variable.
+        def add chars
+          if chars.empty?
+            terminal!
+          else
+            add_to_children_tree chars
+          end
+        end
+
+        # Checks if a path for a set of characters exists in the trie.
+        # @param [Array<String>] chars the characters to look for in the trie.
+        # @return [Boolean] `true` if the characters are found, `false`
+        #   otherwise.
+        def partial_word? chars = []
+          return true if chars.empty?
+
+          letter = chars.slice!(0).to_sym
+          child = children_tree[letter]
+          !!child && child.partial_word?(chars)
+        end
+
+        # Checks if a path for set of characters represents a word in the trie.
+        # @param [Array<String>] chars the characters to look for in the trie.
+        # @return [Boolean] `true` if the characters are found and form a word,
+        #   `false` otherwise.
+        def word? chars = []
+          return terminal? if chars.empty?
+
+          letter = chars.slice!(0).to_sym
+          child = children_tree[letter]
+          !!child && child.word?(chars)
+        end
+
+        # Always return `false` for a raw (uncompressed) node.
+        # @return [Boolean] always `false` for a raw (uncompressed) node.
+        def compressed?
+          false
+        end
+
+        private
+
+        def add_to_children_tree chars
+          letter = chars.pop
+          child = children_tree[letter] || new_node(letter)
+          child.add chars
+          child
+        end
+
+        def new_node letter
+          node = Rambling::Trie::Nodes::Raw.new letter, self
+          children_tree[letter] = node
+          node
+        end
+
+        def closest_node chars
+          letter = chars.slice!(0).to_sym
+          child = children_tree[letter]
+
+          return Rambling::Trie::Nodes::Missing.new unless child
+
+          child.scan chars
+        end
+
+        def children_match_prefix chars
+          return enum_for :children_match_prefix, chars unless block_given?
+
+          return if chars.empty?
+
+          letter = chars.slice!(0).to_sym
+          child = children_tree[letter]
+
+          return unless child
+
+          child.match_prefix chars do |word|
+            yield word
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rambling/trie/readers/plain_text.rb

@@ -8,17 +8,7 @@ module Rambling
         #   from.
         # @yield [String] Each line read from the file.
         def each_word filepath
-          each_line(filepath) { |line| yield line.chomp! }
-        end
-
-        private
-
-        def each_line filepath
-          open(filepath) { |file| file.each_line { |line| yield line } }
-        end
-
-        def open filepath
-          File.open(filepath) { |file| yield file }
+          File.foreach(filepath) { |line| yield line.chomp! }
         end
       end
     end

data/lib/rambling/trie/serializers/marshal.rb

@@ -11,17 +11,17 @@ module Rambling
         end
 
         # Loads marshaled object from contents in filepath and deserializes it
-        # into a {Node Node}.
+        # into a {Nodes::Node Node}.
         # @param [String] filepath the full path of the file to load the
         #   marshaled object from.
-        # @return [Node] The deserialized {Node Node}.
+        # @return [Nodes::Node] The deserialized {Nodes::Node Node}.
         def load filepath
           ::Marshal.load serializer.load filepath
         end
 
-        # Serializes a {Node Node} and dumps it as a marshaled object into
+        # Serializes a {Nodes::Node Node} and dumps it as a marshaled object into
         # filepath.
-        # @param [Node] node the node to serialize
+        # @param [Nodes::Node] node the node to serialize
         # @param [String] filepath the full path of the file to dump the
         #   marshaled object into.
         # @return [Numeric] number of bytes written to disk.

data/lib/rambling/trie/serializers/yaml.rb

@@ -11,17 +11,17 @@ module Rambling
         end
 
         # Loads serialized object from YAML file in filepath and deserializes
-        # it into a {Node Node}.
+        # it into a {Nodes::Node Node}.
         # @param [String] filepath the full path of the file to load the
         #   serialized YAML object from.
-        # @return [Node] The deserialized {Node Node}.
+        # @return [Nodes::Node] The deserialized {Nodes::Node Node}.
         def load filepath
           require 'yaml'
           ::YAML.load serializer.load filepath
         end
 
-        # Serializes a {Node Node} and dumps it as a YAML object into filepath.
-        # @param [Node] node the node to serialize
+        # Serializes a {Nodes::Node Node} and dumps it as a YAML object into filepath.
+        # @param [Nodes::Node] node the node to serialize
         # @param [String] filepath the full path of the file to dump the YAML
         #   object into.
         # @return [Numeric] number of bytes written to disk.

data/lib/rambling/trie/serializers/zip.rb

@@ -4,11 +4,9 @@ module Rambling
       # Zip file serializer. Dumps/loads contents from zip files. Automatically
       # detects if zip file contains `.marshal` or `.yml` file
       class Zip
-        extend ::Forwardable
-
         # Creates a new Zip serializer.
-        # @param [Properties] properties the configuration properties set up so
-        #   far.
+        # @param [Configuration::Properties] properties the configuration
+        #   properties set up so far.
         def initialize properties
           @properties = properties
         end
@@ -52,10 +50,13 @@ module Rambling
 
         attr_reader :properties
 
-        delegate [
-          :serializers,
-          :tmp_path
-        ] => :properties
+        def serializers
+          properties.serializers
+        end
+
+        def tmp_path
+          properties.tmp_path
+        end
 
         def path filename
           require 'securerandom'

data/lib/rambling/trie/version.rb

@@ -1,6 +1,6 @@
 module Rambling
   module Trie
     # Current version of the rambling-trie.
-    VERSION = '1.0.2'.freeze
+    VERSION = '1.0.3'.freeze
   end
 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,68 @@
 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(:words) { %w(a couple of words for our full trie integration test) }
+      let(:trie) { Rambling::Trie.create }
+
+      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(:words) { %w(poquísimas palabras para nuestra prueba de integración completa 🙃) }
+      let(:trie) { Rambling::Trie.create }
+
+      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(:words) { File.readlines(filepath).map &:chomp! }
+    let(:trie) { Rambling::Trie.create filepath }
+
+    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 +70,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

@@ -2,8 +2,8 @@ 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 +67,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

@@ -4,28 +4,103 @@ 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 few words hell)
     end
 
-    before do
-      words.each { |w| root.add w.clone }
+    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
 
-    it 'generates a new root with the words from the passed root' do
-      new_root = compressor.compress root
+    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(words).not_to be_empty
-      words.each do |word|
-        expect(new_root).to include word
+        expect(compressed[:all].letter).to eq :all
+        expect(compressed[:all].children.size).to eq 0
+        expect(compressed[:all]).to be_terminal
+        expect(compressed[:all]).to be_compressed
       end
     end
 
-    it 'compresses the new 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][:ll].letter).to eq :ll
+        expect(compressed[:a][:sk].letter).to eq :sk
+
+        expect(compressed[:a][:ll].children.size).to eq 0
+        expect(compressed[:a][:sk].children.size).to eq 0
+
+        expect(compressed[:a][:ll]).to be_terminal
+        expect(compressed[:a][:sk]).to be_terminal
+
+        expect(compressed[:a][:ll]).to be_compressed
+        expect(compressed[:a][:sk]).to be_compressed
+      end
+    end
+
+    it 'reassigns the parent nodes correctly' do
+      add_words node, %w(repay rest repaint)
+      compressed = compressor.compress node
+
+      expect(compressed[:re].letter).to eq :re
+      expect(compressed[:re].parent).to eq compressed
+      expect(compressed[:re].children.size).to eq 2
+
+      expect(compressed[:re][:pa].letter).to eq :pa
+      expect(compressed[:re][:pa].parent).to eq compressed[:re]
+      expect(compressed[:re][:pa].children.size).to eq 2
+
+      expect(compressed[:re][:st].letter).to eq :st
+      expect(compressed[:re][:st].parent).to eq compressed[:re]
+      expect(compressed[:re][:st].children.size).to eq 0
+
+      expect(compressed[:re][:pa][:y].letter).to eq :y
+      expect(compressed[:re][:pa][:y].parent).to eq compressed[:re][:pa]
+      expect(compressed[:re][:pa][:y].children.size).to eq 0
+
+      expect(compressed[:re][:pa][:int].letter).to eq :int
+      expect(compressed[:re][:pa][:int].parent).to eq compressed[:re][:pa]
+      expect(compressed[:re][:pa][:int].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[:you].letter).to eq :you
+
+      expect(compressed[:you][:r].letter).to eq :r
+      expect(compressed[:you][:r]).to be_compressed
 
-      expect(new_root.children_tree.keys).to eq %i(a few words hell)
+      expect(compressed[:you][:r][:s].letter).to eq :s
+      expect(compressed[:you][:r][:s]).to be_compressed
     end
   end
 end