rambling-trie 2.3.0 → 2.4.0

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

@@ -8,21 +8,23 @@ module Rambling
       let(:node) { Rambling::Trie::Nodes::Raw.new }
       let(:words) { %w(add some words and another word) }
 
-      before do
-        add_words node, words
-      end
+      before { add_words node, words }
 
       describe '#each' do
-        it 'returns an enumerator' do
-          expect(node.each).to be_a Enumerator
+        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 do |word|
-            expect(words).to include word
-          end
+          node.each { |word| expect(words).to include word }
+        end
 
-          expect(node.count).to eq words.count
+        it 'returns the enumerable when a block is given' do
+          expect(node.each { |_| }).to eq node
         end
       end
 
@@ -32,9 +34,15 @@ module Rambling
         end
       end
 
-      it 'includes the core Enumerable module' do
+      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

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

@@ -13,19 +13,23 @@ describe Rambling::Trie::Inspectable do
     let(:child) { node[:o] }
     let(:terminal_node) { node[:o][:n][:l][:y] }
 
-    it 'returns a pretty printed version of the node' do
+    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,
@@ -33,18 +37,20 @@ describe Rambling::Trie::Inspectable do
       TERMINAL
     end
 
-    context 'for a compressed node' do
+    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 node' do
+      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,

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

@@ -7,6 +7,12 @@ describe Rambling::Trie::Nodes::Compressed do
   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

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

@@ -4,6 +4,6 @@ require 'spec_helper'
 
 describe Rambling::Trie::Nodes::Node do
   it_behaves_like 'a trie node' do
-    let(:node) { Rambling::Trie::Nodes::Node.new }
+    let(:node) { described_class.new }
   end
 end

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

@@ -3,7 +3,13 @@
 require 'spec_helper'
 
 describe Rambling::Trie::Nodes::Raw do
-  let(:node) { Rambling::Trie::Nodes::Raw.new }
+  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
@@ -17,10 +23,6 @@ describe Rambling::Trie::Nodes::Raw do
     def assign_letter letter
       node.letter = letter
     end
-
-    it 'is not a word' do
-      expect(node).not_to be_word
-    end
   end
 
   describe '#compressed?' do
@@ -31,26 +33,28 @@ describe Rambling::Trie::Nodes::Raw do
 
   describe '#add' do
     context 'when the node has no branches' do
-      before do
-        add_word node, 'abc'
-      end
+      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
@@ -59,19 +63,23 @@ describe Rambling::Trie::Nodes::Raw do
         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'
@@ -80,21 +88,20 @@ describe Rambling::Trie::Nodes::Raw do
     end
 
     context 'when the word does not exist in the tree but the letters do' do
-      before do
-        add_words node, %w(ack a)
-      end
+      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[:a]).to be_terminal
-
         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'
@@ -103,13 +110,11 @@ describe Rambling::Trie::Nodes::Raw do
     end
 
     context 'when the node has a letter and a parent' do
-      let(:parent) { Rambling::Trie::Nodes::Raw.new }
-      let(:node) { Rambling::Trie::Nodes::Raw.new :a, parent }
+      let(:parent) { described_class.new }
+      let(:node) { described_class.new :a, parent }
 
-      context 'adding an empty string' do
-        before do
-          add_word node, ''
-        end
+      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
@@ -124,19 +129,19 @@ describe Rambling::Trie::Nodes::Raw do
         end
       end
 
-      context 'adding a one letter word' do
-        before do
-          add_word node, 'b'
-        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)
@@ -155,15 +160,14 @@ describe Rambling::Trie::Nodes::Raw do
         end
       end
 
-      context 'adding a large word' do
-        before do
-          add_word node, 'mplified'
-        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
@@ -173,6 +177,7 @@ describe Rambling::Trie::Nodes::Raw do
           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

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

@@ -3,14 +3,24 @@
 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 = []
-      subject.each_word(filepath) { |word| yielded << word }
+      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

@@ -0,0 +1,14 @@
+# 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

@@ -4,10 +4,8 @@ require 'spec_helper'
 
 describe Rambling::Trie::Serializers::File do
   it_behaves_like 'a serializer' do
-    let(:serializer) { Rambling::Trie::Serializers::File.new }
-    let(:format) { :file }
-
+    let(:file_format) { :file }
     let(:content) { trie.to_a.join ' ' }
-    let(:formatted_content) { content }
+    let(:format_content) { ->(content) { content } }
   end
 end

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

@@ -4,9 +4,7 @@ require 'spec_helper'
 
 describe Rambling::Trie::Serializers::Marshal do
   it_behaves_like 'a serializer' do
-    let(:serializer) { Rambling::Trie::Serializers::Marshal.new }
-    let(:format) { :marshal }
-
-    let(:formatted_content) { Marshal.dump content }
+    let(:file_format) { :marshal }
+    let(:format_content) { Marshal.method(:dump) }
   end
 end

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

@@ -0,0 +1,21 @@
+# 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

@@ -4,9 +4,7 @@ require 'spec_helper'
 
 describe Rambling::Trie::Serializers::Yaml do
   it_behaves_like 'a serializer' do
-    let(:serializer) { Rambling::Trie::Serializers::Yaml.new }
-    let(:format) { :yml }
-
-    let(:formatted_content) { YAML.dump content }
+    let(:file_format) { :yml }
+    let(:format_content) { YAML.method(:dump) }
   end
 end

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

@@ -3,26 +3,34 @@
 require 'spec_helper'
 
 describe Rambling::Trie::Serializers::Zip do
-  it_behaves_like 'a serializer' do
-    let(:properties) { Rambling::Trie::Configuration::Properties.new }
-    let(:serializer) { Rambling::Trie::Serializers::Zip.new properties }
-    let(:format) { 'marshal.zip' }
+  {
+    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 }
 
-    before do
-      properties.tmp_path = tmp_path
-    end
-
-    let(:filename) { File.basename(filepath).gsub %r{\.zip}, '' }
-    let(:formatted_content) { zip Marshal.dump content }
+        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}, '' }
 
-    def zip content
-      cursor = Zip::OutputStream.write_buffer do |io|
-        io.put_next_entry filename
-        io.write content
+        before { properties.tmp_path = tmp_path }
       end
+    end
+  end
 
-      cursor.rewind
-      cursor.read
+  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

@@ -6,17 +6,15 @@ describe Rambling::Trie::Stringifyable do
   describe '#as_word' do
     let(:node) { Rambling::Trie::Nodes::Raw.new }
 
-    context 'for an empty node' do
-      before do
-        add_word node, ''
-      end
+    context 'with an empty node' do
+      before { add_word node, '' }
 
       it 'returns nil' do
         expect(node.as_word).to be_empty
       end
     end
 
-    context 'for one letter' do
+    context 'with one letter' do
       before do
         node.letter = :a
         add_word node, ''
@@ -27,7 +25,7 @@ describe Rambling::Trie::Stringifyable do
       end
     end
 
-    context 'for a small word' do
+    context 'with a small word' do
       before do
         node.letter = :a
         add_word node, 'll'
@@ -43,7 +41,7 @@ describe Rambling::Trie::Stringifyable do
       end
     end
 
-    context 'for a long word' do
+    context 'with a long word' do
       before do
         node.letter = :b
         add_word node, 'eautiful'
@@ -54,7 +52,7 @@ describe Rambling::Trie::Stringifyable do
       end
     end
 
-    context 'for a node with nil letter' do
+    context 'with a node with nil letter' do
       let(:node) { Rambling::Trie::Nodes::Raw.new nil }
 
       it 'returns nil' do
@@ -62,7 +60,7 @@ describe Rambling::Trie::Stringifyable do
       end
     end
 
-    context 'for a compressed node' do
+    context 'with a compressed node' do
       let(:compressor) { Rambling::Trie::Compressor.new }
       let(:compressed_node) { compressor.compress node }
 
@@ -71,12 +69,18 @@ describe Rambling::Trie::Stringifyable do
         add_words node, %w(m dd)
       end
 
-      it 'returns the words for the terminal nodes' do
-        expect(compressed_node[:m].as_word).to eq 'am'
-        expect(compressed_node[:d].as_word).to eq 'add'
+      [
+        [: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 'raise an error for non terminal nodes' do
+      it 'raises an error for non terminal nodes' do
         expect { compressed_node.as_word }
           .to raise_error Rambling::Trie::InvalidOperation
       end