rambling-trie 1.0.2 → 2.2.0

data/lib/rambling/trie/configuration/provider_collection.rb

@@ -1,10 +1,10 @@
+# frozen_string_literal: true
+
 module Rambling
   module Trie
     module Configuration
       # Collection of configurable providers.
       class ProviderCollection
-        extend ::Forwardable
-
         # The name of this provider collection.
         # @return [String] the name of this provider collection.
         attr_reader :name
@@ -23,13 +23,6 @@ module Rambling
         #   cannot be resolved in {ProviderCollection#resolve #resolve}.
         attr_reader :default
 
-        delegate [
-          :[],
-          :[]=,
-          :keys,
-          :values,
-        ] => :providers
-
         # Creates a new provider collection.
         # @param [String] name the name for this provider collection.
         # @param [Hash] providers the configured providers.
@@ -52,8 +45,9 @@ module Rambling
         end
 
         def default= provider
-          if provider_not_in_list? provider
-            raise ArgumentError, "default #{name} should be part of configured #{name}s"
+          unless contains? provider
+            raise ArgumentError,
+              "default #{name} should be part of configured #{name}s"
           end
 
           @default = provider
@@ -71,30 +65,57 @@ module Rambling
         # @return [Object] the provider corresponding to the file extension in
         #   this provider collection. {#default} if not found.
         def resolve filepath
-          providers[format filepath] || default
+          providers[file_format filepath] || default
         end
 
         # Resets the provider collection to the initial values.
         def reset
           providers.clear
-          configured_providers.each { |k, v| providers[k] = v }
+          configured_providers.each { |k, v| self[k] = v }
           self.default = configured_default
         end
 
+        # Get provider corresponding to a given format.
+        # @return [Array<Symbol>] the provider corresponding to that format.
+        # @see https://ruby-doc.org/core-2.5.0/Hash.html#method-i-5B-5D
+        #   Hash#keys
+        def formats
+          providers.keys
+        end
+
+        # Get provider corresponding to a given format.
+        # @param [Symbol] format the format to search for in the collection.
+        # @return [Object] the provider corresponding to that format.
+        # @see https://ruby-doc.org/core-2.5.0/Hash.html#method-i-5B-5D
+        #   Hash#[]
+        def [] format
+          providers[format]
+        end
+
         private
 
         attr_reader :configured_providers, :configured_default
 
-        def format filepath
+        def []= format, instance
+          providers[format] = instance
+        end
+
+        def values
+          providers.values
+        end
+
+        def file_format filepath
           format = File.extname filepath
           format.slice! 0
           format.to_sym
         end
 
-        def provider_not_in_list? provider
-          (provider && providers.values.empty?) ||
-            (providers.values.any? && !providers.values.include?(provider))
+        def contains? provider
+          provider.nil? ||
+            (providers.any? && provider_instances.include?(provider))
         end
+
+        alias_method :provider_instances, :values
       end
     end
   end

data/lib/rambling/trie/container.rb

@@ -1,32 +1,17 @@
+# frozen_string_literal: true
+
 module Rambling
   module Trie
     # Wrapper on top of trie data structure.
     class Container
-      extend ::Forwardable
       include ::Enumerable
 
-      delegate [
-        :[],
-        :as_word,
-        :children,
-        :children_tree,
-        :compressed?,
-        :each,
-        :to_a,
-        :has_key?,
-        :inspect,
-        :letter,
-        :parent,
-        :size,
-        :to_s
-      ] => :root
-
       # The root node of this trie.
-      # @return [Node] the root node of this trie.
+      # @return [Nodes::Node] the root node of this trie.
       attr_reader :root
 
       # Creates a new trie.
-      # @param [Node] root the root node for the trie
+      # @param [Nodes::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, compressor
@@ -36,32 +21,53 @@ module Rambling
         yield self if block_given?
       end
 
-      # Adds a word to the trie, without altering the passed word.
+      # Adds a word to the trie.
       # @param [String] word the word to add the branch from.
-      # @return [Node] the just added branch's root node.
+      # @return [Nodes::Node] the just added branch's root node.
       # @raise [InvalidOperation] if the trie is already compressed.
-      # @see RawNode#add
-      # @see CompressedNode#add
-      # @note Avoids altering the contents of the word variable.
+      # @see Nodes::Raw#add
+      # @see Nodes::Compressed#add
       def add word
-        root.add word.clone
+        root.add char_symbols word
+      end
+
+      # Adds all provided words to the trie.
+      # @param [Array<String>] words the words to add the branch from.
+      # @return [Array<Nodes::Node>] the collection of nodes added.
+      # @raise [InvalidOperation] if the trie is already compressed.
+      # @see Nodes::Raw#add
+      # @see Nodes::Compressed#add
+      def concat words
+        words.map { |word| add word }
       end
 
-      # Compresses the existing tree using redundant node elimination. Marks
-      # the trie as compressed.
+      # Compresses the existing trie using redundant node elimination. Marks
+      # the trie as compressed. Does nothing if the trie has already been
+      # compressed.
       # @return [Container] self
-      # @note Only compresses tries that have not already been compressed.
+      # @note This method replaces the root {Nodes::Raw Raw} node with a
+      #   {Nodes::Compressed Compressed} version of it.
       def compress!
-        self.root = compressor.compress root unless root.compressed?
+        self.root = compress_root unless root.compressed?
         self
       end
 
+      # Compresses the existing trie using redundant node elimination. Returns
+      # a new trie with the compressed root.
+      # @return [Container] A new {Container} with the {Nodes::Compressed
+      #   Compressed} root node or self if the trie has already been
+      #   compressed.
+      def compress
+        return self if root.compressed?
+        Rambling::Trie::Container.new compress_root, compressor
+      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.
-      # @see RawNode#partial_word?
-      # @see CompressedNode#partial_word?
+      # @see Nodes::Raw#partial_word?
+      # @see Nodes::Compressed#partial_word?
       def partial_word? word = ''
         root.partial_word? word.chars
       end
@@ -70,8 +76,8 @@ module Rambling
       # @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, `false` otherwise.
-      # @see RawNode#word?
-      # @see CompressedNode#word?
+      # @see Nodes::Raw#word?
+      # @see Nodes::Compressed#word?
       def word? word = ''
         root.word? word.chars
       end
@@ -80,8 +86,8 @@ module Rambling
       # @param [String] word the word to look for in the trie.
       # @return [Array<String>] all the words contained in the trie that start
       #   with the specified characters.
-      # @see RawNode#scan
-      # @see CompressedNode#scan
+      # @see Nodes::Raw#scan
+      # @see Nodes::Compressed#scan
       def scan word = ''
         root.scan(word.chars).to_a
       end
@@ -92,7 +98,7 @@ module Rambling
       # @return [Enumerator<String>] all the words in the given string that
       #   match a word in the trie.
       # @yield [String] each word found in phrase.
-      # @see Node#words_within
+      # @see Nodes::Node#words_within
       def words_within phrase
         words_within_root(phrase).to_a
       end
@@ -113,10 +119,81 @@ module Rambling
         root == other.root
       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?
+
+        root.each do |word|
+          yield word
+        end
+      end
+
+      # @return [String] a string representation of the container.
+      def inspect
+        "#<#{self.class.name} root: #{root.inspect}>"
+      end
+
+      # Get {Nodes::Node Node} corresponding to a given letter.
+      # @param [Symbol] letter the letter to search for in the root node.
+      # @return [Nodes::Node] the node corresponding to that letter.
+      # @see Nodes::Node#[]
+      def [] letter
+        root[letter]
+      end
+
+      # Root node's child nodes.
+      # @return [Array<Nodes::Node>] the array of children nodes contained in
+      #   the root node.
+      # @see Nodes::Node#children
+      def children
+        root.children
+      end
+
+      # Root node's children tree.
+      # @return [Array<Nodes::Node>] the array of children nodes contained in
+      #   the root node.
+      # @see Nodes::Node#children_tree
+      def children_tree
+        root.children_tree
+      end
+
+      # Indicates if the root {Nodes::Node Node} can be
+      # compressed or not.
+      # @return [Boolean] `true` for non-{Nodes::Node#terminal? terminal}
+      #    nodes with one child, `false` otherwise.
+      def compressed?
+        root.compressed?
+      end
+
+      # Array of words contained in the root {Nodes::Node Node}.
+      # @return [Array<String>] all words contained in this trie.
+      # @see https://ruby-doc.org/core-2.5.0/Enumerable.html#method-i-to_a
+      #   Enumerable#to_a
+      def to_a
+        root.to_a
+      end
+
+      # Check if a letter is part of the root {Nodes::Node}'s children tree.
+      # @param [Symbol] letter the letter to search for in the root node.
+      # @return [Boolean] whether the letter is contained or not.
+      # @see Nodes::Node#key?
+      def key? letter
+        root.key? letter
+      end
+
+      # Size of the Root {Nodes::Node Node}'s children tree.
+      # @return [Integer] the number of letters in the root node.
+      def size
+        root.size
+      end
+
       alias_method :include?, :word?
       alias_method :match?, :partial_word?
       alias_method :words, :scan
       alias_method :<<, :add
+      alias_method :has_key?, :key?
+      alias_method :has_letter?, :key?
 
       private
 
@@ -134,6 +211,16 @@ module Rambling
           end
         end
       end
+
+      def compress_root
+        compressor.compress root
+      end
+
+      def char_symbols word
+        symbols = []
+        word.reverse.each_char { |c| symbols << c.to_sym }
+        symbols
+      end
     end
   end
 end

data/lib/rambling/trie/enumerable.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module Rambling
   module Trie
     # Provides enumerable behavior to the trie data structure.
     module Enumerable
       include ::Enumerable
 
-      # Returns number of words contained in the trie. See
-      # {https://ruby-doc.org/core-2.4.0/Enumerable.html#method-i-count
-      # Enumerable}
+      # Returns number of words contained in the trie
+      # @see https://ruby-doc.org/core-2.5.0/Enumerable.html#method-i-count
+      #   Enumerable#count
       alias_method :size, :count
 
       # Iterates over the words contained in the trie.
@@ -16,7 +18,7 @@ module Rambling
 
         yield as_word if terminal?
 
-        children.each do |child|
+        children_tree.each_value do |child|
           child.each do |word|
             yield word
           end

data/lib/rambling/trie/inspectable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rambling
   module Trie
     # Provides pretty printing behavior for the trie data structure.

data/lib/rambling/trie/invalid_operation.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Rambling
   module Trie
     # Raised when trying to execute an invalid operation on a trie data
     # structure.
-    class InvalidOperation < Exception
+    class InvalidOperation < RuntimeError
       # Creates a new {InvalidOperation InvalidOperation} exception.
       # @param [String, nil] message the exception message.
       def initialize message = nil

data/lib/rambling/trie/nodes.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+%w(node missing compressed raw).each do |file|
+  require File.join('rambling', 'trie', 'nodes', file)
+end
+
+module Rambling
+  module Trie
+    # Namespace for all nodes.
+    module Nodes
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Rambling
+  module Trie
+    module Nodes
+      # A representation of a node in an compressed trie data structure.
+      class Compressed < Rambling::Trie::Nodes::Node
+        # Always raises {Rambling::Trie::InvalidOperation InvalidOperation} when
+        # trying to add a word to the current compressed trie node
+        # @param [String] _ the word to add to the trie.
+        # @raise [InvalidOperation] if the trie is already compressed.
+        # @return [nil] this never returns as it always raises an exception.
+        def add _
+          raise Rambling::Trie::InvalidOperation,
+            'Cannot add word to compressed trie'
+        end
+
+        # Always return `true` for a compressed node.
+        # @return [Boolean] always `true` for a compressed node.
+        def compressed?
+          true
+        end
+
+        private
+
+        def partial_word_chars? chars
+          child = children_tree[chars.first.to_sym]
+          return false unless child
+
+          child_letter = child.letter.to_s
+
+          if chars.size >= child_letter.size
+            letter = chars.slice!(0, child_letter.size).join
+            return child.partial_word? chars if child_letter == letter
+          end
+
+          letter = chars.join
+          child_letter = child_letter.slice 0, letter.size
+          child_letter == letter
+        end
+
+        def word_chars? chars
+          letter = chars.slice! 0
+          letter_sym = letter.to_sym
+
+          child = children_tree[letter_sym]
+          return false unless child
+
+          loop do
+            return child.word? chars if letter_sym == child.letter
+
+            break if chars.empty?
+
+            letter << chars.slice!(0)
+            letter_sym = letter.to_sym
+          end
+
+          false
+        end
+
+        def closest_node chars
+          child = children_tree[chars.first.to_sym]
+          return missing unless child
+
+          child_letter = child.letter.to_s
+
+          if chars.size >= child_letter.size
+            letter = chars.slice!(0, child_letter.size).join
+            return child.scan chars if child_letter == letter
+          end
+
+          letter = chars.join
+          child_letter = child_letter.slice 0, letter.size
+
+          child_letter == letter ? child : missing
+        end
+
+        def children_match_prefix chars
+          return enum_for :children_match_prefix, chars unless block_given?
+
+          return if chars.empty?
+
+          child = children_tree[chars.first.to_sym]
+          return unless child
+
+          child_letter = child.letter.to_s
+          letter = chars.slice!(0, child_letter.size).join
+
+          return unless child_letter == letter
+
+          child.match_prefix chars do |word|
+            yield word
+          end
+        end
+      end
+    end
+  end
+end