hanami 2.3.2 → 3.0.0

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/i18n_helper.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Extensions
+    module Action
+      # Action translation and localization helpers.
+      #
+      # These helpers are automatically available on `Hanami::Action` when the `i18n` gem is
+      # bundled.
+      #
+      # When relative translation keys (with a leading dot) are given, they are expanded against a
+      # the action's name. For example, `t(".not_found")` within `Main::Actions::Posts::Show`
+      # becomes `"posts.show.not_found"`.
+      #
+      # @example Basic translation in an action
+      #   module Main
+      #     module Actions
+      #       module Posts
+      #         class Create < Main::Action
+      #           def handle(req, res)
+      #             res.flash[:notice] = t("messages.post_created")
+      #             res.redirect_to routes.path(:posts)
+      #           end
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      # @example Relative key lookup
+      #   # In Main::Actions::Posts::Show, this looks up "posts.show.not_found"
+      #   t(".not_found")
+      #
+      # @see Hanami::Helpers::I18nHelper::Methods
+      #
+      # @api public
+      # @since 3.0.0
+      module I18nHelper
+        include Hanami::Helpers::I18nHelper::Methods
+
+        private
+
+        def _i18n
+          i18n
+        end
+
+        def _resolve_i18n_key(key)
+          return key unless key.to_s.start_with?(".")
+
+          key_base = self.class.config.i18n_key_base
+
+          unless key_base
+            raise(
+              ::I18n::ArgumentError,
+              "Cannot use relative translation key #{key.inspect} outside of a slice-configured action. " \
+              "Use an absolute key (without a leading dot) instead."
+            )
+          end
+
+          "#{key_base}#{key}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Extensions
+    module Action
+      # Infers an action's name (e.g. `posts.show`) from its class name relative to its slice
+      # namespace.
+      #
+      # @api private
+      class NameInferrer
+        class << self
+          # @example
+          #   NameInferrer.call(action_class_name: "Main::Actions::Posts::Show", slice: Main::Slice)
+          #   # => "posts.show"
+          #
+          # @param action_class_name [String, nil] the action class name
+          # @param slice [Hanami::Slice] the slice the action belongs to
+          #
+          # @return [String, nil] the inferred name, or nil if `action_class_name` is nil
+          def call(action_class_name:, slice:)
+            return nil unless action_class_name
+
+            slice
+              .inflector
+              .underscore(action_class_name)
+              .sub(%r{^#{slice.slice_name.path}#{PATH_DELIMITER}}, "")
+              .sub(%r{^#{slice.config.actions.name_inference_base}#{PATH_DELIMITER}}, "")
+              .gsub("/", CONTAINER_KEY_DELIMITER)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,11 +3,12 @@
 module Hanami
   module Extensions
     module Action
+      require_relative "name_inferrer"
+
       # Provides slice-specific configuration and behavior for any action class defined
       # within a slice's module namespace.
       #
       # @api private
-      # @since 2.0.0
       class SliceConfiguredAction < Module
         attr_reader :slice
 
@@ -18,7 +19,9 @@ module Hanami
 
         def extended(action_class)
           configure_action(action_class)
+          configure_action_i18n(action_class)
           extend_behavior(action_class)
+          define_inherited
           define_new
         end
 
@@ -34,6 +37,7 @@ module Hanami
           view_context_class = method(:view_context_class)
           resolve_routes = method(:resolve_routes)
           resolve_rack_monitor = method(:resolve_rack_monitor)
+          resolve_i18n = method(:resolve_i18n)
 
           define_method(:new) do |**kwargs|
             super(
@@ -41,11 +45,24 @@ module Hanami
               view_context_class: kwargs.fetch(:view_context_class) { view_context_class.() },
               routes: kwargs.fetch(:routes) { resolve_routes.() },
               rack_monitor: kwargs.fetch(:rack_monitor) { resolve_rack_monitor.() },
+              i18n: kwargs.fetch(:i18n) { resolve_i18n.() },
               **kwargs,
             )
           end
         end
 
+        # Defines an `inherited` hook on this module so each subclass of the slice-configured
+        # action gets its own `config.i18n_key_base`, inferred from its class name. Mirrors the
+        # approach used by `SliceConfiguredView` for `config.template`.
+        def define_inherited
+          configure_action_i18n = method(:configure_action_i18n)
+
+          define_method(:inherited) do |subclass|
+            super(subclass)
+            configure_action_i18n.call(subclass)
+          end
+        end
+
         def configure_action(action_class)
           action_class.settings.each do |setting|
             # Configure the action from config on the slice, _unless it has already been configured
@@ -98,6 +115,14 @@ module Hanami
           end
         end
 
+        def configure_action_i18n(action_class)
+          return unless action_class.config.respond_to?(:i18n_key_base=)
+
+          action_class.config.i18n_key_base = NameInferrer.call(
+            action_class_name: action_class.name, slice:
+          )
+        end
+
         def extend_behavior(action_class)
           if actions_config.sessions.enabled?
             require "hanami/action/session"
@@ -118,7 +143,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|
@@ -152,6 +177,10 @@ module Hanami
           slice.app["rack.monitor"] if slice.app.key?("rack.monitor")
         end
 
+        def resolve_i18n
+          slice["i18n"] if slice.key?("i18n")
+        end
+
         def actions_config
           slice.config.actions
         end

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
@@ -43,8 +43,7 @@ module Hanami
         # @api private
         attr_reader :view_context_class
 
-        # Returns the app or slice's {Hanami::Slice::RoutesHelper RoutesHelper} for use within
-        # action instance methods.
+        # Returns the slice's {Hanami::Slice::RoutesHelper RoutesHelper}.
         #
         # @return [Hanami::Slice::RoutesHelper]
         #
@@ -52,8 +51,7 @@ module Hanami
         # @since 2.0.0
         attr_reader :routes
 
-        # Returns the app or slice's `Dry::Monitor::Rack::Middleware` for use within
-        # action instance methods.
+        # Returns the slice's `Dry::Monitor::Rack::Middleware`.
         #
         # @return [Dry::Monitor::Rack::Middleware]
         #
@@ -61,6 +59,14 @@ module Hanami
         # @since 2.0.0
         attr_reader :rack_monitor
 
+        # Returns the slice's i18n backend.
+        #
+        # @return [Hanami::Providers::I18n::Backend]
+        #
+        # @api public
+        # @since x.x.x
+        attr_reader :i18n
+
         # @overload def initialize(routes: nil, **kwargs)
         #   Returns a new `Hanami::Action` with app components injected as dependencies.
         #
@@ -71,11 +77,12 @@ module Hanami
         #
         #   @api public
         #   @since 2.0.0
-        def initialize(view: nil, view_context_class: nil, rack_monitor: nil, routes: nil, **kwargs)
+        def initialize(view: nil, view_context_class: nil, rack_monitor: nil, routes: nil, i18n: nil, **kwargs)
           @view = view
           @view_context_class = view_context_class
           @routes = routes
           @rack_monitor = rack_monitor
+          @i18n = i18n
 
           super(**kwargs)
         end
@@ -109,7 +116,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
 
@@ -132,3 +139,9 @@ module Hanami
 end
 
 Hanami::Action.include(Hanami::Extensions::Action)
+
+if Hanami.bundled?("i18n")
+  require_relative "action/i18n_helper"
+  Hanami::Action.setting(:i18n_key_base)
+  Hanami::Action.include(Hanami::Extensions::Action::I18nHelper)
+end

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

@@ -0,0 +1,134 @@
+# 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
+          define_inherited
+        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
+
+        # Reconfigures the template name for each subclass.
+        def define_inherited
+          template_name = method(:template_name)
+
+          define_method(:inherited) do |subclass|
+            super(subclass)
+
+            if (template = template_name.(subclass))
+              subclass.config.template = template
+            end
+          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