LittleWeasel 3.0.4 → 4.0.0

data/spec/factories/dictionary.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: false
+
+FactoryBot.define do
+  factory :dictionary, class: LittleWeasel::Dictionary do
+    dictionary_key { create(:dictionary_key) }
+    dictionary_cache { {} }
+    dictionary_metadata { {} }
+    word_filters {}
+    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
+      new dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_metadata: dictionary_metadata, dictionary_words: dictionary_words, word_filters: word_filters
+    end
+  end
+end

data/spec/factories/dictionary_cache_service.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: false
+
+require 'pry'
+
+FactoryBot.define do
+  factory :dictionary_cache_service, class: LittleWeasel::Services::DictionaryCacheService do
+    dictionary_key { create(:dictionary_key) }
+    dictionary_cache { {} }
+
+    transient do
+      # The dictionary reference created in the cache will point to a MEMORY source.
+      #
+      # Valid values: nil | true | false | <Array of dictionary words>
+      #
+      # If nil or false - No memory source will be added to the dictionary cache.
+      # If true - A memory source will be added to the dictionary cache.
+      # If <An Array of dictionary words> - A memory source will be added to the dictionry cache.
+      #                                     This only makes sense if load == true.
+      dictionary_memory_source {}
+
+      # The dictionary reference created in the cache will point to a FILE source.
+      #
+      # Important: dictionary_file_source will only be used if dictionary_memory_source
+      # is false.
+      #
+      # Valid values: nil | true | false | <Path to dictionary file>
+      #
+      # If nil or false - No file source will be added to the dictionary cache.
+      #
+      # If true - A file source will be added to the dictionry cache.
+      #           dictionary_key.key will be used to create the dictionary
+      #           file path.
+      # If <Path to dictionary file> - A files source will be added to the dictionry cache.
+      #                                The file source will point to <Path to dictionary file>.
+      dictionary_file_source {}
+
+      # If load == true - A dictionary object will be created and added to the dictionary cache
+      #                   depending on the dictionary source (file or memory).
+      load { false }
+    end
+
+    skip_create
+    initialize_with do
+      new(dictionary_key: dictionary_key, dictionary_cache: dictionary_cache)
+    end
+
+    after :create do |dictionary_cache_service, evaluator|
+      dictionary_key = dictionary_cache_service.dictionary_key
+      dictionary_cache = dictionary_cache_service.dictionary_cache
+
+      # Initialize the dictionary cache if the user already passed an
+      # initialized dictionary cache; otherwise, just use what they passed us.
+      dictionary_cache_service.class.init(dictionary_cache: dictionary_cache) \
+        unless dictionary_cache_service.class.count(dictionary_cache: dictionary_cache).positive?
+
+      load = evaluator.load
+      dictionary_memory_source = evaluator.dictionary_memory_source
+      dictionary_file_source = evaluator.dictionary_file_source
+
+      if load
+        unless dictionary_memory_source.present? || dictionary_file_source.present?
+          raise 'Transient attributes dictionary_memory_source or dictionary_file_source ' \
+            "must be present if transient attribute load is true: #{dictionary_reference}"
+        end
+      end
+
+      if dictionary_file_source
+        file_name = if dictionary_file_source == true
+          dictionary_key.key
+        else
+          dictionary_file_source
+        end
+        dictionary_cache_service.add_dictionary_source(source: dictionary_path_for(file_name: file_name))
+      elsif dictionary_memory_source
+        dictionary_cache_service.add_dictionary_source(source: LittleWeasel::Modules::DictionarSourceable.memory_source)
+      end
+
+      if load
+        dictionary_words = if dictionary_file_source
+          dictionary_file_loader_service = create(:dictionary_file_loader_service, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache)
+          dictionary_file_loader_service.execute
+        else
+          unless dictionary_memory_source.is_a? Array
+            raise 'Transient attribute dictionary_memory_source must be an Array of words ' \
+                  "if transient attribute load == true: #{dictionary_memory_source}"
+          end
+          dictionary_memory_source
+        end
+        dictionary_cache_service.dictionary_object = create(:dictionary, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_words: dictionary_words)
+      end
+
+      dictionary_cache_service
+    end
+  end
+end

data/spec/factories/dictionary_creator_service.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: false
+
+FactoryBot.define do
+  factory :dictionary_creator_service, class: LittleWeasel::Services::DictionaryCreatorService do
+    dictionary_key { create(:dictionary_key) }
+    dictionary_cache { {} }
+    dictionary_metadata { {} }
+    word_filters {}
+    word_preprocessors {}
+
+    skip_create
+    initialize_with do
+      new(dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_metadata: dictionary_metadata, word_filters: word_filters, word_preprocessors: word_preprocessors)
+    end
+  end
+end

data/spec/factories/dictionary_file_loader_service.rb

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

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_loader_service.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: false
+
+FactoryBot.define do
+  factory :dictionary_loader_service, class: LittleWeasel::Services::DictionaryLoaderService 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