LittleWeasel 3.0.4 → 5.0.1

data/spec/lib/LittleWeasel/modules/class_name_to_symbol_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Modules::ClassNameToSymbol, type: :module do
+  ClassNameToSymbol = described_class
+
+  subject do
+    module TestModule
+      class TestMeUp
+        include ClassNameToSymbol
+      end
+    end
+  end
+
+  describe '#to_sym' do
+    it 'returns the class name as a snake-case Symbol with namespaces removed' do
+      expect(subject.new.to_sym).to eq :test_me_up
+    end
+  end
+end

data/spec/lib/LittleWeasel/modules/dictionary_file_loader_spec.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Modules::DictionaryFileLoader, type: :module do
+  subject do
+    dictionary_cache_service.init dictionary_cache: dictionary_cache
+    dictionary_file_loader
+  end
+
+  let(:dictionary_file_loader) do
+    Class.new do
+      include LittleWeasel::Modules::DictionaryFileLoader
+
+      attr_reader :dictionary_key, :dictionary_cache, :config
+
+      def initialize(dictionary_key, dictionary_cache)
+        self.dictionary_key = dictionary_key
+        self.dictionary_cache = dictionary_cache
+        self.config = LittleWeasel.configuration
+      end
+
+      private
+
+      attr_writer :dictionary_key, :dictionary_cache, :config
+    end.new(dictionary_key, dictionary_cache)
+  end
+
+  let(:language) { :en }
+  let(:region) { :us }
+  let(:tag) {}
+
+  let(:dictionary_cache_service) { LittleWeasel::Services::DictionaryCacheService }
+  let(:dictionary_key) { LittleWeasel::DictionaryKey.new(language: language, region: region, tag: tag) }
+  let(:key) {  dictionary_key.key }
+  let(:file) { dictionary_path_for locale: dictionary_key.locale }
+  let(:dictionary_file_key) { file }
+  let(:dictionary_cache) { {} }
+
+  #load
+  describe '#load' do
+    context 'with an invalid dictionary file' do
+      context 'when it cannot be found' do
+        let(:dictionary_path) { region_dictionary_path language: :bad, region: :worse }
+
+        it 'raises an error' do
+          expect { subject.load dictionary_path }.to raise_error LittleWeasel::Errors::DictionaryFileNotFoundError
+        end
+      end
+
+      context 'when it is empty' do
+        let(:dictionary_path) { dictionary_path_for file_name: 'empty-dictionary' }
+
+        it 'raises an error' do
+          expect { subject.load dictionary_path  }.to raise_error LittleWeasel::Errors::DictionaryFileEmptyError
+        end
+      end
+
+      context 'when it is too large' do
+        before do
+          allow(LittleWeasel.configuration).to receive(:max_dictionary_file_bytes).and_return 1
+        end
+
+        let(:dictionary_path) { language_dictionary_path language: :en }
+
+        it 'raises an error' do
+          expect { subject.load dictionary_path  }.to raise_error LittleWeasel::Errors::DictionaryFileTooLargeError
+        end
+      end
+    end
+
+    context 'with a valid dictionary file' do
+      subject { dictionary_file_loader.load dictionary_path }
+
+      let(:dictionary_path) { region_dictionary_path language: language, region: region }
+
+      context 'when the dictionary file is already loaded/cached' do
+        before { subject }
+
+        it 'does not raise an error' do
+          expect { subject }.to_not raise_error
+        end
+      end
+
+      context 'when the dictionary is NOT already loaded/cached' do
+        let(:expected_dictionary_key_key) { LittleWeasel::DictionaryKey.new(language: language, region: region, tag: tag).key }
+        let(:expected_results) do
+          ['apple',
+           'better',
+           'cat',
+           'dog',
+           'everyone',
+           'fat',
+           'game',
+           'help',
+           'italic',
+           'jasmine',
+           'kelp',
+           'love',
+           'man',
+           'nope',
+           'octopus',
+           'popeye',
+           'queue',
+           'ruby',
+           'stop',
+           'top',
+           'ultimate',
+           'very',
+           'was',
+           'xylophone',
+           'yes',
+           'zebra']
+        end
+
+        it 'returns an Array of dictionary words loaded from the file' do
+          # This test won't pass if we're not testing against an assumed
+          # dictionary file.
+          expect(dictionary_key.key).to eq expected_dictionary_key_key
+          expect(subject).to eq expected_results
+        end
+      end
+    end
+  end
+end

data/spec/lib/LittleWeasel/modules/dictionary_sourceable_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Modules::DictionarySourceable, type: :module do
+  subject { MockDictionarySourceable.new(dictionary_memory_source) }
+
+  DictionarySourceable = described_class
+
+  class MockDictionarySourceable
+    include DictionarySourceable
+
+    def initialize(dictionary_source)
+      self.dictionary_source = dictionary_source
+    end
+  end
+
+  let(:dictionary_memory_source) { described_class.memory_source }
+  let(:dictionary_file_source) { language_dictionary_path language: :en }
+
+  #.MEMORY_SOURCE
+  describe '::MEMORY_SOURCE' do
+    it 'returns the memory source prefix' do
+      expect(described_class::MEMORY_SOURCE).to eq '*'
+    end
+  end
+
+  #.memory_source
+  describe '.memory_source' do
+    it 'returns a new memory source' do
+      expect(described_class.memory_source).to be_truthy
+    end
+  end
+
+  #.file_source?
+  describe '.file_source?' do
+    context 'when dictionary_source is a file source' do
+      it 'returns truthy' do
+        expect(described_class.file_source? dictionary_file_source).to be_truthy
+      end
+    end
+
+    context 'when dictionary_source is NOT a file source' do
+      it 'returns falsey' do
+        expect(described_class.file_source? dictionary_memory_source).to be_falsey
+      end
+    end
+  end
+
+  #.memory_source?
+  describe '.memory_source?' do
+    context 'when dictionary_source is a memory source' do
+      it 'returns truthy if argument is a valid memory source' do
+        expect(described_class.memory_source? '*12345678').to be_truthy
+        expect(described_class.memory_source? '*abcdef00').to be_truthy
+        expect(described_class.memory_source? '*ABCDEF00').to be_truthy
+        expect(described_class.memory_source? '*aBcDeF00').to be_truthy
+      end
+
+      it 'returns falsey if argument is NOT a memory source' do
+        expect(described_class.memory_source? '*123456789').to be_falsey
+        expect(described_class.memory_source? '*abcdefg0').to be_falsey
+        expect(described_class.memory_source? '*ABCDEFG0').to be_falsey
+        expect(described_class.memory_source? '*aBcDeFg0').to be_falsey
+        expect(described_class.memory_source? '$12345678').to be_falsey
+
+        expect(described_class.memory_source? '123456789').to be_falsey
+        expect(described_class.memory_source? 'abcdefg0').to be_falsey
+        expect(described_class.memory_source? 'ABCDEFG0').to be_falsey
+        expect(described_class.memory_source? 'aBcDeFg0').to be_falsey
+        expect(described_class.memory_source? '123456789').to be_falsey
+      end
+    end
+
+    context 'when dictionary_source is a file source' do
+      it 'returns falsey' do
+        expect(described_class.memory_source? dictionary_file_source).to be_falsey
+      end
+    end
+  end
+end

data/spec/lib/LittleWeasel/modules/language_spec.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Modules::Language, type: :module do
+  Language = described_class
+
+  subject do
+    Class.new do
+      include Language
+
+      attr_reader :language
+
+      def initialize(language)
+        self.language = language
+      end
+
+      private
+
+      attr_writer :language
+    end.new(language)
+  end
+
+  let(:language) {}
+
+  #language?
+  describe '#language?' do
+    context 'when language is present?' do
+      let(:language) { :es }
+
+      it 'returns true' do
+        expect(subject.language?).to eq true
+      end
+    end
+
+    context 'when language is NOT present?' do
+      it 'returns false' do
+        expect(subject.language?).to eq false
+      end
+    end
+  end
+
+  #normalize_language!
+  describe '#normalize_language!' do
+    context 'when language is present?' do
+      context 'when language responds to #upcase!' do
+        before do
+          subject.normalize_language!
+        end
+
+        let(:language) { :AA }
+
+        it 'changes language to lower case' do
+          expect(subject.language).to eq :aa
+        end
+      end
+
+      context 'when language DOES NOT respond to #downcase' do
+        let(:language) { Object.new }
+
+        it 'raises an error' do
+          expect { subject.normalize_language! }.to raise_error(NoMethodError, /undefined method `downcase'/)
+        end
+      end
+    end
+
+    context 'when language is NOT present?' do
+      before do
+        subject.normalize_language!
+      end
+
+      it 'does nothing' do
+        expect(subject.language).to be_nil
+      end
+    end
+  end
+
+  #.normalize_language
+  describe '#.normalize_language' do
+    context 'with a non-nil language' do
+      context 'when passing a Symbol' do
+        let(:language) { :AbCdEfG }
+
+        it 'converts the language to a lower-case Symbol' do
+          expect(described_class.normalize_language(language)).to eq :abcdefg
+        end
+      end
+
+      context 'when passing a String' do
+        let(:language) { 'AbCdEfG' }
+
+        it 'converts the language to a lower-case String' do
+          expect(described_class.normalize_language(language)).to eq 'abcdefg'
+        end
+      end
+    end
+
+    context 'with a nil language' do
+      it 'returns nil' do
+        expect(described_class.normalize_language(language)).to be_nil
+      end
+    end
+
+    context 'when language does not respond to #downcase' do
+      let(:language) { 1 }
+
+      it 'returns nil' do
+        expect { described_class.normalize_language(language) }.to raise_error(NoMethodError, /undefined method `downcase'/)
+      end
+    end
+  end
+end

data/spec/lib/LittleWeasel/modules/locale_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Modules::Locale, type: :module do
+  Locale = described_class
+
+  subject do
+    Class.new do
+      include Locale
+
+      attr_reader :language, :region
+
+      def initialize(language, region)
+        self.language = language
+        self.region = region
+      end
+
+      private
+
+      attr_writer :language, :region
+    end.new(language, region)
+  end
+
+  let(:language) {}
+  let(:region) {}
+
+  #locale
+  describe '#locale' do
+    context 'with valid arguments' do
+      context 'with valid language' do
+        let(:language) { :en }
+
+        it 'returns the expected locale (language only)' do
+          expect(subject.locale).to eq 'en'
+        end
+      end
+
+      context 'with valid language and region' do
+        let(:language) { :en }
+        let(:region) { :us }
+
+        it 'returns the expected locale (language and region)' do
+          expect(subject.locale).to eq 'en-US'
+        end
+
+        describe 'normalizes language and region to the proper case' do
+          let(:language) { :EN }
+          let(:region) { :us }
+
+          it 'returns the expected locale with language lowercase and region uppercase' do
+            expect(subject.locale).to eq 'en-US'
+          end
+        end
+      end
+
+      context 'with valid language and nil region' do
+        let(:language) { :en }
+        let(:region) {}
+
+        it 'returns the expected locale (language only)' do
+          expect(subject.locale).to eq 'en'
+        end
+      end
+
+      context 'with valid language and blank region' do
+        let(:language) { :en }
+        let(:region) { '' }
+
+        it 'returns the expected locale (language only)' do
+          expect(subject.locale).to eq 'en'
+        end
+      end
+    end
+
+    context 'with invalid arguments' do
+      context 'when argument language does not respond to #downcase' do
+        let(:language) { 1 }
+
+        it 'raises an error' do
+          expect { subject.locale }.to raise_error(NoMethodError, /undefined method `downcase'/)
+        end
+      end
+
+      context 'when argument region does not respond to #upcase' do
+        let(:language) { :en }
+        let(:region) { 1 }
+
+        it 'raises an error' do
+          expect { subject.locale }.to raise_error(NoMethodError, /undefined method `upcase'/)
+        end
+      end
+    end
+  end
+end

data/spec/lib/LittleWeasel/modules/region_spec.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Modules::Region, type: :module do
+  Region = described_class
+
+  subject do
+    Class.new do
+      include Region
+
+      attr_reader :region
+
+      def initialize(region)
+        self.region = region
+      end
+
+      private
+
+      attr_writer :region
+    end.new(region)
+  end
+
+  let(:region) {}
+
+  #region?
+  describe '#region?' do
+    context 'when region is present?' do
+      let(:region) { :es }
+
+      it 'returns true' do
+        expect(subject.region?).to eq true
+      end
+    end
+
+    context 'when region is NOT present?' do
+      it 'returns false' do
+        expect(subject.region?).to eq false
+      end
+    end
+  end
+
+  #normalize_region!
+  describe '#normalize_region!' do
+    context 'when region is present?' do
+      context 'when region responds to #upcase' do
+        before do
+          subject.normalize_region!
+        end
+
+        let(:region) { :aa }
+
+        it 'changes region to upper case' do
+          expect(subject.region).to eq :AA
+        end
+      end
+
+      context 'when region DOES NOT respond to #upcase' do
+        let(:region) { Object.new }
+
+        it 'raises an error' do
+          expect { subject.normalize_region! }.to raise_error(NoMethodError, /undefined method `upcase'/)
+        end
+      end
+    end
+
+    context 'when region is NOT present?' do
+      before do
+        subject.normalize_region!
+      end
+
+      it 'does nothing' do
+        expect(subject.region).to be_nil
+      end
+    end
+  end
+
+  #.normalize_region
+  describe '#.normalize_region' do
+    context 'with a non-nil region' do
+      context 'when passing a Symbol' do
+        let(:region) { :AbCdEfG }
+
+        it 'converts the region to a upper-case Symbol' do
+          expect(described_class.normalize_region(region)).to eq :ABCDEFG
+        end
+      end
+
+      context 'when passing a String' do
+        let(:region) { 'AbCdEfG' }
+
+        it 'converts the region to a upper-case String' do
+          expect(described_class.normalize_region(region)).to eq 'ABCDEFG'
+        end
+      end
+    end
+
+    context 'with a nil region' do
+      it 'returns nil' do
+        expect(described_class.normalize_region(region)).to be_nil
+      end
+    end
+
+    context 'when region does not respond to #upcase' do
+      let(:region) { 1 }
+
+      it 'returns nil' do
+        expect { described_class.normalize_region(region) }.to raise_error(NoMethodError, /undefined method `upcase'/)
+      end
+    end
+  end
+end

data/spec/lib/LittleWeasel/preprocessors/en_us/capitalize_preprocessor_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literals: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Preprocessors::EnUs::CapitalizePreprocessor do
+  subject { described_class.new }
+
+  #.new
+  describe '.new' do
+    it 'instantiates the object' do
+      expect { subject }.to_not raise_error
+    end
+
+    describe '#order' do
+      it 'sets #order to 0 by default' do
+        expect(subject.order).to eq 0
+      end
+    end
+
+    describe '#preprocessor_on' do
+      it 'sets #preprocessor_on to true by default' do
+        expect(subject.preprocessor_on).to eq true
+      end
+    end
+  end
+
+  #.preprocess
+  describe '.preprocess' do
+    it 'processes and capitalizes the word' do
+      expect(described_class.preprocess 'wOrD').to eq [true, 'Word']
+      expect(described_class.preprocess 'Word').to eq [true, 'Word']
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Preprocessors::PreprocessedWord do
+  subject do
+    described_class.new(
+      original_word: original_word,
+      preprocessed_word: preprocessed_word,
+      preprocessor: preprocessor,
+      preprocessed: preprocessed,
+      preprocessor_order: preprocessor_order
+    )
+  end
+
+  let(:original_word) { :original_word }
+  let(:preprocessed_word) { :preprocessed_word }
+  let(:preprocessor) { :preprocessor }
+  let(:preprocessed) { true }
+  let(:preprocessor_order) { :preprocessor_order }
+
+  #.new
+  describe '.new' do
+    context 'initializes the attributes' do
+      describe '#original_word' do
+        it 'is initialized' do
+          expect(subject.original_word).to eq :original_word
+        end
+      end
+
+      describe '#preprocessed_word' do
+        it 'is initialized' do
+          expect(subject.preprocessed_word).to eq :preprocessed_word
+        end
+      end
+
+      describe '#preprocessor' do
+        it 'is initialized' do
+          expect(subject.preprocessor).to eq :preprocessor
+        end
+      end
+
+      describe '#preprocessor_order' do
+        it 'is initialized' do
+          expect(subject.preprocessor_order).to eq :preprocessor_order
+        end
+      end
+    end
+  end
+
+  # attributes
+  context 'attributes' do
+    describe 'original_word=' do
+      let(:changed_to) { :original_word_changed }
+
+      it 'sets the attribute' do
+        subject.original_word = changed_to
+        expect(subject.original_word).to eq changed_to
+      end
+    end
+
+    describe 'preprocessed_word=' do
+      let(:changed_to) { :preprocessed_word_changed }
+
+      it 'sets the attribute' do
+        subject.preprocessed_word = changed_to
+        expect(subject.preprocessed_word).to eq changed_to
+      end
+    end
+
+    describe 'preprocessor=' do
+      let(:changed_to) { :preprocessor_changed }
+
+      it 'sets the attribute' do
+        subject.preprocessor = changed_to
+        expect(subject.preprocessor).to eq changed_to
+      end
+    end
+
+    describe 'preprocessor_order=' do
+      let(:changed_to) { :preprocessor_order_changed }
+
+      it 'sets the attribute' do
+        subject.preprocessor_order = changed_to
+        expect(subject.preprocessor_order).to eq changed_to
+      end
+    end
+
+    describe '#preprocessed?' do
+      context 'when preprocessed is true' do
+        it 'returns true' do
+          expect(subject.preprocessed?).to eq true
+        end
+      end
+
+      context 'when preprocessed is false' do
+        let(:preprocessed) { false }
+
+        it 'returns false' do
+          expect(subject.preprocessed?).to eq false
+        end
+      end
+    end
+  end
+end