hanami 2.0.0.beta2 → 2.0.0.beta4

data/lib/hanami/providers/routes.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "dry/system/provider/source"
-
 module Hanami
   module Providers
     class Routes < Dry::System::Provider::Source

data/lib/hanami/routes.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "hanami/slice/router"
+
 module Hanami
   # App routes
   #
@@ -14,38 +16,63 @@ module Hanami
   #
   #   module MyApp
   #     class Routes < Hanami::Routes
-  #       define do
-  #         root to: "home.show"
-  #       end
+  #       root to: "home.show"
   #     end
   #   end
   #
-  #   See {Hanami::Slice::Router} for the syntax allowed within the
-  #   `define` block.
+  #   See {Hanami::Slice::Router} for the syntax allowed within the `define` block.
   #
   # @see Hanami::Slice::Router
   # @since 2.0.0
   class Routes
-    # Defines app routes
-    #
-    # @yield DSL syntax to define app routes executed in the context
-    # of {Hanami::Slice::Router}
-    #
-    # @return [Proc]
-    def self.define(&block)
-      @_routes = block
-    end
-
     # @api private
     def self.routes
-      @_routes || raise(<<~MSG)
-        Routes need to be defined before being able to fetch them. E.g.,
-          define do
-            slice :main, at: "/" do
-              root to: "home.show"
+      @routes ||= build_routes
+    end
+
+    class << self
+      # @api private
+      def build_routes(definitions = self.definitions)
+        return if definitions.empty?
+
+        proc do
+          definitions.each do |(name, args, kwargs, block)|
+            if block
+              public_send(name, *args, **kwargs, &block)
+            else
+              public_send(name, *args, **kwargs)
             end
           end
-      MSG
+        end
+      end
+
+      # @api private
+      def definitions
+        @definitions ||= []
+      end
+
+      private
+
+      # @api private
+      def supported_methods
+        @supported_methods ||= Slice::Router.public_instance_methods
+      end
+
+      # @api private
+      def respond_to_missing?(name, include_private = false)
+        supported_methods.include?(name) || super
+      end
+
+      # Capture all method calls that are supported by the router DSL
+      # so that it can be evaluated lazily during configuration/boot
+      # process
+      #
+      # @api private
+      def method_missing(name, *args, **kwargs, &block)
+        return super unless respond_to?(name)
+        definitions << [name, args, kwargs, block]
+        self
+      end
     end
   end
 end

data/lib/hanami/settings/env_store.rb

@@ -12,7 +12,7 @@ module Hanami
     # @since 2.0.0
     # @api private
     class EnvStore
-      Undefined = Dry::Core::Constants::Undefined
+      NO_ARG = Object.new.freeze
 
       attr_reader :store, :hanami_env
 
@@ -21,9 +21,9 @@ module Hanami
         @hanami_env = hanami_env
       end
 
-      def fetch(name, default_value = Undefined, &block)
+      def fetch(name, default_value = NO_ARG, &block)
         name = name.to_s.upcase
-        args = default_value == Undefined ? [name] : [name, default_value]
+        args = default_value.eql?(NO_ARG) ? [name] : [name, default_value]
 
         store.fetch(*args, &block)
       end

data/lib/hanami/settings.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
+require "dry/core"
 require "dry/configurable"
-require "dry/core/constants"
 
 module Hanami
   # App settings
@@ -33,11 +33,72 @@ module Hanami
   # needs to do is implementing a `#fetch` method with the same signature as `Hash#fetch`.
   #
   # @see Hanami::Settings::DotenvStore
+  #
+  # @api public
   # @since 2.0.0
   class Settings
+    class << self
+      def inherited(subclass)
+        super
+
+        if Hanami.bundled?("dry-types")
+          require "dry/types"
+          subclass.const_set(:Types, Dry.Types())
+        end
+      end
+
+      # Loads the settings for a slice.
+      #
+      # Returns nil if no settings class is defined.
+      #
+      # @return [Settings, nil]
+      #
+      # @api private
+      def load_for_slice(slice)
+        return unless settings_defined?(slice)
+
+        require_slice_settings(slice) unless slice_settings_class?(slice)
+
+        slice_settings_class(slice).new(slice.config.settings_store)
+      end
+
+      private
+
+      # Returns true if settings are defined for the slice.
+      #
+      # Settings are considered defined if a `Settings` class is already defined in the slice
+      # namespace, or a `config/settings.rb` exists under the slice root.
+      def settings_defined?(slice)
+        slice.namespace.const_defined?(SETTINGS_CLASS_NAME) ||
+          slice.root.join("#{SETTINGS_PATH}#{RB_EXT}").file?
+      end
+
+      def slice_settings_class?(slice)
+        slice.namespace.const_defined?(SETTINGS_CLASS_NAME)
+      end
+
+      def slice_settings_class(slice)
+        slice.namespace.const_get(SETTINGS_CLASS_NAME)
+      end
+
+      def require_slice_settings(slice)
+        require "hanami/settings"
+
+        slice_settings_require_path = File.join(slice.root, SETTINGS_PATH)
+
+        begin
+          require slice_settings_require_path
+        rescue LoadError => e
+          raise e unless e.path == slice_settings_require_path
+        end
+      end
+    end
+
     # Exception for errors in the definition of settings.
     #
     # Its message collects all the individual errors that can be raised for each setting.
+    #
+    # @api public
     InvalidSettingsError = Class.new(StandardError) do
       def initialize(errors)
         @errors = errors
@@ -52,6 +113,9 @@ module Hanami
       end
     end
 
+    # @api private
+    Undefined = Dry::Core::Constants::Undefined
+
     # @api private
     EMPTY_STORE = Dry::Core::Constants::EMPTY_HASH
 
@@ -59,14 +123,32 @@ module Hanami
 
     # @api private
     def initialize(store = EMPTY_STORE)
-      errors = config._settings.map(&:name).reduce({}) do |errs, name|
-        public_send("#{name}=", store.fetch(name) { Dry::Core::Constants::Undefined })
-        errs
+      errors = config._settings.map(&:name).each_with_object({}) do |name, errs|
+        value = store.fetch(name, Undefined)
+
+        if value.eql?(Undefined)
+          # When a key is missing entirely from the store, _read_ its value from the config instead,
+          # which ensures its setting constructor runs (with a `nil` argument given) and raises any
+          # necessary errors.
+          public_send(name)
+        else
+          public_send("#{name}=", value)
+        end
       rescue => e # rubocop:disable Style/RescueStandardError
-        errs.merge(name => e)
+        errs[name] = e
       end
 
       raise InvalidSettingsError, errors if errors.any?
+
+      config.finalize!
+    end
+
+    def inspect
+      "#<#{self.class.to_s} [#{config._settings.map(&:name).join(", ")}]>"
+    end
+
+    def inspect_values
+      "#<#{self.class.to_s} #{config._settings.map { |setting| "#{setting.name}=#{config[setting.name].inspect}" }.join(" ")}>"
     end
 
     private

data/lib/hanami/slice/routing/middleware/stack.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "hanami/middleware"
+require "hanami/errors"
+
 module Hanami
   class Slice
     module Routing
@@ -39,11 +42,16 @@ module Hanami
           # @api private
           attr_reader :stack
 
+          # @since 2.0.0
+          # @api public
+          attr_reader :namespaces
+
           # @since 2.0.0
           # @api private
           def initialize
             @prefix = ROOT_PREFIX
             @stack = Hash.new { |hash, key| hash[key] = [] }
+            @namespaces = [Hanami::Middleware]
           end
 
           # @since 2.0.0
@@ -52,11 +60,13 @@ module Hanami
             super
             @prefix = source.instance_variable_get(:@prefix).dup
             @stack = stack.dup
+            @namespaces = namespaces.dup
           end
 
           # @since 2.0.0
           # @api private
-          def use(middleware, *args, before: nil, after: nil, &blk)
+          def use(spec, *args, before: nil, after: nil, &blk)
+            middleware = resolve_middleware_class(spec)
             item = [middleware, args, blk]
 
             if before
@@ -141,6 +151,40 @@ module Hanami
           def index_of(middleware)
             @stack[@prefix].index { |(m, *)| m.equal?(middleware) }
           end
+
+          # @since 2.0.0
+          def resolve_middleware_class(spec)
+            case spec
+            when Symbol then load_middleware_class(spec)
+            when Class, Module then spec
+            else
+              if spec.respond_to?(:call)
+                spec
+              else
+                raise UnsupportedMiddlewareSpecError, spec
+              end
+            end
+          end
+
+          # @since 2.0.0
+          def load_middleware_class(spec)
+            begin
+              require "hanami/middleware/#{spec}"
+            rescue LoadError # rubocop:disable Lint/SuppressedException
+            end
+
+            class_name = Hanami::Utils::String.classify(spec.to_s)
+            namespace = namespaces.detect { |ns| ns.const_defined?(class_name) }
+
+            if namespace
+              namespace.const_get(class_name)
+            else
+              raise(
+                UnsupportedMiddlewareSpecError,
+                "Failed to find corresponding middleware class for `#{spec}` in #{namespaces.join(', ')}"
+              )
+            end
+          end
         end
       end
     end

data/lib/hanami/slice.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
-require "dry/system/container"
 require "zeitwerk"
+require "dry/system"
+
+require_relative "../hanami"
 require_relative "constants"
 require_relative "errors"
+require_relative "settings"
 require_relative "slice_name"
 require_relative "slice_registrar"
-require_relative "providers/settings"
 
 module Hanami
   # A slice represents any distinct area of concern within an Hanami app.
@@ -17,12 +19,11 @@ module Hanami
   # Each slice corresponds a single module namespace and a single root directory of source
   # files for loading as components into its container.
   #
-  # Each slice has its own configuration, and may optionally have its own settings,
-  # routes, as well as other nested slices.
+  # Each slice has its own config, and may optionally have its own settings, routes, as well as
+  # other nested slices.
   #
-  # Slices expect an Hanami app to be defined (which itself is a slice). They will
-  # initialize their configuration as a copy of the app's, and will also configure
-  # certain components
+  # Slices expect an Hanami app to be defined (which itself is a slice). They will initialize their
+  # config as a copy of the app's, and will also configure certain components
   #
   # Slices must be _prepared_ and optionally _booted_ before they can be used (see
   # {ClassMethods.prepare} and {ClassMethods.boot}). A prepared slice will lazily load its
@@ -56,15 +57,14 @@ module Hanami
         Hanami.app
       end
 
-      # A slice's configuration is copied from the app configuration at time of first access. The
-      # app should have its configuration completed before slices are loaded.
-      def configuration
-        @configuration ||= app.configuration.dup.tap do |config|
+      # A slice's config is copied from the app config at time of first access. The app should have
+      # its config completed before slices are loaded.
+      def config
+        @config ||= app.config.dup.tap do |slice_config|
           # Remove specific values from app that will not apply to this slice
-          config.root = nil
+          slice_config.root = nil
         end
       end
-      alias_method :config, :configuration
 
       def slice_name
         @slice_name ||= SliceName.new(self, inflector: method(:inflector))
@@ -75,11 +75,22 @@ module Hanami
       end
 
       def root
-        configuration.root
+        # Provide a best guess for a root when it is not yet configured.
+        #
+        # This is particularly useful for user-defined slice classes that access `settings` inside
+        # the class body (since the root needed to find the settings file). In this case,
+        # `configuration.root` may be nil when `settings` is called, since the root is configured by
+        # `SliceRegistrar#configure_slice` _after_ the class is loaded.
+        #
+        # In common cases, this best guess will be correct since most Hanami slices will be expected
+        # to live in the app SLICES_DIR. For advanced cases, the correct slice root should be
+        # explicitly configured at the beginning of the slice class body, before any calls to
+        # `settings`.
+        config.root || app.root.join(SLICES_DIR, slice_name.to_s)
       end
 
       def inflector
-        configuration.inflector
+        config.inflector
       end
 
       def prepare(provider_name = nil)
@@ -180,6 +191,12 @@ module Hanami
         end
       end
 
+      def settings
+        return @settings if instance_variable_defined?(:@settings)
+
+        @settings = Settings.load_for_slice(self)
+      end
+
       def routes
         @routes ||= load_routes
       end
@@ -209,7 +226,7 @@ module Hanami
       def prepare_slice
         return self if prepared?
 
-        configuration.finalize!
+        config.finalize!
 
         ensure_slice_name
         ensure_slice_consts
@@ -222,8 +239,6 @@ module Hanami
 
         prepare_autoloader
 
-        ensure_prepared
-
         # Load child slices last, ensuring their parent is fully prepared beforehand
         # (useful e.g. for slices that may wish to access constants defined in the
         # parent's autoloaded directories)
@@ -250,17 +265,13 @@ module Hanami
       end
 
       def ensure_root
-        unless configuration.root
+        unless config.root
           raise SliceLoadError, "Slice must have a `config.root` before it can be prepared"
         end
       end
 
-      def ensure_prepared
-        # Load settings so we can fail early in case of non-conformant values
-        self[:settings] if key?(:settings)
-      end
-
       def prepare_all
+        prepare_settings
         prepare_container_consts
         prepare_container_plugins
         prepare_container_base_config
@@ -269,6 +280,15 @@ module Hanami
         prepare_container_providers
       end
 
+      def prepare_settings
+        container.register(:settings, settings) if settings
+      end
+
+      def prepare_container_consts
+        namespace.const_set :Container, container
+        namespace.const_set :Deps, container.injector
+      end
+
       def prepare_container_plugins
         container.use(:env, inferrer: -> { Hanami.env })
 
@@ -285,8 +305,8 @@ module Hanami
         container.config.root = root
         container.config.provider_dirs = [File.join("config", "providers")]
 
-        container.config.env = configuration.env
-        container.config.inflector = configuration.inflector
+        container.config.env = config.env
+        container.config.inflector = config.inflector
       end
 
       def prepare_container_component_dirs
@@ -304,7 +324,7 @@ module Hanami
         # When auto-registering components in the root, ignore files in `config/` (this is
         # for framework config only), `lib/` (these will be auto-registered as above), as
         # well as the configured no_auto_register_paths
-        no_auto_register_paths = ([LIB_DIR, CONFIG_DIR] + configuration.no_auto_register_paths)
+        no_auto_register_paths = ([LIB_DIR, CONFIG_DIR] + config.no_auto_register_paths)
           .map { |path|
             path.end_with?(File::SEPARATOR) ? path : "#{path}#{File::SEPARATOR}"
           }
@@ -335,8 +355,6 @@ module Hanami
           require_relative "providers/routes"
           register_provider(:routes, source: Providers::Routes.for_slice(self))
         end
-
-        Providers::Settings.register_with_slice(self)
       end
 
       def prepare_autoloader
@@ -358,17 +376,14 @@ module Hanami
         autoloader.setup
       end
 
-      def prepare_container_consts
-        namespace.const_set :Container, container
-        namespace.const_set :Deps, container.injector
-      end
-
       def prepare_slices
         slices.load_slices.each(&:prepare)
         slices.freeze
       end
 
       def load_routes
+        return false unless Hanami.bundled?("hanami-router")
+
         if root.directory?
           routes_require_path = File.join(root, ROUTES_PATH)
 
@@ -393,14 +408,14 @@ module Hanami
 
         require_relative "slice/router"
 
-        config = configuration
+        config = self.config
         rack_monitor = self["rack.monitor"]
 
         Slice::Router.new(
           inspector: inspector,
           routes: routes,
-          resolver: configuration.router.resolver.new(slice: self),
-          **configuration.router.options
+          resolver: config.router.resolver.new(slice: self),
+          **config.router.options
         ) do
           use(rack_monitor)
           use(*config.sessions.middleware) if config.sessions.enabled?

data/lib/hanami/slice_configurable.rb

@@ -56,7 +56,7 @@ module Hanami
       def slice_for(klass)
         return unless klass.name
 
-        slices = Hanami.app.slices.to_a + [Hanami.app]
+        slices = Hanami.app.slices.with_nested + [Hanami.app]
 
         slices.detect { |slice| klass.name.include?(slice.namespace.to_s) }
       end

data/lib/hanami/slice_registrar.rb

@@ -75,6 +75,12 @@ module Hanami
       slices.values
     end
 
+    def with_nested
+      to_a.flat_map { |slice|
+        [slice] + slice.slices.with_nested
+      }
+    end
+
     private
 
     def root

data/lib/hanami/version.rb

@@ -8,7 +8,7 @@ module Hanami
   module Version
     # @since 0.9.0
     # @api private
-    VERSION = "2.0.0.beta2"
+    VERSION = "2.0.0.beta4"
 
     # @since 0.9.0
     # @api private

data/lib/hanami.rb

@@ -114,7 +114,6 @@ module Hanami
     @_mutex.synchronize do
       @_bundled[gem_name] ||= begin
         gem(gem_name)
-        true
       rescue Gem::LoadError
         false
       end

data/spec/{new_integration → integration}/action/routes_spec.rb

@@ -14,12 +14,10 @@ RSpec.describe "App action / Routes", :app_integration do
       write "config/routes.rb", <<~RUBY
         module TestApp
           class Routes < Hanami::Routes
-            define do
-              root to: "home.index"
+            root to: "home.index"
 
-              slice :admin, at: "/admin" do
-                root to: "dashboard.index"
-              end
+            slice :admin, at: "/admin" do
+              root to: "dashboard.index"
             end
           end
         end

data/spec/{new_integration → integration}/container/application_routes_helper_spec.rb

@@ -16,9 +16,7 @@ RSpec.describe "App routes helper", :app_integration do
       write "config/routes.rb", <<~RUBY
         module TestApp
           class Routes < Hanami::Routes
-            define do
-              root to: "home.index"
-            end
+            root to: "home.index"
           end
         end
       RUBY

data/spec/{new_integration → integration}/container/prepare_container_spec.rb

@@ -23,6 +23,8 @@ RSpec.describe "Container / prepare_container", :app_integration do
 
     # The prepare_container block is called when the slice is prepared
     slice.prepare
+
+    autoloaders_teardown!
   end
 
   describe "in app", :in_prepare_container do