hanami 2.0.0.alpha6 → 2.0.0.alpha7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3fc76408b7d97db32194d24bf73739bde8405fbd13855b7e4ea744f634d0739e
-  data.tar.gz: 30d954f8332ea7579898a87187a89a0ae2a1b34b5d9f564a86b6f61c0844f2af
+  metadata.gz: d8a7910a3dd4b6e7d82711df4f181de1e8c63fbb91981542d2eb067d2cfe06b4
+  data.tar.gz: 2d09e35743119e1e630f196780df68cf7b7685c2d6e3208fe0c7804816ccb45f
 SHA512:
-  metadata.gz: f64124d027449d451f5be703f4c00850c826e4d55ebef1e6c396be63dea59a9019cb74438f7844f1e68a187299ea45c7f89ba1e98267380e7d8e1b1f8666e4b9
-  data.tar.gz: 8ea32aae47f0fe9536726c977af03904fa23f7258ef747b2cdd1a3b324eb064466beccc9340b7dddfb46d3d6a49c8aba899b1b488c6016377581599efd594577
+  metadata.gz: 51ecc6d32c036bfc2fae43498ca6f88bb937317e610d24e499a069b02ff4c8a49b253684ba4fe47d6f67e2c2fc2b0a989460fc1462b397ddd1a5ec539ace2b7c
+  data.tar.gz: aa3a1f17f9304605135391c3cb915f61cabbd5cbb2e4351e70be122353d36a85af979bbf4710ffdbfa27e1e77aea023f3de7ddda2b547399e1d96b396134da9c

data/CHANGELOG.md

@@ -1,6 +1,65 @@
 # Hanami
 The web, with simplicity.
 
+## v2.0.0.alpha7 - 2020-03-08
+
+## Added
+- [Tim Riley] Introduced `Hanami::ApplicationLoadError` and `Hanami::SliceLoadError` exceptions to represent errors encountered during application and slice loading.
+- [Tim Riley] `Hanami::Slice.shutdown` can be used to stop all the providers in a slice
+
+## Changed
+- [Tim Riley] Slices are now represented as concrete classes (such as `Main::Slice`) inheriting from `Hanami::Slice`, as opposed to _instances_ of `Hanami::Slice`. You may create your own definitions for these slices in `config/slices/[slice_name].rb`, which you can then use for customising per-slice config and behavior, e.g.
+
+    ```ruby
+    # config/slices/main.rb:
+
+    module Main
+      class Slice < Hanami::Slice
+        # slice config here
+      end
+    end
+    ```
+- [Tim Riley] Application-level `config.slice(slice_name, &block)` setting has been removed in favour of slice configuration within concrete slice class definitions
+- [Tim Riley] You can configure your slice imports inside your slice classes, e.g.
+
+    ```ruby
+    # config/slices/main.rb:
+
+    module Main
+      class Slice < Hanami::Slice
+        # Import all exported components from "search" slice
+        import from: :search
+      end
+    end
+    ```
+- [Tim Riley] You can configure your slice exports inside your slice classes, e.g.
+
+    ```ruby
+    # config/slices/search.rb:
+
+    module Search
+      class Slice < Hanami::Slice
+        # Export the "index_entity" component only
+        export ["index_entity"]
+      end
+    end
+    ```
+- [Tim Riley] For advanced cases, you can configure your slice's container via a `prepare_container` block:
+
+    ```ruby
+    # config/slices/search.rb:
+
+    module Search
+      class Slice < Hanami::Slice
+        prepare_container do |container|
+          # `container` object is available here, with
+          # slice-specific configuration already applied
+        end
+      end
+    end
+    ```
+- [Tim Riley] `Hanami::Application.shutdown` will now also shutdown all registered slices
+
 ## v2.0.0.alpha6 - 2022-02-10
 ### Added
 - [Luca Guidi] Official support for Ruby: MRI 3.1

data/lib/hanami/application/routing/router.rb

@@ -0,0 +1,36 @@
+# # frozen_string_literal: true
+
+# require "hanami/application/router"
+
+# Hanami.application.register_provider :router do
+#   start do
+#     configuration = Hanami.application.configuration
+
+#     routes = begin
+#       require File.join(configuration.root, configuration.router.routes_path)
+#       routes_class = Hanami.application.send(:autodiscover_application_constant, configuration.router.routes_class_name) # WIP private
+#       routes_class.routes
+#     rescue LoadError
+#       proc {}
+#     end
+
+#     resolver = configuration.router.resolver.new(
+#       slices: Hanami.application.slices,
+#       inflector: Hanami.application.inflector # TODO: use container[:inflector]?
+#     )
+
+#     router = Hanami::Application::Router.new(
+#       routes: routes,
+#       resolver: resolver,
+#       **configuration.router.options,
+#     ) do
+#       use Hanami.application[:rack_monitor]
+
+#       Hanami.application.config.for_each_middleware do |m, *args, &block|
+#         use(m, *args, &block)
+#       end
+#     end
+
+#     register :router, router
+#   end
+# end

data/lib/hanami/application/slice_registrar.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative "../constants"
+require_relative "../slice"
+
+module Hanami
+  class Application
+    # @api private
+    class SliceRegistrar
+      attr_reader :application, :slices
+      private :application, :slices
+
+      def initialize(application)
+        @application = application
+        @slices = {}
+      end
+
+      def register(name, slice_class = nil, &block)
+        if slices.key?(name.to_sym)
+          raise SliceLoadError, "Slice '#{name}' is already registered"
+        end
+
+        # TODO: raise error unless name meets format (i.e. single level depth only)
+
+        slices[name.to_sym] = slice_class || build_slice(name, &block)
+      end
+
+      def [](name)
+        slices.fetch(name) do
+          raise SliceLoadError, "Slice '#{name}' not found"
+        end
+      end
+
+      def freeze
+        slices.freeze
+        super
+      end
+
+      def load_slices
+        slice_configs = Dir[root.join(CONFIG_DIR, "slices", "*#{RB_EXT}")]
+          .map { |file| File.basename(file, RB_EXT) }
+
+        slice_dirs = Dir[File.join(root, SLICES_DIR, "*")]
+          .select { |path| File.directory?(path) }
+          .map { |path| File.basename(path) }
+
+        (slice_dirs + slice_configs).uniq.sort.each do |slice_name|
+          load_slice(slice_name)
+        end
+
+        self
+      end
+
+      def each(&block)
+        slices.each_value(&block)
+      end
+
+      def to_a
+        slices.values
+      end
+
+      private
+
+      # Attempts to load a slice class defined in `config/slices/[slice_name].rb`, then
+      # registers the slice with the matching class, if found.
+      def load_slice(slice_name)
+        slice_const_name = inflector.camelize(slice_name)
+        slice_require_path = root.join("config", "slices", slice_name).to_s
+
+        begin
+          require(slice_require_path)
+        rescue LoadError => e
+          raise e unless e.path == slice_require_path
+        end
+
+        slice_class =
+          begin
+            inflector.constantize("#{slice_const_name}::Slice")
+          rescue NameError => e
+            raise e unless e.name == :Slice
+          end
+
+        register(slice_name, slice_class)
+      end
+
+      def build_slice(slice_name, &block)
+        slice_module =
+          begin
+            slice_module_name = inflector.camelize(slice_name.to_s)
+            inflector.constantize(slice_module_name)
+          rescue NameError
+            Object.const_set(inflector.camelize(slice_module_name), Module.new)
+          end
+
+        slice_module.const_set(:Slice, Class.new(Hanami::Slice, &block))
+      end
+
+      def root
+        application.root
+      end
+
+      def inflector
+        application.inflector
+      end
+    end
+  end
+end

data/lib/hanami/application.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
 require "dry/system/container"
-require "dry/system/loader/autoloading"
 require "hanami/configuration"
 require "pathname"
 require "rack"
 require "zeitwerk"
+require_relative "constants"
 require_relative "slice"
+require_relative "application/slice_registrar"
 
 module Hanami
   # Hanami application class
@@ -20,8 +21,10 @@ module Hanami
         super
         @_mutex.synchronize do
           klass.class_eval do
-            @_mutex         = Mutex.new
+            @_mutex = Mutex.new
             @_configuration = Hanami::Configuration.new(application_name: name, env: Hanami.env)
+            @autoloader = Zeitwerk::Loader.new
+            @container = Class.new(Dry::System::Container)
 
             extend ClassMethods
           end
@@ -37,6 +40,8 @@ module Hanami
     #
     # rubocop:disable Metrics/ModuleLength
     module ClassMethods
+      attr_reader :autoloader, :container
+
       def self.extended(klass)
         klass.class_eval do
           @prepared = @booted = false
@@ -50,26 +55,13 @@ module Hanami
       alias_method :config, :configuration
 
       def prepare(provider_name = nil)
-        if provider_name
-          container.prepare(provider_name)
-          return self
-        end
+        container.prepare(provider_name) and return self if provider_name
 
         return self if prepared?
 
         configuration.finalize!
 
-        load_settings
-
-        @autoloader = Zeitwerk::Loader.new
-        @container = prepare_container
-        @deps_module = prepare_deps_module
-
-        load_slices
-        slices.each_value(&:prepare)
-        slices.freeze
-
-        @autoloader.setup
+        prepare_all
 
         @prepared = true
         self
@@ -82,40 +74,24 @@ module Hanami
 
         container.finalize!(&block)
 
-        slices.values.each(&:boot)
+        slices.each(&:boot)
 
         @booted = true
         self
       end
 
       def shutdown
+        slices.each(&:shutdown)
         container.shutdown!
+        self
       end
 
       def prepared?
-        @prepared
+        !!@prepared
       end
 
       def booted?
-        @booted
-      end
-
-      def autoloader
-        raise "Application not yet prepared" unless defined?(@autoloader)
-
-        @autoloader
-      end
-
-      def container
-        raise "Application not yet prepared" unless defined?(@container)
-
-        @container
-      end
-
-      def deps
-        raise "Application not yet prepared" unless defined?(@deps_module)
-
-        @deps_module
+        !!@booted
       end
 
       def router
@@ -131,15 +107,11 @@ module Hanami
       end
 
       def slices
-        @slices ||= {}
+        @slices ||= SliceRegistrar.new(self)
       end
 
-      def register_slice(name, **slice_args)
-        raise "Slice +#{name}+ already registered" if slices.key?(name.to_sym)
-
-        slice = Slice.new(self, name: name, **slice_args)
-        slice.namespace.const_set :Slice, slice if slice.namespace # rubocop:disable Style/SafeNavigation
-        slices[name.to_sym] = slice
+      def register_slice(...)
+        slices.register(...)
       end
 
       def register(...)
@@ -202,8 +174,8 @@ module Hanami
       def component_provider(component)
         raise "Hanami.application must be prepared before detecting providers" unless prepared?
 
-        # [Admin, Main, MyApp] or [MyApp::Admin, MyApp::Main, MyApp]
-        providers = slices.values + [self]
+        # e.g. [Admin, Main, MyApp]
+        providers = slices.to_a + [self]
 
         component_class = component.is_a?(Class) ? component : component.class
         component_name = component_class.name
@@ -220,20 +192,25 @@ module Hanami
         $LOAD_PATH.unshift base_path unless $LOAD_PATH.include?(base_path)
       end
 
-      # rubocop:disable Metrics/AbcSize
-      def prepare_container
-        container =
-          begin
-            require "#{application_name}/container"
-            namespace.const_get :Container
-          rescue LoadError, NameError
-            namespace.const_set :Container, Class.new(Dry::System::Container)
-          end
+      def prepare_all
+        load_settings
+        prepare_container_plugins
+        prepare_container_base_config
+        prepare_container_consts
+        container.configured!
+        prepare_slices
+        # For the application, the autoloader must be prepared after the slices, since
+        # they'll be configuring the autoloader with their own dirs
+        prepare_autoloader
+      end
 
-        container.use :env, inferrer: -> { Hanami.env }
-        container.use :zeitwerk, loader: autoloader, run_setup: false, eager_load: false
-        container.use :notifications
+      def prepare_container_plugins
+        container.use(:env, inferrer: -> { Hanami.env })
+        container.use(:zeitwerk, loader: autoloader, run_setup: false, eager_load: false)
+        container.use(:notifications)
+      end
 
+      def prepare_container_base_config
         container.config.root = configuration.root
         container.config.inflector = configuration.inflector
 
@@ -241,63 +218,32 @@ module Hanami
           "config/providers",
           Pathname(__dir__).join("application/container/providers").realpath,
         ]
+      end
 
+      def prepare_autoload_paths
         # Autoload classes defined in lib/[app_namespace]/
         if root.join("lib", namespace_path).directory?
-          container.autoloader.push_dir(root.join("lib", namespace_path), namespace: namespace)
+          autoloader.push_dir(root.join("lib", namespace_path), namespace: namespace)
         end
-
-        # Add lib/ to to the $LOAD_PATH so any files there (outside the app namespace) can
-        # be required
-        container.add_to_load_path!("lib") if root.join("lib").directory?
-
-        container.configured!
-
-        container
-      end
-      # rubocop:enable Metrics/AbcSize
-
-      def prepare_deps_module
-        define_deps_module
       end
 
-      def define_deps_module
-        require "#{application_name}/deps"
-        namespace.const_get :Deps
-      rescue LoadError, NameError
+      def prepare_container_consts
+        namespace.const_set :Container, container
         namespace.const_set :Deps, container.injector
       end
 
-      def load_slices
-        Dir[File.join(slices_path, "*")]
-          .select(&File.method(:directory?))
-          .each(&method(:load_slice))
-      end
-
-      def slices_path
-        File.join(root, config.slices_dir)
+      def prepare_slices
+        slices.load_slices.each(&:prepare)
+        slices.freeze
       end
 
-      def load_slice(slice_path)
-        slice_path = Pathname(slice_path)
-
-        slice_name = slice_path.relative_path_from(Pathname(slices_path)).to_s
-        slice_const_name = inflector.camelize(slice_name)
-
-        if config.slices_namespace.const_defined?(slice_const_name)
-          slice_module = config.slices_namespace.const_get(slice_const_name)
-
-          raise "Cannot use slice +#{slice_const_name}+ since it is not a module" unless slice_module.is_a?(Module)
-        else
-          slice_module = Module.new
-          config.slices_namespace.const_set inflector.camelize(slice_name), slice_module
+      def prepare_autoloader
+        # Autoload classes defined in lib/[app_namespace]/
+        if root.join("lib", namespace_path).directory?
+          autoloader.push_dir(root.join("lib", namespace_path), namespace: namespace)
         end
 
-        register_slice(
-          slice_name,
-          namespace: slice_module,
-          root: slice_path.realpath
-        )
+        autoloader.setup
       end
 
       def load_settings
@@ -311,9 +257,6 @@ module Hanami
         Settings.new
       end
 
-      MODULE_DELIMITER = "::"
-      private_constant :MODULE_DELIMITER
-
       def autodiscover_application_constant(constants)
         inflector.constantize([namespace_name, *constants].join(MODULE_DELIMITER))
       end

data/lib/hanami/boot/source_dirs.rb

@@ -0,0 +1,44 @@
+module Hanami
+  module Boot
+    module SourceDirs
+      def self.setup_component_dir!(component_dir, slice, container)
+        # TODO: this `== "lib"` check should be codified into a method somewhere
+        if component_dir.path == "lib"
+          # Expect component files in the root of the lib
+          # component dir to define classes inside the slice's namespace.
+          #
+          # e.g. "lib/foo.rb" should define SliceNamespace::Foo, and will be
+          # registered as "foo"
+          component_dir.namespaces.root(key: nil, const: slice.namespace_path)
+
+          slice.application.autoloader.push_dir(slice.root.join("lib"), namespace: slice.namespace)
+
+          container.config.component_dirs.add(component_dir)
+        else
+          # Expect component files in the root of these component dirs to define
+          # classes inside a namespace matching the dir.
+          #
+          # e.g. "actions/foo.rb" should define SliceNamespace::Actions::Foo, and
+          # will be registered as "actions.foo"
+
+          dir_namespace_path = File.join(slice.namespace_path, component_dir.path)
+
+          autoloader_namespace = begin
+            slice.inflector.constantize(slice.inflector.camelize(dir_namespace_path))
+          rescue NameError
+            slice.namespace.const_set(slice.inflector.camelize(component_dir.path), Module.new)
+          end
+
+          # TODO: do we need to do something special to clear out any previously configured root namespace here?
+          component_dir.namespaces.root(const: dir_namespace_path, key: component_dir.path) # TODO: do we need to swap path delimiters for key delimiters here?
+          container.config.component_dirs.add(component_dir)
+
+          slice.application.autoloader.push_dir(
+            slice.root.join(component_dir.path),
+            namespace: autoloader_namespace
+          )
+        end
+      end
+    end
+  end
+end

data/lib/hanami/configuration/actions.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# require_relative "application_configuration/cookies"
+# require_relative "application_configuration/sessions"
+# require_relative "application_configuration/content_security_policy"
+# require_relative "configuration"
+# require_relative "view_name_inferrer"
+
+module Hanami
+  class Configuration
+    class Actions
+      include Dry::Configurable
+
+      setting :cookies, default: {}, constructor: -> options { Cookies.new(options) }
+      setting :sessions, constructor: proc { |storage, *options| Sessions.new(storage, *options) }
+      setting :csrf_protection
+
+      setting :name_inference_base, default: "actions"
+      setting :view_context_identifier, default: "view.context"
+      setting :view_name_inferrer, default: ViewNameInferrer
+      setting :view_name_inference_base, default: "views"
+
+      attr_accessor :content_security_policy
+
+      def initialize(*, **options)
+        super()
+
+        @base_configuration = Configuration.new
+        @content_security_policy = ContentSecurityPolicy.new do |csp|
+          if assets_server_url = options[:assets_server_url]
+            csp[:script_src] += " #{assets_server_url}"
+            csp[:style_src] += " #{assets_server_url}"
+          end
+        end
+
+        configure_defaults
+      end
+
+      def finalize!
+        # A nil value for `csrf_protection` means it has not been explicitly configured
+        # (neither true nor false), so we can default it to whether sessions are enabled
+        self.csrf_protection = sessions.enabled? if csrf_protection.nil?
+
+        if self.content_security_policy
+          self.default_headers["Content-Security-Policy"] = self.content_security_policy.to_str
+        end
+      end
+
+      # Returns the list of available settings
+      #
+      # @return [Set]
+      #
+      # @since 2.0.0
+      # @api private
+      def settings
+        base_configuration.settings + self.class.settings
+      end
+
+      private
+
+      attr_reader :base_configuration
+
+      # Apply defaults for base configuration settings
+      def configure_defaults
+        self.default_request_format = :html
+        self.default_response_format = :html
+
+        self.default_headers = {
+          "X-Frame-Options" => "DENY",
+          "X-Content-Type-Options" => "nosniff",
+          "X-XSS-Protection" => "1; mode=block"
+        }
+      end
+
+      def method_missing(name, *args, &block)
+        if config.respond_to?(name)
+          config.public_send(name, *args, &block)
+        elsif base_configuration.respond_to?(name)
+          base_configuration.public_send(name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, _incude_all = false)
+        config.respond_to?(name) || base_configuration.respond_to?(name) || super
+      end
+    end
+  end
+end

data/lib/hanami/configuration.rb

@@ -13,6 +13,7 @@ require_relative "configuration/middleware"
 require_relative "configuration/router"
 require_relative "configuration/sessions"
 require_relative "configuration/source_dirs"
+require_relative "constants"
 
 module Hanami
   # Hanami application configuration
@@ -26,8 +27,7 @@ module Hanami
     DEFAULT_ENVIRONMENTS = Concurrent::Hash.new { |h, k| h[k] = Concurrent::Array.new }
     private_constant :DEFAULT_ENVIRONMENTS
 
-    MODULE_DELIMITER = "::"
-    private_constant :MODULE_DELIMITER
+    attr_reader :env
 
     attr_reader :actions
     attr_reader :middleware
@@ -41,7 +41,7 @@ module Hanami
       @namespace = application_name.split(MODULE_DELIMITER)[0..-2].join(MODULE_DELIMITER)
 
       @environments = DEFAULT_ENVIRONMENTS.clone
-      config.env = env
+      @env = env
 
       # Some default setting values must be assigned at initialize-time to ensure they
       # have appropriate values for the current application
@@ -117,13 +117,6 @@ module Hanami
       inflector.underscore(@namespace).to_sym
     end
 
-    setting :env
-
-    def env=(new_env)
-      config.env = env
-      apply_env_config(new_env)
-    end
-
     setting :root, constructor: -> path { Pathname(path) }
 
     setting :inflector, default: Dry::Inflector.new
@@ -148,20 +141,8 @@ module Hanami
 
     setting :settings_store, default: Application::Settings::DotenvStore
 
-    setting :slices_dir, default: "slices"
-
-    setting :slices_namespace, default: Object
-
-    # TODO: convert into a dedicated object with explicit behaviour around blocks per
-    # slice, etc.
-    setting :slices, default: {}, constructor: :dup.to_proc
-
     setting :source_dirs, default: Configuration::SourceDirs.new, cloneable: true
 
-    def slice(slice_name, &block)
-      slices[slice_name] = block
-    end
-
     setting :base_url, default: "http://0.0.0.0:2300", constructor: -> url { URI(url) }
 
     def for_each_middleware(&blk)

data/lib/hanami/constants.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Hanami
+  # @api private
+  MODULE_DELIMITER = "::"
+  private_constant :MODULE_DELIMITER
+
+  # @api private
+  CONFIG_DIR = "config"
+  private_constant :CONFIG_DIR
+
+  # @api private
+  SLICES_DIR = "slices"
+  private_constant :SLICES_DIR
+
+  # @api private
+  LIB_DIR = "lib"
+  private_constant :LIB_DIR
+
+  # @api private
+  RB_EXT = ".rb"
+  private_constant :RB_EXT
+end

data/lib/hanami/errors.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Hanami
+  # @since 2.0.0
+  Error = Class.new(StandardError)
+
+  # @since 2.0.0
+  ApplicationLoadError = Class.new(Error)
+
+  # @since 2.0.0
+  SliceLoadError = Class.new(Error)
+end

data/lib/hanami/slice.rb

@@ -1,130 +1,190 @@
 # frozen_string_literal: true
 
 require "dry/system/container"
+require "hanami/errors"
 require "pathname"
+require_relative "constants"
 
 module Hanami
   # Distinct area of concern within an Hanami application
   #
   # @since 2.0.0
   class Slice
-    attr_reader :application, :name, :namespace, :root
-
-    def initialize(application, name:, namespace: nil, root: nil, container: nil)
-      @application = application
-      @name = name.to_sym
-      @namespace = namespace
-      @root = root ? Pathname(root) : root
-      @container = container
-    end
+    def self.inherited(klass)
+      super
 
-    def inflector
-      application.inflector
-    end
+      klass.extend(ClassMethods)
 
-    def namespace_path
-      @namespace_path ||= inflector.underscore(namespace.to_s)
+      # Eagerly initialize any variables that may be accessed inside the subclass body
+      klass.instance_variable_set(:@application, Hanami.application)
+      klass.instance_variable_set(:@container, Class.new(Dry::System::Container))
     end
 
-    def prepare(provider_name = nil)
-      if provider_name
-        container.prepare(provider_name)
-        return self
+    # rubocop:disable Metrics/ModuleLength
+    module ClassMethods
+      attr_reader :application, :container
+
+      def slice_name
+        inflector.underscore(name.split(MODULE_DELIMITER)[-2]).to_sym
       end
 
-      @container ||= define_container
+      def namespace
+        inflector.constantize(name.split(MODULE_DELIMITER)[0..-2].join(MODULE_DELIMITER))
+      end
 
-      container.import from: application.container, as: :application
+      def namespace_path
+        inflector.underscore(namespace)
+      end
 
-      slice_block = application.configuration.slices[name]
-      instance_eval(&slice_block) if slice_block
+      def root
+        application.root.join(SLICES_DIR, slice_name.to_s)
+      end
 
-      # This is here and not inside define_container to allow for the slice block to
-      # interact with container config
-      container.configured!
+      def inflector
+        application.inflector
+      end
 
-      self
-    end
+      def prepare(provider_name = nil)
+        container.prepare(provider_name) and return self if provider_name
 
-    def boot
-      container.finalize!
+        return self if prepared?
 
-      @booted = true
-      self
-    end
+        ensure_slice_name
+        ensure_slice_consts
 
-    # rubocop:disable Style/DoubleNegation
-    def booted?
-      !!@booted
-    end
-    # rubocop:enable Style/DoubleNegation
+        prepare_all
 
-    def container
-      @container ||= define_container
-    end
+        @prepared = true
+        self
+      end
+
+      def prepare_container(&block)
+        @prepare_container_block = block
+      end
+
+      def boot
+        return self if booted?
+
+        container.finalize!
 
-    def import(from:, **kwargs)
-      # TODO: This should be handled via dry-system (see dry-rb/dry-system#228)
-      raise "Cannot import after booting" if booted?
+        @booted = true
 
-      if from.is_a?(Symbol) || from.is_a?(String)
-        slice_name = from
-        # TODO: better error than the KeyError from fetch if the slice doesn't exist
-        from = application.slices.fetch(from.to_sym).container
+        self
       end
 
-      as = kwargs[:as] || slice_name
+      def shutdown
+        container.shutdown!
+        self
+      end
 
-      container.import(from: from, as: as, **kwargs)
-    end
+      def prepared?
+        !!@prepared
+      end
 
-    def register(*args, &block)
-      container.register(*args, &block)
-    end
+      def booted?
+        !!@booted
+      end
 
-    def register_provider(...)
-      container.register_provider(...)
-    end
+      def register(...)
+        container.register(...)
+      end
 
-    def start(...)
-      container.start(...)
-    end
+      def register_provider(...)
+        container.register_provider(...)
+      end
 
-    def key?(...)
-      container.key?(...)
-    end
+      def start(...)
+        container.start(...)
+      end
 
-    def keys
-      container.keys
-    end
+      def key?(...)
+        container.key?(...)
+      end
 
-    def [](...)
-      container.[](...)
-    end
+      def keys
+        container.keys
+      end
 
-    def resolve(...)
-      container.resolve(...)
-    end
+      def [](...)
+        container.[](...)
+      end
+
+      def resolve(...)
+        container.resolve(...)
+      end
+
+      def export(keys)
+        container.config.exports = keys
+      end
+
+      def import(from:, **kwargs)
+        # TODO: This should be handled via dry-system (see dry-rb/dry-system#228)
+        raise "Cannot import after booting" if booted?
+
+        application = self.application
+
+        container.after(:configure) do
+          if from.is_a?(Symbol) || from.is_a?(String)
+            slice_name = from
+            from = application.slices[from.to_sym].container
+          end
+
+          as = kwargs[:as] || slice_name
+
+          import(from: from, as: as, **kwargs)
+        end
+      end
+
+      private
+
+      def ensure_slice_name
+        unless name
+          raise SliceLoadError, "Slice must have a class name before it can be prepared"
+        end
+      end
 
-    private
+      def ensure_slice_consts
+        if namespace.const_defined?(:Container) || namespace.const_defined?(:Deps)
+          raise(
+            SliceLoadError,
+            "#{namespace}::Container and #{namespace}::Deps constants must not already be defined"
+          )
+        end
+      end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-    def define_container
-      container = Class.new(Dry::System::Container)
+      def prepare_all
+        prepare_container_plugins
+        prepare_container_base_config
+        prepare_container_component_dirs
+        prepare_autoloader
+        prepare_container_imports
+        prepare_container_consts
+        instance_exec(container, &@prepare_container_block) if @prepare_container_block
+        container.configured!
+      end
 
-      container.use :env
-      container.use :zeitwerk,
-        loader: application.autoloader,
-        run_setup: false,
-        eager_load: false
+      def prepare_container_plugins
+        container.use(:env, inferrer: -> { Hanami.env })
 
-      container.config.name = name
-      container.config.env = application.configuration.env
-      container.config.inflector = application.configuration.inflector
+        container.use(
+          :zeitwerk,
+          loader: application.autoloader,
+          run_setup: false,
+          eager_load: false
+        )
+      end
 
-      if root&.directory?
+      def prepare_container_base_config
+        container.config.name = slice_name
         container.config.root = root
-        container.config.provider_dirs = ["config/providers"]
+        container.config.provider_dirs = [File.join("config", "providers")]
+
+        container.config.env = application.configuration.env
+        container.config.inflector = application.configuration.inflector
+      end
+
+      def prepare_container_component_dirs # rubocop:disable Metrics/AbcSize
+        return unless root&.directory?
 
         # Add component dirs for each configured component path
         application.configuration.source_dirs.component_dirs.each do |component_dir|
@@ -132,8 +192,7 @@ module Hanami
 
           component_dir = component_dir.dup
 
-          # TODO: this `== "lib"` check should be codified into a method somewhere
-          if component_dir.path == "lib"
+          if component_dir.path == LIB_DIR
             # Expect component files in the root of the lib/ component dir to define
             # classes inside the slice's namespace.
             #
@@ -141,8 +200,6 @@ module Hanami
             # "foo"
             component_dir.namespaces.delete_root
             component_dir.namespaces.add_root(key: nil, const: namespace_path)
-
-            container.config.component_dirs.add(component_dir)
           else
             # Expect component files in the root of non-lib/ component dirs to define
             # classes inside a namespace matching that dir.
@@ -154,13 +211,15 @@ module Hanami
 
             component_dir.namespaces.delete_root
             component_dir.namespaces.add_root(const: dir_namespace_path, key: component_dir.path)
-
-            container.config.component_dirs.add(component_dir)
           end
+
+          container.config.component_dirs.add(component_dir)
         end
       end
 
-      if root&.directory?
+      def prepare_autoloader # rubocop:disable Metrics/AbcSize
+        return unless root&.directory?
+
         # Pass configured autoload dirs to the autoloader
         application.configuration.source_dirs.autoload_paths.each do |autoload_path|
           next unless root.join(autoload_path).directory?
@@ -180,13 +239,15 @@ module Hanami
         end
       end
 
-      if namespace
+      def prepare_container_imports
+        container.import from: application.container, as: :application
+      end
+
+      def prepare_container_consts
         namespace.const_set :Container, container
         namespace.const_set :Deps, container.injector
       end
-
-      container
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/hanami/version.rb

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

data/lib/hanami.rb

@@ -1,19 +1,25 @@
 # frozen_string_literal: true
 
+require_relative "hanami/application"
+require_relative "hanami/errors"
+require_relative "hanami/version"
+
+
 # A complete web framework for Ruby
 #
 # @since 0.1.0
 #
 # @see http://hanamirb.org
 module Hanami
-  require "hanami/version"
-  require "hanami/application"
-
   @_mutex = Mutex.new
 
   def self.application
     @_mutex.synchronize do
-      raise "Hanami.application not configured" unless defined?(@_application)
+      unless defined?(@_application)
+        raise ApplicationLoadError,
+          "Hanami.application is not yet configured. " \
+          "You may need to `require \"hanami/setup\"` to load your config/application.rb file."
+      end
 
       @_application
     end
@@ -25,7 +31,9 @@ module Hanami
 
   def self.application=(klass)
     @_mutex.synchronize do
-      raise "Hanami.application already configured" if defined?(@_application)
+      if defined?(@_application)
+        raise ApplicationLoadError, "Hanami.application is already configured."
+      end
 
       @_application = klass unless klass.name.nil?
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hanami
 version: !ruby/object:Gem::Version
-  version: 2.0.0.alpha6
+  version: 2.0.0.alpha7
 platform: ruby
 authors:
 - Luca Guidi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-10 00:00:00.000000000 Z
+date: 2022-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -230,11 +230,14 @@ files:
 - lib/hanami/application/routing/resolver.rb
 - lib/hanami/application/routing/resolver/node.rb
 - lib/hanami/application/routing/resolver/trie.rb
+- lib/hanami/application/routing/router.rb
 - lib/hanami/application/settings.rb
 - lib/hanami/application/settings/dotenv_store.rb
+- lib/hanami/application/slice_registrar.rb
 - lib/hanami/assets/application_configuration.rb
 - lib/hanami/assets/configuration.rb
 - lib/hanami/boot.rb
+- lib/hanami/boot/source_dirs.rb
 - lib/hanami/cli/application/cli.rb
 - lib/hanami/cli/application/command.rb
 - lib/hanami/cli/application/commands.rb
@@ -244,12 +247,15 @@ files:
 - lib/hanami/cli/commands/command.rb
 - lib/hanami/cli/commands/server.rb
 - lib/hanami/configuration.rb
+- lib/hanami/configuration/actions.rb
 - lib/hanami/configuration/logger.rb
 - lib/hanami/configuration/middleware.rb
 - lib/hanami/configuration/null_configuration.rb
 - lib/hanami/configuration/router.rb
 - lib/hanami/configuration/sessions.rb
 - lib/hanami/configuration/source_dirs.rb
+- lib/hanami/constants.rb
+- lib/hanami/errors.rb
 - lib/hanami/prepare.rb
 - lib/hanami/server.rb
 - lib/hanami/setup.rb