rambling-trie 2.4.0 → 2.5.1

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

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

@@ -1,184 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Nodes::Raw do
-  let(:node) { described_class.new }
-
-  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 node, word
-    end
-
-    def add_words_to_tree words
-      add_words node, words
-    end
-
-    def assign_letter letter
-      node.letter = letter
-    end
-  end
-
-  describe '#compressed?' do
-    it 'returns false' do
-      expect(node).not_to be_compressed
-    end
-  end
-
-  describe '#add' do
-    context 'when the node has no branches' do
-      before { add_word node, 'abc' }
-
-      it 'adds only one child' do
-        expect(node.children.size).to eq 1
-      end
-
-      # rubocop:disable RSpec/MultipleExpectations
-      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
-      # rubocop:enable RSpec/MultipleExpectations
-
-      # rubocop:disable RSpec/MultipleExpectations
-      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
-      # rubocop:enable RSpec/MultipleExpectations
-    end
-
-    context 'when a word is added more than once' do
-      before do
-        add_word node, 'ack'
-        add_word node, 'ack'
-      end
-
-      # rubocop:disable RSpec/MultipleExpectations
-      it 'only counts it once' do
-        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
-      # rubocop:enable RSpec/MultipleExpectations
-
-      # rubocop:disable RSpec/MultipleExpectations
-      it 'does not change the terminal nodes in the tree' do
-        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
-      # rubocop:enable RSpec/MultipleExpectations
-
-      it 'still returns the "added" node' do
-        child = add_word node, 'ack'
-        expect(child.letter).to eq :a
-      end
-    end
-
-    context 'when the word does not exist in the tree but the letters do' do
-      before { add_words node, %w(ack a) }
-
-      it 'does not add another branch' do
-        expect(node.children.size).to eq 1
-      end
-
-      # rubocop:disable RSpec/MultipleExpectations
-      it 'marks the corresponding node as terminal' do
-        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
-      # rubocop:enable RSpec/MultipleExpectations
-
-      it 'returns the added node' do
-        child = add_word node, 'a'
-        expect(child.letter).to eq :a
-      end
-    end
-
-    context 'when the node has a letter and a parent' do
-      let(:parent) { described_class.new }
-      let(:node) { described_class.new :a, parent }
-
-      context 'when adding an empty string' do
-        before { add_word node, '' }
-
-        it 'does not alter the node letter' do
-          expect(node.letter).to eq :a
-        end
-
-        it 'does not change the node children' do
-          expect(node.children.size).to eq 0
-        end
-
-        it 'changes the node to terminal' do
-          expect(node).to be_terminal
-        end
-      end
-
-      context 'when adding a one letter word' do
-        before { add_word node, 'b' }
-
-        it 'does not alter the node letter' do
-          expect(node.letter).to eq :a
-        end
-
-        # rubocop:disable RSpec/MultipleExpectations
-        it 'adds a child with the expected letter' do
-          expect(node.children.size).to eq 1
-          expect(node.children.first.letter).to eq :b
-        end
-        # rubocop:enable RSpec/MultipleExpectations
-
-        it 'reports it has the expected letter a key' do
-          expect(node).to have_key(:b)
-        end
-
-        it 'returns the child corresponding to the key' do
-          expect(node[:b]).to eq node.children_tree[:b]
-        end
-
-        it 'does not mark itself as terminal' do
-          expect(node).not_to be_terminal
-        end
-
-        it 'marks the first child as terminal' do
-          expect(node[:b]).to be_terminal
-        end
-      end
-
-      context 'when adding a large word' do
-        before { add_word node, 'mplified' }
-
-        it 'marks the last letter as terminal' do
-          expect(node[:m][:p][:l][:i][:f][:i][:e][:d]).to be_terminal
-        end
-
-        # rubocop:disable RSpec/ExampleLength, RSpec/MultipleExpectations
-        it 'does not mark any other letter as terminal' do
-          expect(node[:m][:p][:l][:i][:f][:i][:e]).not_to be_terminal
-          expect(node[:m][:p][:l][:i][:f][:i]).not_to be_terminal
-          expect(node[:m][:p][:l][:i][:f]).not_to be_terminal
-          expect(node[:m][:p][:l][:i]).not_to be_terminal
-          expect(node[:m][:p][:l]).not_to be_terminal
-          expect(node[:m][:p]).not_to be_terminal
-          expect(node[:m]).not_to be_terminal
-        end
-        # rubocop:enable RSpec/ExampleLength, RSpec/MultipleExpectations
-      end
-    end
-  end
-end

data/spec/lib/rambling/trie/readers/plain_text_spec.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Readers::PlainText do
-  subject(:reader) { described_class.new }
-
-  describe '#each_word' do
-    let(:filepath) { File.join(::SPEC_ROOT, 'assets', 'test_words.en_US.txt') }
-    let(:words) { File.readlines(filepath).map(&:chomp) }
-
-    it 'yields every word yielded by the file' do
-      yielded = []
-      reader.each_word(filepath) { |word| yielded << word }
-      expect(yielded).to eq words
-    end
-
-    it 'returns an enumerator when no block is given' do
-      expect(reader.each_word filepath).to be_an Enumerator
-    end
-
-    it 'returns the enumerable when a block is given' do
-      expect(reader.each_word(filepath) { |_| }).to eq reader
-    end
-  end
-end

data/spec/lib/rambling/trie/readers/reader_spec.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Readers::Reader do
-  subject(:reader) { described_class.new }
-
-  describe '#load' do
-    it 'is an abstract method that raises NotImplementedError' do
-      expect { reader.each_word('any-file.zip') }
-        .to raise_exception NotImplementedError
-    end
-  end
-end

data/spec/lib/rambling/trie/serializers/file_spec.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Serializers::File do
-  it_behaves_like 'a serializer' do
-    let(:file_format) { :file }
-    let(:content) { trie.to_a.join ' ' }
-    let(:format_content) { ->(content) { content } }
-  end
-end

data/spec/lib/rambling/trie/serializers/marshal_spec.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Serializers::Marshal do
-  it_behaves_like 'a serializer' do
-    let(:file_format) { :marshal }
-    let(:format_content) { Marshal.method(:dump) }
-  end
-end

data/spec/lib/rambling/trie/serializers/serializer_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Serializers::Serializer do
-  subject(:serializer) { described_class.new }
-
-  describe '#load' do
-    it 'is an abstract method that raises NotImplementedError' do
-      expect { serializer.load('any-file.zip') }
-        .to raise_exception NotImplementedError
-    end
-  end
-
-  describe '#dump' do
-    it 'is an abstract method that raises NotImplementedError' do
-      expect { serializer.dump('any contents', 'any-file.zip') }
-        .to raise_exception NotImplementedError
-    end
-  end
-end

data/spec/lib/rambling/trie/serializers/yaml_spec.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Serializers::Yaml do
-  it_behaves_like 'a serializer' do
-    let(:file_format) { :yml }
-    let(:format_content) { YAML.method(:dump) }
-  end
-end

data/spec/lib/rambling/trie/serializers/zip_spec.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Serializers::Zip do
-  {
-    yaml: YAML.method(:dump),
-    yml: YAML.method(:dump),
-    marshal: Marshal.method(:dump),
-    file: Marshal.method(:dump),
-  }.each do |file_format, dump_method|
-    context "with '.#{file_format}'" do
-      it_behaves_like 'a serializer' do
-        let(:properties) { Rambling::Trie::Configuration::Properties.new }
-        let(:serializer) { described_class.new properties }
-        let(:file_format) { :zip }
-
-        let(:filepath) { File.join tmp_path, "trie-root.#{file_format}.zip" }
-        let(:format_content) { ->(content) { zip dump_method.call content } }
-        let(:filename) { File.basename(filepath).gsub %r{\.zip}, '' }
-
-        before { properties.tmp_path = tmp_path }
-      end
-    end
-  end
-
-  def zip content
-    cursor = Zip::OutputStream.write_buffer do |io|
-      io.put_next_entry filename
-      io.write content
-    end
-
-    cursor.rewind
-    cursor.read
-  end
-end

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

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Rambling::Trie::Stringifyable do
-  describe '#as_word' do
-    let(:node) { Rambling::Trie::Nodes::Raw.new }
-
-    context 'with an empty node' do
-      before { add_word node, '' }
-
-      it 'returns nil' do
-        expect(node.as_word).to be_empty
-      end
-    end
-
-    context 'with one letter' do
-      before do
-        node.letter = :a
-        add_word node, ''
-      end
-
-      it 'returns the expected one letter word' do
-        expect(node.as_word).to eq 'a'
-      end
-    end
-
-    context 'with a small word' do
-      before do
-        node.letter = :a
-        add_word node, '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 'with a long word' do
-      before do
-        node.letter = :b
-        add_word node, '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 'with a node with nil letter' do
-      let(:node) { Rambling::Trie::Nodes::Raw.new nil }
-
-      it 'returns nil' do
-        expect(node.as_word).to be_empty
-      end
-    end
-
-    context 'with a compressed node' do
-      let(:compressor) { Rambling::Trie::Compressor.new }
-      let(:compressed_node) { compressor.compress node }
-
-      before do
-        node.letter = :a
-        add_words node, %w(m dd)
-      end
-
-      [
-        [:m, 'am'],
-        [:d, 'add'],
-      ].each do |test_params|
-        key, expected = test_params
-
-        it "returns the words for terminal nodes (#{key} => #{expected})" do
-          expect(compressed_node[key].as_word).to eq expected
-        end
-      end
-
-      it 'raises an error for non terminal nodes' do
-        expect { compressed_node.as_word }
-          .to raise_error Rambling::Trie::InvalidOperation
-      end
-    end
-  end
-end