LittleWeasel 3.0.3 → 5.0.0

data/lib/LittleWeasel/preprocessors/word_preprocessor.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative '../errors/must_override_error'
+require_relative '../modules/class_name_to_symbol'
+require_relative '../modules/orderable'
+require_relative 'preprocessed_word'
+
+module LittleWeasel
+  module Preprocessors
+    # This is a base class that provides methods and functionality for
+    # word preprocessors. A "word preprocessor" is an object that manipulates a
+    # word before it is passed to any word filters and before it is compared
+    # against the dictionary for validity.
+    # :reek:MissingSafeMethod, ignored - safe methods for preprocessor_on!/off! make no sense in this case
+    class WordPreprocessor
+      include Modules::ClassNameToSymbol
+      include Modules::Orderable
+
+      attr_reader :preprocessor_on
+
+      # order:Integer, the order in which this preprocessor should
+      # be applied.
+      # preprocessor_on:Boolean, whether or not this preprocessor
+      # should be applied to any words.
+      def initialize(order:)
+        validate_order order: order
+        self.order = order
+        preprocessor_on!
+      end
+
+      class << self
+        # Should return true if word matches the preprocess criteria;
+        # false, otherwise. If this preprocessor has no preprocess criteria,
+        # simply return true. This class method is unlike the instance method in
+        # that it does not consider whether or not this preprocessor is "on"
+        # or "off"; it simply returns true or false based on whether or not the
+        # word matches the preprocess criteria.
+        def preprocess?(_word)
+          true
+        end
+
+        # This method should UNconditionally apply preprocessing to word ONLY if
+        # word meets the criteria for preprocessing (.preprocess?).
+        #
+        # This method should return the following Array:
+        #
+        # [<preprocessed?>, <preprocessed word | nil>]
+        #
+        # Where:
+        #
+        #   <preprocessed?> == whether or not the word was preprocessed
+        #     based on whether or not the word meets the preprocessing
+        #     criteria (.preprocess?).
+        #
+        #   <preprocessed word | nil> == the preprocessed word (if word
+        #     met the preprocessing criteria (.preprocessed?)) or nil if
+        #     word was NOT preprocessed (word did NOT meet the preprocessing
+        #     criteria).
+        def preprocess(_word)
+          raise Errors::MustOverrideError
+        end
+      end
+
+      def preprocessor_on=(value)
+        raise ArgumentError, "Argument value is not true or false: #{value}" \
+          unless [true, false].include? value
+
+        @preprocessor_on = value
+      end
+
+      # Returns true if word meets the criteria for preprocessing. false
+      # is returned if word does not meet the criteria for preprocessing, or,
+      # if the preprocessor is "off".
+      def preprocess?(word)
+        return false if preprocessor_off?
+
+        self.class.preprocess? word
+      end
+
+      # Applies preprocessing to word if this preprocessor is "on" AND if word
+      # meets the criteria for preprocessing; no preprocessing is applied to
+      # word otherwise.
+      #
+      # This method should return a Preprocessors::PreprocessedWord object.
+      def preprocess(word)
+        preprocessed, preprocessed_word = if preprocessor_on?
+          self.class.preprocess word
+        else
+          [false, nil]
+        end
+        preprocessed_word(original_word: word, preprocessed_word: preprocessed_word, preprocessed: preprocessed)
+      end
+
+      # Returns true if this preprocessor is "on"; false, otherwise. If this
+      # preprocessor is "on", preprocessing should be applied to a word if word
+      # meets the criteria for preprocessing.
+      def preprocessor_on?
+        preprocessor_on
+      end
+
+      def preprocessor_on!
+        @preprocessor_on = true
+      end
+
+      # Returns true if this preprocessor is "off". Preprocessing should not
+      # be applied to a word if this preprocessor is "off".
+      def preprocessor_off?
+        !preprocessor_on?
+      end
+
+      def preprocessor_off!
+        @preprocessor_on = false
+      end
+
+      private
+
+      def preprocessed_word(original_word:, preprocessed:, preprocessed_word:)
+        PreprocessedWord.new(original_word: original_word, preprocessed: preprocessed,
+          preprocessed_word: preprocessed_word, preprocessor: to_sym, preprocessor_order: order)
+      end
+    end
+  end
+end

data/lib/LittleWeasel/preprocessors/word_preprocessor_managable.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative 'word_preprocessable'
+require_relative 'word_preprocessor_validatable'
+
+module LittleWeasel
+  module Preprocessors
+    # This module provides methods and functionality to manage word
+    # preprocessors. A "word preprocessor" is an object that manipulates a word
+    # before it is passed to any word filters and before it is compared against
+    # the dictionary for validity.
+    #
+    # When creating your own word preprocessors, here are some things you
+    # need to consider:
+    #
+    # Multiple word preprocessors can be applied to a given word. Word
+    # processors will be applied to a word in
+    # Preprocessors::WordPreprocessor#order order (ascending). Even though this
+    # is the case, it doesn't mean you should seek to apply more than one word
+    # preprocessor at a time. However, if you do, write and order your word
+    # preprocessors in such a way that each preprocessor manipulates the word
+    # in a complimentary rather than contridictionary way. For example,
+    # applying one word preprocessor that convert a word to uppercase and a
+    # second that converts the word to lowercase, contradict each other.
+    #
+    # Another thing you need to consider, is whether or not metadata observers
+    # should be notified of the preprocessed word (now that it has been
+    # potentially manipulated) or if they should be notified of the original
+    # word; this is because, the original word may not be found as a valid word
+    # in the dictionary, while the preprocessed word might and vise versa.
+    module WordPreprocessorManagable
+      include WordPreprocessable
+      include WordPreprocessorsValidatable
+
+      # Override attr_reader word_preprocessor found in WordPreprocessable
+      # so that we don't raise nil errors when using word_preprocessors.
+      def word_preprocessors
+        @word_preprocessors ||= []
+      end
+
+      def clear_preprocessors
+        self.word_preprocessors = []
+      end
+
+      # Appends word preprocessors to the #word_preprocessors Array.
+      #
+      # If Argument word_preprocessor is nil, a block must be passed to populate
+      # the word_preprocessors with an Array of valid word preprocessor objects.
+      #
+      # This method is used for adding/appending word preprocessors to the
+      # word_preprocessors Array. To replace word preprocessors, use #replace_preprocessors;
+      # to perform any other manipulation of the word_preprocessors Array,
+      # use #word_preprocessors directly.
+      def add_preprocessors(word_preprocessors: nil)
+        return if word_preprocessors.is_a?(Array) && word_preprocessors.blank?
+
+        unless word_preprocessors.present? || block_given?
+          raise 'A block is required if argument word_preprocessors is nil'
+        end
+
+        word_preprocessors ||= []
+        yield word_preprocessors if block_given?
+
+        concat_and_sort_word_preprocessors! word_preprocessors
+      end
+      alias append_preprocessors add_preprocessors
+
+      def replace_preprocessors(word_preprocessors:)
+        clear_preprocessors
+        add_preprocessors word_preprocessors: word_preprocessors
+      end
+
+      def preprocessors_on=(on)
+        raise ArgumentError, "Argument on is not true or false: #{on.class}" unless [true, false].include?(on)
+
+        word_preprocessors.each { |word_preprocessor| word_preprocessor.preprocessor_on = on }
+      end
+
+      # Returns a Preprocessors::PreprocessedWords object.
+      def preprocess(word:)
+        preprocessed_words = preprocessed_words word: word
+        PreprocessedWords.new(original_word: word, preprocessed_words: preprocessed_words)
+      end
+
+      def preprocessed_words(word:)
+        word_preprocessors.map do |word_preprocessor|
+          word_preprocessor.preprocess(word).tap do |processed_word|
+            word = processed_word.preprocessed_word
+          end
+        end
+      end
+
+      # Returns the final (or last) preprocessed word in the Array of
+      # preprocessed words. The final preprocessed word is the word that has
+      # passed through all the word preprocessors.
+      def preprocessed_word(word:)
+        preprocessed_words = self.preprocessed_words word: word
+        preprocessed_words.max_by(&:preprocessor_order).preprocessed_word unless preprocessed_words.blank?
+      end
+
+      private
+
+      # This method concatinates preprocessors to #word_preprocessors,
+      # sorts #word_preprocessors by WordPreprocessor#order and
+      # returns the results.
+      def concat_and_sort_word_preprocessors!(preprocessors)
+        validate_word_preprocessors word_preprocessors: preprocessors
+
+        word_preprocessors.concat preprocessors
+        word_preprocessors.sort_by!(&:order)
+      end
+    end
+  end
+end

data/lib/LittleWeasel/preprocessors/word_preprocessor_validatable.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module LittleWeasel
+  module Preprocessors
+    # This module validates word preprocessor types.
+    # rubocop: disable Layout/LineLength
+    module WordPreprocessorValidatable
+      module_function
+
+      # :reek:ManualDispatch - ignored, this is duck-typing not 'simulated polymorphism'
+      # :reek:TooManyStatements - ignored, "too many statements" is easier to understand than arbitrarily breaking all this down into individual methods
+      def validate_word_preprocessor(word_preprocessor:)
+        # You can use your own word preprocessor types as long as they quack
+        # correctly; however, you are responsible for the behavior of these
+        # required methods/ attributes. It's probably better to follow the
+        # pattern of existing word preprocessor objects and inherit from
+        # Preprocessors::WordPreprocessor.
+
+        word_preprocessor_class = word_preprocessor.class
+
+        # class methods
+        raise validation_error_message(object: word_preprocessor_class, respond_to: '.preprocess') unless word_preprocessor_class.respond_to?(:preprocess)
+        raise validation_error_message(object: word_preprocessor_class, respond_to: '.preprocess?') unless word_preprocessor_class.respond_to?(:preprocess?)
+
+        # instance methods
+        raise validation_error_message(object: word_preprocessor_class, respond_to: '#preprocess') unless word_preprocessor.respond_to?(:preprocess)
+        raise validation_error_message(object: word_preprocessor_class, respond_to: '#preprocess?') unless word_preprocessor.respond_to?(:preprocess?)
+        raise validation_error_message(object: word_preprocessor_class, respond_to: '#preprocessor_off?') unless word_preprocessor.respond_to?(:preprocessor_off?)
+        raise validation_error_message(object: word_preprocessor_class, respond_to: '#preprocessor_on') unless word_preprocessor.respond_to?(:preprocessor_on)
+        raise validation_error_message(object: word_preprocessor_class, respond_to: '#preprocessor_on=') unless word_preprocessor.respond_to?(:preprocessor_on=)
+        raise validation_error_message(object: word_preprocessor_class, respond_to: '#preprocessor_on?') unless word_preprocessor.respond_to?(:preprocessor_on?)
+      end
+
+      def validation_error_message(object:, respond_to:)
+        "Argument word_preprocessor: does not respond to: #{object}#{respond_to}"
+      end
+    end
+    # rubocop: enable Layout/LineLength
+  end
+end

data/lib/LittleWeasel/preprocessors/word_preprocessors_validatable.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'word_preprocessor_validatable'
+
+module LittleWeasel
+  module Preprocessors
+    # This module provides methods to validate an Array of word preprocessor
+    # objects.
+    module WordPreprocessorsValidatable
+      module_function
+
+      def validate_word_preprocessors(word_preprocessors:)
+        return if word_preprocessors.blank?
+
+        raise ArgumentError, "Argument word_preprocessors is not an Array: #{word_preprocessors.class}" \
+          unless word_preprocessors.is_a? Array
+
+        word_preprocessors.each do |word_preprocessor|
+          WordPreprocessorValidatable.validate_word_preprocessor word_preprocessor: word_preprocessor
+        end
+      end
+    end
+  end
+end

data/lib/LittleWeasel/services/dictionary_cache_service.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require_relative '../modules/dictionary_cache_keys'
+require_relative '../modules/dictionary_cache_validatable'
+require_relative '../modules/dictionary_keyable'
+require_relative '../modules/dictionary_sourceable'
+
+module LittleWeasel
+  module Services
+    # This class provides methods and attributes that can be used to manage the
+    # dictionary cache. The "dictionary cache" is a simple Hash that provides
+    # access to informaiton related to dictionaries through a dictionary "key".
+    # A dictionary "key" is a unique key comprised of a locale and
+    # optional "tag" (see Modules::Taggable and DictionaryKey for more
+    # information). The dictionary cache also provides a way for dictionary
+    # objects to share dictionary information, in particular, the dictionary
+    # file and dictionary metadata.
+    class DictionaryCacheService
+      include Modules::DictionaryCacheKeys
+      include Modules::DictionaryCacheValidatable
+      include Modules::DictionaryKeyable
+      include Modules::DictionarySourceable
+
+      attr_reader :dictionary_cache
+
+      # This class produces the following (example) Hash that represents the
+      # dictionary cache structure:
+      #
+      # @example This is an example:
+      #
+      # {
+      #   'dictionary_cache' =>
+      #   {
+      #     'dictionary_references' =>
+      #     {
+      #       'en' =>
+      #       {
+      #         'dictionary_id' => 19ec7845
+      #       },
+      #       'en-US' =>
+      #       {
+      #         'dictionary_id' => 0987a3f2
+      #       },
+      #       'en-US-temp' =>
+      #       {
+      #         'dictionary_id' => 9273eac6
+      #       }
+      #     },
+      #     'dictionaries' =>
+      #     {
+      #       19ec7845 =>
+      #         {
+      #           'source' => '/en.txt',
+      #           'dictionary_object' => {}
+      #         },
+      #       0987a3f2 =>
+      #         {
+      #           'source' => '/en-US.txt',
+      #           'dictionary_object' => {}
+      #         },
+      #       9273eac6 =>
+      #         {
+      #           'source' => '*736ed423',
+      #           'dictionary_object' => {}
+      #         }
+      #     }
+      #   }
+      # }
+      def initialize(dictionary_key:, dictionary_cache:)
+        validate_dictionary_key dictionary_key: dictionary_key
+        self.dictionary_key = dictionary_key
+
+        validate_dictionary_cache dictionary_cache: dictionary_cache
+        self.dictionary_cache = dictionary_cache
+
+        self.class.init(dictionary_cache: dictionary_cache) unless dictionary_cache[DICTIONARY_CACHE]
+      end
+
+      class << self
+        # This method resets dictionary_cache to its initialized state.
+        # This class method is different from the #init instance method
+        # in that ALL dictionary references and ALL dictionaries are
+        # initialized.
+        def init(dictionary_cache:)
+          Modules::DictionaryCacheKeys.initialize_dictionary_cache dictionary_cache: dictionary_cache
+        end
+
+        # Returns true if the dictionary cache is initialized; that
+        # is, if the given dictionary_cache is in the same state the
+        # dictionary cache would be in after .init were called.
+        def init?(dictionary_cache:)
+          initialized_dictionary_cache = init(dictionary_cache: {})
+          dictionary_cache.eql?(initialized_dictionary_cache)
+        end
+
+        # Returns the number of dictionaries currently in the cache.
+        def count(dictionary_cache:)
+          dictionary_cache.dig(self::DICTIONARY_CACHE, self::DICTIONARIES)&.keys&.count || 0
+        end
+      end
+
+      # This method resets the dictionary cache for the given key. This method
+      # is different from the .init class method in that ONLY the dictionary
+      # reference and dictionary specific to the given key is initialized.
+      def init
+        # TODO: Do not delete the dictionary if it is being pointed to by
+        # another dictionary reference.
+        dictionary_cache_hash = dictionary_cache[DICTIONARY_CACHE]
+        dictionary_cache_hash[DICTIONARIES]&.delete(dictionary_id)
+        dictionary_cache_hash[DICTIONARY_REFERENCES]&.delete(key)
+        self
+      end
+
+      # Returns true if the dictionary reference exists for the given key; false
+      # otherwise. This method is only concerned with the dictionary reference
+      # and has nothing to do with whether or not the associated dictionary
+      # is actually loaded into the dictionary cache.
+      def dictionary_reference?
+        dictionary_reference&.present? || false
+      end
+
+      # Returns true if a dictionaries Hash key exists for the given dictionary_id
+      # in the dictionary cache. This method is only concerned with the existance of
+      # the key and has nothing to do with whether or not file/memory sources are
+      # present or the presence of a dictionary object.
+      def dictionary?
+        dictionary_cache[DICTIONARY_CACHE][DICTIONARIES].key? dictionary_id
+      end
+
+      # Returns the dictionary id if there is a dictionary id in the dictionary
+      # cache associated with the given key; nil otherwise.
+      def dictionary_id
+        dictionary_cache.dig(DICTIONARY_CACHE, DICTIONARY_REFERENCES, key, DICTIONARY_ID)
+      end
+
+      # Returns the dictionary id if there is a dictionary id in the dictionary
+      # cache associated with the given key. This method raises an error if the
+      # dictionary id cannot be found.
+      def dictionary_id!
+        return dictionary_id if dictionary_id?
+
+        raise ArgumentError, "A dictionary id could not be found for key '#{key}'."
+      end
+
+      # This method returns true if the dictionary associated with the
+      # given dictionary key is loaded/cached. If this is the case,
+      # a dictionary object is available in the dictionary cache.
+      def dictionary_object?
+        dictionary_object.present?
+      end
+      alias dictionary_exist? dictionary_object?
+
+      # <b>DEPRECATED:</b> Use <tt>dictionary_exist?</tt> instead.
+      def dictionary_exists?
+        warn "[DEPRECATION] 'dictionary_exists?' is deprecated. Please use 'dictionary_exist?' instead."
+        dictionary_object?
+      end
+
+      # Returns the dictionary object from the dictionary cache for the given
+      # key. This method raises an error if the dictionary is not in the cache;
+      # that is, if the dictionary was not previously loaded from disk or memory.
+      def dictionary_object!
+        unless dictionary_object?
+          raise ArgumentError,
+            "The dictionary object associated with argument key '#{key}' is not in the cache."
+        end
+
+        dictionary_object
+      end
+
+      def dictionary_object
+        dictionary_cache.dig(DICTIONARY_CACHE, DICTIONARIES, dictionary_id, DICTIONARY_OBJECT)
+      end
+
+      def dictionary_object=(object)
+        raise ArgumentError, 'Argument object is not a Dictionary object' unless object.is_a? Dictionary
+
+        unless dictionary_reference?
+          raise ArgumentError,
+            "The dictionary reference associated with key '#{key}' could not be found."
+        end
+        return if object.equal? dictionary_object
+
+        if dictionary_exist?
+          raise ArgumentError,
+            "The dictionary is already loaded/cached for key '#{key}'; use #unload or #kill first."
+        end
+
+        dictionary_cache[DICTIONARY_CACHE][DICTIONARIES][dictionary_id!][DICTIONARY_OBJECT] = object
+      end
+
+      private
+
+      attr_writer :dictionary_cache
+
+      def dictionary_reference
+        dictionary_cache.dig(DICTIONARY_CACHE, DICTIONARY_REFERENCES, key)
+      end
+
+      def set_dictionary_reference(dictionary_id:)
+        dictionary_cache[DICTIONARY_CACHE][DICTIONARY_REFERENCES][key] = {
+          DICTIONARY_ID => dictionary_id
+        }
+      end
+
+      def dictionary_id?
+        dictionary_id.present?
+      end
+    end
+  end
+end

data/lib/LittleWeasel/services/dictionary_creator_service.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative '../dictionary'
+require_relative '../filters/word_filterable'
+require_relative '../filters/word_filters_validatable'
+require_relative '../metadata/dictionary_metadata'
+require_relative '../modules/dictionary_cache_servicable'
+require_relative '../modules/dictionary_creator_servicable'
+require_relative '../modules/dictionary_keyable'
+require_relative '../modules/dictionary_metadata_servicable'
+require_relative '../modules/dictionary_sourceable'
+require_relative '../preprocessors/word_preprocessor_managable'
+require_relative 'dictionary_file_loader_service'
+
+module LittleWeasel
+  module Services
+    # This class provides a service to load dictionaries from disk, create
+    # and return a Dictionary object.
+    class DictionaryCreatorService
+      include Filters::WordFilterable
+      include Filters::WordFiltersValidatable
+      include Modules::DictionaryCacheServicable
+      include Modules::DictionaryKeyable
+      include Modules::DictionaryMetadataServicable
+      include Modules::DictionarySourceable
+      include Preprocessors::WordPreprocessorManagable
+
+      def initialize(dictionary_key:, dictionary_cache:, dictionary_metadata:,
+        word_filters: nil, word_preprocessors: nil)
+        validate_dictionary_key dictionary_key: dictionary_key
+        self.dictionary_key = dictionary_key
+
+        validate_dictionary_cache dictionary_cache: dictionary_cache
+        self.dictionary_cache = dictionary_cache
+
+        validate_dictionary_metadata dictionary_metadata: dictionary_metadata
+        self.dictionary_metadata = dictionary_metadata
+
+        validate_word_filters word_filters: word_filters unless word_filters.blank?
+        self.word_filters = word_filters
+
+        validate_word_preprocessors word_preprocessors: word_preprocessors unless word_preprocessors.blank?
+        self.word_preprocessors = word_preprocessors
+      end
+
+      def from_file_source(file:)
+        add_dictionary_file_source file: file
+        dictionary_words = dictionary_file_loader_service.execute
+        create_dictionary dictionary_words: dictionary_words
+      end
+
+      def from_memory_source(dictionary_words:)
+        add_dictionary_memory_source
+        create_dictionary dictionary_words: dictionary_words
+      end
+
+      private
+
+      def dictionary_file_loader_service
+        Services::DictionaryFileLoaderService.new dictionary_key: dictionary_key, dictionary_cache: dictionary_cache
+      end
+
+      def create_dictionary(dictionary_words:)
+        Dictionary.new(dictionary_key: dictionary_key, dictionary_cache: dictionary_cache,
+          dictionary_metadata: dictionary_metadata, dictionary_words: dictionary_words, word_filters: word_filters,
+          word_preprocessors: word_preprocessors).tap do |dictionary|
+          dictionary_cache_service.dictionary_object = dictionary
+        end
+      end
+
+      # Adds a dictionary file source. A "file source" is a file path that
+      # indicates that the dictionary words associated with this dictionary are
+      # located on disk. This file path is used to locate and load the
+      # dictionary words into the dictionary cache for use.
+      #
+      # @param file [String] a file path pointing to the dictionary file to load and use.
+      #
+      # @return returns a reference to self.
+      def add_dictionary_file_source(file:)
+        dictionary_cache_service.add_dictionary_source(dictionary_source: file)
+      end
+
+      # Adds a dictionary memory source. A "memory source" indicates that the
+      # dictionary words associated with this dictionary were created
+      # dynamically and will be located in memory, as opposed to loaded from
+      # a file on disk.
+      #
+      # @return returns a reference to self.
+      def add_dictionary_memory_source
+        dictionary_cache_service.add_dictionary_source(dictionary_source: memory_source)
+      end
+    end
+  end
+end

data/lib/LittleWeasel/services/dictionary_file_loader_service.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../modules/configurable'
+require_relative '../modules/dictionary_cache_servicable'
+require_relative '../modules/dictionary_file_loader'
+require_relative '../modules/dictionary_keyable'
+
+module LittleWeasel
+  module Services
+    # This class provides a service for loading dictionaries from disk and
+    # returning a Hash of dictionary words that can be used to instantiate
+    # a Dictionary object or otherwise.
+    class DictionaryFileLoaderService
+      include Modules::Configurable
+      include Modules::DictionaryCacheServicable
+      include Modules::DictionaryFileLoader
+      include Modules::DictionaryKeyable
+
+      def initialize(dictionary_key:, dictionary_cache:)
+        validate_dictionary_key dictionary_key: dictionary_key
+        self.dictionary_key = dictionary_key
+
+        validate_dictionary_cache dictionary_cache: dictionary_cache
+        self.dictionary_cache = dictionary_cache
+      end
+
+      def execute
+        if dictionary_cache_service.dictionary_exist?
+          raise ArgumentError,
+            "The dictionary associated with key '#{key}' already exists."
+        end
+
+        load dictionary_cache_service.dictionary_file!
+      end
+    end
+  end
+end

data/lib/LittleWeasel/services/dictionary_killer_service.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../modules/dictionary_cache_servicable'
+require_relative '../modules/dictionary_metadata_servicable'
+require_relative '../modules/dictionary_keyable'
+
+module LittleWeasel
+  module Services
+    # This service removes a dictionary (Dictionary object) associated with
+    # the dictionary key from the dictionary cache along with the dictionary
+    # file reference and any metadata associated with the dictionary from the
+    # dictionary cache.
+    class DictionaryKillerService
+      include Modules::DictionaryCacheServicable
+      include Modules::DictionaryMetadataServicable
+      include Modules::DictionaryKeyable
+
+      def initialize(dictionary_key:, dictionary_cache:, dictionary_metadata:)
+        validate_dictionary_key dictionary_key: dictionary_key
+        self.dictionary_key = dictionary_key
+
+        validate_dictionary_cache dictionary_cache: dictionary_cache
+        self.dictionary_cache = dictionary_cache
+
+        validate_dictionary_metadata dictionary_metadata: dictionary_metadata
+        self.dictionary_metadata = dictionary_metadata
+      end
+
+      def execute
+        dictionary_cache_service.init
+        dictionary_metadata_service.class.init dictionary_metadata: dictionary_metadata
+      end
+    end
+  end
+end