hanami 2.3.2 → 3.0.0.rc1

data/lib/hanami/settings.rb

@@ -140,8 +140,8 @@ module Hanami
 
         begin
           require slice_settings_require_path
-        rescue LoadError => e
-          raise e unless e.path == slice_settings_require_path
+        rescue LoadError => exception
+          raise exception unless exception.path == slice_settings_require_path
         end
       end
     end
@@ -167,8 +167,8 @@ module Hanami
         else
           public_send("#{name}=", value)
         end
-      rescue => e # rubocop:disable Style/RescueStandardError
-        errs[name] = e
+      rescue => exception # rubocop:disable Style/RescueStandardError
+        errs[name] = exception
       end
 
       raise InvalidSettingsError, errors if errors.any?

data/lib/hanami/slice/router.rb

@@ -23,7 +23,14 @@ module Hanami
       attr_reader :path_prefix
 
       # @api private
-      def initialize(routes:, inflector:, middleware_stack: Routing::Middleware::Stack.new, prefix: ::Hanami::Router::DEFAULT_PREFIX, **kwargs, &blk)
+      def initialize(
+        routes:,
+        inflector:,
+        middleware_stack: Routing::Middleware::Stack.new,
+        prefix: ::Hanami::Router::DEFAULT_PREFIX,
+        **kwargs,
+        &blk
+      )
         @path_prefix = Hanami::Router::Prefix.new(prefix)
         @inflector = inflector
         @middleware_stack = middleware_stack
@@ -233,22 +240,20 @@ module Hanami
 
         def route_suffix(suffix)
           return suffix.sub(LEADING_ID_REGEX, "") if suffix && singular?
+
           suffix
         end
         LEADING_ID_REGEX = %r{\A/:id}
 
         def key_path_base
-          @key_path_base ||=
-            if @options[:to]
-              @options[:to]
+          @key_path_base ||= @options[:to] || begin
+            if @resource_scope.any?
+              prefix = @resource_scope.join(CONTAINER_KEY_DELIMITER)
+              "#{prefix}#{CONTAINER_KEY_DELIMITER}#{@name}"
             else
-              @name.to_s.then { |name|
-                next name unless @resource_scope.any?
-
-                prefix = @resource_scope.join(CONTAINER_KEY_DELIMITER)
-                "#{prefix}#{CONTAINER_KEY_DELIMITER}#{name}"
-              }
+              @name.to_s
             end
+          end
         end
 
         def route_name(action, prefix)

data/lib/hanami/slice.rb

@@ -46,7 +46,6 @@ module Hanami
       end
     end
 
-    # rubocop:disable Metrics/ModuleLength
     module ClassMethods
       # Returns the slice's parent.
       #
@@ -797,12 +796,24 @@ module Hanami
       #
       #   @return [Array] the three-element Rack response array
       #
+      #   @raise [Hanami::NoRoutesDefinedError] if the hanami-router gem is missing or
+      #   no routes are defined.
+      #
       #   @see #rack_app
       #
       #   @api public
       #   @since 2.0.0
       def call(...)
-        rack_app.call(...)
+        if rack_app
+          rack_app.call(...)
+        else
+          error_message = if Hanami.bundled?("hanami-router")
+                            "Could not handle this rack request because no routes are defined"
+                          else
+                            "Could not handle this rack request because the hanami router gem is missing, please add it"
+                          end
+          raise NoRoutesDefinedError, error_message
+        end
       end
 
       private
@@ -893,10 +904,27 @@ module Hanami
         container.config.provider_dirs = [File.join("config", "providers")]
         container.config.registrations_dir = File.join("config", "registrations")
 
+        container.config.component_dirs.memoize = memoize_policy
+
         container.config.env = config.env
         container.config.inflector = config.inflector
       end
 
+      def memoize_policy
+        # Do not memoize components in the test env, so they can be stubbed if required.
+        return false if config.env == :test
+
+        no_memoize = config.no_memoize
+
+        if no_memoize.respond_to?(:call)
+          ->(component) { !no_memoize.call(component) }
+        elsif no_memoize.is_a?(Array) && no_memoize.any?
+          ->(component) { !component.key.start_with?(*no_memoize) }
+        else
+          true
+        end
+      end
+
       def prepare_container_component_dirs
         return unless root.directory?
 
@@ -935,6 +963,7 @@ module Hanami
         )
       end
 
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def prepare_container_providers
         # Check here for the `routes` definition only, not `router` itself, because the
         # `router` requires the slice to be prepared before it can be loaded, and at this
@@ -956,19 +985,39 @@ module Hanami
 
           if register_db_provider?
             # Only register providers if the user hasn't provided their own
-            if !container.providers[:db]
+            unless container.providers[:db]
               register_provider(:db, namespace: true, source: Providers::DB)
             end
 
-            if !container.providers[:relations]
+            unless container.providers[:relations]
               register_provider(:relations, namespace: true, source: Providers::Relations)
             end
           end
         end
+
+        if Hanami.bundled?("i18n")
+          require_relative "providers/i18n"
+
+          if register_i18n_provider? && !container.providers[:i18n]
+            register_provider(:i18n, source: Providers::I18n)
+          end
+        end
+
+        if Hanami.bundled?("hanami-mailer")
+          # Explicit require here to ensure the provider source registers itself, to allow the
+          # user to configure it within their own concrete provider file.
+          require_relative "providers/mailers"
+
+          # Only register the provider if the user hasn't provided their own.
+          unless container.providers[:mailers]
+            register_provider(:mailers, namespace: true, source: Providers::Mailers)
+          end
+        end
       end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
       def prepare_autoloader
-        autoloader.tag = "hanami.slices.#{slice_name.to_s}"
+        autoloader.tag = "hanami.slices.#{slice_name}"
 
         # Component dirs are automatically pushed to the autoloader by dry-system's zeitwerk plugin.
         # This method adds other dirs that are not otherwise configured as component dirs.
@@ -1009,19 +1058,20 @@ module Hanami
           begin
             require_relative "./routes"
             require routes_require_path
-          rescue LoadError => e
-            raise e unless e.path == routes_require_path
+          rescue LoadError => exception
+            raise exception unless exception.path == routes_require_path
           end
         end
 
         begin
           routes_class = namespace.const_get(ROUTES_CLASS_NAME)
           routes_class.routes
-        rescue NameError => e
-          raise e unless e.name == ROUTES_CLASS_NAME.to_sym
+        rescue NameError => exception
+          raise exception unless exception.name == ROUTES_CLASS_NAME.to_sym
         end
       end
 
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def load_router(inspector:)
         return unless routes
 
@@ -1065,7 +1115,7 @@ module Hanami
             use(Hanami::Webconsole::Middleware, config)
           end
 
-          if Hanami.bundled?("hanami-controller")
+          if Hanami.bundled?("hanami-action")
             if config.actions.method_override
               require "rack/method_override"
               use(Rack::MethodOverride)
@@ -1088,6 +1138,7 @@ module Hanami
           middleware_stack.update(config.middleware_stack)
         end
       end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
       def render_errors?
         config.render_errors
@@ -1111,6 +1162,16 @@ module Hanami
         source_path.join("assets").directory?
       end
 
+      # Ensures an i18n provider is available in every slice.
+      #
+      # For the app, this will always be a standalone provider. For slices, this will be a
+      # standalone provider unless the slice is configured to share the app's "i18n" component.
+      def register_i18n_provider?
+        return true if self == app
+
+        !config.shared_app_component_keys.include?("i18n")
+      end
+
       def register_db_provider?
         concrete_db_provider? ||
           db_config_dir? ||
@@ -1143,6 +1204,5 @@ module Hanami
 
       # rubocop:enable Metrics/AbcSize
     end
-    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/hanami/slice_registrar.rb

@@ -108,8 +108,8 @@ module Hanami
       slice_class =
         begin
           inflector.constantize("#{slice_module_name(slice_name)}#{MODULE_DELIMITER}Slice")
-        rescue NameError => e
-          raise e unless e.name.to_s == inflector.camelize(slice_name) || e.name.to_s == :Slice
+        rescue NameError => exception
+          raise exception unless exception.name.to_s == inflector.camelize(slice_name) || exception.name.to_s == :Slice
         end
 
       register(slice_name, slice_class)

data/lib/hanami/universal_logger.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Hanami
+  # An adapter that optionally wraps the logger configured for a Hanami app. Ensures that both
+  # structured and tagged logging can be used across the Hanami framework.
+  #
+  # Provides `.call` as its main entrypoint, expecting a logger object. If a compatible logger is
+  # given (such as the Dry Logger instance provided by default in Hanami apps), then that logger is
+  # returned directly and not wrapped.
+  #
+  # If a non-compatible logger is given, then it will be wrapped by an instance of UniversalLogger,
+  # which adapts a structured and tagged logging API to the given logger.
+  #
+  # This leads to two levels of logger enhancement:
+  #
+  # 1. Structured-capable loggers (accepts keyword arguments, but no `#tagged` method): tags are are
+  #    provided as a `:tags` keyword argument when logging.
+  # 2. Legacy loggers (such as the Ruby standard `Logger`, no keyword arguments, no `#tagged`
+  #    method): messages are logged as JSON, with tags under a `"tags"` key.
+  #
+  # This adapter is used for all loggers configured in Hanami apps.
+  #
+  # @api public
+  # @since x.x.x
+  class UniversalLogger
+    class << self
+      # Wrap a logger if needed, or return it as-is if fully compatible.
+      #
+      # @param logger [Object] the logger to wrap
+      # @return [Object, UniversalLogger] the original logger or wrapped logger
+      #
+      # @api private
+      def call(logger)
+        return logger if compatible_logger?(logger)
+
+        new(logger)
+      end
+
+      # @api private
+      alias_method :[], :call
+
+      # @api private
+      def compatible_logger?(logger)
+        structured_logger?(logger) && tagged_logger?(logger)
+      end
+
+      # @api private
+      def tagged_logger?(logger)
+        logger.respond_to?(:tagged)
+      end
+
+      # @api private
+      def structured_logger?(logger)
+        logger.respond_to?(:info) &&
+          logger.method(:info).parameters.any? { |(type, _)| type == :keyrest }
+      end
+    end
+
+    # @api public
+    # @since x.x.x
+    attr_reader :logger
+
+    # @api private
+    def initialize(logger)
+      @logger = logger
+      @structured_logger = self.class.structured_logger?(logger)
+      @tags_thread_key = :"hanami_universal_logger_tags_#{object_id}"
+    end
+
+    # @api private
+    LOG_LEVEL_METHODS = %i[debug info warn error fatal unknown].freeze
+    private_constant :LOG_LEVEL_METHODS
+
+    # @!method debug(message = nil, **payload, &blk)
+    #   Logs a debug message.
+    #
+    #   @param message [String, nil] the log message
+    #   @param payload [Hash] structured data to include in the log entry
+    #   @yieldreturn [Hash] additional payload data to merge
+    #   @return [void]
+    #
+    #   @api public
+    #   @since x.x.x
+
+    # @!method info(message = nil, **payload, &blk)
+    #   Logs an info message.
+    #
+    #   @param message [String, nil] the log message
+    #   @param payload [Hash] structured data to include in the log entry
+    #   @yieldreturn [Hash] additional payload data to merge
+    #   @return [void]
+    #   @api public
+    #   @since x.x.x
+
+    # @!method warn(message = nil, **payload, &blk)
+    #   Logs a warning message.
+    #
+    #   @param message [String, nil] the log message
+    #   @param payload [Hash] structured data to include in the log entry
+    #   @yieldreturn [Hash] additional payload data to merge
+    #   @return [void]
+    #
+    #   @api public
+    #   @since x.x.x
+
+    # @!method error(message = nil, **payload, &blk)
+    #   Logs an error message.
+    #
+    #   @param message [String, nil] the log message
+    #   @param payload [Hash] structured data to include in the log entry
+    #   @yieldreturn [Hash] additional payload data to merge
+    #   @return [void]
+    #
+    #   @api public
+    #   @since x.x.x
+
+    # @!method fatal(message = nil, **payload, &blk)
+    #   Logs a fatal message.
+    #
+    #   @param message [String, nil] the log message
+    #   @param payload [Hash] structured data to include in the log entry
+    #   @yieldreturn [Hash] additional payload data to merge
+    #   @return [void]
+    #
+    #   @api public
+    #   @since x.x.x
+
+    # @!method unknown(message = nil, **payload, &blk)
+    #   Logs a message with unknown severity.
+    #
+    #   @param message [String, nil] the log message
+    #   @param payload [Hash] structured data to include in the log entry
+    #   @yieldreturn [Hash] additional payload data to merge
+    #   @return [void]
+    #
+    #   @api public
+    #   @since x.x.x
+
+    LOG_LEVEL_METHODS.each do |level|
+      define_method(level) do |message = nil, **payload, &blk|
+        _log(level, message, payload, &blk)
+      end
+    end
+
+    # @api public
+    # @since x.x.x
+    def add(severity, message = nil, progname = nil, &blk)
+      # Convert severity to a level symbol if it's an integer (the standard Logger uses integers).
+      level = _severity_to_level(severity)
+
+      payload = {}
+      payload[:progname] = progname if progname
+
+      _log(level, message, payload, &blk)
+    end
+
+    # @api public
+    # @since x.x.x
+    alias_method :log, :add
+
+    # @api public
+    # @since x.x.x
+    def tagged(*tags)
+      previous_tags = _current_tags
+      self._current_tags = tags
+      begin
+        yield
+      ensure
+        self._current_tags = previous_tags
+      end
+    end
+
+    private
+
+    # Delegates any other methods to the wrapped logger.
+    def method_missing(method, ...)
+      if logger.respond_to?(method)
+        logger.public_send(method, ...)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      logger.respond_to?(method, include_private) || super
+    end
+
+    # Maps a standard Logger severity integer (e.g. 1) to a level name (`:info`).
+    #
+    # We need this be able to support the basic `Logger#log` and `#add` methods in addition to the
+    # named severity methods.
+    def _severity_to_level(severity)
+      return severity if severity.is_a?(Symbol)
+
+      SEVERITY_MAP.fetch(severity, :unknown)
+    end
+
+    SEVERITY_MAP = {
+      0 => :debug,   # Logger::DEBUG
+      1 => :info,    # Logger::INFO
+      2 => :warn,    # Logger::WARN
+      3 => :error,   # Logger::ERROR
+      4 => :fatal,   # Logger::FATAL
+      5 => :unknown  # Logger::UNKNOWN
+    }.freeze
+    private_constant :SEVERITY_MAP
+
+    def _log(level, message, payload, &blk)
+      if @structured_logger
+        _log_structured(level, message, payload, &blk)
+      else
+        _log_json(level, message, payload, &blk)
+      end
+    end
+
+    def _log_structured(method, message, payload)
+      payload = payload.merge(yield) if block_given?
+
+      tags = _current_tags
+      payload[:tags] = tags if tags && !tags.empty?
+
+      logger.public_send(method, message, **payload)
+    end
+
+    def _log_json(method, message, payload)
+      json_data =
+        if block_given?
+          yield
+        else
+          payload[:message] = message if message
+          payload
+        end
+
+      tags = _current_tags
+      json_data[:tags] = tags if tags && !tags.empty?
+
+      logger.public_send(method, JSON.generate(json_data))
+    end
+
+    def _current_tags
+      Thread.current[@tags_thread_key]
+    end
+
+    def _current_tags=(tags)
+      Thread.current[@tags_thread_key] = tags
+    end
+  end
+end

data/lib/hanami/version.rb

@@ -7,7 +7,7 @@ module Hanami
   # @api private
   module Version
     # @api public
-    VERSION = "2.3.2"
+    VERSION = "3.0.0.rc1"
 
     # @since 0.9.0
     # @api private

data/lib/hanami/web/rack_logger.rb

@@ -56,87 +56,10 @@ module Hanami
         end
       end
 
-      # @since 2.1.0
-      # @api private
-      class UniversalLogger
-        class << self
-          # @since 2.1.0
-          # @api private
-          def call(logger)
-            return logger if compatible_logger?(logger)
-
-            new(logger)
-          end
-
-          # @since 2.1.0
-          # @api private
-          alias_method :[], :call
-
-          private
-
-          def compatible_logger?(logger)
-            logger.respond_to?(:tagged) && accepts_entry_payload?(logger)
-          end
-
-          def accepts_entry_payload?(logger)
-            logger.method(:info).parameters.any? { |(type, _)| type == :keyrest }
-          end
-        end
-
-        # @since 2.1.0
-        # @api private
-        attr_reader :logger
-
-        # @since 2.1.0
-        # @api private
-        def initialize(logger)
-          @logger = logger
-        end
-
-        # @since 2.1.0
-        # @api private
-        def tagged(*, &blk)
-          blk.call
-        end
-
-        # Logs the entry as JSON.
-        #
-        # This ensures a reasonable (and parseable) representation of our log payload structures for
-        # loggers that are configured to wholly replace Hanami's default logger.
-        #
-        # @since 2.1.0
-        # @api private
-        def info(message = nil, **payload, &blk)
-          logger.info do
-            if blk
-              JSON.generate(blk.call)
-            else
-              payload[:message] = message if message
-              JSON.generate(payload)
-            end
-          end
-        end
-
-        # @see info
-        #
-        # @since 2.1.0
-        # @api private
-        def error(message = nil, **payload, &blk)
-          logger.error do
-            if blk
-              JSON.generate(blk.call)
-            else
-              payload[:message] = message if message
-              JSON.generate(payload)
-            end
-          end
-        end
-      end
-
       # @api private
       # @since 2.0.0
       def initialize(logger, env: :development)
-        @logger = UniversalLogger[logger]
+        @logger = Hanami::UniversalLogger[logger]
         extend(Development) if %i[development test].include?(env)
       end
 
@@ -157,7 +80,6 @@ module Hanami
       # @since 2.0.0
       def log_request(env, status, elapsed)
         logger.tagged(:rack) do
-
           logger.info do
             data(env, status: status, elapsed: elapsed)
           end
@@ -189,7 +111,7 @@ module Hanami
           length: extract_content_length(env),
           params: env.fetch(ROUTER_PARAMS, EMPTY_PARAMS),
           elapsed: elapsed,
-          elapsed_unit: MICROSECOND,
+          elapsed_unit: MICROSECOND
         }
       end