hanami 2.3.2 → 3.0.0

data/lib/hanami/providers/mailers.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Providers
+    # Registers the `"mailers.delivery_method"` component. This is an SMTP delivery method built
+    # from SMTP environment variables when present, otherwise the test delivery method.
+    #
+    # SMTP env vars may take a per-slice prefix derived from the slice name (e.g. an "admin" slice
+    # reads `ADMIN__SMTP_ADDRESS`, falling back to `SMTP_ADDRESS`). Register your own `:mailers`
+    # provider if you need to use another delivery method or different setup logic.
+    #
+    # In the test env, environment variables are ignored, and the test delivery method is always
+    # used, so the test suite can never send real email.
+    #
+    # In the production env, warns noisily when there is no SMTP configuration, before falling back
+    # to the test delivery method. This ensures an app whose mail setup is a work in progress can
+    # still boot.
+    #
+    # @api private
+    class Mailers < Hanami::Provider::Source
+      # Maps SMTP environment variable names to their compatible delivery option keys.
+      #
+      # Example values:
+      #
+      #   SMTP_ADDRESS=smtp.example.com
+      #   SMTP_PORT=587
+      #   SMTP_USERNAME=postmaster@example.com
+      #   SMTP_PASSWORD=s3cr3t
+      #   SMTP_AUTHENTICATION=plain
+      SMTP_ENV_VARS = {
+        "SMTP_ADDRESS" => :address,
+        "SMTP_PORT" => :port,
+        "SMTP_USERNAME" => :user_name,
+        "SMTP_PASSWORD" => :password,
+        "SMTP_AUTHENTICATION" => :authentication
+      }.freeze
+
+      # Coercions applied to SMTP env var values, keyed by option. Options not listed here are
+      # passed through unchanged (as strings).
+      SMTP_COERCIONS = Hash.new(:itself.to_proc).update(
+        port: ->(value) { Integer(value) },
+        authentication: ->(value) { value.to_sym }
+      ).freeze
+
+      def start
+        require "hanami/mailer"
+
+        register "delivery_method", build_delivery_method
+      end
+
+      private
+
+      def build_delivery_method
+        return Hanami::Mailer::Delivery::Test.new if Hanami.env?(:test)
+
+        smtp_options = smtp_options_from_env
+
+        return Hanami::Mailer::Delivery::SMTP.new(**smtp_options) if smtp_options.key?(:address)
+
+        warn_missing_smtp if Hanami.env?(:production)
+
+        Hanami::Mailer::Delivery::Test.new
+      end
+
+      def smtp_options_from_env
+        SMTP_ENV_VARS.each_with_object({}) do |(var, option), options|
+          value = env_value(var)
+          next if value.nil?
+
+          coercion = SMTP_COERCIONS[option]
+          options[option] = coercion ? coercion.call(value) : value
+        end
+      end
+
+      # Reads an SMTP env var, preferring a per-slice prefixed name (e.g. `ADMIN__SMTP_ADDRESS`)
+      # and falling back to the unprefixed name shared across slices.
+      def env_value(var)
+        return ENV[var] if slice.app?
+
+        slice_prefixed_var = "#{slice.slice_name.name.gsub("/", "__").upcase}__#{var}"
+        ENV[slice_prefixed_var] || ENV[var]
+      end
+
+      def warn_missing_smtp
+        message = \
+          "No SMTP configuration found for #{slice.slice_name.name} in production; " \
+          "falling back to the test delivery method — mail will NOT be sent. " \
+          "Set SMTP_ADDRESS (and related SMTP_* variables), or register a custom :mailers provider."
+
+        slice.app["logger"].warn(message)
+      end
+    end
+
+    Dry::System.register_provider_source(
+      :mailers,
+      source: Mailers,
+      group: :hanami,
+      provider_options: {namespace: true}
+    )
+  end
+end

data/lib/hanami/routes.rb

@@ -137,6 +137,7 @@ module Hanami
       # @api private
       def method_missing(name, *args, **kwargs, &block)
         return super unless respond_to?(name)
+
         definitions << [name, args, kwargs, block]
         self
       end

data/lib/hanami/settings/composite_store.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "dry/core/constants"
+
+module Hanami
+  class Settings
+    # A settings store that chains multiple stores with fallback resolution.
+    #
+    # Each store is tried in order. The first store to return a value wins.
+    # Stores must implement `#fetch` with the same signature as `Hash#fetch`.
+    #
+    # @example
+    #   # config/app.rb
+    #   config.settings_store = Hanami::Settings::CompositeStore.new(
+    #     Hanami::Settings::EnvStore.new,
+    #     MyCustomStore.new
+    #   )
+    #
+    # @api public
+    # @since 3.0.0
+    class CompositeStore
+      # @api private
+      Undefined = Dry::Core::Constants::Undefined
+
+      # @param stores [Array<#fetch>] ordered list of stores to query
+      def initialize(*stores)
+        @stores = stores
+      end
+
+      # Fetches a value by trying each store in order.
+      #
+      # @param name [String, Symbol] the setting name
+      # @param args [Array] optional default value
+      # @yield [name] optional block for default value
+      # @return [Object] the setting value
+      # @raise [KeyError] if no store has the key and no default is given
+      #
+      # @api public
+      # @since 3.0.0
+      def fetch(name, *args, &block)
+        @stores.each do |store|
+          value = store.fetch(name, Undefined)
+          return value unless value.equal?(Undefined)
+        end
+
+        return args.first unless args.empty?
+        return yield(name) if block
+
+        raise KeyError, "key not found: #{name.inspect}"
+      end
+    end
+  end
+end

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.
       #
@@ -395,6 +394,26 @@ module Hanami
         @slices ||= SliceRegistrar.new(self)
       end
 
+      # Returns an array of this slice and all of its nested slices.
+      #
+      # The nested slices are returned first (with their more specific namespaces ahead of their
+      # parents'), and this slice is returned last. This ordering means a class can be matched to
+      # its most specific slice by detecting the first slice whose namespace it belongs to. It is
+      # useful when you need to operate across every container, such as in test support code.
+      #
+      # @example
+      #   Hanami.app.with_slices # => [Main::Nested::Slice, Main::Slice, Admin::Slice, MyApp::App]
+      #
+      # @return [Array<Hanami::Slice>] this slice and all of its (nested) slices, this slice last
+      #
+      # @see #slices
+      #
+      # @api public
+      # @since 3.0.0
+      def with_slices
+        slices.with_nested + [self]
+      end
+
       # @overload register_slice(name, &block)
       #   Registers a nested slice with the given name.
       #
@@ -797,12 +816,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 +924,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 +983,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 +1005,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.
+          if register_mailers_provider? && !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 +1078,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 +1135,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 +1158,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 +1182,27 @@ 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
+
+      # Ensures a mailers 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
+      # "mailers.delivery_method" component.
+      def register_mailers_provider?
+        return true if self == app
+
+        !config.shared_app_component_keys.include?("mailers.delivery_method")
+      end
+
       def register_db_provider?
         concrete_db_provider? ||
           db_config_dir? ||
@@ -1143,6 +1235,5 @@ module Hanami
 
       # rubocop:enable Metrics/AbcSize
     end
-    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/hanami/slice_configurable.rb

@@ -57,9 +57,7 @@ module Hanami
       def slice_for(klass)
         return unless klass.name
 
-        slices = Hanami.app.slices.with_nested + [Hanami.app]
-
-        slices.detect { |slice| klass.name.start_with?("#{slice.namespace}#{MODULE_DELIMITER}") }
+        Hanami.app.with_slices.detect { |slice| klass.name.start_with?("#{slice.namespace}#{MODULE_DELIMITER}") }
       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)