LittleWeasel 3.0.4 → 4.0.0

data/lib/LittleWeasel/modules/configurable.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module LittleWeasel
+  module Modules
+    # This module provides convienience methods for accessing this gem's
+    # configuration.
+    module Configurable
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # class method inclusions for convenience.
+      module ClassMethods
+        def config
+          LittleWeasel.configuration
+        end
+      end
+
+      private
+
+      def config
+        @config ||= self.class.config
+      end
+    end
+  end
+end

data/lib/LittleWeasel/modules/deep_dup.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module LittleWeasel
+  module Modules
+    # This module simply includes ActiveSupport's core for #deep_dup support. If
+    # we ever want to roll our own, we can do so here.
+    module DeepDup
+      require 'active_support/core_ext/object/deep_dup'
+    end
+  end
+end

data/lib/LittleWeasel/modules/dictionary_cache_keys.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module LittleWeasel
+  module Modules
+    # This module provides methods and constants used to define, initialize
+    # and manipulate a dictionary cache Hash object.
+    module DictionaryCacheKeys
+      DICTIONARY_CACHE = 'dictionary_cache'
+      DICTIONARY_REFERENCES = 'dictionary_references'
+      DICTIONARY_ID = 'dictionary_id'
+      DICTIONARIES = 'dictionaries'
+      SOURCE = 'source'
+      DICTIONARY_OBJECT = 'dictionary_object'
+
+      module_function
+
+      def initialize_dictionary_cache(dictionary_cache:)
+        dictionary_cache.each_key { |key| dictionary_cache.delete(key) }
+        dictionary_cache[DICTIONARY_CACHE] = initialized_dictionary_cache(include_root: false)
+        dictionary_cache
+      end
+
+      def initialized_dictionary_cache(include_root: true)
+        dictionary_cache = {
+          DICTIONARY_REFERENCES => {},
+          DICTIONARIES => {}
+        }
+        return { DICTIONARY_CACHE => dictionary_cache } if include_root
+
+        dictionary_cache
+      end
+    end
+  end
+end

data/lib/LittleWeasel/modules/dictionary_cache_servicable.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../dictionary_key'
+require_relative '../services/dictionary_cache_service'
+require_relative 'dictionary_cache_validatable'
+
+module LittleWeasel
+  module Modules
+    # This module defines methods and attributes to consume the dictionary
+    # cache service.
+    module DictionaryCacheServicable
+      include DictionaryKeyable
+      include DictionaryCacheValidatable
+
+      attr_reader :dictionary_cache, :dictionary_key
+
+      def dictionary_cache_service
+        Services::DictionaryCacheService.new(dictionary_key: dictionary_key, dictionary_cache: dictionary_cache)
+      end
+
+      private
+
+      attr_writer :dictionary_cache, :dictionary_key
+    end
+  end
+end

data/lib/LittleWeasel/modules/dictionary_cache_validatable.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module LittleWeasel
+  module Modules
+    # This module provides methods to validate a dictionary cache object.
+    # A dictionary cache object is a container that holds cached data
+    # related to one or more dictionaries. Dictionary cache objects are
+    # normally specific to a DictionaryManager object.
+    module DictionaryCacheValidatable
+      def self.validate(dictionary_cache:)
+        raise ArgumentError, "Argument dictionary_cache is not a valid Hash object: #{dictionary_cache.class}" \
+          unless dictionary_cache.is_a? Hash
+      end
+
+      def validate_dictionary_cache(dictionary_cache:)
+        DictionaryCacheValidatable.validate dictionary_cache: dictionary_cache
+      end
+    end
+  end
+end

data/lib/LittleWeasel/modules/dictionary_creator_servicable.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../dictionary_key'
+require_relative '../services/dictionary_cache_service'
+require_relative '../filters/word_filters_validatable'
+
+module LittleWeasel
+  module Modules
+    # This module defines methods and attributes to consume the dictionary
+    # creator service.
+    module DictionaryCreatorServicable
+      include DictionaryKeyable
+      include Filters::WordFiltersValidatable
+
+      attr_reader :dictionary_cache, :dictionary_key, :word_filters
+
+      def dictionary_creator_service
+        Services::DictionaryCreatorService.new(dictionary_key: dictionary_key, dictionary_cache: dictionary_cache,
+          dictionary_metadata: dictionary_metadata, word_filters: word_filters)
+      end
+
+      private
+
+      attr_writer :dictionary_cache, :dictionary_key, :word_filters
+    end
+  end
+end

data/lib/LittleWeasel/modules/dictionary_file_loader.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative '../errors/dictionary_file_already_loaded_error'
+require_relative '../errors/dictionary_file_empty_error'
+require_relative '../errors/dictionary_file_not_found_error'
+require_relative '../errors/dictionary_file_too_large_error'
+
+module LittleWeasel
+  module Modules
+    # Defines methods to load dictionaries. The dictionary file path is used
+    # as a key to avoid loading the same dictionary multiple times.
+    module DictionaryFileLoader
+      def load(dictionary_file_path)
+        Loader.new(dictionary_file_path, config).load
+      end
+
+      # Helps with dictionary loading.
+      class Loader
+        def initialize(dictionary_file_path, config)
+          self.dictionary_file_path = dictionary_file_path
+          self.config = config
+        end
+
+        # Loads but DOES NOT update the dictionaries_hash. Use this if the dictionary
+        # DOES NOT need to hang around for any length of time.
+        def load
+          raise Errors::DictionaryFileNotFoundError unless file_exist?
+          raise Errors::DictionaryFileEmptyError if file_empty?
+          raise Errors::DictionaryFileTooLargeError if file_too_large?
+
+          load_dictionary
+        end
+
+        private
+
+        attr_accessor :config, :dictionary_file_path, :dictionary_words
+
+        def load_dictionary
+          prepare_dictionary(File.read(dictionary_file_path, mode: 'r')&.split)
+        end
+
+        def prepare_dictionary(words)
+          words&.uniq!&.compact!
+          words if words.present?
+        end
+
+        def file_size
+          # File.size? returns nil if file_name doesn't exist or has zero size,
+          # the size of the file otherwise.
+          @file_size ||= File.size?(dictionary_file_path) || 0
+        end
+
+        def file_exist?
+          @file_exist ||= File.exist? dictionary_file_path
+        end
+
+        def file_empty?
+          @file_empty ||= file_exist? && file_size.zero?
+        end
+
+        def file_too_large?
+          @file_too_large ||= file_exist? && file_size > config.max_dictionary_file_bytes
+        end
+      end
+    end
+  end
+end

data/lib/LittleWeasel/modules/dictionary_key_validatable.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../dictionary_key'
+
+module LittleWeasel
+  module Modules
+    # Provides methods to validate a dictionary key object.
+    module DictionaryKeyValidatable
+      def self.validate(dictionary_key:)
+        raise ArgumentError, "Argument dictionary_key is not a valid DictionaryKey object: #{dictionary_key.class}" \
+          unless dictionary_key.is_a? DictionaryKey
+      end
+
+      def validate_dictionary_key(dictionary_key:)
+        DictionaryKeyValidatable.validate(dictionary_key: dictionary_key)
+      end
+    end
+  end
+end

data/lib/LittleWeasel/modules/dictionary_keyable.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/delegation'
+require_relative 'dictionary_key_validatable'
+
+module LittleWeasel
+  module Modules
+    # This module defines attributes and functionality for a dictionary
+    # key. A dictionary key is a unique key (basically a locale and optional
+    # tag suffix) that is used to link a dictionary to the dictionary cache
+    # and dictionary metadata objects.
+    module DictionaryKeyable
+      include Modules::DictionaryKeyValidatable
+
+      attr_reader :dictionary_key
+
+      delegate :key, to: :dictionary_key
+
+      private
+
+      attr_writer :dictionary_key
+    end
+  end
+end

data/lib/LittleWeasel/modules/dictionary_loader_servicable.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../dictionary_key'
+require_relative '../services/dictionary_loader_service'
+require_relative 'dictionary_cache_validatable'
+
+module LittleWeasel
+  module Modules
+    # This module defines methods and attributes to consume the dictionary
+    # loader service.
+    module DictionaryLoaderServicable
+      include DictionaryCacheValidatable
+      include DictionaryKeyable
+
+      attr_reader :dictionary_cache, :dictionary_key, :dictionary_metadata
+
+      def dictionary_loader_service
+        Services::DictionaryLoaderService.new(dictionary_key: dictionary_key, dictionary_cache: dictionary_cache,
+          dictionary_metadata: dictionary_metadata)
+      end
+
+      private
+
+      attr_writer :dictionary_cache, :dictionary_key, :dictionary_metadata
+    end
+  end
+end

data/lib/LittleWeasel/modules/dictionary_metadata_servicable.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../dictionary_key'
+require_relative '../services/dictionary_metadata_service'
+require_relative 'dictionary_cache_validatable'
+require_relative 'dictionary_metadata_validatable'
+
+module LittleWeasel
+  module Modules
+    # This module defines methods and attributes to consume the dictionary
+    # metadata service.
+    module DictionaryMetadataServicable
+      include DictionaryKeyable
+      include DictionaryCacheValidatable
+      include DictionaryMetadataValidatable
+
+      attr_reader :dictionary_cache, :dictionary_key, :dictionary_metadata
+
+      def dictionary_metadata_service
+        Services::DictionaryMetadataService.new(dictionary_key: dictionary_key, dictionary_cache: dictionary_cache,
+          dictionary_metadata: dictionary_metadata)
+      end
+
+      private
+
+      attr_writer :dictionary_cache, :dictionary_key, :dictionary_metadata
+    end
+  end
+end

data/lib/LittleWeasel/modules/dictionary_metadata_validatable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module LittleWeasel
+  module Modules
+    # This module provides methods to validate a dictionary metadata object.
+    module DictionaryMetadataValidatable
+      def self.validate(dictionary_metadata:)
+        raise ArgumentError, "Argument dictionary_metadata is not a valid Hash object: #{dictionary_metadata.class}" \
+          unless dictionary_metadata.is_a? Hash
+      end
+
+      def validate_dictionary_metadata(dictionary_metadata:)
+        DictionaryMetadataValidatable.validate dictionary_metadata: dictionary_metadata
+      end
+    end
+  end
+end

data/lib/LittleWeasel/modules/dictionary_sourceable.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module LittleWeasel
+  module Modules
+    # This module provides methods to manage dictionary sources.
+    module DictionarySourceable
+      MEMORY_SOURCE = '*'
+
+      module_function
+
+      def file_source?(source)
+        !memory_source? source
+      end
+
+      def memory_source?(source)
+        source =~ /^#{Regexp.quote(MEMORY_SOURCE)}[0-9a-fA-F]{8}$/
+      end
+
+      def memory_source
+        "#{MEMORY_SOURCE}#{SecureRandom.uuid[0..7]}"
+      end
+    end
+  end
+end

data/lib/LittleWeasel/modules/dictionary_validatable.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module LittleWeasel
+  module Modules
+    # This module provides validations related to dictionaries in
+    # the dictionary cache.
+    module DictionaryValidatable
+      module_function
+
+      def validate_dictionary_source_does_not_exist(dictionary_cache_service:)
+        # If a dictionary_reference exists, the dictionary_source must exist.
+        if dictionary_cache_service.dictionary_reference?
+          raise "The dictionary source associated with key '#{dictionary_cache_service.key}' already exists."
+        end
+      end
+
+      def validate_dictionary_does_not_exist(dictionary_cache_service:)
+        if dictionary_cache_service.dictionary_exists?
+          raise "The dictionary associated with key '#{dictionary_cache_service.key}' already exists."
+        end
+      end
+
+      def validate_dictionary_reference_does_not_exist(dictionary_cache_service:)
+        if dictionary_cache_service.dictionary_reference?
+          raise "A dictionary reference associated with key '#{dictionary_cache_service.key}' already exists."
+        end
+      end
+    end
+  end
+end

data/lib/LittleWeasel/modules/language.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module LittleWeasel
+  module Modules
+    # Provides methods for normalizing language for a locale.
+    module Language
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # class method inclusions for convenience.
+      module ClassMethods
+        def normalize_language(language)
+          language&.downcase
+        end
+      end
+
+      def normalize_language
+        self.class.normalize_language language
+      end
+    end
+  end
+end

data/lib/LittleWeasel/modules/language_validatable.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module LittleWeasel
+  module Modules
+    # This module provides methods to validate a language.
+    module LanguageValidatable
+      def self.validate(language:)
+        raise ArgumentError, "Argument language '#{language}' is not a Symbol." unless language.is_a? Symbol
+      end
+
+      def validate_language(language:)
+        LanguageValidatable.validate language: language
+      end
+    end
+  end
+end