rambling-trie 2.4.0 → 2.5.1

data/spec/support/shared_examples/a_trie_node.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-shared_examples_for 'a trie node' do
-  let(:node_class) { node.class }
-
-  describe '.new' do
-    it 'has no letter' do
-      expect(node.letter).to be_nil
-    end
-
-    it 'has no children' do
-      expect(node.children.size).to eq 0
-    end
-
-    it 'is not terminal' do
-      expect(node).not_to be_terminal
-    end
-
-    it 'returns empty string as its word' do
-      expect(node.as_word).to be_empty
-    end
-
-    context 'with a letter and a parent' do
-      let(:parent) { node_class.new }
-      # noinspection RubyArgCount
-      let(:node_with_parent) { node_class.new :a, parent }
-
-      it 'does not have any letter' do
-        expect(node_with_parent.letter).to eq :a
-      end
-
-      it 'has no children' do
-        expect(node_with_parent.children.size).to eq 0
-      end
-
-      it 'is not terminal' do
-        expect(node_with_parent).not_to be_terminal
-      end
-    end
-  end
-
-  describe '#root?' do
-    context 'when the node has a parent' do
-      before { node.parent = node }
-
-      it 'returns false' do
-        expect(node).not_to be_root
-      end
-    end
-
-    context 'when the node does not have a parent' do
-      before { node.parent = nil }
-
-      it 'returns true' do
-        expect(node).to be_root
-      end
-    end
-  end
-
-  describe '#terminal!' do
-    # rubocop:disable RSpec/MultipleExpectations
-    it 'forces the node to be terminal' do
-      expect(node).not_to be_terminal
-      node.terminal!
-      expect(node).to be_terminal
-    end
-    # rubocop:enable RSpec/MultipleExpectations
-
-    it 'returns the node' do
-      expect(node.terminal!).to eq node
-    end
-  end
-
-  describe 'delegates and aliases' do
-    let :children_tree do
-      instance_double(
-        'Hash',
-        :children_tree,
-        :[] => 'value',
-        :[]= => nil,
-        key?: false,
-        delete: true,
-      )
-    end
-
-    before { node.children_tree = children_tree }
-
-    # rubocop:disable RSpec/MultipleExpectations
-    it 'delegates `#[]` to its children tree' do
-      expect(node[:key]).to eq 'value'
-      expect(children_tree).to have_received(:[]).with :key
-    end
-    # rubocop:enable RSpec/MultipleExpectations
-
-    it 'delegates `#[]=` to its children tree' do
-      node[:key] = 'value'
-      expect(children_tree).to have_received(:[]=).with(:key, 'value')
-    end
-
-    # rubocop:disable RSpec/MultipleExpectations
-    it 'delegates `#key?` to its children tree' do
-      allow(children_tree).to receive(:key?)
-        .with(:present_key)
-        .and_return true
-
-      expect(node).to have_key(:present_key)
-      expect(node).not_to have_key(:absent_key)
-    end
-    # rubocop:enable RSpec/MultipleExpectations
-
-    # rubocop:disable RSpec/MultipleExpectations
-    it 'delegates `#delete` to its children tree' do
-      expect(node.delete :key).to be true
-      expect(children_tree).to have_received(:delete).with :key
-    end
-    # rubocop:enable RSpec/MultipleExpectations
-
-    # rubocop:disable RSpec/ExampleLength
-    it 'delegates `#children` to its children tree values' do
-      children = [
-        instance_double('Rambling::Trie::Nodes::Node', :child_one),
-        instance_double('Rambling::Trie::Nodes::Node', :child_two),
-      ]
-      allow(children_tree).to receive(:values).and_return children
-
-      expect(node.children).to eq children
-    end
-    # rubocop:enable RSpec/ExampleLength
-
-    it 'aliases `#has_key?` to `#key?`' do
-      node.has_key? :nope
-      expect(children_tree).to have_received(:key?).with :nope
-    end
-  end
-end

data/spec/support/shared_examples/a_trie_node_implementation.rb

@@ -1,149 +0,0 @@
-# frozen_string_literal: true
-
-shared_examples_for 'a trie node implementation' do
-  it_behaves_like 'a trie node'
-
-  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 { add_word_to_tree 'abc' }
-
-        [%w(a), %w(a b), %w(a b c)].each do |letters|
-          it "returns true for '#{letters}'" do
-            expect(node.partial_word? letters).to be true
-          end
-        end
-      end
-
-      context 'when the node has a tree that does not match the characters' do
-        before { add_word_to_tree 'cba' }
-
-        [%w(a), %w(a b), %w(a b c)].each do |letters|
-          it "returns false for '#{letters}'" do
-            expect(node.partial_word? letters).to be false
-          end
-        end
-      end
-    end
-  end
-
-  describe '#word?' do
-    context 'when the chars array is empty' do
-      context 'when the node is terminal' do
-        before { node.terminal! }
-
-        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 { add_word_to_tree 'abc' }
-
-        it 'returns true' do
-          expect(node.word? %w(a b c).map(&:dup)).to be true
-        end
-      end
-
-      context 'when the node subtree does not match all the characters' do
-        before { add_word_to_tree 'abc' }
-
-        [%w(a), %w(a b)].each do |letters|
-          it "returns false for '#{letters}'" do
-            expect(node.word? letters.map(&:dup)).to be false
-          end
-        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 { add_words_to_tree %w(cba ccab) }
-
-      context 'when the chars are found' do
-        [
-          [%w(c), %w(cba ccab)],
-          [%w(c b), %w(cba)],
-          [%w(c b a), %w(cba)],
-        ].each do |test_params|
-          letters, expected = test_params
-
-          it "returns the corresponding children (#{letters} => #{expected})" do
-            expect(node.scan letters).to match_array expected
-          end
-        end
-      end
-
-      context 'when the chars are not found' do
-        [
-          %w(a),
-          %w(a b),
-          %w(a b c),
-          %w(c a),
-          %w(c c b),
-          %w(c b a d),
-        ].each do |letters|
-          it "returns a Nodes::Missing for '#{letters}'" do
-            expect(node.scan letters).to be_a Rambling::Trie::Nodes::Missing
-          end
-        end
-      end
-    end
-  end
-
-  describe '#match_prefix' do
-    before do
-      assign_letter :i
-      add_words_to_tree %w(gnite mport mportant mportantly)
-    end
-
-    context 'when the node is terminal' do
-      before { node.terminal! }
-
-      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