LittleWeasel 3.0.4 → 4.0.0

data/spec/lib/LittleWeasel/configure_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel do
+  subject do
+    described_class.configure { |config| }
+    described_class.configuration
+  end
+
+  context 'default configurable settings' do
+    describe '#max_dictionary_file_megabytes' do
+      it 'set to 5 by default' do
+        expect(subject.max_dictionary_file_megabytes).to eq 5
+      end
+    end
+
+    describe '#max_invalid_words_bytesize' do
+      it 'set to 25_000 by default' do
+        expect(subject.max_invalid_words_bytesize).to eq 25_000
+      end
+    end
+
+    describe '#metadata_observers' do
+      it 'set to an Array with InvalidWordsMetadata by default' do
+        expect(subject.metadata_observers).to eq [
+          LittleWeasel::Metadata::InvalidWordsMetadata
+        ]
+      end
+    end
+
+    describe '#word_block_regex' do
+      it 'set to the default regex to split work blocks by default' do
+        expect(subject.word_block_regex).to eq /[[[:word:]]'-]+/
+      end
+    end
+  end
+
+  #.configuration
+  describe '.configuration' do
+    context 'when passing a block' do
+      subject do
+        described_class.configure do |config|
+          config.max_dictionary_file_megabytes = max_dictionary_file_megabytes
+          config.metadata_observers = metadata_observers
+          config.word_block_regex = word_block_regex
+        end
+        described_class.configuration
+      end
+
+      let(:max_dictionary_file_megabytes) { 1_222_333 }
+      let(:metadata_observers) { %i(observer0 observer1) }
+      let(:word_block_regex) { :word_block_regex }
+
+      describe '#max_dictionary_file_megabytes=' do
+        it 'sets the value' do
+          expect(subject.max_dictionary_file_megabytes).to eq max_dictionary_file_megabytes
+        end
+      end
+
+      describe '#metadata_observers=' do
+        it 'sets the value' do
+          expect(subject.metadata_observers).to eq metadata_observers
+        end
+      end
+
+      describe '#word_block_regex=' do
+        it 'sets the value' do
+          expect(subject.word_block_regex).to eq word_block_regex
+        end
+      end
+    end
+  end
+end

data/spec/lib/LittleWeasel/dictionary_key_spec.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::DictionaryKey, type: :class do
+  subject { described_class.new(language: language, region: region, tag: tag) }
+
+  let(:language) {}
+  let(:region) {}
+  let(:tag) {}
+
+  #.new
+  describe '.new' do
+    context 'when passing valid arguments' do
+      let(:language) { :EN }
+      let(:region) { :us }
+      let(:tag) { :TAGGED}
+
+      it 'instantiates the object' do
+        expect { subject }.to_not raise_error
+      end
+
+      it 'normalizes language and converts it to lowercase' do
+        expect(subject.language).to eq :en
+      end
+
+      it 'normalizes region and converts it to uppercase' do
+        expect(subject.region).to eq :US
+      end
+
+      it 'leaves tag case unchanged' do
+        expect(subject.tag).to eq :TAGGED
+      end
+    end
+
+    context 'when passing invalid arguments' do
+      context 'when passing an invalid language' do
+        it 'raises an error' do
+          expect { subject }.to raise_error "Argument language '#{language}' is not a Symbol."
+        end
+      end
+
+      context 'when passing an invalid region' do
+        let(:language) { :en }
+        let(:region) { 1 }
+
+        it 'raises an error' do
+          expect { subject }.to raise_error "Argument region '#{region}' is not a Symbol."
+        end
+      end
+    end
+  end
+
+  #.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'
+    end
+  end
+
+  #key
+  describe '#key' do
+    context 'with no tag' do
+      context 'with language' do
+        let(:language) { :EN }
+
+        it 'returns the key in the form of a locale String that includes language only (e.g. "en")' do
+          expect(subject.key).to eq 'en'
+        end
+      end
+
+      context 'with language and region' 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
+          expect(subject.key).to eq 'en-US'
+        end
+      end
+    end
+
+    context 'with a tag' do
+      let(:tag) { :tagged }
+
+      context 'with language and a tag' do
+        let(:language) { :EN }
+
+        it 'returns the key in the form of a locale String that includes the language and appended tag (e.g. "en-tag")' do
+          expect(subject.key).to eq 'en-tagged'
+        end
+      end
+
+      context 'with language and region' 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
+          expect(subject.key).to eq 'en-US-tagged'
+        end
+      end
+    end
+  end
+
+  #to_s
+  describe '#to_s' do
+    let(:language) { :en }
+    let(:region) { :us }
+    let(:tag) { :tagged }
+
+    it '#to_s is an alias for #key' do
+      expect(subject.to_s).to eq 'en-US-tagged'
+    end
+  end
+end

data/spec/lib/LittleWeasel/dictionary_manager_spec.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::DictionaryManager do
+  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)}
+  let(:dictionary_key) { create(:dictionary_key, language: language, region: region, tag: tag) }
+  let(:dictionary_cache) { subject.dictionary_cache }
+  let(:dictionary_metadata) { subject.dictionary_metadata }
+
+  let(:language) { :en }
+  let(:region) { :us }
+  let(:tag) {}
+  let(:file) { dictionary_path_for(file_name: dictionary_key.key) }
+
+  let(:metadata_key) do
+    dictionary_cache_service.dictionary_object.dictionary_metadata_object.observers.keys.first
+  end
+
+  before(:each) do
+    subject.init
+  end
+
+  #.new
+  describe '.new' do
+    it 'does not raise an error' do
+      expect { subject }.not_to raise_error
+    end
+  end
+
+  #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
+      end
+    end
+
+    context 'when the dictionary already exists' do
+      before do
+        subject.create_dictionary_from_file(dictionary_key: dictionary_key, file: file)
+      end
+
+      it 'raises an error' do
+        expect { subject.create_dictionary_from_file(dictionary_key: dictionary_key, file: file) }
+          .to raise_error("The dictionary source associated with key '#{dictionary_key.key}' already exists.")
+      end
+    end
+  end
+
+  #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
+      end
+    end
+
+    context 'when the dictionary reference exists' do
+      before do
+        subject.create_dictionary_from_memory(dictionary_key: dictionary_key, dictionary_words: dictionary_words)
+      end
+
+      it 'raises an error' do
+        expect { subject.create_dictionary_from_memory(dictionary_key: dictionary_key, dictionary_words: dictionary_words) }
+          .to raise_error "The dictionary source associated with key '#{dictionary_key.key}' already exists."
+      end
+    end
+  end
+
+  #kill
+  describe '#kill_dictionary' do
+    context 'dictionaries created from files' do
+      before do
+        subject.create_dictionary_from_file(dictionary_key: dictionary_key, file: file)
+      end
+
+      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_exists?).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
+      end
+
+      it 'returns the dictionary manager instance' do
+        expect(subject.kill_dictionary(dictionary_key: dictionary_key)).to eq subject
+      end
+    end
+
+    context 'dictionaries created from memory' do
+      before do
+        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_exists?).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
+      end
+
+      it 'returns the dictionary manager instance' do
+        expect(subject.kill_dictionary(dictionary_key: dictionary_key)).to eq subject
+      end
+    end
+  end
+end

data/spec/lib/LittleWeasel/dictionary_spec.rb

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Dictionary do
+  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 }
+
+  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) }
+  let(:dictionary_cache) { {} }
+  let(:dictionary_metadata) { {} }
+  let(:dictionary_file_path) { dictionary_path_for(file_name: dictionary_key.key) }
+  let(:dictionary_words) { dictionary_words_for(dictionary_file_path: dictionary_file_path) }
+  let(:word_filters) {}
+
+  def block_results_include?(block_results, word)
+    word_results = block_results.word_results.find do |word_results|
+      word_results.original_word == word
+    end
+    [word_results.present?, word_results&.word_valid]
+  end
+
+  #.new
+  describe '.new' do
+    context 'with a valid dictionary words Array' do
+      it 'instantiates without error' do
+        expect { subject }.to_not raise_error
+      end
+    end
+
+    context 'with an invalid dictionary words Array' do
+      context 'when nil' do
+        let(:dictionary_words) {}
+
+        it 'raises an error' do
+          expect { subject }.to raise_error ArgumentError
+        end
+      end
+
+      context 'when not an Array' do
+        let(:dictionary_words) { :not_an_array }
+
+        it 'raises an error' do
+          expect { subject }.to raise_error ArgumentError
+        end
+      end
+    end
+
+    describe 'word_filter:' do
+      context 'when argument word_filters is nil' do
+        it 'no word filters will be used' do
+          expect(subject.word_filters).to be_blank
+        end
+      end
+
+      context 'when argument word_filters is an empty Array ([])' do
+        let(:word_filters) { [] }
+
+        it 'no word filters will be used' do
+          expect(subject.word_filters.count).to eq 0
+        end
+      end
+
+      context 'when argument word_filters is NOT nil' do
+        let(:word_filters) { [WordFilter01.new, WordFilter02.new] }
+
+        it 'the dictionary will use the word filters passed' do
+          expect(subject.word_filters.count).to eq 2
+          expect(subject.word_filters).to include(a_kind_of(WordFilter01))
+          expect(subject.word_filters).to include(a_kind_of(WordFilter02))
+        end
+      end
+    end
+  end
+
+  #.to_hash
+  describe '.to_hash' do
+    let(:expected_hash) do
+      {
+        'this' => true,
+        'is' => true,
+        'a' => true,
+        'test' => true
+      }
+    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
+    end
+  end
+
+  #detached?
+  describe '#detached?' do
+    before do
+      subject
+    end
+
+    let(:dictionary_cache_service) { create(:dictionary_cache_service, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_file_source: dictionary_key.key, load: true) }
+
+    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
+      end
+    end
+
+    context 'when the dictionary object is NOT in the dictionary cache' do
+      before do
+        dictionary_cache_service
+        dictionary_killer_service = create(:dictionary_killer_service, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_metadata: dictionary_metadata)
+        dictionary_killer_service.execute
+      end
+
+      it 'returns true' do
+        expect(dictionary_cache_service.dictionary_object?).to eq false
+        expect(subject.detached?).to eq true
+      end
+    end
+  end
+
+  #key
+  describe '#key' do
+    it 'returns the expected key' do
+      expect(subject.key).to eq dictionary_key.key
+    end
+  end
+
+  #count
+  describe '#count' do
+    before do
+      subject.word_results('badword')
+    end
+
+    it 'returns the count of all valid words' do
+      expect(subject.count).to eq dictionary_words.count
+    end
+  end
+
+  #count_all_words
+  describe '#count_all_words' do
+    before do
+      subject.word_results('badword')
+    end
+
+    it 'returns the count of all valid and invalid words' do
+      expect(subject.count_all_words).to eq dictionary_words.count + 1
+    end
+  end
+
+  #count_invalid_words
+  describe '#count_invalid_words' do
+    before do
+      subject.word_results('badword')
+    end
+
+    it 'returns the count of all invalid words' do
+      expect(subject.count_invalid_words).to eq 1
+    end
+  end
+
+  #word_results
+  describe '#word_results' do
+    context 'when argument word is INVALID' do
+      context 'when not a String' do
+        let(:word) { :not_a_string }
+
+        it 'raises an error' do
+          expect { subject.word_results(word) }.to raise_error "Argument word is not a String: #{word.class}"
+        end
+      end
+    end
+
+    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
+        end
+      end
+
+      context 'when the word is not found' do
+        it 'returns false' do
+          expect(subject.word_results('badword').success?).to eq false
+        end
+      end
+    end
+  end
+
+  #block_results
+  describe '#block_results' do
+    context 'when nil is passed' do
+      it 'raises an error' do
+        expect { subject.block_results nil }.to raise_error(/Argument word_block is not a String/)
+      end
+    end
+
+    context 'when an empty String is passed' do
+      it 'raises an error' do
+        expect { subject.block_results '' }.to raise_error(/Argument word_block is empty/)
+      end
+    end
+
+    context 'when a valid block of words is passed' do
+      subject do
+        create(:dictionary,
+          dictionary_key: dictionary_key,
+          dictionary_cache: dictionary_cache,
+          dictionary_words: dictionary_words,
+          word_filters: word_filters).block_results word_block
+      end
+
+      let(:word_filters) { [LittleWeasel::Filters::EnUs::NumericFilter.new] }
+      let(:word_block) do
+        "I'm older than you bubble-butt; I was born in 1964, before your time!"
+      end
+
+      it 'returns a WordResults object with the correct data about the words passed' do
+        DictionaryResultsHelpers.print_block_results word_block, subject
+
+        expect(subject.word_results.count).to eq 13
+        expect(block_results_include?(subject, "I'm")).to eq [true, true]
+        expect(block_results_include?(subject, 'older')).to eq [true, true]
+        expect(block_results_include?(subject, 'than')).to eq [true, true]
+        expect(block_results_include?(subject, 'you')).to eq [true, true]
+        expect(block_results_include?(subject, 'bubble-butt')).to eq [true, false]
+        expect(block_results_include?(subject, 'I')).to eq [true, true]
+        expect(block_results_include?(subject, 'was')).to eq [true, true]
+        expect(block_results_include?(subject, 'born')).to eq [true, true]
+        expect(block_results_include?(subject, 'in')).to eq [true, true]
+        expect(block_results_include?(subject, '1964')).to eq [true, false]
+        expect(block_results_include?(subject, 'before')).to eq [true, true]
+        expect(block_results_include?(subject, 'your')).to eq [true, true]
+        expect(block_results_include?(subject, 'time')).to eq [true, true]
+      end
+    end
+  end
+
+  # Configuration
+  context 'configuration options that alter behavior' do
+    context 'when max_invalid_words_bytesize? is true' 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)
+          end
+        end
+
+        context 'when the max_invalid_words_bytesize threashold HAS been exceeded' do
+          before do
+            LittleWeasel.configure { |config| config.max_invalid_words_bytesize = 30 }
+          end
+
+          it 'does NOT add the word to the cache' do
+            expect do
+              subject.word_results('IWillBeCached01')
+              subject.word_results('IWillBeCached02')
+              subject.word_results('IWontBeCached01')
+              subject.word_results('IWontBeCached02')
+            end.to change { subject.count_all_words }.by(2)
+          end
+        end
+      end
+    end
+
+    context 'when max_invalid_words_bytesize? is false' do
+      before do
+        LittleWeasel.configure { |config| config.max_invalid_words_bytesize = 0 }
+      end
+
+      it 'does NOT add the word to the cache' do
+        expect do
+          subject.word_results('IWillBeCached01')
+          subject.word_results('IWillBeCached02')
+          subject.word_results('IWontBeCached01')
+          subject.word_results('IWontBeCached02')
+        end.to change { subject.count_all_words }.by(0)
+      end
+    end
+  end
+end