hanami 2.3.2 → 3.0.0.rc1

data/lib/hanami/config.rb

@@ -6,7 +6,7 @@ require "dry/configurable"
 require "dry/inflector"
 
 require_relative "constants"
-require_relative "config/console"
+require_relative "universal_logger"
 
 module Hanami
   # Hanami app config
@@ -105,7 +105,9 @@ module Hanami
     # @!attribute [rw] no_auto_register_paths
     #   Sets the paths to skip from container auto-registration.
     #
-    #   Defaults to `["entities"]`.
+    #   Paths are relative to `/app` or a slice root.
+    #
+    #   Defaults to `["db", "entities", "relations", "structs"]`.
     #
     #   @return [Array<String>] array of relative paths
     #
@@ -118,6 +120,36 @@ module Hanami
       "structs"
     ]
 
+    # @!attribute [rw] no_memoize
+    #   Sets the components that should not be memoized in the container.
+    #
+    #   All auto-registered components are memoized by default, meaning each component is resolved
+    #   only once, with the same instance returned on every subsequent resolution.
+    #
+    #   Use this setting to opt specific components out of memoization. It accepts an array of key
+    #   prefixes (strings) for the simple case, or a proc for full control. The proc receives a
+    #   `Dry::System::Component` and should return `true` for components that should _not_ be
+    #   memoized.
+    #
+    #   Individual components can also opt out by adding a `# memoize: false` magic comment at the
+    #   top of their source file.
+    #
+    #   Defaults to `[]` (all components memoized).
+    #
+    #   @example Opt out by key prefix
+    #     config.no_memoize = ["workers", "jobs"]
+    #
+    #   @example Opt out with a proc
+    #     config.no_memoize = ->(component) {
+    #       component.key.start_with?("workers")
+    #     }
+    #
+    #   @return [Array<String>, Proc]
+    #
+    #   @api public
+    #   @since 2.3.0
+    setting :no_memoize, default: []
+
     # @!attribute [rw] base_url
     #   Sets the base URL for app's web server.
     #
@@ -182,7 +214,7 @@ module Hanami
     #   @since 2.1.0
     setting :render_error_responses, default: Hash.new(:internal_server_error).merge!(
       "Hanami::Router::NotAllowedError" => :not_found,
-      "Hanami::Router::NotFoundError" => :not_found,
+      "Hanami::Router::NotFoundError" => :not_found
     )
 
     # @!attribute [rw] console
@@ -220,12 +252,12 @@ module Hanami
     # @since 2.0.0
     attr_reader :env
 
-    # Returns the app's actions config, or a null config if hanami-controller is not bundled.
+    # Returns the app's actions config, or a null config if hanami-action is not bundled.
     #
-    # @example When hanami-controller is bundled
+    # @example When hanami-action is bundled
     #   config.actions.default_request_format # => :html
     #
-    # @example When hanami-controller is not bundled
+    # @example When hanami-action is not bundled
     #   config.actions.default_request_format # => NoMethodError
     #
     # @return [Hanami::Config::Actions, Hanami::Config::NullConfig]
@@ -248,6 +280,20 @@ module Hanami
     # @since 2.2.0
     attr_reader :db
 
+    # Returns the app's i18n config, or a null config if i18n is not bundled.
+    #
+    # @example When i18n is bundled
+    #   config.i18n.default_locale # => :en
+    #
+    # @example When i18n is not bundled
+    #   config.i18n.default_locale # => NoMethodError
+    #
+    # @return [Hanami::Config::I18n, Hanami::Config::NullConfig]
+    #
+    # @api public
+    # @since 2.2.0
+    attr_reader :i18n
+
     # Returns the app's middleware stack, or nil if hanami-router is not bundled.
     #
     # Use this to configure middleware that should apply to all routes.
@@ -320,7 +366,7 @@ module Hanami
       self.render_detailed_errors = (env == :development)
       load_from_env
 
-      @actions = load_dependent_config("hanami-controller") {
+      @actions = load_dependent_config("hanami-action") {
         require_relative "config/actions"
         Actions.new
       }
@@ -332,6 +378,11 @@ module Hanami
 
       @db = load_dependent_config("hanami-db") { DB.new }
 
+      @i18n = load_dependent_config("i18n") {
+        require_relative "config/i18n"
+        I18n.new
+      }
+
       @logger = Config::Logger.new(env: env, app_name: app_name)
 
       @middleware = load_dependent_config("hanami-router") {
@@ -362,6 +413,7 @@ module Hanami
       @actions = source.actions.dup
       @assets = source.assets.dup
       @db = source.db.dup
+      @i18n = source.i18n.dup
       @logger = source.logger.dup
       @middleware = source.middleware.dup
       @router = source.router.dup.tap do |router|
@@ -385,8 +437,6 @@ module Hanami
       logger.finalize!
       router.finalize!
 
-      use_body_parser_middleware
-
       super
     end
 
@@ -434,13 +484,19 @@ module Hanami
     # Sets the app's logger instance.
     #
     # This entirely replaces the default `Dry::Logger::Dispatcher` instance that would have been
+    # configured via {#logger}.
+    #
+    # The provided logger will be wrapped with {Hanami::UniversalLogger} if it doesn't support both
+    # keyword arguments and `#tagged` logging, ensuring compatibility with Hanami's logging
+    # interface.
     #
     # @see #logger_instance
+    # @see Hanami::UniversalLogger
     #
     # @api public
     # @since 2.0.0
     def logger=(logger_instance)
-      @logger_instance = logger_instance
+      @logger_instance = Hanami::UniversalLogger[logger_instance]
     end
 
     # rubocop:enable Style/TrivialAccessors
@@ -484,18 +540,6 @@ module Hanami
       self.slices = ENV["HANAMI_SLICES"]&.split(",")&.map(&:strip)
     end
 
-    DEFAULT_MIDDLEWARE_PARSERS = {
-      form: ["multipart/form-data"],
-      json: ["application/json", "application/vnd.api+json"]
-    }.freeze
-    private_constant :DEFAULT_MIDDLEWARE_PARSERS
-
-    def use_body_parser_middleware
-      return unless Hanami.bundled?("hanami-router") && Hanami.bundled?("hanami-controller")
-
-      middleware.use(:body_parser, [DEFAULT_MIDDLEWARE_PARSERS])
-    end
-
     def load_dependent_config(gem_name)
       if Hanami.bundled?(gem_name)
         yield

data/lib/hanami/errors.rb

@@ -25,6 +25,12 @@ module Hanami
   # @since 2.0.0
   ComponentLoadError = Class.new(Error)
 
+  # Error raised when there are no routes defined.
+  #
+  # @api public
+  # @since 2.4.0
+  NoRoutesDefinedError = Class.new(Error)
+
   # Error raised when unsupported middleware configuration is given.
   #
   # @see Hanami::Slice::Routing::Middleware::Stack#use

data/lib/hanami/extensions/action/slice_configured_action.rb

@@ -118,7 +118,7 @@ module Hanami
         def resolve_paired_view(action_class)
           view_identifiers = actions_config.view_name_inferrer.call(
             action_class_name: action_class.name,
-            slice: slice,
+            slice: slice
           )
 
           view_identifiers.each do |identifier|

data/lib/hanami/extensions/action.rb

@@ -9,7 +9,7 @@ module Hanami
     # Integrated behavior for `Hanami::Action` classes within Hanami apps.
     #
     # @see InstanceMethods
-    # @see https://github.com/hanami/controller
+    # @see https://github.com/hanami/hanami-action
     #
     # @api public
     # @since 2.0.0
@@ -109,7 +109,7 @@ module Hanami
         end
 
         # @api private
-        def view_context_options(request, response) # rubocop:disable Lint:UnusedMethodArgument
+        def view_context_options(request, response)
           {request: request}
         end
 

data/lib/hanami/extensions/mailer/slice_configured_mailer.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Extensions
+    module Mailer
+      # Provides slice-specific configuration and behavior for any mailer class defined within a
+      # slice's module namespace.
+      #
+      # This injects the slice's `"mailers.delivery_method"` component into mailer instances, and
+      # points the mailer's view at a slice-configured view class so that mailer templates behave
+      # like regular Hanami view templates — sharing the slice's view context, parts, scopes and
+      # helpers (including i18n). The only behavior not available to mailer views is
+      # request-related state (`request`/`session`/`flash`/`csrf_token`), since mailers are not
+      # rendered from a request.
+      #
+      # @api private
+      class SliceConfiguredMailer < Module
+        attr_reader :slice
+
+        def initialize(slice)
+          super()
+          @slice = slice
+        end
+
+        def extended(mailer_class)
+          configure_mailer(mailer_class)
+          define_new
+        end
+
+        def inspect
+          "#<#{self.class.name}[#{slice.name}]>"
+        end
+
+        private
+
+        def define_new
+          resolve_delivery_method = method(:resolve_delivery_method)
+
+          define_method(:new) do |**kwargs|
+            super(
+              delivery_method: kwargs.fetch(:delivery_method) { resolve_delivery_method.() },
+              **kwargs
+            )
+          end
+        end
+
+        def resolve_delivery_method
+          slice["mailers.delivery_method"] if slice.key?("mailers.delivery_method")
+        end
+
+        def configure_mailer(mailer_class)
+          return unless Hanami.bundled?("hanami-view")
+
+          # Build the mailer's view from a slice-configured view class, so it inherits the slice's
+          # context, parts, scopes, paths and helpers. The mailer only needs to supply its own
+          # template name.
+          mailer_class.config.view_class = mailer_view_class
+
+          if (template = template_name(mailer_class))
+            mailer_class.config.template = template
+          end
+        end
+
+        # Returns the view class that mailer views are built from, defining a `Mailers::View` within
+        # the slice if one is not already present.
+        #
+        # This mirrors how the view extension defines a `Views::Context`: because the class is
+        # defined within the slice's namespace, it is configured automatically (paths, context,
+        # parts, scopes, helpers) just like any other view in the slice. A user may define their own
+        # `<Slice>::Mailers::View` to customize mailer rendering; it is used when present.
+        def mailer_view_class
+          namespace = mailers_namespace
+
+          if namespace.const_defined?(:View, _inherit = false)
+            namespace.const_get(:View)
+          else
+            namespace.const_set(:View, define_mailer_view)
+          end
+        end
+
+        # Defines and configures a view class for the slice's mailers, inheriting from the slice's
+        # own base view class if present, otherwise from the plain `Hanami::View`.
+        def define_mailer_view
+          superclass =
+            begin
+              slice.inflector.constantize("#{slice.namespace.name}::View")
+            rescue NameError
+              Hanami::View
+            end
+
+          Class.new(superclass).tap { |klass|
+            # Call configure_for_slice explicitly, since this is an anonymous class at this point,
+            # so the slice cannot be inferred from its name.
+            klass.configure_for_slice(slice)
+          }
+        end
+
+        def mailers_namespace
+          if slice.namespace.const_defined?(:Mailers, _inherit = false)
+            slice.namespace.const_get(:Mailers)
+          else
+            slice.namespace.const_set(:Mailers, Module.new)
+          end
+        end
+
+        # Returns the template name for the mailer, retaining the `mailers/` segment from the
+        # mailer's namespace so templates resolve under `templates/mailers/` within the slice.
+        #
+        # For example, `App::Mailers::Welcome` will use template `"mailers/welcome"`.
+        def template_name(mailer_class)
+          return unless mailer_class.name
+
+          slice.inflector
+            .underscore(mailer_class.name)
+            .sub(/^#{slice.slice_name.path}\//, "")
+        end
+      end
+    end
+  end
+end

data/lib/hanami/extensions/mailer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "hanami/mailer"
+require_relative "mailer/slice_configured_mailer"
+
+module Hanami
+  module Extensions
+    # Integrated behavior for `Hanami::Mailer` classes within Hanami apps.
+    #
+    # @api private
+    module Mailer
+      def self.included(mailer_class)
+        super
+
+        mailer_class.extend(Hanami::SliceConfigurable)
+        mailer_class.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def configure_for_slice(slice)
+          extend SliceConfiguredMailer.new(slice)
+        end
+      end
+    end
+  end
+end
+
+Hanami::Mailer.include(Hanami::Extensions::Mailer)

data/lib/hanami/extensions/operation/slice_configured_db_operation.rb

@@ -51,6 +51,7 @@ module Hanami
           attr_reader :rom
 
           def initialize(rom:, **)
+            super()
             @rom = rom
           end
         end
@@ -59,6 +60,7 @@ module Hanami
           attr_reader :slice
 
           def initialize(slice)
+            super()
             @slice = slice
           end
 

data/lib/hanami/extensions/view/context.rb

@@ -25,6 +25,8 @@ module Hanami
             end
 
             views_namespace.const_set(:Context, Class.new(context_superclass(slice)).tap { |klass|
+              # Call configure_for_slice explicitly, since this is an anonymous class at this point,
+              # so the slice cannot be inferred from its name.
               klass.configure_for_slice(slice)
             })
           end
@@ -40,8 +42,8 @@ module Hanami
               slice.inflector.constantize(
                 slice.inflector.camelize("#{slice.app.slice_name.name}/views/context")
               )
-            rescue NameError => e
-              raise e unless %i[Views Context].include?(e.name)
+            rescue NameError => exception
+              raise exception unless %i[Views Context].include?(exception.name)
 
               Hanami::View::Context
             end
@@ -95,17 +97,19 @@ module Hanami
             #
             # @api private
             # @since 2.1.0
-            def initialize( # rubocop:disable Metrics/ParameterLists
+            def initialize(
               inflector: nil,
               routes: nil,
               assets: nil,
               request: nil,
+              i18n: nil,
               **args
             )
               @inflector = inflector
               @routes = routes
               @assets = assets
               @request = request
+              @i18n = i18n
 
               @content_for = {}
 
@@ -157,7 +161,9 @@ module Hanami
             # @since 2.1.0
             def request
               unless @request
-                raise Hanami::ComponentLoadError, "Request not available. Only views rendered from Hanami::Action instances have a request."
+                raise Hanami::ComponentLoadError, <<~STR
+                  Request not available. Only views rendered from Hanami::Action instances have a request.
+                STR
               end
 
               @request
@@ -190,6 +196,22 @@ module Hanami
               @routes
             end
 
+            # Returns the slice's i18n backend.
+            #
+            # @return [Hanami::Providers::I18n::Backend] the i18n backend
+            #
+            # @raise [Hanami::ComponentLoadError] if the i18n gem is not bundled
+            #
+            # @api public
+            # @since x.x.x
+            def i18n
+              unless @i18n
+                raise Hanami::ComponentLoadError, "the i18n gem is required to access translations"
+              end
+
+              @i18n
+            end
+
             # @overload content_for(key, value = nil, &block)
             #   Stores a string or block of template markup for later use.
             #

data/lib/hanami/extensions/view/part.rb

@@ -27,6 +27,8 @@ module Hanami
             extend SliceConfiguredPart.new(slice)
 
             const_set :PartHelpers, Class.new(PartHelpers) { |klass|
+              # Call configure_for_slice explicitly, since this is an anonymous class at this point,
+              # so the slice cannot be inferred from its name.
               klass.configure_for_slice(slice)
             }
           end

data/lib/hanami/extensions/view/slice_configured_context.rb

@@ -39,15 +39,18 @@ module Hanami
         #   - the configured inflector as `inflector`
         #   - "routes" from the app container as `routes`
         #   - "assets" from the app container as `assets`
+        #   - "i18n" from the slice container as `i18n`
         def define_new
           inflector = slice.inflector
           resolve_routes = method(:resolve_routes)
           resolve_assets = method(:resolve_assets)
+          resolve_i18n = method(:resolve_i18n)
 
           define_method :new do |**kwargs|
             kwargs[:inflector] ||= inflector
             kwargs[:routes] ||= resolve_routes.()
             kwargs[:assets] ||= resolve_assets.()
+            kwargs[:i18n] ||= resolve_i18n.()
 
             super(**kwargs)
           end
@@ -60,6 +63,10 @@ module Hanami
         def resolve_assets
           slice["assets"] if slice.key?("assets")
         end
+
+        def resolve_i18n
+          slice["i18n"] if slice.key?("i18n")
+        end
       end
     end
   end

data/lib/hanami/extensions/view/slice_configured_part.rb

@@ -57,6 +57,8 @@ module Hanami
           define_method(:new) do |**args|
             return super(**args) if args.key?(:rendering)
 
+            # Call configure_for_slice explicitly, since this is an anonymous class at this point,
+            # so the slice cannot be inferred from its name.
             slice_rendering = Class.new(Hanami::View)
               .configure_for_slice(slice)
               .new

data/lib/hanami/extensions/view/slice_configured_view.rb

@@ -49,12 +49,12 @@ module Hanami
 
           begin
             slice.app.namespace.const_get(:View, false)
-          rescue NameError => e
-            raise unless e.name == :View
+          rescue NameError => exception
+            raise unless exception.name == :View
           end
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def configure_view(view_class)
           view_class.settings.each do |setting|
             next unless slice.config.views.respond_to?(setting.name)
@@ -134,7 +134,7 @@ module Hanami
             view_class.config.scope_namespace = scope_namespace
           end
         end
-        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def define_inherited
           template_name = method(:template_name)
@@ -185,8 +185,8 @@ module Hanami
               views_namespace.const_get(:Part)
             else
               views_namespace.const_set(:Part, Class.new(part_superclass).tap { |klass|
-                # Give the slice to `configure_for_slice`, since it cannot be inferred when it is
-                # called via `.inherited`, because the class is anonymous at this point
+                # Call configure_for_slice explicitly, since this is an anonymous class at this point,
+                # so the slice cannot be inferred from its name.
                 klass.configure_for_slice(slice)
               })
             end
@@ -208,8 +208,8 @@ module Hanami
               views_namespace.const_get(:Scope)
             else
               views_namespace.const_set(:Scope, Class.new(scope_superclass).tap { |klass|
-                # Give the slice to `configure_for_slice`, since it cannot be inferred when it is
-                # called via `.inherited`, since the class is anonymous at this point
+                # Call configure_for_slice explicitly, since this is an anonymous class at this point,
+                # so the slice cannot be inferred from its name.
                 klass.configure_for_slice(slice)
               })
             end

data/lib/hanami/extensions/view/standard_helpers.rb

@@ -16,6 +16,10 @@ module Hanami
         if Hanami.bundled?("hanami-assets")
           include Helpers::AssetsHelper
         end
+
+        if Hanami.bundled?("i18n")
+          include Helpers::I18nHelper
+        end
       end
     end
   end

data/lib/hanami/extensions.rb

@@ -4,7 +4,7 @@ if Hanami.bundled?("hanami-db")
   require_relative "extensions/db/repo"
 end
 
-if Hanami.bundled?("hanami-controller")
+if Hanami.bundled?("hanami-action")
   require_relative "extensions/action"
 end
 
@@ -20,6 +20,11 @@ if Hanami.bundled?("hanami-router")
   require_relative "extensions/router/errors"
 end
 
+if Hanami.bundled?("hanami-mailer")
+  require "hanami/mailer"
+  require_relative "extensions/mailer"
+end
+
 if Hanami.bundled?("dry-operation")
   require_relative "extensions/operation"
 end

data/lib/hanami/helpers/assets_helper.rb

@@ -4,8 +4,6 @@ require "uri"
 require "hanami/view"
 require_relative "../constants"
 
-# rubocop:disable Metrics/ModuleLength
-
 module Hanami
   module Helpers
     # HTML assets helpers
@@ -804,5 +802,3 @@ module Hanami
     end
   end
 end
-
-# rubocop:enable Metrics/ModuleLength

data/lib/hanami/helpers/form_helper.rb

@@ -32,7 +32,7 @@ module Hanami
 
       # CSRF Token session key
       #
-      # This name of this key is shared with the hanami and hanami-controller gems.
+      # This name of this key is shared with the hanami and hanami-action gems.
       #
       # @since 2.1.0
       # @api private