LittleWeasel 3.0.4 → 4.0.0

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_exists?
+          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

data/lib/LittleWeasel/services/dictionary_loader_service.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative '../dictionary'
+require_relative '../metadata/dictionary_metadata'
+require_relative '../modules/dictionary_cache_servicable'
+require_relative '../modules/dictionary_metadata_servicable'
+require_relative '../modules/dictionary_keyable'
+require_relative 'dictionary_file_loader_service'
+
+module LittleWeasel
+  module Services
+    # This class provides services to load dictionaries from either disk (if
+    # the dictionary has not been loaded) or from the dictionary cache if the
+    # dictionary has already been loaded from disk.
+    class DictionaryLoaderService
+      include Modules::DictionaryKeyable
+      include Modules::DictionaryCacheServicable
+      include Modules::DictionaryMetadataServicable
+
+      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
+        if dictionary_cache_service.dictionary_exists?
+          load_from_cache
+        else
+          dictionary_cache_service.dictionary_object = load_from_disk
+        end
+      end
+
+      private
+
+      def load_from_cache
+        dictionary_cache_service.dictionary_object!
+      end
+
+      def load_from_disk
+        dictionary_for dictionary_words: dictionary_file_loader_service.execute
+      end
+
+      def dictionary_for(dictionary_words:)
+        Dictionary.new dictionary_key: dictionary_key, dictionary_cache: dictionary_cache,
+          dictionary_metadata: dictionary_metadata, dictionary_words: dictionary_words
+      end
+
+      def dictionary_file_loader_service
+        Services::DictionaryFileLoaderService.new dictionary_key: dictionary_key, dictionary_cache: dictionary_cache
+      end
+    end
+  end
+end

data/lib/LittleWeasel/services/dictionary_metadata_service.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative '../modules/dictionary_cache_servicable'
+require_relative '../modules/dictionary_keyable'
+require_relative '../modules/dictionary_metadata_validatable'
+
+module LittleWeasel
+  module Services
+    # This class provides methods for managing and manipulating the
+    # dictionary metadata associated with the given dictionary,
+    # (dictionary_key) for the supplied metadata_key.
+    class DictionaryMetadataService
+      include Modules::DictionaryKeyable
+      include Modules::DictionaryCacheServicable
+      include Modules::DictionaryMetadataValidatable
+
+      attr_reader :dictionary_metadata
+
+      # @example metadata Hash structure:
+      #
+      #   {
+      #     <dictionary_id!> =>
+      #       {
+      #         :<metadata_key> => <metadata_object>
+      #       },
+      #       ...
+      #     }
+      #   }
+      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
+
+      class << self
+        # This method initializes the dictionary_metadata object to its
+        # initialized state - all data is lost, but the object reference is
+        # maintained.
+        def init(dictionary_metadata:)
+          Modules::DictionaryMetadataValidatable.validate dictionary_metadata: dictionary_metadata
+
+          dictionary_metadata.each_key { |key| dictionary_metadata.delete(key) }
+          dictionary_metadata
+        end
+
+        # Returns true if the dictionary metadata is initialized; that is, if
+        # it's in the same state the dictionary metadata would be in if #init
+        # were called.
+        def init?(dictionary_metadata:)
+          Modules::DictionaryMetadataValidatable.validate dictionary_metadata: dictionary_metadata
+
+          initialized_dictionary_metadata = init(dictionary_metadata: {})
+          dictionary_metadata.eql?(initialized_dictionary_metadata)
+        end
+        alias initialized? init?
+      end
+
+      # This method initializes the dictionary metadata for dictionary metadata
+      # associated with the dictionary_id! and metadata_key.
+      def init(metadata_key:)
+        metadata = dictionary_metadata[dictionary_id!]
+        metadata&.delete(metadata_key)
+        metadata = dictionary_metadata_init_if
+        metadata[metadata_key] = nil
+        self
+      end
+
+      # This method will return true if metadata exists for the dictionary
+      # associated with the given dictionary key, for the given metadata key.
+      def dictionary_metadata?(metadata_key:)
+        dictionary_metadata.dig(dictionary_id, metadata_key)&.present? || false
+      end
+
+      def get_dictionary_metadata(metadata_key:)
+        dictionary_metadata.dig(dictionary_id!, metadata_key)
+      end
+
+      def set_dictionary_metadata(value:, metadata_key:)
+        dictionary_metadata[dictionary_id!][metadata_key] = value
+        self
+      end
+
+      private
+
+      attr_writer :dictionary_metadata
+
+      def dictionary_metadata_init_needed?
+        dictionary_metadata[dictionary_id!].blank?
+      end
+
+      # This method initializes the metadata for the
+      # dictionary_id! if it is not already initialized.
+      # The metadata for the given dictionary_id! is returned.
+      def dictionary_metadata_init_if
+        return dictionary_metadata[dictionary_id!] unless dictionary_metadata_init_needed?
+
+        dictionary_metadata[dictionary_id!] = {}
+      end
+
+      def dictionary_id
+        dictionary_cache_service.dictionary_id
+      end
+
+      def dictionary_id!
+        dictionary_cache_service.dictionary_id!
+      end
+    end
+  end
+end

data/lib/LittleWeasel/services/invalid_words_service.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative '../metadata/invalid_words_service_results'
+
+module LittleWeasel
+  module Services
+    # This class calculates the total amount of bytes cached invalid words take
+    # up in the given dictionary and returns the results. In addition to this,
+    # metadata is also compiled to determine how many more bytes of invalid
+    # word data can be cached before the cache is depleted and shutdown.
+    class InvalidWordsService
+      def initialize(dictionary)
+        self.dictionary = dictionary
+        self.current_bytesize = 0
+      end
+
+      def execute
+        return build_return unless max_invalid_words_bytesize?
+
+        self.current_bytesize = calculate_current_bytesize
+        build_return
+      end
+
+      private
+
+      attr_accessor :current_bytesize, :dictionary
+
+      def calculate_current_bytesize
+        dictionary.reduce(0) do |bytesize, word_and_found|
+          unless word_and_found.last
+            bytesize += word_and_found.first.bytesize
+            break unless bytesize < max_invalid_words_bytesize
+          end
+          bytesize
+        end
+      end
+
+      def build_return
+        Metadata::InvalidWordsServiceResults.new(
+          max_invalid_words_bytesize_on: max_invalid_words_bytesize?,
+          current_invalid_word_bytesize: current_bytesize,
+          max_invalid_words_bytesize: max_invalid_words_bytesize
+        )
+      end
+
+      def max_invalid_words_bytesize
+        @max_invalid_words_bytesize ||= config.max_invalid_words_bytesize
+      end
+
+      def max_invalid_words_bytesize?
+        config.max_invalid_words_bytesize?
+      end
+
+      def config
+        @config ||= LittleWeasel.configuration
+      end
+    end
+  end
+end

data/lib/LittleWeasel/version.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 # The version of this gem
 module LittleWeasel
-  VERSION = "3.0.4"
+  VERSION = '4.0.0'
 end

data/lib/LittleWeasel/word_results.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/delegation'
+require_relative 'modules/word_results_validatable'
+require_relative 'preprocessors/preprocessed_words_validatable'
+
+module LittleWeasel
+  # This class represents the results of gathering information about a word.
+  class WordResults
+    include Modules::WordResultsValidatable
+    include Preprocessors::PreprocessedWordsValidatable
+
+    attr_reader :filters_matched, :original_word, :preprocessed_words, :word_cached, :word_valid
+
+    delegate :preprocessed_word, to: :preprocessed_words, allow_nil: true
+
+    # Important: Regarding Boolean Methods
+    #
+    # The return value of some of the boolean methods (i.e. methods ending with
+    # a '?') of this class depend on whether or not #original_word
+    # has passed through any preprocessing. If #orginal_word has passed
+    # through preprocessing, the following boolean methods will reflect
+    # that of #preprocessed_word; if #original_word has NOT passed through
+    # any preprocessing, the following methods will reflect that of
+    # #original_word:
+    #
+    # #success?
+    # #filter_match?
+    # #word_cached?
+    # #word_valid?
+    #
+    # In other words, if #original_word has passed through preprocessing
+    # and has been altered by any of the preprocessing modules, it is the
+    # #preprocessed_word that is passed through any subsequent word filters,
+    # checked against the dictionary for validity, and cached, NOT
+    # #original_word.
+    # :reek:BooleanParameter - ignored, boolean params do not determine logic path, but only report status.
+    def initialize(original_word:, filters_matched: [],
+      preprocessed_words: nil, word_cached: false, word_valid: false)
+
+      self.original_word = original_word
+      self.filters_matched = filters_matched
+      self.word_cached = word_cached
+      self.word_valid = word_valid
+      self.preprocessed_words = preprocessed_words
+    end
+
+    def original_word=(value)
+      @original_word = value
+      validate_original_word
+    end
+
+    def filters_matched=(value)
+      @filters_matched = value
+      validate_filters_matched
+    end
+
+    def word_cached=(value)
+      @word_cached = value
+      validate_word_cached
+    end
+
+    def word_valid=(value)
+      @word_valid = value
+      vaidate_word_valid
+    end
+
+    def preprocessed_words=(value)
+      if value.present?
+        validate_prepreprocessed_words preprocessed_words: value
+        @preprocessed_words = value
+      else
+        @preprocessed_words = nil
+      end
+    end
+
+    # Returns true if the word is valid (found in the dictionary), or
+    # the word was matched against at least one filter; false, otherwise.
+    #
+    # Use the results of this method if you want to consider a word's
+    # validity as having been found in the dictionary as a valid word OR
+    # if the word has at least one word filter match. If the word has
+    # NOT passed through any word filters, or if word DID NOT match any
+    # filters, yet, it was found as a valid word in the dictionary, this
+    # method will return true and vice versa.
+    #
+    # See "Important: Regarding Boolean Methods" notes at the top of this
+    # class definition for more detail.
+    def success?
+      filter_match? || word_valid?
+    end
+
+    # Returns true if the word was found in the dictionary; false, otherwise.
+    #
+    # Use the results of this method if you want to consider a word's
+    # validity irrespective of whether or not the word has matched any word
+    # filters (if any).
+    #
+    # See "Important: Regarding Boolean Methods" notes at the top of this
+    # class definition for more detail.
+    def word_valid?
+      word_valid
+    end
+
+    # Returns true if the word was matched against at least one filter;
+    # false, otherwise.
+    #
+    # See "Important: Regarding Boolean Methods" notes at the top of this
+    # class definition for more detail.
+    def filter_match?
+      filters_matched.present?
+    end
+
+    # Returns true if #original_word passed through any preprocessing. If
+    # this is the case, #preprocessed_word may be different than
+    # #original_word. Preprocessing should take place before any filtering
+    # takes place.
+    #
+    # #word_cached, #word_valid and #filters_matched should all
+    # reflect that of the #preprocessed_word if #preprocessed_word is
+    # present?; otherwise, they should all reflect that of #original_word.
+    def preprocessed_word?
+      preprocessed_word.present?
+    end
+
+    # Returns #preprocessed_word (if available) or #original_word.
+    # #preprocessed_word will be present if #original_word has
+    # met the criteria for preprocessing and passed through at least
+    # one preprocessor.
+    #
+    # See "Important: Regarding Boolean Methods" notes at the top of this
+    # class definition for more detail.
+    def preprocessed_word_or_original_word
+      preprocessed_word || original_word
+    end
+
+    # Returns true if the word was found in the dictionary as a valid word
+    # OR if the word was found in the cache as an invalid word.
+    #
+    # See "Important: Regarding Boolean Methods" notes at the top of this
+    # class definition for more detail.
+    def word_cached?
+      word_cached
+    end
+  end
+end