rambling-trie 2.3.0 → 2.4.0

data/spec/lib/rambling/trie_spec.rb

@@ -15,25 +15,27 @@ describe Rambling::Trie do
     end
 
     it 'returns a new instance of the trie container' do
-      expect(Rambling::Trie.create).to eq container
+      expect(described_class.create).to eq container
     end
 
     context 'with a block' do
       it 'yields the new container' do
         yielded = nil
-        Rambling::Trie.create { |trie| yielded = trie }
+        described_class.create { |trie| yielded = trie }
         expect(yielded).to eq container
       end
     end
 
     context 'with a filepath' do
       let(:filepath) { 'a test filepath' }
-      let(:reader) { double :reader }
+      let :reader do
+        instance_double 'Rambling::Trie::Readers::PlainText', :reader
+      end
       let(:words) { %w(a couple of test words over here) }
 
       before do
         receive_and_yield = receive(:each_word)
-        words.inject(receive_and_yield) do |yielder, word|
+        words.inject receive_and_yield do |yielder, word|
           yielder.and_yield word
         end
 
@@ -42,7 +44,7 @@ describe Rambling::Trie do
       end
 
       it 'loads every word' do
-        Rambling::Trie.create filepath, reader
+        described_class.create filepath, reader
 
         words.each do |word|
           expect(container).to have_received(:<<).with word
@@ -52,17 +54,23 @@ describe Rambling::Trie do
 
     context 'without any reader' do
       let(:filepath) { 'a test filepath' }
-      let(:reader) { double :reader, each_word: nil }
+      let :reader do
+        instance_double(
+          'Rambling::Trie::Readers::PlainText',
+          :reader,
+          each_word: nil,
+        )
+      end
 
       before do
-        Rambling::Trie.config do |c|
+        described_class.config do |c|
           c.readers.add :default, reader
           c.readers.default = reader
         end
       end
 
       it 'defaults to a plain text reader' do
-        Rambling::Trie.create filepath, nil
+        described_class.create filepath, nil
 
         expect(reader).to have_received(:each_word).with filepath
       end
@@ -70,29 +78,53 @@ describe Rambling::Trie do
   end
 
   describe '.load' do
+    let(:filepath) { 'a path to a file' }
     let(:root) { Rambling::Trie::Nodes::Raw.new }
     let(:compressor) { Rambling::Trie::Compressor.new }
     let(:container) { Rambling::Trie::Container.new root, compressor }
-    let(:serializer) { double :serializer, load: root }
-    let(:filepath) { 'a path to a file' }
+    let :serializer do
+      instance_double(
+        'Rambling::True::Serializers::File',
+        :serializer,
+        load: root,
+      )
+    end
 
     it 'returns a new container with the loaded root node' do
-      trie = Rambling::Trie.load filepath, serializer
+      trie = described_class.load filepath, serializer
       expect(trie).to eq container
     end
 
     it 'uses the serializer to load the root node from the given filepath' do
-      Rambling::Trie.load filepath, serializer
+      described_class.load filepath, serializer
       expect(serializer).to have_received(:load).with filepath
     end
 
     context 'without a serializer' do
-      let(:marshal_serializer) { double :marshal_serializer, load: nil }
-      let(:default_serializer) { double :default_serializer, load: nil }
-      let(:yaml_serializer) { double :yaml_serializer, load: nil }
+      let :marshal_serializer do
+        instance_double(
+          'Rambling::Trie::Serializers::Marshal',
+          :marshal_serializer,
+          load: nil,
+        )
+      end
+      let :default_serializer do
+        instance_double(
+          'Rambling::Trie::Serializers::File',
+          :default_serializer,
+          load: nil,
+        )
+      end
+      let :yaml_serializer do
+        instance_double(
+          'Rambling::Trie::Serializers::Yaml',
+          :yaml_serializer,
+          load: nil,
+        )
+      end
 
       before do
-        Rambling::Trie.config do |c|
+        described_class.config do |c|
           c.serializers.add :default, default_serializer
           c.serializers.add :marshal, marshal_serializer
           c.serializers.add :yml, yaml_serializer
@@ -102,18 +134,21 @@ describe Rambling::Trie do
         end
       end
 
-      it 'determines the serializer based on the file extension' do
-        Rambling::Trie.load 'test.marshal'
-        expect(marshal_serializer).to have_received(:load).with 'test.marshal'
+      [
+        ['.marshal', :marshal_serializer],
+        ['.yml', :yaml_serializer],
+        ['.yaml', :yaml_serializer],
+        ['', :default_serializer],
+      ].each do |test_params|
+        extension, serializer = test_params
+        filepath = "test#{extension}"
 
-        Rambling::Trie.load 'test.yml'
-        expect(yaml_serializer).to have_received(:load).with 'test.yml'
+        it "uses extension-based serializer (#{filepath} -> #{serializer})" do
+          serializer_instance = public_send serializer
 
-        Rambling::Trie.load 'test.yaml'
-        expect(yaml_serializer).to have_received(:load).with 'test.yaml'
-
-        Rambling::Trie.load 'test'
-        expect(default_serializer).to have_received(:load).with 'test'
+          described_class.load filepath
+          expect(serializer_instance).to have_received(:load).with filepath
+        end
       end
     end
 
@@ -121,7 +156,7 @@ describe Rambling::Trie do
       it 'yields the new container' do
         yielded = nil
 
-        Rambling::Trie.load filepath, serializer do |trie|
+        described_class.load filepath, serializer do |trie|
           yielded = trie
         end
 
@@ -132,16 +167,36 @@ describe Rambling::Trie do
 
   describe '.dump' do
     let(:filename) { 'a trie' }
-    let(:root) { double :root }
-    let(:compressor) { double :compressor }
+    let(:root) { instance_double 'Rambling::Trie::Serializers::Marshal', :root }
+    let :compressor do
+      instance_double 'Rambling::Trie::Serializers::Marshal', :compressor
+    end
     let(:trie) { Rambling::Trie::Container.new root, compressor }
 
-    let(:marshal_serializer) { double :marshal_serializer, dump: nil }
-    let(:yaml_serializer) { double :yaml_serializer, dump: nil }
-    let(:default_serializer) { double :default_serializer, dump: nil }
+    let :marshal_serializer do
+      instance_double(
+        'Rambling::Trie::Serializers::Marshal',
+        :marshal_serializer,
+        dump: nil,
+      )
+    end
+    let :yaml_serializer do
+      instance_double(
+        'Rambling::Trie::Serializers::Yaml',
+        :yaml_serializer,
+        dump: nil,
+      )
+    end
+    let :default_serializer do
+      instance_double(
+        'Rambling::Trie::Serializers::File',
+        :default_serializer,
+        dump: nil,
+      )
+    end
 
     before do
-      Rambling::Trie.config do |c|
+      described_class.config do |c|
         c.serializers.add :default, default_serializer
         c.serializers.add :marshal, marshal_serializer
         c.serializers.add :yml, yaml_serializer
@@ -151,32 +206,39 @@ describe Rambling::Trie do
     end
 
     it 'uses the configured default serializer by default' do
-      Rambling::Trie.dump trie, filename
+      described_class.dump trie, filename
       expect(default_serializer).to have_received(:dump).with root, filename
     end
 
     context 'when provided with a format' do
-      it 'uses the corresponding serializer' do
-        Rambling::Trie.dump trie, "#{filename}.marshal"
-        expect(marshal_serializer).to have_received(:dump)
-          .with root, "#{filename}.marshal"
-
-        Rambling::Trie.dump trie, "#{filename}.yml"
-        expect(yaml_serializer).to have_received(:dump)
-          .with root, "#{filename}.yml"
+      [
+        ['.marshal', :marshal_serializer],
+        ['.yml', :yaml_serializer],
+        ['', :default_serializer],
+      ].each do |test_params|
+        extension, serializer = test_params
+
+        it 'uses the corresponding serializer' do
+          filepath = "#{filename}#{extension}"
+          serializer_instance = public_send serializer
+
+          described_class.dump trie, filepath
+          expect(serializer_instance).to have_received(:dump)
+            .with root, filepath
+        end
       end
     end
   end
 
   describe '.config' do
     it 'returns the properties' do
-      expect(Rambling::Trie.config).to eq Rambling::Trie.send :properties
+      expect(described_class.config).to eq described_class.send :properties
     end
 
     it 'yields the properties' do
       yielded = nil
-      Rambling::Trie.config { |c| yielded = c }
-      expect(yielded).to eq Rambling::Trie.send :properties
+      described_class.config { |c| yielded = c }
+      expect(yielded).to eq described_class.send :properties
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,15 +1,21 @@
 # frozen_string_literal: true
 
+require 'yaml'
 require 'simplecov'
-require 'coveralls'
 
-SimpleCov.formatters = [
-  SimpleCov::Formatter::HTMLFormatter,
-  Coveralls::SimpleCov::Formatter,
-]
+COVERAGE_FILTER = %r{/spec/}.freeze
 
-Coveralls.wear! do
-  add_filter '/spec/'
+if ENV.key? 'COVERALLS_REPO_TOKEN'
+  require 'coveralls'
+
+  SimpleCov.formatters = [
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter,
+  ]
+
+  Coveralls.wear! { add_filter COVERAGE_FILTER }
+else
+  SimpleCov.start { add_filter COVERAGE_FILTER }
 end
 
 require 'rspec'
@@ -21,7 +27,7 @@ RSpec.configure do |config|
   config.tty = true
   config.formatter = :documentation
   config.order = :random
-  config.run_all_when_everything_filtered = true
+  config.filter_run_when_matching :focus
   config.raise_errors_for_deprecations!
 end
 
@@ -29,7 +35,8 @@ require 'support/config'
 
 %w(
   a_compressible_trie a_serializable_trie a_serializer a_trie_data_structure
-  a_trie_node a_trie_node_implementation
+  a_trie_node a_trie_node_implementation a_container_scan a_container_word
+  a_container_partial_word a_container_words_within
 ).each do |name|
   require File.join('support', 'shared_examples', name)
 end

data/spec/support/shared_examples/a_compressible_trie.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 shared_examples_for 'a compressible trie' do
-  context 'and the trie is not compressed' do
+  context 'with an uncompressed trie' do
     it_behaves_like 'a trie data structure'
 
     it 'does not alter the input' do
@@ -16,7 +16,7 @@ shared_examples_for 'a compressible trie' do
     end
   end
 
-  context 'and the trie is compressed' do
+  context 'with an compressed trie' do
     let!(:original_root) { trie.root }
     let!(:original_keys) { original_root.children_tree.keys }
     let!(:original_values) { original_root.children_tree.values }
@@ -31,9 +31,15 @@ shared_examples_for 'a compressible trie' do
       expect(trie).to be_compressed
     end
 
-    it 'leaves the original root intact' do
+    it 'leaves the original root keys intact' do
       expect(original_root.children_tree.keys).to eq original_keys
+    end
+
+    it 'leaves the original trie keys intact' do
       expect(trie.children_tree.keys).to eq original_keys
+    end
+
+    it 'leaves the original trie values intact' do
       expect(trie.children_tree.values).not_to eq original_values
     end
   end

data/spec/support/shared_examples/a_container_partial_word.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+shared_examples_for 'a matching container#partial_word' do
+  %w(h he hell hello hi hig high).each do |prefix|
+    it 'matches part of the word' do
+      expect(container.partial_word? prefix).to be true
+    end
+  end
+end
+
+shared_examples_for 'a non-matching container#partial_word' do
+  it 'does not match any part of the word' do
+    %w(ha hal al).each do |word|
+      expect(container.partial_word? word).to be false
+    end
+  end
+end

data/spec/support/shared_examples/a_container_scan.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+shared_examples_for 'a matching container#scan' do
+  [
+    ['hi', %w(hi high highlight histerical)],
+    ['hig', %w(high highlight)],
+  ].each do |test_params|
+    prefix, expected = test_params
+
+    it "returns an array with the words that match '#{prefix}'" do
+      expect(container.scan prefix).to eq expected
+    end
+  end
+end

data/spec/support/shared_examples/a_container_word.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+shared_examples_for 'a matching container#word' do
+  %w(hello high).each do |word|
+    it 'matches the whole word' do
+      expect(container.word? word).to be true
+    end
+  end
+end
+
+shared_examples_for 'a non-matching container#word' do
+  %w(halt al).each do |word|
+    it 'does not match the whole word' do
+      expect(container.word? word).to be false
+    end
+  end
+end
+
+shared_examples_for 'a propagating node' do
+  [
+    [true, 'Rambling::Trie::Nodes::Compressed'],
+    [false, 'Rambling::Trie::Nodes::Raw'],
+  ].each do |test_params|
+    compressed_value, instance_double_class = test_params
+
+    context "when root has compressed=#{compressed_value}" do
+      let :root do
+        instance_double(
+          instance_double_class,
+          :root,
+          compressed?: compressed_value,
+          word?: nil,
+          partial_word?: nil,
+        )
+      end
+
+      it 'calls the root with the word characters' do
+        container.public_send method_name, 'words'
+        expect(root).to have_received(method_name).with %w(w o r d s)
+      end
+    end
+  end
+end

data/spec/support/shared_examples/a_container_words_within.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+shared_examples_for 'a matching container#words_within' do
+  [
+    ['word', %w(word)],
+    ['wordxyz', %w(word)],
+  ].each do |test_params|
+    phrase, expected = test_params
+
+    it "returns an array with the word found in the phrase '#{phrase}'" do
+      expect(container.words_within phrase).to match_array expected
+    end
+  end
+end
+
+shared_examples_for 'a non-matching container#words_within' do
+  it 'returns an array with all words found in the phrase' do
+    expect(container.words_within 'xyzword otherzxyone')
+      .to match_array %w(word other one)
+  end
+end
+
+shared_examples_for 'a matching container#words_within?' do
+  context 'when phrase does not contain any words' do
+    it 'returns false' do
+      expect(container.words_within? 'xyz').to be false
+    end
+  end
+
+  context 'when phrase contains any word' do
+    ['xyz words', 'xyzone word'].each do |phrase|
+      it "returns true for '#{phrase}'" do
+        expect(container.words_within? phrase).to be true
+      end
+    end
+  end
+end
+
+shared_examples_for 'a non-matching container#words_within?' do
+  it 'returns an array with all words found in the phrase' do
+    expect(container.words_within 'xyzword otherzxyone')
+      .to match_array %w(word other one)
+  end
+end

data/spec/support/shared_examples/a_serializable_trie.rb

@@ -2,24 +2,20 @@
 
 shared_examples_for 'a serializable trie' do
   let(:tmp_path) { File.join ::SPEC_ROOT, 'tmp' }
-  let(:filepath) { File.join tmp_path, "trie-root.#{format}" }
+  let(:filepath) { File.join tmp_path, "trie-root.#{file_format}" }
 
-  context 'and the trie is not compressed' do
-    before do
-      Rambling::Trie.dump trie_to_serialize, filepath
-    end
+  context 'with an uncompressed trie' do
+    before { Rambling::Trie.dump trie_to_serialize, filepath }
 
     it_behaves_like 'a compressible trie' do
       let(:trie) { Rambling::Trie.load filepath }
     end
   end
 
-  context 'and the trie is compressed' do
+  context 'with an compressed trie' do
     let(:trie) { Rambling::Trie.load filepath }
 
-    before do
-      Rambling::Trie.dump trie_to_serialize.compress!, filepath
-    end
+    before { Rambling::Trie.dump trie_to_serialize.compress!, filepath }
 
     it_behaves_like 'a trie data structure'
 

data/spec/support/shared_examples/a_serializer.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 shared_examples_for 'a serializer' do
+  subject(:serializer) { described_class.new }
+
   let(:trie) { Rambling::Trie.create }
   let(:tmp_path) { File.join ::SPEC_ROOT, 'tmp' }
-  let(:filepath) { File.join tmp_path, "trie-root.#{format}" }
+  let(:filepath) { File.join tmp_path, "trie-root.#{file_format}" }
   let(:content) { trie.root }
 
   before do
@@ -12,26 +14,47 @@ shared_examples_for 'a serializer' do
   end
 
   describe '#dump' do
-    before do
-      serializer.dump content, filepath
-    end
+    [true, false].each do |compress_value|
+      context "with compressed=#{compress_value} trie" do
+        let(:formatted_content) { format_content.call content }
 
-    it 'creates the file with the provided path' do
-      expect(File.exist? filepath).to be true
-    end
+        before { trie.compress! if compress_value }
+
+        it 'returns the size in bytes of the file dumped' do
+          total_bytes = serializer.dump content, filepath
+          expect(total_bytes).to be_within(20).of formatted_content.size
+        end
 
-    it 'converts the contents to the appropriate format' do
-      expect(File.read(filepath).size).to be_within(10).of formatted_content.size
+        it 'creates the file with the provided path' do
+          serializer.dump content, filepath
+          expect(File.exist? filepath).to be true
+        end
+
+        it 'converts the contents to the appropriate format' do
+          serializer.dump content, filepath
+          expect(File.size filepath).to be_within(20).of formatted_content.size
+        end
+      end
     end
   end
 
   describe '#load' do
-    before do
-      serializer.dump content, filepath
-    end
+    [true, false].each do |compress_value|
+      context "with compressed=#{compress_value} trie" do
+        before do
+          trie.compress! if compress_value
+          serializer.dump content, filepath
+        end
+
+        it 'loads the dumped object back into memory' do
+          expect(serializer.load filepath).to eq content
+        end
 
-    it 'loads the dumped object back into memory' do
-      expect(serializer.load filepath).to eq content
+        it "loads a compressed=#{compress_value} object" do
+          loaded = serializer.load filepath
+          expect(loaded.compressed?).to be compress_value unless :file == file_format
+        end
+      end
     end
   end
 end

data/spec/support/shared_examples/a_trie_data_structure.rb

@@ -2,25 +2,39 @@
 
 shared_examples_for 'a trie data structure' do
   it 'contains all the words previously provided' do
-    words.each do |word|
-      expect(trie).to include word
-      expect(trie.word? word).to be true
-    end
+    words.each { |word| expect(trie).to include word }
+  end
+
+  it 'returns true for #word? for all words previously provided' do
+    words.each { |word| expect(trie.word? word).to be true }
+  end
+
+  it 'matches the full word for all words in file' do
+    words.each { |word| expect(trie.match? word).to be true }
+  end
+
+  it 'matches the start of all the words in file' do
+    words.each { |word| expect(trie.match? word[0..-2]).to be true }
   end
 
-  it 'matches the start of all the words from the file' do
+  it 'returns true for #partial_word? with full word for all words in file' do
+    words.each { |word| expect(trie.partial_word? word).to be true }
+  end
+
+  it 'returns true for #partial_word? with the start of all words in file' do
+    words.each { |word| expect(trie.partial_word? word[0..-2]).to be true }
+  end
+
+  it 'extracts words within larger strings' do
     words.each do |word|
-      expect(trie.match? word).to be true
-      expect(trie.match? word[0..-2]).to be true
-      expect(trie.partial_word? word).to be true
-      expect(trie.partial_word? word[0..-2]).to be true
+      phrase = "x#{word}y"
+      expect(trie.words_within phrase).to include word
     end
   end
 
   it 'identifies words within larger strings' do
     words.each do |word|
       phrase = "x#{word}y"
-      expect(trie.words_within phrase).to include word
       expect(trie.words_within? phrase).to be true
     end
   end