rambling-trie 1.0.1 → 2.1.1

data/lib/rambling/trie/forwardable.rb

@@ -1,21 +0,0 @@
-# module Rambling
-#   module Trie
-#     # Provides delegation behavior.
-#     module Forwardable
-#       # Custom delegation behavior due to Ruby 2.4 delegation performance
-#       # degradation. See {https://bugs.ruby-lang.org/issues/13111 Bug #13111}.
-#       # @param [Hash] methods_to_target a Hash consisting of the methods to be
-#       #   delegated and the target to delegate those methods to.
-#       # @return [Hash] the `methods_to_target` parameter.
-#       def delegate methods_to_target
-#         methods_to_target.each do |methods, target|
-#           methods.each do |method|
-#             define_method method do |*args|
-#               send(target).send method, *args
-#             end
-#           end
-#         end
-#       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/node_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-describe Rambling::Trie::Node do
-  let(:node) { Rambling::Trie::Node.new }
-
-  describe '#root?' do
-    context 'when the node has a parent' do
-      before do
-        node.parent = double :parent
-      end
-
-      it 'returns false' do
-        expect(node).not_to be_root
-      end
-    end
-
-    context 'when the node does not have a parent' do
-      before do
-        node.parent = nil
-      end
-
-      it 'returns true' do
-        expect(node).to be_root
-      end
-    end
-  end
-
-  describe '.new' do
-    let(:node) { Rambling::Trie::Node.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 '#terminal!' do
-    it 'forces the node to be terminal' do
-      expect(node).not_to be_terminal
-      node.terminal!
-
-      expect(node).to be_terminal
-    end
-
-    it 'returns the node' do
-      expect(node.terminal!).to eq node
-    end
-  end
-
-  describe 'delegates and aliases' do
-    it 'delegates `#[]` to its children tree' do
-      expect(node.children_tree).to receive(:[]).with(:key).and_return('value')
-      expect(node[:key]).to eq 'value'
-    end
-
-    it 'delegates `#[]=` to its children tree' do
-      expect(node.children_tree).to receive(:[]=).with(:key, 'value')
-      node[:key] = 'value'
-    end
-
-    it 'delegates `#has_key?` to its children tree' do
-      expect(node.children_tree).to receive(:has_key?).with(:present_key).and_return(true)
-      expect(node).to have_key(:present_key)
-
-      expect(node.children_tree).to receive(:has_key?).with(:absent_key).and_return(false)
-      expect(node).not_to have_key(:absent_key)
-    end
-
-    it 'delegates `#children` to its children tree values' do
-      children = [double(:child_1), double(:child_2)]
-      expect(node.children_tree).to receive(:values).and_return(children)
-      expect(node.children).to eq children
-    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