rambling-trie 0.8.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c7aefe84824bbbfa09b239caca901b1e8022e33a
-  data.tar.gz: e7e22e2ac50d2f8be672063efb5bcae8342369b7
+  metadata.gz: 3bb17c6b1df5c473eb696bc484ff0e3b46517867
+  data.tar.gz: 0b6daafa67a20409389b80aaf9ac5d1bc6694cd2
 SHA512:
-  metadata.gz: 6d15a5de1d200e156fae33ca82e25b5be1d43d4916be1e88761ce0142c6c7002985164c2e2b95bf1c95f0e04b108f9f11671d3e50028e397d5f9520f996a8efe
-  data.tar.gz: ea776aaf5b0a0ecefc1ba7626a5d2676b04499f268e5acf39c7bd8b45f17160acd170358d7b2b52eb8c6022431696fc04dcaa2ab8f016cb4a2b31224ec824191
+  metadata.gz: ecaecb91b920793208c878134881f08a7718d9f9771857a49cb15f8059e35273e29f81ce21a497de37566cfae8273a13ff611b43f0d049694b0207c65efa35bd
+  data.tar.gz: 810db517696450d411d75ad59df68e410e0c1109ad1133bc7aa95363609520f8db51031a72e1b3392475524f8d10b28ca1e827bd5dbb9c3fba0aaa2417eeef41

data/Rakefile

@@ -3,6 +3,6 @@ require 'rspec/core/rake_task'
 require 'rambling-trie'
 require 'rambling/trie/tasks/performance'
 
-RSpec::Core::RakeTask.new(:spec)
+RSpec::Core::RakeTask.new :spec
 
 task default: :spec

data/lib/rambling/trie.rb

@@ -1,8 +1,7 @@
 require 'forwardable'
 %w{
-  branches compressor enumerable inspector
-  invalid_operation node missing_node
-  plain_text_reader root version
+  compression compressor inspector container enumerable invalid_operation
+  plain_text_reader node missing_node compressed_node raw_node version
 }.each do |file|
   require File.join('rambling', 'trie', file)
 end
@@ -14,14 +13,27 @@ module Rambling
     class << self
       # Creates a new Trie. Entry point for the Rambling::Trie API.
       # @param [String, nil] filepath the file to load the words from.
-      # @return [Root] the trie just created.
-      # @yield [Root] the trie just created.
-      def create filepath = nil, reader = PlainTextReader.new
-        Root.new do |root|
-          reader.each_word(filepath) { |word| root << word } if filepath
-          yield root if block_given?
+      # @return [Container] the trie just created.
+      # @yield [Container] the trie just created.
+      def create filepath = nil, reader = nil
+        reader ||= default_reader
+
+        Rambling::Trie::Container.new do |container|
+          if filepath
+            reader.each_word filepath do |word|
+              container << word
+            end
+          end
+
+          yield container if block_given?
         end
       end
+
+      private
+
+      def default_reader
+        Rambling::Trie::PlainTextReader.new
+      end
     end
   end
 end

data/lib/rambling/trie/compressed_node.rb

@@ -0,0 +1,112 @@
+module Rambling
+  module Trie
+    # A representation of a node in an compressed Trie data structure.
+    class CompressedNode < Rambling::Trie::Node
+      # Always raises [Rambling::Trie::InvalidOperation] when trying to add a
+      # branch to the current trie node based on the word
+      # @param [String] word the word to add the branch from.
+      # @raise [InvalidOperation] if the trie is already compressed.
+      def add word
+        raise Rambling::Trie::InvalidOperation, 'Cannot add branch to compressed trie'
+      end
+
+      # Checks if a path for set of characters exists in the trie.
+      # @param [Array] chars the characters to look for in the trie.
+      # @return [Boolean] `true` if the characters are found, `false` otherwise.
+      def partial_word? chars
+        chars.empty? || has_partial_word?(chars)
+      end
+
+      # Checks if a path for set of characters represents a word in the trie.
+      # @param [Array] 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
+        if chars.empty?
+          terminal?
+        else
+          has_word? chars
+        end
+      end
+
+      # Returns all words that start with the specified characters.
+      # @param [Array] chars the characters to look for in the trie.
+      # @return [Array] all the words contained in the trie that start with the specified characters.
+      def scan chars
+        closest_node(chars).to_a
+      end
+
+      # Always return `true` for a raw (compressed) node.
+      # @return [Boolean] always true for a raw (compressed) node.
+      def compressed?
+        true
+      end
+
+      protected
+
+      def closest_node chars
+        if chars.empty?
+          self
+        else
+          current_length = 0
+          current_key, current_key_string = current_key chars.slice!(0)
+
+          begin
+            current_length += 1
+
+            if current_key_string.length == current_length || chars.empty?
+              return children_tree[current_key].closest_node chars
+            end
+          end while current_key_string[current_length] == chars.slice!(0)
+
+          Rambling::Trie::MissingNode.new
+        end
+      end
+
+      private
+
+      def has_partial_word? chars
+        current_length = 0
+        current_key, current_key_string = current_key chars.slice!(0)
+
+        begin
+          current_length += 1
+
+          if current_key_string.length == current_length || chars.empty?
+            return children_tree[current_key].partial_word? chars
+          end
+        end while current_key_string[current_length] == chars.slice!(0)
+
+        false
+      end
+
+      def has_word? chars
+        current_key_string = ''
+
+        while !chars.empty?
+          current_key_string << chars.slice!(0)
+          current_key = current_key_string.to_sym
+          child = children_tree[current_key]
+          return child.word? chars if child
+        end
+
+        false
+      end
+
+      def current_key letter
+        current_key_string = current_key = ''
+
+        children_tree.keys.each do |key|
+          key_string = key.to_s
+          if key_string.start_with? letter
+            current_key = key
+            current_key_string = key_string
+            break
+          end
+        end
+
+        [current_key, current_key_string]
+      end
+    end
+  end
+end

data/lib/rambling/trie/compression.rb

@@ -0,0 +1,13 @@
+module Rambling
+  module Trie
+    # Provides the compressing behavior for the Trie data structure.
+    module Compression
+      # Indicates if the current [Rambling::Trie::Node] can be compressed.
+      # @return [Boolean] `true` for non-terminal nodes with one child,
+      # `false` otherwise.
+      def compressable?
+        !(root? || terminal?) && children_tree.size == 1
+      end
+    end
+  end
+end

data/lib/rambling/trie/compressor.rb

@@ -1,47 +1,46 @@
 module Rambling
   module Trie
-    # Provides the compressing behavior for the Trie data structure.
-    module Compressor
-      # Flag for compressed tries.
-      # @return [Boolean] `true` for compressed tries, `false` otherwise.
-      def compressed?
-        parent && parent.compressed?
+    # Responsible for the compression process of a Trie data structure.
+    class Compressor
+      # Compresses a node from a Trie data structure.
+      # @param [RawNode] node the node to compress
+      # @return [CompressedNode] node the compressed version of the node
+      def compress node, parent = nil
+        if node.compressable?
+          merge_node_with_compressed_child node, parent
+        else
+          copy_node_and_compress_children node, parent
+        end
       end
 
-      # Compress the current node using redundant node elimination.
-      # @return [Root, Node] the compressed node.
-      def compress_tree!
-        if compressable?
-          merge_with! children.first
-          compress_tree!
-        end
+      private
 
-        children.each &:compress_tree!
+      def merge_node_with_compressed_child node, parent
+        compressed_child = compress node.children.first
 
-        self
-      end
+        new_node = Rambling::Trie::CompressedNode.new parent
+        new_node.letter = node.letter.to_s << compressed_child.letter.to_s
+        new_node.terminal! if compressed_child.terminal?
+        new_node.children_tree = compressed_child.children_tree
 
-      private
+        new_node.children.each do |child|
+          child.parent = new_node
+        end
 
-      def compressable?
-        !(root? || terminal?) && children_tree.size == 1
+        new_node
       end
 
-      def merge_with! child
-        delete_old_key_on_parent!
-        redefine_self! child
+      def copy_node_and_compress_children node, parent
+        new_node = Rambling::Trie::CompressedNode.new parent
 
-        children.each { |node| node.parent = self }
-      end
+        new_node.letter = node.letter
+        new_node.terminal! if node.terminal?
 
-      def delete_old_key_on_parent!
-        parent.delete letter if parent
-      end
+        node.children.map do |child|
+          compress child, new_node
+        end
 
-      def redefine_self! merged_node
-        self.letter = letter.to_s << merged_node.letter.to_s
-        self.children_tree = merged_node.children_tree
-        self.terminal = merged_node.terminal?
+        new_node
       end
     end
   end

data/lib/rambling/trie/{root.rb → container.rb}

@@ -1,12 +1,27 @@
 module Rambling
   module Trie
-    # A representation of the root node in the Trie data structure.
-    class Root < Node
+    # Wrapper on top of Trie data structure.
+    class Container
+      extend ::Forwardable
+
+      include ::Enumerable
+
+      delegate [
+        :each,
+        :compressed?,
+        :[],
+        :letter,
+        :inspect
+      ] => :root
+
       # Creates a new Trie.
-      # @yield [Root] the trie just created.
-      def initialize
-        super
-        self.compressed = false
+      # @param [Node] root the root node for the trie
+      # @param [Compressor] compressor responsible for compressing the trie
+      # @yield [Container] the trie just created.
+      def initialize root = nil, compressor = nil
+        @root = root || default_root
+        @compressor = compressor || default_compressor
+
         yield self if block_given?
       end
 
@@ -14,71 +29,59 @@ module Rambling
       # @param [String] word the word to add the branch from.
       # @return [Node] the just added branch's root node.
       # @raise [InvalidOperation] if the trie is already compressed.
-      # @see Branches#add
+      # @see RawNode#add
+      # @see CompressedNode#add
       # @note Avoids clearing the contents of the word variable.
       def add word
-        super word.clone
+        root.add word.clone
       end
 
-      # Compresses the existing tree using redundant node elimination. Flags the trie as compressed.
-      # @return [Root] self
+      # Compresses the existing tree using redundant node elimination. Flags
+      # the trie as compressed.
+      # @return [Container] self
+      # @note Avoids compressing again if the trie has already been compressed.
       def compress!
-        self.compressed = compressed? || !!compress_tree!
+        self.root = compressor.compress root unless root.compressed?
         self
       end
 
-      # Flag for compressed tries. Overrides {Compressor#compressed?}.
-      # @return [Boolean] `true` for compressed tries, `false` otherwise.
-      def compressed?
-        !!compressed
-      end
-
       # Checks if a path for a word or partial word exists in the trie.
       # @param [String] word the word or partial word to look for in the trie.
       # @return [Boolean] `true` if the word or partial word is found, `false` otherwise.
       def partial_word? word = ''
-        is? :partial_word, word
-      end
-
-      alias_method :match?, :partial_word?
-
-      # If the current node is the root node.
-      # @return [Boolean] `true`
-      def root?
-        true
+        root.partial_word? word.chars.to_a
       end
 
       # Checks if a whole word exists in the trie.
       # @param [String] word the word to look for in the trie.
       # @return [Boolean] `true` only if the word is found and the last character corresponds to a terminal node.
       def word? word = ''
-        is? :word, word
+        root.word? word.chars.to_a
       end
 
-      alias_method :include?, :word?
-
       # Returns all words that start with the specified characters.
       # @param [String] word the word to look for in the trie.
       # @return [Array] all the words contained in the trie that start with the specified characters.
       def scan word = ''
-        closest_node(word).to_a
+        root.scan(word.chars).to_a
       end
 
+      alias_method :include?, :word?
+      alias_method :match?, :partial_word?
       alias_method :words, :scan
+      alias_method :<<, :add
 
       private
 
-      attr_accessor :compressed
+      attr_reader :compressor
+      attr_accessor :root
 
-      def is? method, word
-        method = compressed? ? "#{method}_when_compressed?" : "#{method}_when_uncompressed?"
-        send method, word.chars.to_a
+      def default_root
+        Rambling::Trie::RawNode.new
       end
 
-      def closest_node word
-        method = compressed? ? :closest_node_when_compressed : :closest_node_when_uncompressed
-
-        send method, word.chars.to_a
+      def default_compressor
+        Rambling::Trie::Compressor.new
       end
     end
   end

data/lib/rambling/trie/enumerable.rb

@@ -6,14 +6,18 @@ module Rambling
 
       alias_method :size, :count
 
-      # Calls block once for each of the words contained in the trie. If no block given, an Enumerator is returned.
-      def each &block
-        enumerator = Enumerator.new do |words|
-          words << as_word if terminal?
-          children.each { |child| child.each { |word| words << word } }
-        end
+      # Iterates over the words contained in the trie.
+      # @yield [String] the words contained in this trie node.
+      def each
+        return enum_for :each unless block_given?
+
+        yield as_word if terminal?
 
-        block.nil? ? enumerator : enumerator.each(&block)
+        children.each do |child|
+          child.each do |word|
+            yield word
+          end
+        end
       end
     end
   end

data/lib/rambling/trie/missing_node.rb

@@ -1,7 +1,7 @@
 module Rambling
   module Trie
     # A representation of a missing node in the Trie data structure.
-    class MissingNode < Node
+    class MissingNode < Rambling::Trie::Node
     end
   end
 end

data/lib/rambling/trie/node.rb

@@ -2,14 +2,18 @@ module Rambling
   module Trie
     # A representation of a node in the Trie data structure.
     class Node
-      extend Forwardable
+      extend ::Forwardable
 
-      delegate [:[], :[]=, :delete, :has_key?] => :children_tree
+      delegate [
+        :[],
+        :[]=,
+        :delete,
+        :has_key?
+      ] => :children_tree
 
-      include Compressor
-      include Branches
-      include Enumerable
-      include Inspector
+      include Rambling::Trie::Compression
+      include Rambling::Trie::Enumerable
+      include Rambling::Trie::Inspector
 
       # Letter or letters corresponding to this node.
       # @return [Symbol, nil] the corresponding letter(s) or nil.
@@ -17,24 +21,17 @@ module Rambling
 
       # Children nodes.
       # @return [Hash] the children_tree hash, consisting of :letter => node.
-      attr_reader :children_tree
+      attr_accessor :children_tree
 
       # Parent node.
       # @return [Node, nil] the parent node or nil for the root element.
       attr_accessor :parent
 
       # Creates a new Node.
-      # @param [String, nil] word the word from which to create this Node and his branch.
       # @param [Node, nil] parent the parent of this node.
-      def initialize word = nil, parent = nil
+      def initialize parent = nil
         self.parent = parent
         self.children_tree = {}
-
-        unless word.nil? || word.empty?
-          self.letter = word.slice! 0
-          self.terminal = word.empty?
-          self << word
-        end
       end
 
       # String representation of the current node, if it is a terminal node.
@@ -52,9 +49,9 @@ module Rambling
       end
 
       # If the current node is the root node.
-      # @return [Boolean] `false`
+      # @return [Boolean] `true` only if the node does not have a parent
       def root?
-        false
+        !parent
       end
 
       # Flag for terminal nodes.
@@ -63,23 +60,29 @@ module Rambling
         !!terminal
       end
 
+      # Force [Node] to be `terminal`
+      # @return [Node] the modified node.
+      def terminal!
+        self.terminal = true
+        self
+      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
       end
 
-      protected
-
-      attr_writer :children_tree
-      attr_accessor :terminal
-
       def letter= new_letter
         if new_letter
           @letter = new_letter.to_sym
           parent[letter] = self if parent
         end
       end
+
+      private
+
+      attr_accessor :terminal
     end
   end
 end