rambling-trie 1.0.2 → 1.0.3

data/lib/rambling/trie/compressable.rb

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

data/lib/rambling/trie/compressed_node.rb

@@ -1,120 +0,0 @@
-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 InvalidOperation} when
-      # trying to add a word to the current compressed trie node
-      # @param [String] word 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 word
-        raise Rambling::Trie::InvalidOperation, 'Cannot add word to compressed trie'
-      end
-
-      # Checks if a path for set a 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
-        chars.empty? || has_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
-        chars.empty? ? terminal? : has_word?(chars)
-      end
-
-      # Returns the node that starts with the specified characters.
-      # @param [Array<String>] chars the characters to look for in the trie.
-      # @return [Node] the node that matches the specified characters.
-      #   {MissingNode MissingNode} when not found.
-      def scan chars
-        chars.empty? ? self : closest_node(chars)
-      end
-
-      # Always return `true` for a compressed node.
-      # @return [Boolean] always `true` for a compressed node.
-      def compressed?
-        true
-      end
-
-      private
-
-      def has_partial_word? chars
-        recursive_get(:partial_word?, chars) || false
-      end
-
-      def has_word? chars
-        current_key = nil
-
-        while !chars.empty?
-          if current_key
-            current_key << chars.slice!(0)
-          else
-            current_key = chars.slice!(0)
-          end
-
-          child = children_tree[current_key.to_sym]
-          return child.word? chars if child
-        end
-
-        false
-      end
-
-      def closest_node chars
-        recursive_get(:scan, chars) || Rambling::Trie::MissingNode.new
-      end
-
-      def children_match_prefix chars
-        return enum_for :children_match_prefix, chars unless block_given?
-
-        current_key = nil
-
-        while !chars.empty?
-          if current_key
-            current_key << chars.slice!(0)
-          else
-            current_key = chars.slice!(0)
-          end
-
-          child = children_tree[current_key.to_sym]
-
-          if child
-            child.match_prefix chars do |word|
-              yield word
-            end
-          end
-        end
-      end
-
-      def recursive_get method, chars
-        current_length = 0
-        current_key = current_key chars.slice!(0)
-
-        begin
-          current_length += 1
-
-          if current_key && (current_key.length == current_length || chars.empty?)
-            return children_tree[current_key.to_sym].send method, chars
-          end
-        end while current_key && current_key[current_length] == chars.slice!(0)
-      end
-
-      def current_key letter
-        current_key = nil
-
-        children_tree.keys.each do |key|
-          key_string = key.to_s
-          if key_string.start_with? letter
-            current_key = key_string
-            break
-          end
-        end
-
-        current_key
-      end
-    end
-  end
-end

data/lib/rambling/trie/missing_node.rb

@@ -1,8 +0,0 @@
-module Rambling
-  module Trie
-    # A representation of a missing node in the trie data structure. Returned
-    # when a node is not found.
-    class MissingNode < Rambling::Trie::Node
-    end
-  end
-end

data/lib/rambling/trie/node.rb

@@ -1,97 +0,0 @@
-module Rambling
-  module Trie
-    # A representation of a node in the trie data structure.
-    class Node
-      extend ::Forwardable
-      include Rambling::Trie::Compressable
-      include Rambling::Trie::Enumerable
-      include Rambling::Trie::Comparable
-      include Rambling::Trie::Stringifyable
-      include Rambling::Trie::Inspectable
-
-      delegate [
-        :[],
-        :[]=,
-        :delete,
-        :has_key?
-      ] => :children_tree
-
-      # @overload letter
-      #   Letter(s) corresponding to the current node.
-      # @overload letter=(letter)
-      #   Sets the letter(s) corresponding to the current node. Ensures the
-      #   {Node#letter #letter} in the {Node#parent #parent}'s
-      #   {Node#children_tree #children_tree} is updated.
-      #   @param [String, Symbol, nil] letter the new letter value.
-      # @return [Symbol, nil] the corresponding letter(s).
-      attr_reader :letter
-
-      # Children nodes tree.
-      # @return [Hash] the children_tree hash, consisting of `:letter => node`.
-      attr_accessor :children_tree
-
-      # Parent node.
-      # @return [Node, nil] the parent of the current node.
-      attr_accessor :parent
-
-      # Creates a new node.
-      # @param [Node, nil] parent the parent of the current node.
-      def initialize parent = nil
-        self.parent = parent
-        self.children_tree = {}
-      end
-
-      # Children nodes.
-      # @return [Array<Node>] the array of children nodes contained in the
-      #   current node.
-      def children
-        children_tree.values
-      end
-
-      # Indicates if the current node is the root node.
-      # @return [Boolean] `true` if the node does not have a parent, `false`
-      #   otherwise.
-      def root?
-        !parent
-      end
-
-      # Indicates if a {Node Node} is terminal or not.
-      # @return [Boolean] `true` for terminal nodes, `false` otherwise.
-      def terminal?
-        !!terminal
-      end
-
-      # Mark {Node Node} as terminal.
-      # @return [Node] the modified node.
-      def terminal!
-        self.terminal = true
-        self
-      end
-
-      def letter= letter
-        if letter
-          @letter = letter.to_sym
-          parent[letter] = self if parent
-        end
-      end
-
-      # Returns all words that match a prefix of any length within chars.
-      # @param [String] chars the chars to base the prefix on.
-      # @return [Enumerator<String>] all the words that match a prefix given by
-      #   chars.
-      # @yield [String] each word found.
-      def match_prefix chars
-        return enum_for :match_prefix, chars unless block_given?
-
-        yield as_word if terminal?
-        children_match_prefix chars do |word|
-          yield word
-        end
-      end
-
-      private
-
-      attr_accessor :terminal
-    end
-  end
-end

data/lib/rambling/trie/raw_node.rb

@@ -1,96 +0,0 @@
-module Rambling
-  module Trie
-    # A representation of a node in an uncompressed trie data structure.
-    class RawNode < Rambling::Trie::Node
-      # Adds a word to the current raw (uncompressed) trie node.
-      # @param [String] word the word to add to the trie.
-      # @return [RawNode] the added/modified node based on the word added.
-      # @note This method clears the contents of the word variable.
-      def add word
-        if word.empty?
-          terminal!
-        else
-          add_to_children_tree word
-        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 = []
-        if chars.empty?
-          true
-        else
-          letter = chars.slice!(0).to_sym
-          child = children_tree[letter]
-          !!child && child.partial_word?(chars)
-        end
-      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 = []
-        if chars.empty?
-          terminal?
-        else
-          letter = chars.slice!(0).to_sym
-          child = children_tree[letter]
-          !!child && child.word?(chars)
-        end
-      end
-
-      # Returns the node that starts with the specified characters.
-      # @param [Array<String>] chars the characters to look for in the trie.
-      # @return [Node] the node that matches the specified characters.
-      #   {MissingNode MissingNode} when not found.
-      def scan chars
-        chars.empty? ? self : closest_node(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 word
-        letter = word.slice!(0).to_sym
-        child = children_tree[letter] || new_node(letter)
-        child.add word
-        child
-      end
-
-      def new_node letter
-        node = Rambling::Trie::RawNode.new self
-        node.letter = letter
-        children_tree[letter] = node
-      end
-
-      def closest_node chars
-        letter = chars.slice!(0).to_sym
-        child = children_tree[letter]
-
-        child ? child.scan(chars) : Rambling::Trie::MissingNode.new
-      end
-
-      def children_match_prefix chars
-        return enum_for :children_match_prefix, chars unless block_given?
-
-        if !chars.empty?
-          letter = chars.slice!(0).to_sym
-          child = children_tree[letter]
-          if child
-            child.match_prefix chars do |word|
-              yield word
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,389 +0,0 @@
-require 'spec_helper'
-
-describe Rambling::Trie::RawNode do
-  let(:node) { Rambling::Trie::RawNode.new }
-
-  describe '#compressed?' do
-    it 'returns false' do
-      expect(node).not_to be_compressed
-    end
-  end
-
-  describe '.new' do
-    context 'with no word' do
-      let(:node) { Rambling::Trie::RawNode.new }
-
-      it 'does not have any letter' do
-        expect(node.letter).to be_nil
-      end
-
-      it 'includes no children' do
-        expect(node.children.size).to eq 0
-      end
-
-      it 'is not a terminal node' do
-        expect(node).not_to be_terminal
-      end
-
-      it 'returns empty string as its word' do
-        expect(node.as_word).to be_empty
-      end
-    end
-
-    describe '#letter=' do
-      let(:parent) { Rambling::Trie::RawNode.new }
-      let(:node) { Rambling::Trie::RawNode.new parent }
-
-      context 'with empty string' do
-        before do
-          node.letter = :a
-          node.add ''
-        end
-
-        it 'makes it the node letter' do
-          expect(node.letter).to eq :a
-        end
-
-        it 'includes no children' do
-          expect(node.children.size).to eq 0
-        end
-
-        it 'is a terminal node' do
-          expect(node).to be_terminal
-        end
-      end
-
-      context 'with one letter' do
-        before do
-          node.letter = :b
-          node.add 'a'
-        end
-
-        it 'takes the first as the node letter' do
-          expect(node.letter).to eq :b
-        end
-
-        it 'includes one child' do
-          expect(node.children.size).to eq 1
-        end
-
-        it 'includes a child with the expected letter' do
-          expect(node.children.first.letter).to eq :a
-        end
-
-        it 'has the expected letter as a key' do
-          expect(node).to have_key(:a)
-        end
-
-        it 'returns the child corresponding to the key' do
-          expect(node[:a]).to eq node.children_tree[:a]
-        end
-
-        it 'does not mark itself as a terminal node' do
-          expect(node).not_to be_terminal
-        end
-
-        it 'marks the first child as a terminal node' do
-          expect(node[:a]).to be_terminal
-        end
-      end
-
-      context 'with a large word' do
-        before do
-          node.letter = :s
-          node.add 'paghetti'
-        end
-
-        it 'marks the last letter as terminal node' do
-          expect(node[:p][:a][:g][:h][:e][:t][:t][:i]).to be_terminal
-        end
-
-        it 'does not mark any other letter as terminal node' do
-          expect(node[:p][:a][:g][:h][:e][:t][:t]).not_to be_terminal
-          expect(node[:p][:a][:g][:h][:e][:t]).not_to be_terminal
-          expect(node[:p][:a][:g][:h][:e]).not_to be_terminal
-          expect(node[:p][:a][:g][:h]).not_to be_terminal
-          expect(node[:p][:a][:g]).not_to be_terminal
-          expect(node[:p][:a]).not_to be_terminal
-          expect(node[:p]).not_to be_terminal
-        end
-      end
-
-      context 'with no parent' do
-        before do
-          node.letter = :a
-          node.add ''
-        end
-
-        it 'makes it the node letter' do
-          expect(node.letter).to eq :a
-        end
-
-        it 'includes no children' do
-          expect(node.children.size).to eq 0
-        end
-
-        it 'is a terminal node' do
-          expect(node).to be_terminal
-        end
-      end
-    end
-
-    context 'with no parent' do
-      let(:node) { Rambling::Trie::RawNode.new }
-
-      it 'is marked as root' do
-        expect(node).to be_root
-      end
-    end
-
-    context 'with a specified parent' do
-      let(:node) { Rambling::Trie::RawNode.new double(:root) }
-
-      it 'is not marked as root' do
-        expect(node).not_to be_root
-      end
-    end
-
-    it 'has no children' do
-      expect(node.children.size).to eq 0
-    end
-
-    it 'has no letter' do
-      expect(node.letter).to be_nil
-    end
-
-    it 'is not a terminal node' do
-      expect(node).not_to be_terminal
-    end
-
-    it 'is not a word' do
-      expect(node).not_to be_word
-    end
-  end
-
-  describe '#add' do
-    context 'when the node has no branches' do
-      before do
-        node.add 'abc'
-      end
-
-      it 'adds only one child' do
-        expect(node.children.size).to eq 1
-      end
-
-      it 'adds the full subtree' do
-        expect(node[:a]).not_to be_nil
-        expect(node[:a][:b]).not_to be_nil
-        expect(node[:a][:b][:c]).not_to be_nil
-      end
-
-      it 'marks only the last child as terminal' do
-        expect(node).not_to be_terminal
-        expect(node[:a]).not_to be_terminal
-        expect(node[:a][:b]).not_to be_terminal
-        expect(node[:a][:b][:c]).to be_terminal
-      end
-    end
-
-    context 'when the word being added already exists in the node' do
-      before do
-        node.add 'ack'
-      end
-
-      it 'does not increment any child count in the tree' do
-        node.add 'ack'
-
-        expect(node.children.size).to eq 1
-        expect(node[:a].children.size).to eq 1
-        expect(node[:a][:c].children.size).to eq 1
-        expect(node[:a][:c][:k].children.size).to eq 0
-      end
-
-      it 'does not mark any child as terminal in the tree' do
-        node.add 'ack'
-
-        expect(node).not_to be_terminal
-        expect(node[:a]).not_to be_terminal
-        expect(node[:a][:c]).not_to be_terminal
-        expect(node[:a][:c][:k]).to be_terminal
-      end
-
-      it 'returns the added node' do
-        expect(node.add('ack').letter).to eq :a
-      end
-    end
-
-    context 'when the word does not exist in the tree but the letters do' do
-      before do
-        node.add 'ack'
-      end
-
-      it 'does not add another branch' do
-        node.add 'a'
-        expect(node.children.size).to eq 1
-      end
-
-      it 'marks the corresponding node as terminal' do
-        node.add 'a'
-
-        expect(node).not_to be_terminal
-        expect(node[:a]).to be_terminal
-        expect(node[:a][:c]).not_to be_terminal
-        expect(node[:a][:c][:k]).to be_terminal
-      end
-
-      it 'returns the added node' do
-        expect(node.add('a').letter).to eq :a
-      end
-    end
-  end
-
-  describe '#partial_word?' do
-    context 'when the chars array is empty' do
-      it 'returns true' do
-        expect(node.partial_word? []).to be true
-      end
-    end
-
-    context 'when the chars array is not empty' do
-      context 'when the node has a tree that matches the characters' do
-        before do
-          node.add 'abc'
-        end
-
-        it 'returns true' do
-          expect(node.partial_word? %w(a)).to be true
-          expect(node.partial_word? %w(a b)).to be true
-          expect(node.partial_word? %w(a b c)).to be true
-        end
-      end
-
-      context 'when the node has a tree that does not match the characters' do
-        before do
-          node.add 'cba'
-        end
-
-        it 'returns false' do
-          expect(node.partial_word? %w(a)).to be false
-          expect(node.partial_word? %w(a b)).to be false
-          expect(node.partial_word? %w(a b c)).to be false
-        end
-      end
-    end
-  end
-
-  describe '#word?' do
-    context 'when the chars array is empty' do
-      context 'when the node is terminal' do
-        before do
-          node.terminal!
-        end
-
-        it 'returns true' do
-          expect(node.word? []).to be true
-        end
-      end
-
-      context 'when the node is not terminal' do
-        it 'returns false' do
-          expect(node.word? []).to be false
-        end
-      end
-    end
-
-    context 'when the chars array is not empty' do
-      context 'when the node has a tree that matches all the characters' do
-        before do
-          node.add 'abc'
-        end
-
-        it 'returns true' do
-          expect(node.word? %w(a b c)).to be true
-        end
-      end
-
-      context 'when the node has a tree that does not match all the characters' do
-        before do
-          node.add 'abc'
-        end
-
-        it 'returns false' do
-          expect(node.word? %w(a)).to be false
-          expect(node.word? %w(a b)).to be false
-        end
-      end
-    end
-  end
-
-  describe '#scan' do
-    context 'when the chars array is empty' do
-      it 'returns itself' do
-        expect(node.scan []).to eq node
-      end
-    end
-
-    context 'when the chars array is not empty' do
-      before do
-        node.add 'cba'
-      end
-
-      context 'when the chars are found' do
-        it 'returns the found child' do
-          expect(node.scan %w(c)).to eq node[:c]
-          expect(node.scan %w(c b)).to eq node[:c][:b]
-          expect(node.scan %w(c b a)).to eq node[:c][:b][:a]
-        end
-      end
-
-      context 'when the chars are not found' do
-        it 'returns a MissingNode' do
-          expect(node.scan %w(a)).to be_a Rambling::Trie::MissingNode
-          expect(node.scan %w(a b)).to be_a Rambling::Trie::MissingNode
-          expect(node.scan %w(a b c)).to be_a Rambling::Trie::MissingNode
-          expect(node.scan %w(c b a d)).to be_a Rambling::Trie::MissingNode
-        end
-      end
-    end
-  end
-
-  describe '#match_prefix' do
-    before do
-      node.letter = :i
-      node.add 'gnite'
-      node.add 'mport'
-      node.add 'mportant'
-      node.add 'mportantly'
-    end
-
-    context 'when the node is terminal' do
-      before do
-        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