LittleWeasel 5.0.5 → 5.0.6

data/spec/lib/LittleWeasel/dictionary_key_spec.rb

@@ -9,15 +9,15 @@ RSpec.describe LittleWeasel::DictionaryKey, type: :class do
   let(:region) {}
   let(:tag) {}
 
-  #.new
+  # .new
   describe '.new' do
     context 'when passing valid arguments' do
       let(:language) { :EN }
       let(:region) { :us }
-      let(:tag) { :TAGGED}
+      let(:tag) { :TAGGED }
 
       it 'instantiates the object' do
-        expect { subject }.to_not raise_error
+        expect { subject }.not_to raise_error
       end
 
       it 'normalizes language and converts it to lowercase' do
@@ -51,18 +51,18 @@ RSpec.describe LittleWeasel::DictionaryKey, type: :class do
     end
   end
 
-  #.key
+  # .key
   describe '.key' do
     let(:language) { :xx }
     let(:region) { :yy }
     let(:tag) { :zz }
 
     it 'returns the locale' do
-      expect(described_class.key language: language, region: region, tag: tag).to eq 'xx-YY-zz'
+      expect(described_class.key(language: language, region: region, tag: tag)).to eq 'xx-YY-zz'
     end
   end
 
-  #key
+  # key
   describe '#key' do
     context 'with no tag' do
       context 'with language' do
@@ -77,7 +77,7 @@ RSpec.describe LittleWeasel::DictionaryKey, type: :class do
         let(:language) { :EN }
         let(:region) { :us }
 
-        it 'returns the key in the form of a locale String that includes language and region  (e.g. "en-US")' do
+        it 'returns the key in the form of a locale String that includes language and region (e.g. "en-US")' do
           expect(subject.key).to eq 'en-US'
         end
       end
@@ -98,14 +98,14 @@ RSpec.describe LittleWeasel::DictionaryKey, type: :class do
         let(:language) { :EN }
         let(:region) { :us }
 
-        it 'returns the key in the form of a locale String that includes language, region and the appended tag  (e.g. "en-US-tag")' do
+        it 'returns the key in the form of a locale String that includes language, region and the appended tag (e.g. "en-US-tag")' do
           expect(subject.key).to eq 'en-US-tagged'
         end
       end
     end
   end
 
-  #to_s
+  # to_s
   describe '#to_s' do
     let(:language) { :en }
     let(:region) { :us }

data/spec/lib/LittleWeasel/dictionary_manager_spec.rb

@@ -3,12 +3,12 @@
 require 'spec_helper'
 
 RSpec.describe LittleWeasel::DictionaryManager do
-  include_context 'dictionary keys'
-
   subject { create(:dictionary_manager) }
 
-  let(:dictionary_cache_service) { create(:dictionary_cache_service, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache)}
-  let(:dictionary_metadata_service) { create(:dictionary_metadata_service, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_metadata: dictionary_metadata)}
+  include_context 'dictionary keys'
+
+  let(:dictionary_cache_service) { create(:dictionary_cache_service, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache) }
+  let(:dictionary_metadata_service) { create(:dictionary_metadata_service, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_metadata: dictionary_metadata) }
   let(:dictionary_key) { create(:dictionary_key, language: language, region: region, tag: tag) }
   let(:dictionary_cache) { subject.dictionary_cache }
   let(:dictionary_metadata) { subject.dictionary_metadata }
@@ -22,28 +22,28 @@ RSpec.describe LittleWeasel::DictionaryManager do
     dictionary_cache_service.dictionary_object.dictionary_metadata_object.observers.keys.first
   end
 
-  before(:each) do
+  before do
     subject.init
   end
 
-  #.new
+  # .new
   describe '.new' do
     it 'does not raise an error' do
       expect { subject }.not_to raise_error
     end
   end
 
-  #dictionary_exist?
+  # dictionary_exist?
   describe '#dictionary_exist?' do
     let!(:expected_dictionary_object) do
       subject.create_dictionary_from_memory(dictionary_key: dictionary_key,
-          dictionary_words:  %w(My dictionary words) )
+        dictionary_words:  %w[My dictionary words])
     end
 
     context 'when the dictionary exists' do
       it 'returns true' do
-        expect(subject.dictionary_exist? dictionary_key: dictionary_key)
-          .to eq true
+        expect(subject.dictionary_exist?(dictionary_key: dictionary_key))
+          .to be true
       end
     end
 
@@ -51,22 +51,22 @@ RSpec.describe LittleWeasel::DictionaryManager do
       let(:en_gb_dictionary_key) { dictionary_key_for(language: :en, region: :gb) }
 
       it 'returns false' do
-        expect(subject.dictionary_exist? dictionary_key: en_gb_dictionary_key)
-          .to eq false
+        expect(subject.dictionary_exist?(dictionary_key: en_gb_dictionary_key))
+          .to be false
       end
     end
   end
 
-  #dictionary_for
+  # dictionary_for
   describe '#dictionary_for' do
     let!(:expected_dictionary_object) do
       subject.create_dictionary_from_memory(dictionary_key: dictionary_key,
-          dictionary_words:  %w(My dictionary words) )
+        dictionary_words:  %w[My dictionary words])
     end
 
     context 'when the dictionary exists' do
       it 'returns the dictionary object' do
-        expect(subject.dictionary_for dictionary_key: dictionary_key)
+        expect(subject.dictionary_for(dictionary_key: dictionary_key))
           .to be expected_dictionary_object
       end
     end
@@ -81,11 +81,11 @@ RSpec.describe LittleWeasel::DictionaryManager do
     end
   end
 
-  #create_dictionary_from_file
+  # create_dictionary_from_file
   describe '#create_dictionary_from_file' do
     context 'when the dictionary DOES NOT exist' do
       it 'creates a dictionary and returns a dictionary object' do
-        expect(subject.create_dictionary_from_file(dictionary_key: dictionary_key, file: file)).to be_kind_of LittleWeasel::Dictionary
+        expect(subject.create_dictionary_from_file(dictionary_key: dictionary_key, file: file)).to be_a LittleWeasel::Dictionary
       end
     end
 
@@ -101,15 +101,15 @@ RSpec.describe LittleWeasel::DictionaryManager do
     end
   end
 
-  #create_dictionary_from_memory
+  # create_dictionary_from_memory
   describe '#create_dictionary_from_memory' do
     let(:dictionary_words) { dictionary_words_for(dictionary_file_path: file) }
 
     context 'when the dictionary reference does not exist and the dictionary is not cached' do
       it 'adds a dictionary reference caches the dictionary and returns a dictionary object' do
-        expect(subject.create_dictionary_from_memory(dictionary_key: dictionary_key, dictionary_words: dictionary_words)).to be_kind_of LittleWeasel::Dictionary
-        expect(dictionary_cache_service.dictionary_reference?).to eq true
-        expect(dictionary_cache_service.dictionary_object?).to eq true
+        expect(subject.create_dictionary_from_memory(dictionary_key: dictionary_key, dictionary_words: dictionary_words)).to be_a LittleWeasel::Dictionary
+        expect(dictionary_cache_service.dictionary_reference?).to be true
+        expect(dictionary_cache_service.dictionary_object?).to be true
       end
     end
 
@@ -125,7 +125,7 @@ RSpec.describe LittleWeasel::DictionaryManager do
     end
   end
 
-  #kill
+  # kill
   describe '#kill_dictionary' do
     context 'dictionaries created from files' do
       before do
@@ -135,9 +135,9 @@ RSpec.describe LittleWeasel::DictionaryManager do
       it 'removes the dictionary, file source reference and metadata from the dictionary cache' do
         metadata_key # Capture this before we unload the dictionary
         subject.kill_dictionary(dictionary_key: dictionary_key)
-        expect(dictionary_cache_service.dictionary_exist?).to eq false
-        expect(dictionary_cache_service.dictionary_reference?).to eq false
-        expect(dictionary_metadata_service.dictionary_metadata?(metadata_key: metadata_key)).to eq false
+        expect(dictionary_cache_service.dictionary_exist?).to be false
+        expect(dictionary_cache_service.dictionary_reference?).to be false
+        expect(dictionary_metadata_service.dictionary_metadata?(metadata_key: metadata_key)).to be false
       end
 
       it 'returns the dictionary manager instance' do
@@ -147,15 +147,15 @@ RSpec.describe LittleWeasel::DictionaryManager do
 
     context 'dictionaries created from memory' do
       before do
-        subject.create_dictionary_from_memory(dictionary_key: dictionary_key, dictionary_words: %w(Abel Cain Deborah Elijah))
+        subject.create_dictionary_from_memory(dictionary_key: dictionary_key, dictionary_words: %w[Abel Cain Deborah Elijah])
       end
 
       it 'removes the dictionary, memory source reference and metadata from the dictionary cache' do
         metadata_key # Capture this before we unload the dictionary
         subject.kill_dictionary(dictionary_key: dictionary_key)
-        expect(dictionary_cache_service.dictionary_exist?).to eq false
-        expect(dictionary_cache_service.dictionary_reference?).to eq false
-        expect(dictionary_metadata_service.dictionary_metadata?(metadata_key: metadata_key)).to eq false
+        expect(dictionary_cache_service.dictionary_exist?).to be false
+        expect(dictionary_cache_service.dictionary_reference?).to be false
+        expect(dictionary_metadata_service.dictionary_metadata?(metadata_key: metadata_key)).to be false
       end
 
       it 'returns the dictionary manager instance' do

data/spec/lib/LittleWeasel/dictionary_spec.rb

@@ -3,16 +3,17 @@
 require 'spec_helper'
 
 RSpec.describe LittleWeasel::Dictionary do
+  subject { create(:dictionary, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_words: dictionary_words, word_filters: word_filters) }
+
   include_context 'dictionary keys'
   include_context 'mock word filters'
 
   DictionaryResultsHelpers = Support::GeneralHelpers::DictionaryResultsHelpers
 
-
-  subject { create(:dictionary, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_words: dictionary_words, word_filters: word_filters) }
-
-  before(:each) { LittleWeasel.configure { |config| config.reset } }
-  before { dictionary_cache_service }
+  before do
+    LittleWeasel.configure(&:reset)
+    dictionary_cache_service
+  end
 
   let(:dictionary_cache_service) { create(:dictionary_cache_service, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_file_source: dictionary_key.key) }
   let(:dictionary_key) { dictionary_key_for(language: :en, region: :us, tag: :big) }
@@ -29,11 +30,11 @@ RSpec.describe LittleWeasel::Dictionary do
     [word_results.present?, word_results&.word_valid]
   end
 
-  #.new
+  # .new
   describe '.new' do
     context 'with a valid dictionary words Array' do
       it 'instantiates without error' do
-        expect { subject }.to_not raise_error
+        expect { subject }.not_to raise_error
       end
     end
 
@@ -82,23 +83,23 @@ RSpec.describe LittleWeasel::Dictionary do
     end
   end
 
-  #.to_hash
+  # .to_hash
   describe '.to_hash' do
     let(:expected_hash) do
       {
-        'this' => true,
-        'is' => true,
-        'a' => true,
-        'test' => true
+        'this' => true, # rubocop:disable Style/StringHashKeys
+        'is' => true, # rubocop:disable Style/StringHashKeys
+        'a' => true, # rubocop:disable Style/StringHashKeys
+        'test' => true # rubocop:disable Style/StringHashKeys
       }
     end
 
     it 'returns a Hash of dictionary words' do
-      expect(described_class.to_hash(dictionary_words: %w(this is a test))).to eq expected_hash
+      expect(described_class.to_hash(dictionary_words: %w[this is a test])).to eq expected_hash
     end
   end
 
-  #detached?
+  # detached?
   describe '#detached?' do
     before do
       subject
@@ -109,8 +110,8 @@ RSpec.describe LittleWeasel::Dictionary do
     context 'when the dictionary object is in the dictionary cache' do
       it 'returns false' do
         dictionary_cache_service
-        expect(dictionary_cache_service.dictionary_object?).to eq true
-        expect(subject.detached?).to eq false
+        expect(dictionary_cache_service.dictionary_object?).to be true
+        expect(subject.detached?).to be false
       end
     end
 
@@ -122,20 +123,20 @@ RSpec.describe LittleWeasel::Dictionary do
       end
 
       it 'returns true' do
-        expect(dictionary_cache_service.dictionary_object?).to eq false
-        expect(subject.detached?).to eq true
+        expect(dictionary_cache_service.dictionary_object?).to be false
+        expect(subject.detached?).to be true
       end
     end
   end
 
-  #key
+  # key
   describe '#key' do
     it 'returns the expected key' do
       expect(subject.key).to eq dictionary_key.key
     end
   end
 
-  #count
+  # count
   describe '#count' do
     before do
       subject.word_results('badword')
@@ -146,7 +147,7 @@ RSpec.describe LittleWeasel::Dictionary do
     end
   end
 
-  #count_all_words
+  # count_all_words
   describe '#count_all_words' do
     before do
       subject.word_results('badword')
@@ -157,7 +158,7 @@ RSpec.describe LittleWeasel::Dictionary do
     end
   end
 
-  #count_invalid_words
+  # count_invalid_words
   describe '#count_invalid_words' do
     before do
       subject.word_results('badword')
@@ -168,7 +169,7 @@ RSpec.describe LittleWeasel::Dictionary do
     end
   end
 
-  #word_results
+  # word_results
   describe '#word_results' do
     context 'when argument word is INVALID' do
       context 'when not a String' do
@@ -183,19 +184,19 @@ RSpec.describe LittleWeasel::Dictionary do
     context 'when searching for words in the dictionary' do
       context 'when the word is found' do
         it 'returns true' do
-          expect(subject.word_results('dog').success?).to eq true
+          expect(subject.word_results('dog').success?).to be true
         end
       end
 
       context 'when the word is not found' do
         it 'returns false' do
-          expect(subject.word_results('badword').success?).to eq false
+          expect(subject.word_results('badword').success?).to be false
         end
       end
     end
   end
 
-  #block_results
+  # block_results
   describe '#block_results' do
     context 'when nil is passed' do
       it 'raises an error' do
@@ -250,7 +251,7 @@ RSpec.describe LittleWeasel::Dictionary do
       context 'when a word is not found' do
         context 'when the max_invalid_words_bytesize threashold has not been exceeded' do
           it 'adds the word to the cache' do
-            expect { subject.word_results('badword') }.to change { subject.count_all_words }.by(1)
+            expect { subject.word_results('badword') }.to change(subject, :count_all_words).by(1)
           end
         end
 
@@ -265,7 +266,7 @@ RSpec.describe LittleWeasel::Dictionary do
               subject.word_results('IWillBeCached02')
               subject.word_results('IWontBeCached01')
               subject.word_results('IWontBeCached02')
-            end.to change { subject.count_all_words }.by(2)
+            end.to change(subject, :count_all_words).by(2)
           end
         end
       end
@@ -282,7 +283,7 @@ RSpec.describe LittleWeasel::Dictionary do
           subject.word_results('IWillBeCached02')
           subject.word_results('IWontBeCached01')
           subject.word_results('IWontBeCached02')
-        end.to change { subject.count_all_words }.by(0)
+        end.not_to(change(subject, :count_all_words))
       end
     end
   end

data/spec/lib/LittleWeasel/filters/en_us/currency_filter_spec.rb

@@ -5,48 +5,48 @@ require 'spec_helper'
 RSpec.describe LittleWeasel::Filters::EnUs::CurrencyFilter do
   subject { described_class.new }
 
-  #filter_match?
+  # filter_match?
   describe 'filter_match?' do
+    let(:word) { 1 }
+
     context 'when word is currency' do
       it 'returns true' do
-        expect(subject.filter_match?('-$1.00')).to eq true
-        expect(subject.filter_match?('-$1')).to eq true
-        expect(subject.filter_match?('$0')).to eq true
-        expect(subject.filter_match?('$1')).to eq true
-        expect(subject.filter_match?('$100')).to eq true
-        expect(subject.filter_match?('$100.10')).to eq true
-        expect(subject.filter_match?('$123456')).to eq true
-        expect(subject.filter_match?('+$110.09')).to eq true
-        expect(subject.filter_match?('-$1,000.09')).to eq true
-        expect(subject.filter_match?('$1000000.00')).to eq true
-        expect(subject.filter_match?('$1100000.10')).to eq true
-        expect(subject.filter_match?('$120000.01')).to eq true
-        expect(subject.filter_match?('$1,000,000.01')).to eq true
+        expect(subject.filter_match?('-$1.00')).to be true
+        expect(subject.filter_match?('-$1')).to be true
+        expect(subject.filter_match?('$0')).to be true
+        expect(subject.filter_match?('$1')).to be true
+        expect(subject.filter_match?('$100')).to be true
+        expect(subject.filter_match?('$100.10')).to be true
+        expect(subject.filter_match?('$123456')).to be true
+        expect(subject.filter_match?('+$110.09')).to be true
+        expect(subject.filter_match?('-$1,000.09')).to be true
+        expect(subject.filter_match?('$1000000.00')).to be true
+        expect(subject.filter_match?('$1100000.10')).to be true
+        expect(subject.filter_match?('$120000.01')).to be true
+        expect(subject.filter_match?('$1,000,000.01')).to be true
       end
     end
 
     context 'when word has decimals, but not 2 decimal places' do
       it 'returns false' do
-        expect(subject.filter_match?('-$1.1')).to eq false
-        expect(subject.filter_match?('$0.1')).to eq false
-        expect(subject.filter_match?('$100.9')).to eq false
-        expect(subject.filter_match?('+$100.2')).to eq false
-        expect(subject.filter_match?('$1000000.0')).to eq false
-        expect(subject.filter_match?('$1000000.1')).to eq false
-        expect(subject.filter_match?('$1000000.5')).to eq false
+        expect(subject.filter_match?('-$1.1')).to be false
+        expect(subject.filter_match?('$0.1')).to be false
+        expect(subject.filter_match?('$100.9')).to be false
+        expect(subject.filter_match?('+$100.2')).to be false
+        expect(subject.filter_match?('$1000000.0')).to be false
+        expect(subject.filter_match?('$1000000.1')).to be false
+        expect(subject.filter_match?('$1000000.5')).to be false
       end
     end
 
     context 'when word is NOT currency' do
       it 'returns false' do
-        expect(subject.filter_match? 'a').to eq false
-        expect(subject.filter_match? :a).to eq false
-        expect(subject.filter_match? Object.new).to eq false
+        expect(subject.filter_match?('a')).to be false
+        expect(subject.filter_match?(:a)).to be false
+        expect(subject.filter_match?(Object.new)).to be false
       end
     end
 
-    let(:word) { 1 }
-
     context 'when #filter_match? returns true' do
       before { allow(subject.class).to receive(:filter_match?).and_return(true) }
 

data/spec/lib/LittleWeasel/filters/en_us/numeric_filter_spec.rb

@@ -5,34 +5,34 @@ require 'spec_helper'
 RSpec.describe LittleWeasel::Filters::EnUs::NumericFilter do
   subject { described_class.new }
 
-  #filter_match?
+  # filter_match?
   describe 'filter_match?' do
+    let(:word) { 1 }
+
     context 'when word is a number' do
       it 'returns true' do
-        expect(subject.filter_match?('-1.00')).to eq true
-        expect(subject.filter_match?('-1')).to eq true
-        expect(subject.filter_match?('0')).to eq true
-        expect(subject.filter_match?('1')).to eq true
-        expect(subject.filter_match?('100')).to eq true
-        expect(subject.filter_match?('100.10')).to eq true
-        expect(subject.filter_match?(1234_56)).to eq true
-        expect(subject.filter_match?('+100.0')).to eq true
-        expect(subject.filter_match?(1_000_000.00)).to eq true
-        expect(subject.filter_match?(1_000_000.10)).to eq true
-        expect(subject.filter_match?(1_000_000.01)).to eq true
+        expect(subject.filter_match?('-1.00')).to be true
+        expect(subject.filter_match?('-1')).to be true
+        expect(subject.filter_match?('0')).to be true
+        expect(subject.filter_match?('1')).to be true
+        expect(subject.filter_match?('100')).to be true
+        expect(subject.filter_match?('100.10')).to be true
+        expect(subject.filter_match?(123_456)).to be true
+        expect(subject.filter_match?('+100.0')).to be true
+        expect(subject.filter_match?(1_000_000.00)).to be true
+        expect(subject.filter_match?(1_000_000.10)).to be true
+        expect(subject.filter_match?(1_000_000.01)).to be true
       end
     end
 
     context 'when word is NOT a number' do
       it 'returns false' do
-        expect(subject.filter_match? 'a').to eq false
-        expect(subject.filter_match? :a).to eq false
-        expect(subject.filter_match? Object.new).to eq false
+        expect(subject.filter_match?('a')).to be false
+        expect(subject.filter_match?(:a)).to be false
+        expect(subject.filter_match?(Object.new)).to be false
       end
     end
 
-    let(:word) { 1 }
-
     context 'when #filter_match? returns true' do
       before { allow(subject.class).to receive(:filter_match?).and_return(true) }
 

data/spec/lib/LittleWeasel/filters/en_us/single_character_word_filter_spec.rb

@@ -5,26 +5,26 @@ require 'spec_helper'
 RSpec.describe LittleWeasel::Filters::EnUs::SingleCharacterWordFilter do
   subject { described_class.new }
 
-  #filter_match?
+  # filter_match?
   describe '#filter_match?' do
+    let(:word) { 'x' }
+
     context 'when word single character word' do
       it 'returns true' do
-        %w(a A I).each do |number|
-          expect(subject.filter_match? number).to eq true
+        %w[a A I].each do |number|
+          expect(subject.filter_match?(number)).to be true
         end
       end
     end
 
     context 'when word is NOT a single character word' do
       it 'returns false' do
-        expect(subject.filter_match? 'X').to eq false
-        expect(subject.filter_match? :a).to eq false
-        expect(subject.filter_match? Object.new).to eq false
+        expect(subject.filter_match?('X')).to be false
+        expect(subject.filter_match?(:a)).to be false
+        expect(subject.filter_match?(Object.new)).to be false
       end
     end
 
-    let(:word) { 'x' }
-
     context 'when #filter_match? returns true' do
       before { allow(subject.class).to receive(:filter_match?).and_return(true) }