rambling-trie 2.4.0 → 2.5.0

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

@@ -1,466 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Container do
-  subject(:container) { described_class.new root, compressor }
-
-  let(:compressor) { Rambling::Trie::Compressor.new }
-  let(:root) { Rambling::Trie::Nodes::Raw.new }
-
-  describe '.new' do
-    it 'uses the provided node as root' do
-      expect(container.root).to be root
-    end
-
-    context 'with a block' do
-      it 'yields the container' do
-        yielded = nil
-
-        container = described_class.new root, compressor do |c|
-          yielded = c
-        end
-
-        expect(yielded).to be container
-      end
-    end
-  end
-
-  describe '#add' do
-    # rubocop:disable RSpec/MultipleExpectations
-    it 'adds the word to the root node' do
-      add_word container, 'hello'
-
-      expect(root.children.size).to eq 1
-      expect(root.to_a).to eq %w(hello)
-    end
-    # rubocop:enable RSpec/MultipleExpectations
-  end
-
-  describe '#concat' do
-    # rubocop:disable RSpec/MultipleExpectations
-    it 'adds all the words to the root node' do
-      container.concat %w(other words)
-
-      expect(root.children.size).to eq 2
-      expect(root.to_a).to eq %w(other words)
-    end
-
-    it 'returns all the corresponding nodes' do
-      nodes = container.concat %w(other words)
-
-      expect(nodes.first.letter).to eq :o
-      expect(nodes.last.letter).to eq :w
-    end
-    # rubocop:enable RSpec/MultipleExpectations
-  end
-
-  describe '#compress' do
-    let(:node) { Rambling::Trie::Nodes::Compressed.new }
-
-    before do
-      allow(compressor).to receive(:compress).and_return node
-
-      add_word root, 'yes'
-      node[:yes] = Rambling::Trie::Nodes::Compressed.new
-    end
-
-    it 'compresses the trie using the compressor' do
-      container.compress
-
-      expect(compressor).to have_received(:compress).with root
-    end
-
-    # rubocop:disable RSpec/MultipleExpectations
-    it 'returns a container with the new root' do
-      new_container = container.compress
-
-      expect(new_container.root).not_to eq root
-      expect(new_container.root).to eq node
-    end
-    # rubocop:enable RSpec/MultipleExpectations
-
-    it 'returns a new container' do
-      expect(container.compress).not_to eq container
-    end
-
-    it 'can compress multiple times' do
-      container.compress
-      container.compress
-
-      expect(compressor).to have_received(:compress).twice
-    end
-
-    it 'cannot compress the result' do
-      new_container = container.compress
-      new_container.compress
-
-      expect(compressor).to have_received(:compress).once
-    end
-  end
-
-  describe '#compress!' do
-    let(:node) { Rambling::Trie::Nodes::Compressed.new }
-
-    context 'with a mocked result' do
-      before do
-        allow(compressor).to receive(:compress).and_return node
-
-        add_word root, 'yes'
-        node[:yes] = Rambling::Trie::Nodes::Compressed.new
-      end
-
-      it 'compresses the trie using the compressor' do
-        container.compress!
-
-        expect(compressor).to have_received(:compress).with root
-      end
-
-      # rubocop:disable RSpec/MultipleExpectations
-      it 'changes to the root returned by the compressor' do
-        container.compress!
-
-        expect(container.root).not_to eq root
-        expect(container.root).to eq node
-      end
-      # rubocop:enable RSpec/MultipleExpectations
-
-      it 'returns itself' do
-        expect(container.compress!).to eq container
-      end
-
-      it 'does not compress multiple times' do
-        container.compress!
-        allow(node).to receive(:compressed?).and_return(true)
-
-        container.compress!
-        expect(compressor).to have_received(:compress).once
-      end
-
-      # rubocop:disable RSpec/MultipleExpectations
-      it 'gets a new root from the compressor' do
-        container.compress!
-
-        expect(container.root).not_to be root
-        expect(container.root).to be_compressed
-        expect(root).not_to be_compressed
-      end
-      # rubocop:enable RSpec/MultipleExpectations
-    end
-
-    it 'generates a new root with the words from the passed root' do
-      words = %w(a few words hello hell)
-
-      add_words container, words
-      container.compress!
-
-      words.each { |word| expect(container).to include word }
-    end
-
-    describe 'and trying to add a word' do
-      it 'raises an error' do
-        add_words container, %w(repay rest repaint)
-        container.compress!
-
-        expect do
-          add_word container, 'restaurant'
-        end.to raise_error Rambling::Trie::InvalidOperation
-      end
-    end
-  end
-
-  describe '#word?' do
-    it_behaves_like 'a propagating node' do
-      let(:method_name) { :word? }
-    end
-
-    context 'when word is contained' do
-      before { add_words container, %w(hello high) }
-
-      it_behaves_like 'a matching container#word'
-
-      context 'with compressed root' do
-        before { container.compress! }
-
-        it_behaves_like 'a matching container#word'
-      end
-    end
-
-    context 'when word is not contained' do
-      before { add_word container, 'hello' }
-
-      it_behaves_like 'a non-matching container#word'
-
-      context 'with compressed root' do
-        before { container.compress! }
-
-        it_behaves_like 'a non-matching container#word'
-      end
-    end
-  end
-
-  describe '#partial_word?' do
-    context 'with underlying node' do
-      it_behaves_like 'a propagating node' do
-        let(:method_name) { :partial_word? }
-      end
-    end
-
-    context 'when word is contained' do
-      before { add_words container, %w(hello high) }
-
-      it_behaves_like 'a matching container#partial_word'
-
-      context 'with compressed root' do
-        before { container.compress! }
-
-        it_behaves_like 'a matching container#partial_word'
-      end
-    end
-
-    context 'when word is not contained' do
-      before { add_word container, 'hello' }
-
-      it_behaves_like 'a non-matching container#partial_word'
-
-      context 'with compressed root' do
-        before { container.compress! }
-
-        it_behaves_like 'a non-matching container#partial_word'
-      end
-    end
-  end
-
-  describe '#scan' do
-    context 'when words that match are contained' do
-      before do
-        add_words container, %w(hi hello high hell highlight histerical)
-      end
-
-      it_behaves_like 'a matching container#scan'
-
-      context 'with compressed root' do
-        before { container.compress! }
-
-        it_behaves_like 'a matching container#scan'
-      end
-    end
-
-    context 'when words that match are not contained' do
-      before { add_word container, 'hello' }
-
-      it 'returns an empty array' do
-        expect(container.scan 'hi').to eq %w()
-      end
-
-      context 'with compressed root' do
-        before { container.compress! }
-
-        it 'returns an empty array' do
-          expect(container.scan 'hi').to eq %w()
-        end
-      end
-    end
-  end
-
-  describe '#words_within' do
-    before { add_words container, %w(one word and other words) }
-
-    context 'when phrase does not contain any words' do
-      it 'returns an empty array' do
-        expect(container.words_within 'xyz').to match_array []
-      end
-
-      context 'with compressed node' do
-        before { container.compress! }
-
-        it 'returns an empty array' do
-          expect(container.words_within 'xyz').to match_array []
-        end
-      end
-    end
-
-    context 'when phrase contains one word at the start of the phrase' do
-      it_behaves_like 'a matching container#words_within'
-
-      context 'with compressed node' do
-        before { container.compress! }
-
-        it_behaves_like 'a matching container#words_within'
-      end
-    end
-
-    context 'when phrase contains one word at the end of the phrase' do
-      it 'returns an array with the word found in the phrase' do
-        expect(container.words_within 'xyz word').to match_array %w(word)
-      end
-
-      context 'with compressed node' do
-        before { container.compress! }
-
-        it 'returns an array with the word found in the phrase' do
-          expect(container.words_within 'xyz word').to match_array %w(word)
-        end
-      end
-    end
-
-    context 'when phrase contains a few words' do
-      it_behaves_like 'a non-matching container#words_within'
-
-      context 'with compressed node' do
-        before { container.compress! }
-
-        it_behaves_like 'a non-matching container#words_within'
-      end
-    end
-  end
-
-  describe '#words_within?' do
-    before { add_words container, %w(one word and other words) }
-
-    it_behaves_like 'a matching container#words_within?'
-
-    context 'with compressed node' do
-      before { container.compress! }
-
-      it_behaves_like 'a non-matching container#words_within?'
-    end
-  end
-
-  describe '#==' do
-    context 'when the root nodes are the same' do
-      let :other_container do
-        described_class.new container.root, compressor
-      end
-
-      it 'returns true' do
-        expect(container).to eq other_container
-      end
-    end
-
-    context 'when the root nodes are not the same' do
-      let(:other_root) { Rambling::Trie::Nodes::Raw.new }
-      let :other_container do
-        described_class.new other_root, compressor
-      end
-
-      before { add_word other_container, 'hola' }
-
-      it 'returns false' do
-        expect(container).not_to eq other_container
-      end
-    end
-  end
-
-  describe '#each' do
-    before { add_words container, %w(yes no why) }
-
-    it 'returns an enumerator when no block is given' do
-      expect(container.each).to be_instance_of Enumerator
-    end
-
-    it 'iterates through all words contained' do
-      expect(container.each.to_a).to eq %w(yes no why)
-    end
-  end
-
-  describe '#inspect' do
-    before { add_words container, %w(a few words hello hell) }
-
-    it 'returns the container class name plus the root inspection' do
-      expect(container.inspect).to eq one_line <<~CONTAINER
-        #<Rambling::Trie::Container root: #<Rambling::Trie::Nodes::Raw letter: nil,
-        terminal: nil,
-        children: [:a, :f, :w, :h]>>
-      CONTAINER
-    end
-  end
-
-  describe 'delegates and aliases' do
-    before do
-      allow(root).to receive_messages(
-        :[] => nil,
-        add: nil,
-        as_word: nil,
-        children: nil,
-        children_tree: nil,
-        compressed?: nil,
-        each: nil,
-        key?: nil,
-        inspect: nil,
-        letter: nil,
-        parent: nil,
-        partial_word?: nil,
-        scan: nil,
-        size: nil,
-        to_s: nil,
-        word?: nil,
-      )
-    end
-
-    it 'aliases `#include?` to `#word?`' do
-      container.include? 'words'
-      expect(root).to have_received(:word?).with %w(w o r d s)
-    end
-
-    it 'aliases `#match?` to `#partial_word?`' do
-      container.match? 'words'
-      expect(root).to have_received(:partial_word?).with %w(w o r d s)
-    end
-
-    it 'aliases `#words` to `#scan`' do
-      container.words 'hig'
-      expect(root).to have_received(:scan).with %w(h i g)
-    end
-
-    it 'aliases `#<<` to `#add`' do
-      container << 'words'
-      expect(root).to have_received(:add).with %i(s d r o w)
-    end
-
-    it 'delegates `#[]` to the root node' do
-      container[:yep]
-      expect(root).to have_received(:[]).with :yep
-    end
-
-    it 'delegates `#children` to the root node' do
-      container.children
-      expect(root).to have_received :children
-    end
-
-    it 'delegates `#children_tree` to the root node' do
-      container.children_tree
-      expect(root).to have_received :children_tree
-    end
-
-    it 'delegates `#compressed?` to the root node' do
-      container.compressed?
-      expect(root).to have_received :compressed?
-    end
-
-    it 'delegates `#key?` to the root node' do
-      container.key? :yup
-      expect(root).to have_received(:key?).with :yup
-    end
-
-    it 'aliases `#has_key?` to `#key?`' do
-      container.has_key? :yup
-      expect(root).to have_received(:key?).with :yup
-    end
-
-    it 'aliases `#has_letter?` to `#has_key?`' do
-      container.has_letter? :yup
-      expect(root).to have_received(:key?).with :yup
-    end
-
-    it 'delegates `#inspect` to the root node' do
-      container.inspect
-      expect(root).to have_received :inspect
-    end
-
-    it 'delegates `#size` to the root node' do
-      container.size
-      expect(root).to have_received :size
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Rambling
-  module Trie
-    describe Enumerable do
-      let(:node) { Rambling::Trie::Nodes::Raw.new }
-      let(:words) { %w(add some words and another word) }
-
-      before { add_words node, words }
-
-      describe '#each' do
-        it 'returns an enumerator when no block is given' do
-          expect(node.each).to be_an Enumerator
-        end
-
-        it 'has the same word count as the trie' do
-          expect(node.count).to eq words.count
-        end
-
-        it 'includes every word contained in the trie' do
-          node.each { |word| expect(words).to include word }
-        end
-
-        it 'returns the enumerable when a block is given' do
-          expect(node.each { |_| }).to eq node
-        end
-      end
-
-      describe '#size' do
-        it 'delegates to #count' do
-          expect(node.size).to eq words.size
-        end
-      end
-
-      it 'includes #all? from the core Enumerable module' do
-        expect(node.all? { |word| words.include? word }).to be true
-      end
-
-      it 'includes #any? from the core Enumerable module' do
-        expect(node.any? { |word| word.start_with? 's' }).to be true
-      end
-
-      it 'includes #to_a from the core Enumerable module' do
-        expect(node.to_a).to match_array words
-      end
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Inspectable do
-  let(:node) { Rambling::Trie::Nodes::Raw.new }
-
-  before do
-    add_words node, %w(only three words)
-  end
-
-  describe '#inspect' do
-    let(:child) { node[:o] }
-    let(:terminal_node) { node[:o][:n][:l][:y] }
-
-    it 'returns a pretty printed version of the parent node' do
-      expect(node.inspect).to eq one_line <<~RAW
-        #<Rambling::Trie::Nodes::Raw letter: nil,
-        terminal: nil,
-        children: [:o, :t, :w]>
-      RAW
-    end
-
-    it 'returns a pretty printed version of the child node' do
-      expect(child.inspect).to eq one_line <<~CHILD
-        #<Rambling::Trie::Nodes::Raw letter: :o,
-        terminal: nil,
-        children: [:n]>
-      CHILD
-    end
-
-    it 'returns a pretty printed version of the terminal node' do
-      expect(terminal_node.inspect).to eq one_line <<~TERMINAL
-        #<Rambling::Trie::Nodes::Raw letter: :y,
-        terminal: true,
-        children: []>
-      TERMINAL
-    end
-
-    context 'with a compressed node' do
-      let(:compressor) { Rambling::Trie::Compressor.new }
-      let(:compressed) { compressor.compress node }
-      let(:compressed_child) { compressed[:o] }
-
-      it 'returns a pretty printed version of the compressed parent node' do
-        expect(compressed.inspect).to eq one_line <<~COMPRESSED
-          #<Rambling::Trie::Nodes::Compressed letter: nil,
-          terminal: nil,
-          children: [:o, :t, :w]>
-        COMPRESSED
-      end
-
-      it 'returns a pretty printed version of the compressed child node' do
-        expect(compressed_child.inspect).to eq one_line <<~CHILD
-          #<Rambling::Trie::Nodes::Compressed letter: :only,
-          terminal: true,
-          children: []>
-        CHILD
-      end
-    end
-  end
-end

data/spec/lib/rambling/trie/nodes/compressed_spec.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Nodes::Compressed do
-  let(:raw_node) { Rambling::Trie::Nodes::Raw.new }
-  let(:compressor) { Rambling::Trie::Compressor.new }
-  let(:node) { compressor.compress raw_node }
-
-  describe '#new' do
-    it 'is not a word' do
-      expect(node).not_to be_word
-    end
-  end
-
-  it_behaves_like 'a trie node implementation' do
-    def add_word_to_tree word
-      add_word raw_node, word
-    end
-
-    def add_words_to_tree words
-      add_words raw_node, words
-    end
-
-    def assign_letter letter
-      raw_node.letter = letter
-    end
-  end
-
-  describe '#compressed?' do
-    it 'returns true' do
-      expect(node).to be_compressed
-    end
-  end
-
-  describe '#add' do
-    it 'raises an error' do
-      expect do
-        add_word node, 'restaurant'
-      end.to raise_error Rambling::Trie::InvalidOperation
-    end
-  end
-end

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

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Nodes::Node do
-  it_behaves_like 'a trie node' do
-    let(:node) { described_class.new }
-  end
-end