LittleWeasel 3.0.3 → 5.0.0

data/spec/factories/dictionary_hash.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: false
+
+FactoryBot.define do
+  factory :dictionary_hash, class: Hash do
+    dictionary_words do
+      %w(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
+
+    skip_create
+    initialize_with do
+      LittleWeasel::Dictionary.to_hash(dictionary_words: dictionary_words)
+    end
+  end
+end

data/spec/factories/dictionary_key.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: false
+
+FactoryBot.define do
+  factory :dictionary_key, class: LittleWeasel::DictionaryKey do
+    language { :en }
+    region { :us }
+    tag {}
+
+    skip_create
+    initialize_with do
+      new language: language, region: region, tag: tag
+    end
+  end
+end

data/spec/factories/dictionary_killer_service.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: false
+
+FactoryBot.define do
+  factory :dictionary_killer_service, class: LittleWeasel::Services::DictionaryKillerService do
+    dictionary_key { create(:dictionary_key) }
+    dictionary_cache { {} }
+    dictionary_metadata { {} }
+
+    skip_create
+    initialize_with do
+      new(dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_metadata: dictionary_metadata)
+    end
+  end
+end

data/spec/factories/dictionary_manager.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: false
+
+FactoryBot.define do
+  factory :dictionary_manager, class: LittleWeasel::DictionaryManager do
+    skip_create
+    initialize_with do
+      new
+    end
+  end
+end

data/spec/factories/dictionary_metadata.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: false
+
+FactoryBot.define do
+  factory :dictionary_metadata, class: LittleWeasel::Metadata::DictionaryMetadata do
+    dictionary_words {}
+    dictionary_key { create(:dictionary_key) }
+    dictionary_cache { {} }
+    dictionary_metadata { {} }
+
+    skip_create
+    initialize_with do
+      dictionary_hash = dictionary_words || create(:dictionary_hash)
+      new dictionary_words: dictionary_hash, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_metadata: dictionary_metadata
+    end
+  end
+end

data/spec/factories/dictionary_metadata_service.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: false
+
+require 'pry'
+
+FactoryBot.define do
+  factory :dictionary_metadata_service, class: LittleWeasel::Services::DictionaryMetadataService do
+    dictionary_key { create(:dictionary_key) }
+    dictionary_cache { {} }
+    dictionary_metadata { {} }
+
+    skip_create
+    initialize_with do
+      new(dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_metadata: dictionary_metadata)
+    end
+  end
+end

data/spec/factories/numeric_filter.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: false
+
+FactoryBot.define do
+  factory :numeric_filter, class: LittleWeasel::Filters::EnUs::NumericFilter do
+    filter_on { true }
+
+    skip_create
+    initialize_with do
+      new filter_on: filter_on
+    end
+  end
+end

data/spec/factories/preprocessed_word.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: false
+
+FactoryBot.define do
+  factory :preprocessed_word, class: LittleWeasel::Preprocessors::PreprocessedWord do
+    original_word {}
+    preprocessed {}
+    preprocessed_word {}
+    preprocessor {}
+    preprocessor_order {}
+
+    skip_create
+    initialize_with do
+      new original_word: original_word, preprocessed: preprocessed, preprocessed_word: preprocessed_word, preprocessor: preprocessor, preprocessor_order: preprocessor_order
+    end
+  end
+end

data/spec/factories/preprocessed_words.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: false
+
+require 'pry'
+
+FactoryBot.define do
+  factory :preprocessed_words, class: LittleWeasel::Preprocessors::PreprocessedWords do
+    original_word { 'word' }
+    preprocessed_words {}
+
+    transient do
+      with_word_processors { 0 }
+    end
+
+    skip_create
+    initialize_with do
+      new original_word: original_word, preprocessed_words: preprocessed_words
+    end
+
+    after :create do |preprocessed_words, evaluator|
+      with_word_processors = evaluator.with_word_processors
+
+      if with_word_processors.positive?
+        preprocessed_words.preprocessed_words = []
+        preprocessed_word = evaluator.original_word
+
+        with_word_processors.times do |index|
+          preprocessed_word_object = create(:preprocessed_word,
+            original_word: preprocessed_word,
+            preprocessed: true,
+            preprocessed_word: "#{preprocessed_word}-#{index}").tap do |preprocessed_word_object|
+            preprocessed_word_object.preprocessed_word = "#{preprocessed_word}-#{index}"
+            preprocessed_word_object.preprocessor = "preprocesor#{index}"
+            preprocessed_word_object.preprocessor_order = index
+          end
+          preprocessed_words.preprocessed_words << preprocessed_word_object
+          preprocessed_word = preprocessed_word_object.preprocessed_word
+        end
+      end
+    end
+  end
+end

data/spec/factories/single_character_word_filter.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: false
+
+FactoryBot.define do
+  factory :single_character_word_filter, class: LittleWeasel::Filters::EnUs::SingleCharacterWordFilter do
+    filter_on { true }
+
+    skip_create
+    initialize_with do
+      new filter_on: filter_on
+    end
+  end
+end

data/spec/factories/word_results.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: false
+
+FactoryBot.define do
+  factory :word_results, class: LittleWeasel::WordResults do
+    original_word {}
+    filters_matched { [] }
+    preprocessed_words {}
+    word_cached { false }
+    word_valid { false }
+
+    skip_create
+    initialize_with do
+      new filters_matched: filters_matched, original_word: original_word, preprocessed_words: preprocessed_words, word_cached: word_cached, word_valid: word_valid
+    end
+  end
+end

data/spec/lib/LittleWeasel/block_results_spec.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::BlockResults do
+  subject { described_class.new original_word_block: original_word_block }
+
+  def ceate_word_results(word:, word_valid: false, word_cached: false, filters_matched: [], preprocessed_words: nil)
+    create(:word_results, original_word: word, word_valid: word_valid, word_cached: word_cached, filters_matched: filters_matched, preprocessed_words: preprocessed_words)
+  end
+
+  let(:original_word_block) { 'Original word block' }
+
+  #.new
+  describe '.new' do
+    it 'instantiates an object' do
+      expect { subject }.to_not raise_error
+    end
+
+    it 'initializes #word_results to an empty Array' do
+      expect(subject.word_results).to eq []
+    end
+
+    it 'initializes #original_word_block to the original_word_block argument passed' do
+      expect(subject.original_word_block).to eq original_word_block
+    end
+  end
+
+  #<<
+  describe '<<' do
+    context 'with an invalid argument' do
+      it 'raises an error' do
+        expect { subject << :not_a_word_results_object }.to raise_error(/Argument word_result is not a WordResults object/)
+      end
+    end
+
+    context 'with a valid argument' do
+      it 'adds the WordResults object to the #word_results Array' do
+        expect { subject << ceate_word_results(word: 'word01') }.to \
+          change { subject.word_results.count }.from(0).to(1)
+      end
+    end
+  end
+
+  #success?
+  describe '#success?' do
+    before do
+      subject << ceate_word_results(word: 'word01', word_valid: true)
+      subject << ceate_word_results(word: 'word02', word_valid: false, filters_matched: [:matched_filter])
+    end
+
+    context 'when all WordResults#successful? return true' do
+      before do
+        subject << ceate_word_results(word: 'word03', word_valid: false, filters_matched: [:matched_filter])
+        subject << ceate_word_results(word: 'word04', word_valid: false, filters_matched: [:matched_filter])
+      end
+
+      it 'returns true' do
+        expect(subject.success?).to be true
+      end
+    end
+
+    context 'when any WordResults#word_valid? objects return false' do
+      before do
+        subject << ceate_word_results(word: 'word03', word_valid: false)
+      end
+
+      it 'returns false' do
+        expect(subject.success?).to be false
+      end
+    end
+
+    context 'when any WordResults#filter_match? objects return false' do
+      before do
+        subject << ceate_word_results(word: 'word03')
+      end
+
+      it 'returns false' do
+        expect(subject.success?).to be false
+      end
+    end
+  end
+
+  #words_valid?
+  describe '#words_valid?' do
+    before do
+      subject << ceate_word_results(word: 'word01', word_valid: true)
+      subject << ceate_word_results(word: 'word02', word_valid: true)
+    end
+
+    context 'when all WordResults#word_valid? objects return true' do
+      it 'returns true' do
+        expect(subject.words_valid?).to be true
+      end
+    end
+
+    context 'when any WordResults#word_valid? objects return false' do
+      before do
+        subject << ceate_word_results(word: 'word03', word_valid: false)
+      end
+
+      it 'returns false' do
+        expect(subject.words_valid?).to be false
+      end
+    end
+  end
+
+  #filters_match?
+  describe '#filters_match?' do
+    before do
+      subject << ceate_word_results(word: 'word01', filters_matched: [:matched_filter])
+      subject << ceate_word_results(word: 'word02', filters_matched: [:matched_filter])
+    end
+
+    context 'when all WordResults#filters_match? objects return true' do
+      it 'returns true' do
+        expect(subject.filters_match?).to be true
+      end
+    end
+
+    context 'when any WordResults#filters_match? objects return false' do
+      before do
+        subject << ceate_word_results(word: 'word03', filters_matched: [])
+      end
+
+      it 'returns false' do
+        expect(subject.filters_match?).to be false
+      end
+    end
+  end
+
+  #preprocessed_words?
+  describe '#preprocessed_words?' do
+    before do
+      subject << ceate_word_results(word: word, preprocessed_words: preprocessed_words)
+    end
+
+    let(:word) { 'word' }
+    let(:preprocessed_words) { create(:preprocessed_words, original_word: word, with_word_processors: 1) }
+
+    context 'when all WordResults#preprocessed_word? objects return true' do
+      it 'returns true' do
+        expect(subject.preprocessed_words?).to be true
+      end
+    end
+  end
+
+  #preprocessed_words_or_original_words
+  describe '#preprocessed_words_or_original_words' do
+    context 'with all preprocessed words' do
+      before do
+        subject << ceate_word_results(word: words[0], preprocessed_words: preprocessed_words[0])
+        subject << ceate_word_results(word: words[1], preprocessed_words: preprocessed_words[1])
+      end
+
+      let(:words) { %w(word1 word2) }
+      let(:preprocessed_words) do
+        [
+        create(:preprocessed_words, original_word: words[0], with_word_processors: 1),
+        create(:preprocessed_words, original_word: words[1], with_word_processors: 2)
+        ]
+      end
+
+      it 'returns all the preprocessed words' do
+        expect(subject.preprocessed_words_or_original_words).to eq %w(word1-0 word2-0-1)
+      end
+    end
+
+    context 'with all original words' do
+      before do
+        subject << ceate_word_results(word: words[0])
+        subject << ceate_word_results(word: words[1])
+      end
+
+      let(:words) { %w(word1 word2) }
+
+      it 'returns all the original words' do
+        expect(subject.preprocessed_words_or_original_words).to eq %w(word1 word2)
+      end
+    end
+
+    context 'with mixed original words and preprocessed words' do
+      before do
+        subject << ceate_word_results(word: words[0], word_valid: true)
+        subject << ceate_word_results(word: words[1], word_valid: true, preprocessed_words: preprocessed_words[0])
+        subject << ceate_word_results(word: words[2], word_valid: true)
+        subject << ceate_word_results(word: words[3], word_valid: true, preprocessed_words: preprocessed_words[1])
+      end
+
+      let(:words) { %w(word0 word1 word2 word3) }
+      let(:preprocessed_words) do
+        [
+        create(:preprocessed_words, original_word: words[1], with_word_processors: 1),
+        create(:preprocessed_words, original_word: words[3], with_word_processors: 2)
+        ]
+      end
+
+      it 'returns all the original and preprocessed words' do
+        expect(subject.preprocessed_words_or_original_words).to eq %w(word0 word1-0 word2 word3-0-1)
+      end
+    end
+  end
+
+  #words_cached?
+  describe '#words_cached?' do
+    before do
+      subject << ceate_word_results(word: words[0])
+      subject << ceate_word_results(word: words[1])
+      subject << ceate_word_results(word: words[2])
+      subject << ceate_word_results(word: words[3])
+    end
+
+    let(:words) { %w(word1 word2 word3 word4) }
+
+    context 'when all the words are cached' do
+      before do
+        allow_any_instance_of(LittleWeasel::WordResults).to receive(:word_cached?).and_return(true)
+      end
+
+      it 'returns true' do
+        expect(subject.words_cached?).to eq true
+      end
+    end
+
+    context 'when some of the words are cached' do
+      before do
+        allow(subject.word_results[0]).to receive(:word_cached?).and_return(false)
+        allow(subject.word_results[1]).to receive(:word_cached?).and_return(true)
+        allow(subject.word_results[2]).to receive(:word_cached?).and_return(false)
+        allow(subject.word_results[3]).to receive(:word_cached?).and_return(true)
+      end
+
+      it 'returns false' do
+        expect(subject.words_cached?).to eq false
+      end
+    end
+
+    context 'when NONE of the words are cached' do
+      before do
+        allow_any_instance_of(LittleWeasel::WordResults).to receive(:word_cached?).and_return(false)
+      end
+
+      it 'returns false' do
+        expect(subject.words_cached?).to eq false
+      end
+    end
+  end
+end

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