LittleWeasel 3.0.4 → 4.0.0

data/spec/lib/LittleWeasel/preprocessors/word_preprocessor_validatable_spec.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Preprocessors::WordPreprocessorValidatable, type: :module do
+  subject { MockSubject.new }
+
+  WordPreprocessorValidatable = described_class
+
+  class MockSubject
+    include WordPreprocessorValidatable
+  end
+
+  class MockWordPreprocessor < LittleWeasel::Preprocessors::WordPreprocessor
+    def preprocess(word)
+      [true, "#{word}-preprocessed"]
+    end
+  end
+
+  let(:order) { 0 }
+  let(:preprocessor_on) { true }
+  let(:word_preprocessor) do
+    word_preprocessor = MockWordPreprocessor.new order: order
+    word_preprocessor.preprocessor_on = preprocessor_on
+    word_preprocessor
+  end
+
+  shared_examples 'an instance method is missing' do
+    before do
+      allow(word_preprocessor).to receive(:respond_to?).with(method).and_return(false)
+    end
+
+    it 'raises an error' do
+      expect { WordPreprocessorValidatable.validate_word_preprocessor word_preprocessor: word_preprocessor }.to raise_error expected_error_message
+    end
+  end
+
+  shared_examples 'a class method is missing' do
+    before do
+      allow(word_preprocessor.class).to receive(:respond_to?).with(method).and_return(false)
+    end
+
+    it 'raises an error' do
+      expect { WordPreprocessorValidatable.validate_word_preprocessor word_preprocessor: word_preprocessor }.to raise_error expected_error_message
+    end
+  end
+
+  #.validate_word_preprocessor
+  describe '.validate_word_preprocessor' do
+    before do
+      allow(word_preprocessor.class).to receive(:respond_to?).and_call_original
+      allow(word_preprocessor).to receive(:respond_to?).and_call_original
+    end
+
+    context 'when the object quacks right' do
+      it 'passes validation' do
+        expect { WordPreprocessorValidatable.validate_word_preprocessor word_preprocessor: word_preprocessor }.to_not raise_error
+      end
+    end
+
+    context 'when the object DOES NOT quack right' do
+      let(:expected_error_message) { /Argument word_preprocessor: does not respond to/ }
+
+      context 'when a class method is missing' do
+        context 'when the class does not respond to .preprocess' do
+          let(:method) { :preprocess }
+          it_behaves_like 'a class method is missing'
+        end
+
+        context 'when the class does not respond to .preprocess?' do
+          let(:method) { :preprocess? }
+          it_behaves_like 'a class method is missing'
+        end
+      end
+
+      context 'when an instance method is missing' do
+        context 'when the object does not respond to #preprocess' do
+          let(:method) { :preprocess }
+          it_behaves_like 'an instance method is missing'
+        end
+
+        context 'when the object does not respond to #preprocess?' do
+          let(:method) { :preprocess? }
+          it_behaves_like 'an instance method is missing'
+        end
+
+        context 'when the object does not respond to #preprocessor_off?' do
+          let(:method) { :preprocessor_off? }
+          it_behaves_like 'an instance method is missing'
+        end
+
+        context 'when the object does not respond to #preprocessor_on' do
+          let(:method) { :preprocessor_on }
+          it_behaves_like 'an instance method is missing'
+        end
+
+        context 'when the object does not respond to #preprocessor_on=' do
+          let(:method) { :preprocessor_on= }
+          it_behaves_like 'an instance method is missing'
+        end
+
+        context 'when the object does not respond to #preprocessor_on?' do
+          let(:method) { :preprocessor_on? }
+          it_behaves_like 'an instance method is missing'
+        end
+      end
+    end
+  end
+end

data/spec/lib/LittleWeasel/preprocessors/word_preprocessors_validatable_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Preprocessors::WordPreprocessorsValidatable, type: :module do
+  subject { MockSubject.new }
+
+  WordPreprocessorsValidatable = described_class
+
+  class MockSubject
+    include WordPreprocessorsValidatable
+  end
+
+  subject { MockSubject.new }
+
+  class MockWordPreprocessor < LittleWeasel::Preprocessors::WordPreprocessor
+    def initialize(order: 0)
+      super order: order
+      self.preprocessor_on = preprocessor_on
+    end
+
+    class << self
+      def preprocess(word) [true, "#{word}-0"]; end
+    end
+  end
+
+  #.validate_word_preprocessors
+  describe '.validate_word_preprocessors' do
+    context 'when passing a blank Array' do
+      it 'passes validaton' do
+        expect { WordPreprocessorsValidatable.validate_word_preprocessors(word_preprocessors: []) }.to_not raise_error
+      end
+    end
+
+    context 'when passing a an Array with valid word preprocessors' do
+      it 'passes validation' do
+        expect { WordPreprocessorsValidatable.validate_word_preprocessors(word_preprocessors: [MockWordPreprocessor.new]) }.to_not raise_error
+      end
+    end
+
+    context 'when passing an INVALID argument' do
+      context 'when passing an invalid Array' do
+        it 'raises an error' do
+          expect { WordPreprocessorsValidatable.validate_word_preprocessors(word_preprocessors: :not_an_array) }.to raise_error(/Argument word_preprocessors is not an Array/)
+        end
+      end
+    end
+  end
+end

data/spec/lib/LittleWeasel/services/dictionary_cache_service_spec.rb

@@ -0,0 +1,444 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Services::DictionaryCacheService do
+  include_context 'dictionary cache'
+  include_context 'dictionary keys'
+  include_context 'dictionary sourceable'
+
+  subject { create(:dictionary_cache_service, dictionary_cache: dictionary_cache) }
+
+  let(:en_us_dictionary_key) { dictionary_key_for(language: :en, region: :us) }
+  let(:en_gb_dictionary_key) { dictionary_key_for(language: :en, region: :gb) }
+  let(:es_es_dictionary_key) { dictionary_key_for(language: :es, region: :es) }
+
+  let(:dictionary_key) { en_us_dictionary_key }
+  let(:key) { dictionary_key.key }
+  let(:file) { dictionary_path_for(file_name: key) }
+  let(:file_minus_ext) { key }
+  let(:dictionary_cache) { {} }
+  let!(:initialized_dictionary_cache) { LittleWeasel::Modules::DictionaryCacheKeys.initialize_dictionary_cache(dictionary_cache: {}) }
+
+  shared_examples 'the dictionary_cache object reference has not changed' do
+    it 'the dictionary_cache object has not changed' do
+      expect(actual_dictionary_cache).to eq expected_dictionary_cache
+    end
+  end
+
+  describe 'class methods' do
+    #.init
+    describe '.init' do
+      subject! { create(:dictionary_cache_service, dictionary_file_source: true, dictionary_cache: dictionary_cache) }
+
+      before do
+        create(:dictionary_cache_service, dictionary_file_source: true, dictionary_cache: dictionary_cache, dictionary_key: en_gb_dictionary_key)
+      end
+
+      it 'resets the cache to an initiaized state for all keys in the cache' do
+        expect { described_class.init(dictionary_cache: dictionary_cache) }.to change { dictionary_cache }.to(initialized_dictionary_cache)
+      end
+
+      describe 'maintains dictionary_cache object integrity' do
+        it_behaves_like 'the dictionary_cache object reference has not changed' do
+          before { subject }
+          let(:actual_dictionary_cache) { described_class.init(dictionary_cache: dictionary_cache) }
+          let(:expected_dictionary_cache) { dictionary_cache }
+        end
+      end
+    end
+
+    #.init?
+    describe '.init?' do
+      context 'when passing an initialized dictionary cache Hash' do
+        it 'returns true' do
+          expect(described_class.init? dictionary_cache: initialized_dictionary_cache).to eq true
+        end
+      end
+
+      context 'when passing a NON-initialized dictionary cache Hash' do
+        before do
+          subject.add_dictionary_source source: file
+        end
+
+        it 'returns false' do
+          expect(described_class.init? dictionary_cache: dictionary_cache).to eq false
+        end
+      end
+    end
+
+    #.count
+    describe '.count' do
+      context 'when there are no dictionary references' do
+        subject { create(:dictionary_cache_service) }
+
+        it 'returns 0' do
+          expect(described_class.count(dictionary_cache: subject.dictionary_cache)).to eq 0
+        end
+      end
+
+      context 'when there are are dictionary references' do
+        subject { create(:dictionary_cache_service, dictionary_file_source: true) }
+
+        it 'returns the dictionary reference count' do
+          expect(described_class.count(dictionary_cache: subject.dictionary_cache)).to eq 1
+        end
+      end
+    end
+  end
+
+  #init
+  describe '#init' do
+    subject! { create(:dictionary_cache_service, dictionary_file_source: true, dictionary_cache: dictionary_cache) }
+
+    let!(:subject2) { create(:dictionary_cache_service, dictionary_file_source: true, dictionary_cache: dictionary_cache, dictionary_key: en_gb_dictionary_key) }
+    let!(:original_dictionary_cache) { dictionary_cache }
+
+    it 'resets the cache to an initiaized state for the GIVEN KEY ONLY' do
+      expect { subject.init }.to change { dictionary_cache }.from(original_dictionary_cache).to(subject2.dictionary_cache)
+      expect { subject2.init }.to change { dictionary_cache }.from(original_dictionary_cache).to(subject.dictionary_cache)
+    end
+
+    describe 'maintains dictionary_cache object integrity' do
+      it_behaves_like 'the dictionary_cache object reference has not changed' do
+        let(:actual_dictionary_cache) { subject.init.dictionary_cache }
+        let(:expected_dictionary_cache) { dictionary_cache }
+      end
+    end
+  end
+
+  #dictionary_reference?
+  describe '#dictionary_reference?' do
+    subject { create(:dictionary_cache_service, dictionary_key: dictionary_key, dictionary_file_source: true, dictionary_cache: dictionary_cache) }
+
+    context 'when the dictionary reference exists' do
+      it 'returns true' do
+        expect(subject.dictionary_reference?).to eq true
+      end
+    end
+
+    context 'when the dictionary reference DOES NOT exist' do
+      subject { create(:dictionary_cache_service, dictionary_key: es_es_dictionary_key, dictionary_cache: dictionary_cache) }
+
+      before do
+        create(:dictionary_cache_service, dictionary_key: en_us_dictionary_key, dictionary_cache: dictionary_cache)
+          .add_dictionary_source source: memory_source
+        create(:dictionary_cache_service, dictionary_key: en_gb_dictionary_key, dictionary_cache: dictionary_cache)
+          .add_dictionary_source source: dictionary_path_for(file_name: en_gb_dictionary_key.key)
+      end
+
+      it 'returns false' do
+        expect(subject.dictionary_reference?).to eq false
+      end
+    end
+
+    describe 'maintains dictionary_cache object integrity' do
+      it_behaves_like 'the dictionary_cache object reference has not changed' do
+        let(:actual_dictionary_cache) { subject.dictionary_cache }
+        let(:expected_dictionary_cache) { dictionary_cache }
+      end
+    end
+  end
+
+  #add_dictionary_source source: memory_source
+  describe '#add_dictionary_source source: memory_source' do
+    subject! do
+      create(:dictionary_cache_service, dictionary_cache: dictionary_cache, dictionary_key: dictionary_key)
+        .add_dictionary_source source: memory_source
+    end
+
+    context 'when a dictionary already exists' do
+      it 'raises an error' do
+        expect do
+          create(:dictionary_cache_service, dictionary_key: dictionary_key, dictionary_cache: subject.dictionary_cache)
+            .add_dictionary_source source: memory_source
+        end.to raise_error "The dictionary source associated with key '#{key}' already exists."
+      end
+    end
+
+    context 'when a dictionary reference for the key DOES NOT already exist' do
+      let(:dictionary_cache_service) do
+        create(:dictionary_cache_service, dictionary_key: en_gb_dictionary_key, dictionary_cache: subject.dictionary_cache)
+      end
+
+      before do
+        dictionary_cache_service.add_dictionary_source source: memory_source
+      end
+
+      let(:dictionary_source) { dictionary_cache_service.dictionary_source }
+
+      it 'creates a new dictionary reference' do
+        expect(dictionary_cache_service.dictionary_reference?).to eq true
+      end
+
+      it 'creates a unique memory source' do
+        expect(LittleWeasel::Modules::DictionarySourceable.memory_source? dictionary_source).to be_truthy
+        expect(dictionary_source == subject.dictionary_source).to_not eq true
+      end
+    end
+
+    describe 'maintains dictionary_cache object integrity' do
+      it_behaves_like 'the dictionary_cache object reference has not changed' do
+        subject { create(:dictionary_cache_service, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache) }
+        let(:actual_dictionary_cache) { subject.add_dictionary_source(source: memory_source).dictionary_cache }
+        let(:expected_dictionary_cache) { dictionary_cache }
+      end
+    end
+  end
+
+  #add_dictionary_source
+  describe '#add_dictionary_source' do
+    context 'when a dictionary reference for the key already exists' do
+      before do
+        create(:dictionary_cache_service, dictionary_cache: dictionary_cache, dictionary_key: dictionary_key)
+          .add_dictionary_source(source: file)
+      end
+
+      it 'raises an error' do
+        expect do
+          create(:dictionary_cache_service, dictionary_cache: dictionary_cache, dictionary_key: dictionary_key, dictionary_cache: subject.dictionary_cache)
+            .add_dictionary_source(source: file)
+        end.to raise_error "The dictionary source associated with key '#{key}' already exists."
+      end
+    end
+
+    context 'when a dictionary reference for the key DOES NOT already exist' do
+      subject! do
+        create(:dictionary_cache_service, dictionary_cache: dictionary_cache, dictionary_key: dictionary_key)
+          .add_dictionary_source(source: file)
+      end
+
+      let(:en_gb_file) do
+        "#{ dictionary_path_for(file_name: en_gb_dictionary_key.key) }"
+      end
+
+      it 'creates a new dictionary reference' do
+        dictionary_cache_service = create(:dictionary_cache_service, dictionary_key: en_gb_dictionary_key, dictionary_cache: subject.dictionary_cache)
+        dictionary_cache_service.add_dictionary_source source: en_gb_file
+        expect(dictionary_cache_service.dictionary_reference?).to eq true
+      end
+
+      context 'when the file source already exists' do
+        it 'reuses the existing file source' do
+          dictionary_cache_service = create(:dictionary_cache_service, dictionary_key: en_gb_dictionary_key, dictionary_cache: subject.dictionary_cache)
+          # Note: We're using the same file as en-US dictionary key, so
+          # the file source is NOT unique and will be reused.
+          dictionary_cache_service.add_dictionary_source source: file
+          expect(LittleWeasel::Modules::DictionarySourceable.file_source? dictionary_cache_service.dictionary_source).to be_truthy
+          expect(dictionary_cache_service.dictionary_source == subject.dictionary_source).to eq true
+        end
+      end
+
+      context 'when the file source DOES NOT already exists' do
+        it 'creates a unique file source' do
+          dictionary_cache_service = create(:dictionary_cache_service, dictionary_key: en_gb_dictionary_key, dictionary_cache: subject.dictionary_cache)
+          # Note: We're using file that is DIFFERENT from the file being used by the
+          # en-US dictionary key, the file source created will be unique.
+          dictionary_cache_service.add_dictionary_source source: en_gb_file
+          expect(LittleWeasel::Modules::DictionarySourceable.file_source? dictionary_cache_service.dictionary_source).to be_truthy
+          expect(dictionary_cache_service.dictionary_source == subject.dictionary_source).to eq false
+        end
+      end
+    end
+
+    describe 'maintains dictionary_cache object integrity' do
+      it_behaves_like 'the dictionary_cache object reference has not changed' do
+        subject { create(:dictionary_cache_service, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache) }
+        let(:actual_dictionary_cache) { subject.add_dictionary_source(source: file).dictionary_cache }
+        let(:expected_dictionary_cache) { dictionary_cache }
+      end
+    end
+  end
+
+  #dictionary_file
+  describe '#dictionary_file' do
+    context 'when a file source is used' do
+      subject! { create(:dictionary_cache_service, dictionary_key: dictionary_key).add_dictionary_source(source: file) }
+
+      it 'returns the dictionary file' do
+        expect(subject.dictionary_file).to eq file
+      end
+    end
+
+    context 'when a memory source is used' do
+      subject! { create(:dictionary_cache_service, dictionary_key: dictionary_key).add_dictionary_source source: memory_source }
+
+      let(:dictionary_words) { dictionary_words_for(dictionary_file_path: file) }
+
+      it 'returns the dictionary file' do
+        expect(LittleWeasel::Modules::DictionarySourceable.memory_source? subject.dictionary_file).to be_truthy
+      end
+    end
+  end
+
+  #dictionary_id
+  describe '#dictionary_id' do
+    context 'when a dictionary id exists for the given dictionary key' do
+      before do
+        subject.add_dictionary_source source: memory_source
+      end
+
+      it 'returns the key' do
+        expect(subject.dictionary_id).to_not be_nil
+      end
+    end
+
+    context 'when a dictionary id DOES NOT exist for the given dictionary key' do
+      it 'returns nil' do
+        expect(subject.dictionary_id).to be_nil
+      end
+    end
+  end
+
+  #dictionary_id!
+  describe '#dictionary_id!' do
+    context 'when a dictionary id associated with the dictionary key exists' do
+      subject { create(:dictionary_cache_service, dictionary_cache: dictionary_cache, dictionary_key: dictionary_key, dictionary_file_source: true) }
+
+      it 'returns the dictionary id' do
+        expect { subject.dictionary_id! }.to_not raise_error
+      end
+    end
+
+    context 'when a dictionary id associated with the dictionary key DOES NOT exist' do
+      subject { create(:dictionary_cache_service) }
+
+      it 'raises an error' do
+        expect { subject.dictionary_id! }.to raise_error "A dictionary id could not be found for key '#{key}'."
+      end
+    end
+  end
+
+  #dictionary_exists?
+  describe '#dictionary_exists?' do
+    context 'when the dictionary reference does not exist' do
+      subject { create(:dictionary_cache_service, dictionary_cache: dictionary_cache) }
+
+      it 'returns false' do
+        expect(subject.dictionary_exists?).to eq false
+      end
+    end
+
+    context 'when the dictionary is already loaded' do
+      subject { create(:dictionary_cache_service, dictionary_cache: dictionary_cache, dictionary_file_source: true, load: true) }
+
+      it 'returns true' do
+        expect(subject.dictionary_exists?).to eq true
+      end
+    end
+
+    context 'when the dictionary is NOT already loaded' do
+      subject { create(:dictionary_cache_service, dictionary_cache: dictionary_cache, dictionary_file_source: true) }
+
+      it 'returns false' do
+        expect(subject.dictionary_exists?).to eq false
+      end
+    end
+  end
+
+  #dictionary_object
+  describe '#dictionary_object' do
+    context 'when the dictionary object is already cached/loaded' do
+      subject { create(:dictionary_cache_service, dictionary_file_source: true, load: true) }
+
+      it 'returns the dictionary object' do
+        expect(subject.dictionary_object).to be_kind_of LittleWeasel::Dictionary
+      end
+    end
+
+    context 'when the dictionary object is NOT already cached/loaded' do
+      context 'when the dictionary reference exists' do
+        it 'returns an object that is not present?' do
+          expect(create(:dictionary_cache_service, dictionary_file_source: true).dictionary_object).to_not be_present
+        end
+      end
+
+      context 'when the dictionary reference DOES NOT exist' do
+        it 'returns an object that is not present?' do
+          expect(create(:dictionary_cache_service).dictionary_object).to_not be_present
+        end
+      end
+    end
+  end
+
+  #dictionary_object!
+  describe '#dictionary_object!' do
+    describe 'when the dictionary is NOT in the cache' do
+      it 'raises an error' do
+        expect { subject.dictionary_object! }.to raise_error("The dictionary object associated with argument key '#{key}' is not in the cache.")
+      end
+    end
+
+    describe 'when the dictionary is loaded/cached' do
+      subject { create(:dictionary_cache_service, dictionary_file_source: true, load: true) }
+
+      it 'returns the dictionary cache for the dictionary' do
+        expect(subject.dictionary_reference?).to eq true
+        expect(subject.dictionary_exists?).to eq true
+        expect(subject.dictionary_object!).to be_kind_of LittleWeasel::Dictionary
+      end
+    end
+  end
+
+  #dictionary_object=
+  describe '#dictionary_object=' do
+    context 'when the dictionary object passed is invalid' do
+      subject { create(:dictionary_cache_service) }
+
+      context 'when nil' do
+        it 'raises an error' do
+          expect { subject.dictionary_object = nil }.to raise_error 'Argument object is not a Dictionary object'
+        end
+      end
+
+      context 'when not a Dictionary object' do
+        it 'raises an error' do
+          expect { subject.dictionary_object = :wrong_object }.to raise_error 'Argument object is not a Dictionary object'
+        end
+      end
+    end
+
+    context 'when there is NO dictionary reference' do
+      before do
+        allow(dictionary_object).to receive(:is_a?).and_return(true)
+      end
+
+      subject { create(:dictionary_cache_service, dictionary_cache: dictionary_cache, dictionary_key: dictionary_key) }
+
+      let(:dictionary_object) { Object.new }
+
+      it 'raises an error' do
+        expect { subject.dictionary_object = dictionary_object }.to raise_error "The dictionary reference associated with key '#{key}' could not be found."
+      end
+    end
+
+    context 'when the dictionary is already loaded/cached and different from the dictionary object passed' do
+      subject { create(:dictionary_cache_service, dictionary_cache: dictionary_cache, dictionary_key: dictionary_key, dictionary_file_source: true, load: true) }
+
+      let(:dictionary) { create(:dictionary, dictionary_cache: dictionary_cache, dictionary_key: dictionary_key) }
+
+      it 'raises an error' do
+        expect { subject.dictionary_object = dictionary }.to raise_error  "The dictionary is already loaded/cached for key '#{key}'; use #unload or #kill first."
+      end
+    end
+
+    context 'when the dictionary is already loaded/cached and the dictionary object is the same as the one that is loaded/cached' do
+      subject { create(:dictionary_cache_service, dictionary_file_source: true, load: true) }
+
+      it 'returns the same object' do
+        expect(subject.dictionary_object = subject.dictionary_object).to eq subject.dictionary_object
+      end
+    end
+
+    context 'when the dictionary is NOT already loaded/cached' do
+      subject { create(:dictionary_cache_service, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_file_source: true) }
+
+      let(:dictionary) { create(:dictionary, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache) }
+
+      it 'updates the dictionary object' do
+        expect { subject.dictionary_object = dictionary }.to_not raise_error
+        expect(subject.dictionary_object).to eq dictionary
+      end
+    end
+  end
+end