stannum 0.1.0 → 0.3.0

data/lib/stannum/messages/default_loader.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'sleeping_king_studios/tools/toolbelt'
+require 'yaml'
+
+require 'stannum/messages'
+
+module Stannum::Messages
+  # Loads and parses messages configuration files and merges configuration data.
+  class DefaultLoader
+    # @param file_paths [Array<String>] The directories from which to load the
+    #   configuration files.
+    # @param locale [String] The name of the locale for which to load
+    #   configuration.
+    def initialize(file_paths:, locale: 'en')
+      @file_paths = file_paths
+      @locale     = locale
+    end
+
+    # @return [Array<String>] the directories from which to load the
+    #   configuration files.
+    attr_reader :file_paths
+
+    # @return [String] the name of the locale for which to load configuration.
+    attr_reader :locale
+
+    # Loads and parses each file, then deep merges the data from each file.
+    #
+    # The configuration file should be either a Ruby file or a YAML file, with
+    # the filename of the format locale.extname, e.g. en.rb or en-gb.yml, and
+    # located in one of the directories defined in #file_paths.
+    #
+    # The contents of each file should be either a Ruby Hash or a YAML document
+    # containing an associative array, with a single key equal to the locale.
+    # The value of the key must be a Hash or associative array, which contains
+    # the scoped messages to load.
+    #
+    # Each file is read in order and parsed into a Hash. Each hash is then deep
+    # merged in sequence, with nested hashes merged together instead of
+    # overwritten.
+    #
+    # @return [Hash<Symbol, Object>] the merged configuration data.
+    def call
+      file_paths.reduce({}) do |config, file_path|
+        loaded = load_configuration_file(file_path)
+
+        deep_update(config, loaded)
+      end
+    end
+    alias load call
+
+    private
+
+    def deep_update(original, target)
+      target.each do |key, value|
+        if original[key].is_a?(Hash) && value.is_a?(Hash)
+          deep_update(original[key], value)
+        else
+          original[key] = value
+        end
+      end
+
+      original
+    end
+
+    def load_configuration_file(file_path)
+      ruby_file = File.join(file_path, "#{locale}.rb")
+
+      return read_ruby_file(ruby_file) if File.exist?(ruby_file)
+
+      yaml_file = File.join(file_path, "#{locale}.yml")
+
+      return read_yaml_file(yaml_file) if File.exist?(yaml_file)
+
+      {}
+    end
+
+    def read_ruby_file(filename)
+      ruby = File.read(filename)
+
+      eval(ruby, binding, filename) # rubocop:disable Security/Eval
+    end
+
+    def read_yaml_file(filename)
+      raw  = File.read(filename)
+      yaml = YAML.safe_load(raw)
+
+      tools.hsh.convert_keys_to_symbols(yaml)
+    end
+
+    def tools
+      SleepingKingStudios::Tools::Toolbelt.instance
+    end
+  end
+end

data/lib/stannum/messages/default_strategy.rb

@@ -9,16 +9,28 @@ require 'stannum/messages'
 module Stannum::Messages
   # Strategy to generate error messages from gem configuration.
   class DefaultStrategy
+    # The default directories from which to load configured error messages.
+    DEFAULT_LOAD_PATHS = [Stannum::Messages.locales_path].freeze
+
+    # @return [Array<String>] The directories from which to load configured
+    #   error messages.
+    def self.load_paths
+      @load_paths ||= DEFAULT_LOAD_PATHS.dup
+    end
+
     # @param configuration [Hash{Symbol, Object}] The configured messages.
-    # @param load_path [Array<String>] The filenames for the configuration
-    #   file(s).
-    def initialize(configuration: nil, load_path: nil)
-      @load_path     = load_path.nil? ? [default_filename] : Array(load_path)
+    # @param load_paths [Array<String>] The directories from which to load
+    #   configured error messages.
+    # @param locale [String] The locale used to load and scope configured
+    #   messages.
+    def initialize(configuration: nil, load_paths: nil, locale: 'en')
+      @load_paths    = Array(load_paths) unless load_paths.nil?
+      @locale        = locale
       @configuration = configuration
     end
 
-    # @return [Array<String>] the filenames for the configuration file(s).
-    attr_reader :load_path
+    # @return [String] The locale used to load and scope configured messages.
+    attr_reader :locale
 
     # @param error_type [String] The qualified path to the configured error
     #   message.
@@ -34,6 +46,12 @@ module Stannum::Messages
       interpolate_message(message, options)
     end
 
+    # @return [Array<String>] The directories from which to load configured
+    #   error messages.
+    def load_paths
+      @load_paths || self.class.load_paths
+    end
+
     # Reloads the configuration from the configured load_path.
     #
     # This can be useful when the load_path is updated after creating the
@@ -52,23 +70,9 @@ module Stannum::Messages
       @configuration ||= load_configuration
     end
 
-    def deep_merge(source, target)
-      hsh = tools.hash_tools.deep_dup(source)
-
-      target.each do |key, value|
-        hsh[key] = value.is_a?(Hash) ? deep_merge(hsh[key] || {}, value) : value
-      end
-
-      hsh
-    end
-
-    def default_filename
-      File.join(Stannum::Messages.locales_path, 'en.rb')
-    end
-
     def generate_message(error_type, options)
       path = error_type.to_s.split('.').map(&:intern)
-      path.unshift(:en)
+      path.unshift(locale.intern)
 
       message = configuration.dig(*path)
 
@@ -90,35 +94,12 @@ module Stannum::Messages
     end
 
     def load_configuration
-      load_path.reduce({}) do |config, filename|
-        deep_merge(config, read_configuration(filename))
-      end
-    end
-
-    def read_configuration(filename)
-      case File.extname(filename)
-      when '.rb'
-        read_ruby_file(filename)
-      when '.yml'
-        read_yaml_file(filename)
-      else
-        raise "unable to load configuration file #{filename} with extension" \
-              " #{File.extname(filename)}"
-      end
-    end
-
-    def read_ruby_file(filename)
-      eval(File.read(filename), binding, filename) # rubocop:disable Security/Eval
-    end
-
-    def read_yaml_file(filename)
-      tools.hash_tools.convert_keys_to_symbols(
-        YAML.safe_load(File.read(filename))
-      )
-    end
-
-    def tools
-      SleepingKingStudios::Tools::Toolbelt.instance
+      Stannum::Messages::DefaultLoader
+        .new(
+          file_paths: load_paths,
+          locale:     locale
+        )
+        .call
     end
   end
 end

data/lib/stannum/messages.rb

@@ -5,6 +5,7 @@ require 'stannum'
 module Stannum
   # Namespace for generating messages for Stannum::Errors.
   module Messages
+    autoload :DefaultLoader,   'stannum/messages/default_loader'
     autoload :DefaultStrategy, 'stannum/messages/default_strategy'
 
     # @return [String] the absolute path to the configured locales.

data/lib/stannum/rspec/match_errors_matcher.rb

@@ -4,8 +4,8 @@ begin
   require 'rspec/sleeping_king_studios/matchers/core/deep_matcher'
 rescue NameError
   # :nocov:
-  Kernel.warn 'WARNING: RSpec::SleepingKingStudios is a dependency for using' \
-              ' the MatchErrorsMatcher or the #match_errors method.'
+  Kernel.warn 'WARNING: RSpec::SleepingKingStudios is a dependency for using ' \
+              'the MatchErrorsMatcher or the #match_errors method.'
   # :nocov:
 end
 
@@ -40,8 +40,8 @@ module Stannum::RSpec
     # @return [String] a summary message describing a failed expectation.
     def failure_message
       unless errors?
-        return 'expected the errors to match the expected errors, but the' \
-               ' object is not an array or Errors object'
+        return 'expected the errors to match the expected errors, but the ' \
+               'object is not an array or Errors object'
       end
 
       equality_matcher.failure_message
@@ -51,8 +51,8 @@ module Stannum::RSpec
     #   expectation.
     def failure_message_when_negated
       unless errors?
-        return 'expected the errors not to match the expected errors, but the' \
-               ' object is not an array or Errors object'
+        return 'expected the errors not to match the expected errors, but ' \
+               'the object is not an array or Errors object'
       end
 
       equality_matcher.failure_message_when_negated

data/lib/stannum/rspec/validate_parameter_matcher.rb

@@ -6,6 +6,7 @@ rescue NameError
   # Optional dependency.
 end
 
+require 'stannum/constraints/parameters/extra_keywords'
 require 'stannum/rspec'
 require 'stannum/support/coercion'
 
@@ -138,11 +139,11 @@ module Stannum::RSpec
         when :method_does_not_have_parameter
           "##{method_name} does not have a #{parameter_name.inspect} parameter"
         when :parameter_not_validated
-          "##{method_name} does not expect a #{parameter_name.inspect}" \
-          " #{parameter_type}"
+          "##{method_name} does not expect a #{parameter_name.inspect} " \
+          "#{parameter_type}"
         when :valid_parameter_value
-          "#{valid_value.inspect} is a valid value for the" \
-          " #{parameter_name.inspect} #{parameter_type}"
+          "#{valid_value.inspect} is a valid value for the " \
+          "#{parameter_name.inspect} #{parameter_type}"
         end
 
       [message, reason].compact.join(', but ')
@@ -280,20 +281,20 @@ module Stannum::RSpec
       unless @expected_constraint.nil?
         raise RuntimeError,
           '#does_not_match? with #using_constraint is not supported',
-          caller[1..-1]
+          caller[1..]
       end
 
       unless @parameters.nil?
         raise RuntimeError,
           '#does_not_match? with #with_parameters is not supported',
-          caller[1..-1]
+          caller[1..]
       end
 
       return if @parameter_value.nil?
 
       raise RuntimeError,
         '#does_not_match? with #with_value is not supported',
-        caller[1..-1]
+        caller[1..]
     end
 
     def equality_matcher
@@ -313,9 +314,9 @@ module Stannum::RSpec
 
     def extra_parameter?
       extra_arguments_type =
-        Stannum::Contracts::Parameters::ArgumentsContract::EXTRA_ARGUMENTS_TYPE
+        Stannum::Constraints::Parameters::ExtraArguments::TYPE
       extra_keywords_type =
-        Stannum::Contracts::Parameters::KeywordsContract::EXTRA_KEYWORDS_TYPE
+        Stannum::Constraints::Parameters::ExtraKeywords::TYPE
 
       return false unless scoped_errors(indexed: true).any? do |error|
         error[:type] == extra_arguments_type ||

data/lib/stannum/schema.rb

@@ -18,27 +18,6 @@ module Stannum
       @attributes = {}
     end
 
-    # @!method each
-    #   Iterates through the the attributes by name and attribute object.
-    #
-    #   @yieldparam name [String] The name of the attribute.
-    #   @yieldparam attribute [Stannum::Attribute] The attribute object.
-
-    # @!method each_key
-    #   Iterates through the the attributes by name.
-    #
-    #   @yieldparam name [String] The name of the attribute.
-
-    # @!method each_value
-    #   Iterates through the the attributes by attribute object.
-    #
-    #   @yieldparam attribute [Stannum::Attribute] The attribute object.
-
-    def_delegators :attributes,
-      :each,
-      :each_key,
-      :each_value
-
     # Retrieves the named attribute object.
     #
     # @param key [String, Symbol] The name of the requested attribute.
@@ -48,9 +27,17 @@ module Stannum
     # @raise ArgumentError if the key is invalid.
     # @raise KeyError if the attribute is not defined.
     def [](key)
-      validate_key(key)
+      tools.assertions.assert_name(key, as: 'key', error_class: ArgumentError)
+
+      str = -key.to_s
 
-      attributes.fetch(key.to_s)
+      each_ancestor do |ancestor|
+        next unless ancestor.own_attributes.key?(str)
+
+        return ancestor.own_attributes[str]
+      end
+
+      {}.fetch(str)
     end
 
     # rubocop:disable Metrics/MethodLength
@@ -81,33 +68,83 @@ module Stannum
     end
     # rubocop:enable Metrics/MethodLength
 
+    # Iterates through the the attributes by name and attribute object.
+    #
+    # @yieldparam name [String] The name of the attribute.
+    # @yieldparam attribute [Stannum::Attribute] The attribute object.
+    def each(&block)
+      return enum_for(:each) { size } unless block_given?
+
+      each_ancestor do |ancestor|
+        ancestor.own_attributes.each(&block)
+      end
+    end
+
+    # Iterates through the the attributes by name.
+    #
+    # @yieldparam name [String] The name of the attribute.
+    def each_key(&block)
+      return enum_for(:each_key) { size } unless block_given?
+
+      each_ancestor do |ancestor|
+        ancestor.own_attributes.each_key(&block)
+      end
+    end
+
+    # Iterates through the the attributes by attribute object.
+    #
+    # @yieldparam attribute [Stannum::Attribute] The attribute object.
+    def each_value(&block)
+      return enum_for(:each_value) { size } unless block_given?
+
+      each_ancestor do |ancestor|
+        ancestor.own_attributes.each_value(&block)
+      end
+    end
+
     # Checks if the given attribute is defined.
     #
     # @param key [String, Symbol] the name of the attribute to check.
     #
     # @return [Boolean] true if the attribute is defined; otherwise false.
     def key?(key)
-      validate_key(key)
+      tools.assertions.assert_name(key, as: 'key', error_class: ArgumentError)
 
-      attributes.key?(key.to_s)
+      each_ancestor.any? do |ancestor|
+        ancestor.own_attributes.key?(key.to_s)
+      end
     end
     alias has_key? key?
 
+    # Returns the defined attribute keys.
+    #
+    # @return [Array<String>] the attribute keys.
+    def keys
+      each_key.to_a
+    end
+
     # @private
     def own_attributes
       @attributes
     end
 
-    private
+    # @return [Integer] the number of defined attributes.
+    def size
+      each_ancestor.reduce(0) do |memo, ancestor|
+        memo + ancestor.own_attributes.size
+      end
+    end
+    alias count size
 
-    def attributes
-      ancestors
-        .reverse_each
-        .select { |mod| mod.is_a?(Stannum::Schema) }
-        .map(&:own_attributes)
-        .reduce(&:merge)
+    # Returns the defined attribute value.
+    #
+    # @return [Array<Stannum::Attribute>] the attribute values.
+    def values
+      each_value.to_a
     end
 
+    private
+
     def define_reader(attr_name, reader_name)
       define_method(reader_name) { @attributes[attr_name] }
     end
@@ -118,14 +155,18 @@ module Stannum
       end
     end
 
-    def validate_key(key)
-      raise ArgumentError, "key can't be blank" if key.nil?
+    def each_ancestor
+      return enum_for(:each_ancestor) unless block_given?
 
-      unless key.is_a?(String) || key.is_a?(Symbol)
-        raise ArgumentError, 'key must be a String or Symbol'
+      ancestors.reverse_each do |ancestor|
+        break unless ancestor.is_a?(Stannum::Schema)
+
+        yield ancestor
       end
+    end
 
-      raise ArgumentError, "key can't be blank" if key.to_s.empty?
+    def tools
+      SleepingKingStudios::Tools::Toolbelt.instance
     end
   end
 end