rambling-trie 0.8.1 → 0.9.0

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

@@ -3,11 +3,11 @@ require 'spec_helper'
 module Rambling
   module Trie
     describe Enumerable do
-      let(:root) { Root.new }
+      let(:root) { Rambling::Trie::RawNode.new }
       let(:words) { %w(add some words and another word) }
 
       before do
-        words.each { |word| root << word.clone }
+        words.each { |word| root.add word.clone }
       end
 
       describe '#each' do

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

@@ -1,21 +1,28 @@
 require 'spec_helper'
 
-module Rambling
-  module Trie
-    describe Inspector do
-      let(:root) do
-        Root.new do |trie|
-          %w(only three words).each { |word| trie << word }
-        end
-      end
+describe Rambling::Trie::Inspector do
+  let(:root) { Rambling::Trie::RawNode.new }
+
+  before do
+    %w(only three words).each { |word| root.add word }
+  end
+
+  describe '#inspect' do
+    let(:node) { root[:o] }
+
+    it 'returns a pretty printed version of the node' do
+      expect(root.inspect).to eq "#<Rambling::Trie::RawNode letter: nil, children: [:o, :t, :w]>"
+      expect(node.inspect).to eq "#<Rambling::Trie::RawNode letter: :o, children: [:n]>"
+    end
 
-      let(:node) { root[:o] }
+    context 'for a compressed node' do
+      let(:compressor) { Rambling::Trie::Compressor.new }
+      let(:compressed_root) { compressor.compress root }
+      let(:compressed_node) { compressed_root[:only] }
 
-      describe '#inspect' do
-        it 'returns a pretty printed version of the node' do
-          expect(root.inspect).to eq "#<Rambling::Trie::Root letter: nil, children: [:o, :t, :w]>"
-          expect(node.inspect).to eq "#<Rambling::Trie::Node letter: :o, children: [:n]>"
-        end
+      it 'returns a pretty printed version of the compressed node' do
+        expect(compressed_root.inspect).to eq "#<Rambling::Trie::CompressedNode letter: nil, children: [:only, :three, :words]>"
+        expect(compressed_node.inspect).to eq "#<Rambling::Trie::CompressedNode letter: :only, children: []>"
       end
     end
   end

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

@@ -1,228 +1,91 @@
 require 'spec_helper'
 
-module Rambling
-  module Trie
-    describe Node do
-      it 'delegates `#[]` to its children tree' do
-        expect(subject.children_tree).to receive(:[]).with(:key).and_return('value')
-        expect(subject[:key]).to eq 'value'
-      end
+describe Rambling::Trie::Node do
+  let(:node) { Rambling::Trie::Node.new }
 
-      it 'delegates `#[]=` to its children tree' do
-        expect(subject.children_tree).to receive(:[]=).with(:key, 'value')
-        subject[:key] = 'value'
+  describe '#root?' do
+    context 'when the node has a parent' do
+      before do
+        node.parent = double :parent
       end
 
-      it 'delegates `#delete` to its children tree' do
-        expect(subject.children_tree).to receive(:delete).with(:key).and_return('value')
-        expect(subject.delete :key).to eq 'value'
+      it 'returns false' do
+        expect(node).not_to be_root
       end
+    end
 
-      it 'delegates `#has_key?` to its children tree' do
-        expect(subject.children_tree).to receive(:has_key?).with(:present_key).and_return(true)
-        expect(subject).to have_key(:present_key)
-
-        expect(subject.children_tree).to receive(:has_key?).with(:absent_key).and_return(false)
-        expect(subject).not_to have_key(:absent_key)
+    context 'when the node does not have a parent' do
+      before do
+        node.parent = nil
       end
 
-      it 'delegates `#children` to its children tree values' do
-        children = [double(:child_1), double(:child_2)]
-        expect(subject.children_tree).to receive(:values).and_return(children)
-        expect(subject.children).to eq children
+      it 'returns true' do
+        expect(node).to be_root
       end
+    end
+  end
 
-      describe '#root?' do
-        it 'returns false' do
-          expect(subject).not_to be_root
-        end
-      end
+  describe '.new' do
+    let(:node) { Rambling::Trie::Node.new }
 
-      describe '.new' do
-        context 'with no word' do
-          subject { Node.new }
+    it 'does not have any letter' do
+      expect(node.letter).to be_nil
+    end
 
-          it 'does not have any letter' do
-            expect(subject.letter).to be_nil
-          end
+    it 'includes no children' do
+      expect(node.children.size).to eq 0
+    end
 
-          it 'includes no children' do
-            expect(subject.children.size).to eq 0
-          end
-
-          it 'is not a terminal node' do
-            expect(subject).not_to be_terminal
-          end
-
-          it 'returns empty string as its word' do
-            expect(subject.as_word).to be_empty
-          end
-
-          it 'is not compressed' do
-            expect(subject).not_to be_compressed
-          end
-        end
-
-        context 'with an empty word' do
-          subject { Node.new '' }
-
-          it 'does not have any letter' do
-            expect(subject.letter).to be_nil
-          end
-
-          it 'includes no children' do
-            expect(subject.children.size).to eq 0
-          end
-
-          it 'is not a terminal node' do
-            expect(subject).not_to be_terminal
-          end
-
-          it 'returns empty string as its word' do
-            expect(subject.as_word).to be_empty
-          end
-
-          it 'is not compressed' do
-            expect(subject).not_to be_compressed
-          end
-        end
-
-        context 'with one letter' do
-          subject { Node.new 'a' }
-
-          it 'makes it the node letter' do
-            expect(subject.letter).to eq :a
-          end
-
-          it 'includes no children' do
-            expect(subject.children.size).to eq 0
-          end
-
-          it 'is a terminal node' do
-            expect(subject).to be_terminal
-          end
-        end
-
-        context 'with two letters' do
-          subject { Node.new 'ba' }
-
-          it 'takes the first as the node letter' do
-            expect(subject.letter).to eq :b
-          end
-
-          it 'includes one child' do
-            expect(subject.children.size).to eq 1
-          end
-
-          it 'includes a child with the expected letter' do
-            expect(subject.children.first.letter).to eq :a
-          end
-
-          it 'has the expected letter as a key' do
-            expect(subject).to have_key(:a)
-          end
-
-          it 'returns the child corresponding to the key' do
-            expect(subject[:a]).to eq subject.children_tree[:a]
-          end
-
-          it 'does not mark itself as a terminal node' do
-            expect(subject).not_to be_terminal
-          end
-
-          it 'marks the first child as a terminal node' do
-            expect(subject[:a]).to be_terminal
-          end
-        end
-
-        context 'with a large word' do
-          subject { Node.new 'spaghetti' }
-
-          it 'marks the last letter as terminal node' do
-            expect(subject[:p][:a][:g][:h][:e][:t][:t][:i]).to be_terminal
-          end
-
-          it 'does not mark any other letter as terminal node' do
-            expect(subject[:p][:a][:g][:h][:e][:t][:t]).not_to be_terminal
-            expect(subject[:p][:a][:g][:h][:e][:t]).not_to be_terminal
-            expect(subject[:p][:a][:g][:h][:e]).not_to be_terminal
-            expect(subject[:p][:a][:g][:h]).not_to be_terminal
-            expect(subject[:p][:a][:g]).not_to be_terminal
-            expect(subject[:p][:a]).not_to be_terminal
-            expect(subject[:p]).not_to be_terminal
-          end
-        end
-      end
+    it 'is not a terminal node' do
+      expect(node).not_to be_terminal
+    end
 
-      describe '#as_word' do
-        context 'for an empty node' do
-          subject { Node.new '' }
-
-          it 'returns nil' do
-            expect(subject.as_word).to be_empty
-          end
-        end
-
-        context 'for one letter' do
-          subject { Node.new 'a' }
-
-          it 'returns the expected one letter word' do
-            expect(subject.as_word).to eq 'a'
-          end
-        end
-
-        context 'for a small word' do
-          subject { Node.new 'all' }
-
-          it 'returns the expected small word' do
-            expect(subject[:l][:l].as_word).to eq 'all'
-          end
-
-          it 'raises an error for a non terminal node' do
-            expect { subject[:l].as_word }.to raise_error InvalidOperation
-          end
-        end
-
-        context 'for a long word' do
-          subject { Node.new 'beautiful' }
-
-          it 'returns the expected long word' do
-            expect(subject[:e][:a][:u][:t][:i][:f][:u][:l].as_word).to eq 'beautiful'
-          end
-        end
-
-        context 'for a node with nil letter' do
-          subject { Node.new nil }
-          it 'returns nil' do
-            expect(subject.as_word).to be_empty
-          end
-        end
-      end
+    it 'returns empty string as its word' do
+      expect(node.as_word).to be_empty
+    end
+  end
 
-      describe '#compressed?' do
-        let(:root) { double :root }
-        subject { Node.new '', root }
-
-        context 'parent is compressed' do
-          before do
-            allow(root).to receive(:compressed?).and_return true
-          end
-
-          it 'returns true' do
-            expect(subject).to be_compressed
-          end
-        end
-
-        context 'parent is not compressed' do
-          before do
-            allow(root).to receive(:compressed?).and_return false
-          end
-
-          it 'returns false' do
-            expect(subject).not_to be_compressed
-          end
-        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 `#delete` to its children tree' do
+      expect(node.children_tree).to receive(:delete).with(:key).and_return('value')
+      expect(node.delete :key).to eq '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

@@ -0,0 +1,377 @@
+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 '#as_word' do
+    let(:node) { Rambling::Trie::RawNode.new }
+
+    context 'for an empty node' do
+      before do
+        node.add ''
+      end
+
+      it 'returns nil' do
+        expect(node.as_word).to be_empty
+      end
+    end
+
+    context 'for one letter' do
+      before do
+        node.letter = :a
+        node.add ''
+      end
+
+      it 'returns the expected one letter word' do
+        expect(node.as_word).to eq 'a'
+      end
+    end
+
+    context 'for a small word' do
+      before do
+        node.letter = :a
+        node.add 'll'
+      end
+
+      it 'returns the expected small word' do
+        expect(node[:l][:l].as_word).to eq 'all'
+      end
+
+      it 'raises an error for a non terminal node' do
+        expect { node[:l].as_word }.to raise_error Rambling::Trie::InvalidOperation
+      end
+    end
+
+    context 'for a long word' do
+      before do
+        node.letter = :b
+        node.add 'eautiful'
+      end
+
+      it 'returns the expected long word' do
+        expect(node[:e][:a][:u][:t][:i][:f][:u][:l].as_word).to eq 'beautiful'
+      end
+    end
+
+    context 'for a node with nil letter' do
+      let(:node) { Rambling::Trie::RawNode.new nil }
+
+      it 'returns nil' do
+        expect(node.as_word).to be_empty
+      end
+    end
+  end
+end