LittleWeasel 3.0.3 → 5.0.0

data/lib/LittleWeasel/services/dictionary_metadata_service.rb

@@ -0,0 +1,116 @@
+# 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
+
+          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: 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.3"
+  VERSION = '5.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

data/lib/LittleWeasel.rb

@@ -1,186 +1,7 @@
-require 'singleton'
-require "LittleWeasel/version"
-require 'active_support/inflector'
+# frozen_string_literal: true
 
-module LittleWeasel
+require 'active_support/core_ext/object/blank'
 
-  # Provides methods to interrogate the dictionary.
-  class Checker
-    include Singleton
-
-    # Returns the dictionary.
-    #
-    # @return [Hash] the dictionary.
-    attr_reader :dictionary
-
-    private
-
-    attr_reader :alphabet_exclusion_list
-
-    # Keep these private...will expose as options later.
-    attr_accessor :word_regex, :numeric_regex, :non_wordchar_regex
-
-    public
-
-    # The constructor
-    def initialize
-      @options = { exclude_alphabet: false, strip_whitespace: false, ignore_numeric: true, single_word_mode: false }
-      @alphabet_exclusion_list = %w{ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z }
-      @numeric_regex = /^[-+]?[0-9]?(\.[0-9]+)?$+/
-      @word_regex = /\s+(?=(?:[^"]*"[^"]*")*[^"]*$)/
-      @non_wordchar_regex = /\W+/
-      @dictionary = Hash.new(1)
-      load
-    end
-
-    # Interrogates the dictionary to determine whether or not [word] exists.
-    #
-    # @param [String] word the word or words to interrogate
-    # @param [Hash] options options to apply to this query (see #options=).  Options passed to this
-    #   method are applied for this query only.
-    #
-    # @return [Boolean] true if the word/words in *word* exists, false otherwise.
-    #
-    # @example
-    #
-    #  LittleWeasel::Checker.instance.exists?('C') # true (default options, :exclude_alphabet => false)
-    #  LittleWeasel::Checker.instance.exists?('A', {exclude_alphabet:true}) # false
-    #  LittleWeasel::Checker.instance.exists?('X', {exclude_alphabet:false}) # true
-    #  LittleWeasel::Checker.instance.exists?('Hello') # true
-    #
-    #  LittleWeasel::Checker.instance.exists?(' Hello ') # false (default options, :strip_whitespace => false)
-    #  LittleWeasel::Checker.instance.exists?(' Yes ', {strip_whitespace:true}) # true
-    #  LittleWeasel::Checker.instance.exists?('No ', {strip_whitespace:false}) # false
-    #  LittleWeasel::Checker.instance.exists?('How dy', {strip_whitespace:true}) # false, strip_whitespace only removes leading and trailing spaces
-    #
-    #  LittleWeasel::Checker.instance.exists?('90210') # true (default options, ignore_numeric => true)
-    #  LittleWeasel::Checker.instance.exists?('90210', {ignore_numeric:false}) # false
-    #
-    #  LittleWeasel::Checker.instance.exists?('Hello World') # true, we're accepting multiple words now by default (default options, single_word_mode => false) :)
-    #  LittleWeasel::Checker.instance.exists?("hello, mister; did I \'mention\'' that lemon cake is \"great?\" It's just wonderful!") # true
-    #
-    #  LittleWeasel::Checker.instance.exists?('I love ice cream', {single_word_mode:true}) # false; while all the words are valid, more than one word will return false
-    #
-    def exists?(word, options=nil)
-      options = options || @options
-
-      return false unless word.is_a?(String)
-
-      word = word.dup
-      word.strip! if options[:strip_whitespace]
-
-      return false if word.empty?
-
-      if block? word
-        return false if options[:single_word_mode]
-        return block_exists? word
-      end
-      
-      return true if options[:ignore_numeric] && number?(word)
-      return false if options[:exclude_alphabet] && word.length == 1 && @alphabet_exclusion_list.include?(word.upcase)
-
-      valid_word? word
-    end
-
-    # Sets the global options for this gem.
-    #
-    # @param [Hash] options options that should apply to all subsequent calls to method *exists?* (see #exists?).
-    #  Options set via this property apply to all subsequent queries.
-    #
-    # @option options [Boolean] :exclude_alphabet (false) If false, letters of the alphabet are considered words.
-    # @option options [Boolean] :strip_whitespace (false) If true, leading and trailing spaces are removed before checking to see if the word exists.
-    # @option options [Boolean] :ignore_numeric (true) If true, numeric values are considered valid words.
-    # @option options [Boolean] :single_word_mode (false) If false, word blocks (more than one word) are considered valid if all the words exist in the dictionary.
-    #
-    # @return [Hash] The options
-    #
-    # @example
-    #  LittleWeasel::Checker.instance.options({exclude_alphabet:true})
-    #  LittleWeasel::Checker.instance.exists?('A') # false
-    #
-    #  LittleWeasel::Checker.instance.options({exclude_alphabet:false})
-    #  LittleWeasel::Checker.instance.exists?('A') # true
-    #
-    #  LittleWeasel::Checker.instance.options({strip_whitespace:false})
-    #  LittleWeasel::Checker.instance.exists?(' Hello ') # false
-    #  LittleWeasel::Checker.instance.exists?('No ') # false
-    #  LittleWeasel::Checker.instance.exists?(' No') # false
-    #
-    #  LittleWeasel::Checker.instance.options({strip_whitespace:true})
-    #  LittleWeasel::Checker.instance.exists?(' Yes ') # true
-    #  LittleWeasel::Checker.instance.exists?('How dy') # false, strip_whitespace only removes leading and trailing spaces
-    #
-    #  LittleWeasel::Checker.instance.exists?('90210') # true (default options, ignore_numeric => true)
-    #  LittleWeasel::Checker.instance.exists?('90210', {ignore_numeric:false}) # false
-    #  LittleWeasel::Checker.instance.exists?('I watch Beverly Hills 90210') # true (default options, ignore_numeric => true)
-    #  LittleWeasel::Checker.instance.exists?('I watch Beverly Hills 90210', {ignore_numeric:false}) # false
-    #
-    #  LittleWeasel::Checker.instance.options({single_word_mode:true})
-    #  LittleWeasel::Checker.instance.exists?('I love ice cream') # false; while all the words are valid, more than one word will return false
-    #  LittleWeasel::Checker.instance.exists?('Baby') # true
-    #
-    def options=(options)
-      @options = options
-    end
-
-    # Gets the global options currently set for this gem.
-    #
-    # @return [Hash] The options
-    def options
-      @options
-    end
-
-    protected
-
-    def number?(word)
-      word.strip.gsub(@numeric_regex).count > 0
-    end
-
-    def block?(string)
-      string = string.dup
-      return false unless string.is_a?(String)
-      string.gsub!(@numeric_regex, "")
-      return false unless string.length > 1
-      string.strip.scan(/[\w'-]+/).length > 1
-    end
-
-    def block_exists?(word_block)
-      word_block = word_block.dup
-
-      word_block.gsub!(@numeric_regex, "") if options[:ignore_numeric]
-      return false if word_block.nil?
-      word_block.strip! unless word_block.nil?
-      word_block.gsub!(@non_wordchar_regex, " ")
-      word_block.split(@word_regex).uniq.each { |word|
-        return false unless valid_block_word?(word)
-      }
-      return true
-    end
-
-    def valid_word?(word)
-      word = word.dup.downcase
-      exists = dictionary.has_key?(word)
-      exists = dictionary.has_key?(word.singularize) unless exists
-      exists
-    end
-
-    def valid_block_word?(word)
-      return true if word.length == 1
-      valid_word? word.strip
-    end
-
-    private
-
-    def dictionary_path
-      File.expand_path(File.dirname(__FILE__) + '/dictionary')
-    end
-
-    def load
-      File.open(dictionary_path) do |io|
-        io.each { |line| line.chomp!; @dictionary[line] = line }
-      end
-    end
-
-  end
-
-end
+Dir[File.join('.', 'lib/LittleWeasel/**/*.rb')].each do |f|
+  require f
+end

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(dictionary_source: dictionary_path_for(file_name: file_name))
+      elsif dictionary_memory_source
+        dictionary_cache_service.add_dictionary_source(dictionary_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