hanami 2.0.0.alpha1 → 2.0.0.alpha2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c197523a333228ef0596099b121a0f3a3e02c4a5a0da3f3f4fe837e794b7cf8
-  data.tar.gz: 5a7526ef47fc6f64ebffdae725d26a17944e390274dbc478ff52d593c7ba63b9
+  metadata.gz: ee3c6a367cfd05f2b18ae080da80b75a08a8680bd922ac8b00433e0c59f53f2b
+  data.tar.gz: 2de0d4102bf80606d130c04d83716370fe2c1c985986cd034ce232ff08e9be61
 SHA512:
-  metadata.gz: dd55bf77935140473affae77676eae8afe042f385dee3288dd9d80729fb887899f89950f26b83e2b793161545347cdc3dab8a5f6e0915013aa333c2caf2e080d
-  data.tar.gz: d254599b55640e0e3a27b718c1ae7141a40662c7291e60463d9620383cc419d49f06f5c8d1712b484f50ba758b71bf3f0ae79729452243532a0769e00478af8b
+  metadata.gz: a7d143ccf35f088d91fa1702d40b5aac22b3cada72cf566b239403d97fdd22b0839f93a1c20286853ae440ea4898902605b0bfbd3b05854f149de98ef9a78a83
+  data.tar.gz: 8f512b014ed54456df5beb0d3ecccbe260f0186d3ebfba7fb2fc51f9d80956b511ab87e08e1149dd2dd02d94939a1b260059f2cfcaa1ee34ca6681aee1408434

data/CHANGELOG.md

@@ -1,6 +1,40 @@
 # Hanami
 The web, with simplicity.
 
+## v2.0.0.alpha2 - 2021-05-04
+### Added
+- [Luca Guidi] Official support for Ruby: MRI 3.0
+- [Tim Riley] Code autoloading via Zeitwerk
+- [Tim Riley] `Hanami::Application` subclasses generate and configure a `Dry::System::Container`, accessible via `.container` and `AppNamespace::Container`, with several common container methods available directly via the application subclass (e.g. `Bookshelf::Application["foo"]` or `Hanami.application["foo"]`)
+- [Tim Riley] Introduced `Hanami::Application.register_bootable` to register custom components
+- [Tim Riley] Introduced `Hanami::Application.keys` to get the list of resolved components
+- [Tim Riley] Dynamically create an auto-injection mixin (e.g. `Bookshelf::Deps`)
+    ```ruby
+    # frozen_string_literal: true
+
+    module Bookshelf
+      class CreateThing
+        include Deps[service_client: "some_service.client"]
+
+        def call(attrs)
+          # Validate attrs, etc.
+          service_client.create(attrs)
+        end
+      end
+    end
+    ```
+- [Tim Riley] Introduced application settings. They are accessible via `Hanami.application.settings` in `config/settings.rb`
+- [Tim Riley] Introduced application slices to organise high-level application concerns. Slices are generated based on subdirectories of `slices/`, and map onto corresponding ruby module namespaces, e.g. `slices/main` -> `Main`, with the slice instance itself being `Main::Slice` (as well as being accessible via `Hanami.application.slices[:main]`)
+- [Tim Riley] Each slice generates and configures has its own `Dry::System::Container`, accessible via the slice instance (e.g. `Main::Slice.container`) as well as via its own constant (e.g. `Main::Container`)
+- [Tim Riley] Slice containers automatically import the application container, under the `"application"` namespace
+- [Tim Riley] Allow slice containers to be imported by other slice containers
+
+### Changed
+- [Luca Guidi] Drop support for Ruby: MRI 2.5
+- [Tim Riley] Removed `config.cookies` in favor of `config.actions.cookies`
+- [Tim Riley] Removed `config.sessions` in favor of `config.actions.sessions`
+- [Tim Riley] Removed `config.security` settings
+
 ## v2.0.0.alpha1 - 2019-01-30
 ### Added
 - [Luca Guidi] Implemented from scratch `hanami version`
@@ -50,6 +84,37 @@ end
 - [Luca Guidi] Removed `shotgun` and code reloading from the core. Code reloading is implemented by `hanami-reloader` gem.
 - [Luca Guidi] Removed support for `.hanamirc`
 
+## v1.3.4 - 2021-05-02
+### Fixed
+- [Slava Kardakov] Fix generated `config.ru` `require_relative` statement
+- [Armin] Fix `Hanami::CommonLogger` elapsed time compatibility with `rack` 2.1.0+
+- [Adam Daniels] Fix generated tests compatibility with `minitest` 6.0+
+
+## v1.3.3 - 2019-09-20
+### Added
+- [Gray Manley] Standardize file loading for `.env` files (see: https://github.com/bkeepers/dotenv#what-other-env-files-can-i-use)
+
+### Fixed
+- [Alfonso Uceda & Luca Guidi] Ensure to use `:host` option when mounting an application in main router (e.g. `mount Beta::Application.new, at: "/", host: "beta.hanami.test"`)
+
+## v1.3.2 - 2019-07-26
+### Added
+- [Luca Guidi] Support both `hanami-validations` 1 and 2
+
+### Fixed
+- [Wisnu Adi Nurcahyo] Ensure `hanami generate` syntax for Welcome page is compatible with ZSH
+- [Luca Guidi] Don't let `hanami` to crash when called without `bundle exec`
+
+## v1.3.1 - 2019-01-18
+### Added
+- [Luca Guidi] Official support for Ruby: MRI 2.6
+- [Luca Guidi] Support `bundler` 2.0+
+
+### Fixed
+- [Aidan Coyle] Remove from app generator support for deprecated `force_ssl` setting
+- [Alessandro Caporrini] Remove from app generator support for deprecated `body_parsers` setting
+- [Daphne Rouw & Sean Collins] Make app generator to work when code in `config/environment.rb` uses double quotes
+
 ## v1.3.0 - 2018-10-24
 ### Added
 - [Luca Guidi] Automatically log body payload from body parsers
@@ -65,7 +130,7 @@ end
 
 ### Fixed
 - [Anton Davydov] Make possible to pass extra settings for custom logger instances (eg. `logger SemanticLogger.new, :foo, :bar`)
-- [graywolf] Ensure `hanami generate app` to work without `require_relative` entries in `config/enviroment.rb`
+- [graywolf] Ensure `hanami generate app` to work without `require_relative` entries in `config/environment.rb`
 - [Makoto Tajitsu & Luca Guidi] Fixed regression for `hanami new .` that used to generate a broken project
 
 ### Fixed
@@ -182,7 +247,7 @@ end
 - [Luca Guidi] Make compatible with Rack 2.0 only
 - [Luca Guidi] Removed `logger` settings from Hanami applications
 - [Luca Guidi] Removed logger for Hanami applications (eg `Web.logger`)
-- [Luca Guidi] Changed mailer syntax in `config/enviroment.rb`
+- [Luca Guidi] Changed mailer syntax in `config/environment.rb`
 
 ## v0.9.2 - 2016-12-19
 ## Added
@@ -271,11 +336,11 @@ end
 
 ## v0.7.2 - 2016-02-09
 ### Fixed
-- [Alfonso Uceda Pompa] Fixed routing issue when static assets server tried to hijiack paths that are matching directories in public directory
+- [Alfonso Uceda Pompa] Fixed routing issue when static assets server tried to hijack paths that are matching directories in public directory
 
 ## v0.7.1 - 2016-02-05
 ### Fixed
-- [Anton Davydov] Fixed routing issue when static assets server tried to hijiack requests belonging to dynamic endpoints
+- [Anton Davydov] Fixed routing issue when static assets server tried to hijack requests belonging to dynamic endpoints
 - [Anatolii Didukh] Ensure to fallback to default engine for `hanami console`
 
 ## v0.7.0 - 2016-01-22
@@ -410,7 +475,7 @@ end
 ## v0.3.0 - 2015-03-23
 ### Added
 - [Luca Guidi] Introduced action generator. Eg. `bundle exec lotus generate action web dashboard#index`
-- [Alfonso Uceda Pompa] Allow to specify default coookies options in application configuration. Eg. `cookies true, { domain: 'lotusrb.org' }`
+- [Alfonso Uceda Pompa] Allow to specify default cookies options in application configuration. Eg. `cookies true, { domain: 'lotusrb.org' }`
 - [Tom Kadwill] Include `Lotus::Helpers` in views.
 - [Linus Pettersson] Allow to specify `--database` CLI option when generate a new project. Eg. `lotus new bookshelf --database=postgresql`
 - [Linus Pettersson] Initialize a Git repository when generating a new project

data/FEATURES.md

@@ -5,6 +5,14 @@
 
 ## v2.0.0.alpha1 - 2019-01-30
 
+## v1.3.3 - 2019-09-20
+
+- Standardize file loading for `.env` files (see: https://github.com/bkeepers/dotenv#what-other-env-files-can-i-use)
+
+## v1.3.2 - 2019-07-26
+
+## v1.3.1 - 2019-01-18
+
 ## v1.3.0 - 2018-10-24
 
 - Default testing framework is RSpec
@@ -20,7 +28,7 @@
 - Unobtrusive JavaScript (UJS) (via `hanami-ujs` gem)
 - Interactive console for development error page (via `hanami-webconsole` gem)
 - CLI: register callbacks for `hanami` commands (`Hanami::CLI.after("db migrate", MyCallback.new)` or `Hanami::CLI.after("db migrate") { ... }`)
-- Project level Rack middleware stack (`Hanami.configure { middleware.use MyRackMiddlewre }`)
+- Project level Rack middleware stack (`Hanami.configure { middleware.use MyRackMiddleware }`)
 - Plugins can hook into project configuration (`Hanami.plugin { middleware.use AnotherRackMiddleware }`)
 - Custom repository commands
 - Coloured logging

data/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright © 2014-2017 Luca Guidi
+Copyright © 2014-2021 Luca Guidi
 
 MIT License
 

data/README.md

@@ -18,7 +18,6 @@ which provides the glue that ties all the parts together:
 * [**Hanami::Helpers**](https://github.com/hanami/helpers) - View helpers for Ruby applications
 * [**Hanami::Mailer**](https://github.com/hanami/mailer) - Mail for Ruby applications
 * [**Hanami::Assets**](https://github.com/hanami/assets) - Assets management for Ruby
-* [**Hanami::CLI**](https://github.com/hanami/cli) - Ruby command line interface
 * [**Hanami::Utils**](https://github.com/hanami/utils) - Ruby core extensions and class utilities
 
 These components are designed to be used independently or together in a Hanami application.
@@ -26,14 +25,14 @@ These components are designed to be used independently or together in a Hanami a
 ## Status
 
 [![Gem Version](https://badge.fury.io/rb/hanami.svg)](https://badge.fury.io/rb/hanami)
-[![TravisCI](https://travis-ci.org/hanami/hanami.svg?branch=master)](https://travis-ci.org/hanami/hanami)
-[![Test Coverage](https://codecov.io/gh/hanami/hanami/branch/master/graph/badge.svg)](https://codecov.io/gh/hanami/hanami)
+[![CI](https://github.com/hanami/hanami/workflows/ci/badge.svg?branch=unstable)](https://github.com/hanami/hanami/actions?query=workflow%3Aci+branch%3Aunstable)
+[![Test Coverage](https://codecov.io/gh/hanami/hanami/branch/unstable/graph/badge.svg)](https://codecov.io/gh/hanami/hanami)
 [![Depfu](https://badges.depfu.com/badges/ba000e0f69e6ef1c44cd3038caaa1841/overview.svg)](https://depfu.com/github/hanami/hanami?project=Bundler)
 [![Inline Docs](http://inch-ci.org/github/hanami/hanami.svg)](http://inch-ci.org/github/hanami/hanami)
 
 ## Installation
 
-__Hanami__ supports Ruby (MRI) 2.5+
+__Hanami__ supports Ruby (MRI) 2.6+
 
 ```shell
 gem install hanami
@@ -137,4 +136,4 @@ Released under MIT License.
 
 This project was formerly known as Lotus (`lotusrb`).
 
-Copyright © 2014-2019 Luca Guidi.
+Copyright © 2014-2021 Luca Guidi.

data/hanami.gemspec

@@ -4,7 +4,7 @@ lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "hanami/version"
 
-Gem::Specification.new do |spec|
+Gem::Specification.new do |spec| # rubocop:disable Metrics/BlockLength
   spec.name          = "hanami"
   spec.version       = Hanami::VERSION
   spec.authors       = ["Luca Guidi"]
@@ -15,22 +15,22 @@ Gem::Specification.new do |spec|
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -c -o --exclude-standard -z -- lib/* bin/* LICENSE.md README.md CODE_OF_CONDUCT.md CHANGELOG.md FEATURES.md hanami.gemspec`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test)/})
   spec.require_paths = ["lib"]
-  spec.required_ruby_version = ">= 2.5.0"
+  spec.required_ruby_version = ">= 2.6.0"
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
 
-  spec.add_dependency "hanami-utils",      "~> 2.0.alpha"
-  spec.add_dependency "hanami-router",     "~> 2.0.alpha"
-  spec.add_dependency "hanami-controller", "~> 2.0.alpha"
-  spec.add_dependency "hanami-cli",        "~> 1.0.alpha"
-  spec.add_dependency "dry-system",        "~> 0.10"
-  spec.add_dependency "dry-inflector",     "~> 0.1", ">= 0.1.2"
   spec.add_dependency "bundler",           ">= 1.16", "< 3"
+  spec.add_dependency "dry-core",          "~> 0.4"
+  spec.add_dependency "dry-inflector",     "~> 0.1", ">= 0.1.2"
+  spec.add_dependency "dry-monitor"
+  spec.add_dependency "dry-system",        "~> 0.19", ">= 0.19.0"
+  spec.add_dependency "hanami-cli",        "~> 2.0.alpha"
+  spec.add_dependency "hanami-utils",      "~> 2.0.alpha"
+  spec.add_dependency "zeitwerk",          "~> 2.4"
 
-  spec.add_development_dependency "rspec",     "~>  3.8"
+  spec.add_development_dependency "rspec",     "~> 3.8"
   spec.add_development_dependency "rack-test", "~> 1.1"
-  spec.add_development_dependency "rake",      "~> 12.0"
+  spec.add_development_dependency "rake",      "~> 13.0"
 end

data/lib/hanami.rb

@@ -7,25 +7,27 @@
 # @see http://hanamirb.org
 module Hanami
   require "hanami/version"
-  require "hanami/frameworks"
-  require "hanami/container"
   require "hanami/application"
 
   @_mutex = Mutex.new
 
   def self.application
     @_mutex.synchronize do
-      raise "Hanami application not configured" unless defined?(@_application)
+      raise "Hanami.application not configured" unless defined?(@_application)
 
       @_application
     end
   end
 
-  def self.application=(app)
+  def self.application?
+    defined?(@_application)
+  end
+
+  def self.application=(klass)
     @_mutex.synchronize do
-      raise "Hanami application already configured" if defined?(@_application)
+      raise "Hanami.application already configured" if defined?(@_application)
 
-      @_application = app unless app.name.nil?
+      @_application = klass unless klass.name.nil?
     end
   end
 
@@ -45,10 +47,6 @@ module Hanami
     end
   end
 
-  def self.root
-    Container.root
-  end
-
   def self.env
     (ENV["HANAMI_ENV"] || "development").to_sym
   end
@@ -58,18 +56,21 @@ module Hanami
   end
 
   def self.logger
-    Container[:logger]
+    application[:logger]
   end
 
-  def self.boot
-    @_mutex.synchronize do
-      raise "Hanami application already booted" if defined?(@_booted)
+  def self.init
+    application.init
+  end
 
-      @_booted = true
-    end
+  def self.boot(web: true)
+    if defined?(@_app)
+      @_app
+    else
+      application.boot
 
-    Container.finalize!
-    self.app = application.new
+      @_app = application.new if web
+    end
   end
 
   def self.bundler_groups

data/lib/hanami/application.rb

@@ -1,66 +1,362 @@
 # frozen_string_literal: true
 
+require "dry/system/container"
 require "hanami/configuration"
-require "hanami/routes"
-require "hanami/router"
+require "pathname"
+require "rack"
+require_relative "slice"
+require_relative "application/autoloader/inflector_adapter"
+require_relative "application/settings"
 
 module Hanami
-  # Hanami application
+  # Hanami application class
   #
   # @since 2.0.0
   class Application
     @_mutex = Mutex.new
 
-    def self.inherited(app)
-      @_mutex.synchronize do
-        app.class_eval do
-          @_mutex         = Mutex.new
-          @_configuration = Hanami::Configuration.new(env: Hanami.env)
+    class << self
+      def inherited(klass)
+        @_mutex.synchronize do
+          klass.class_eval do
+            @_mutex         = Mutex.new
+            @_configuration = Hanami::Configuration.new(env: Hanami.env)
 
-          extend ClassMethods
-          include InstanceMethods
-        end
+            extend ClassMethods
+            include InstanceMethods
+          end
+
+          klass.send :prepare_base_load_path
 
-        Hanami.application = app
+          Hanami.application = klass
+        end
       end
     end
 
-    # Class method interface
+    # Application class interface
     #
-    # @since 2.0.0
+    # rubocop:disable Metrics/ModuleLength
     module ClassMethods
+      def self.extended(klass)
+        klass.class_eval do
+          @inited = @booted = false
+        end
+      end
+
       def configuration
         @_configuration
       end
 
       alias config configuration
 
-      def routes(&blk)
+      def init # rubocop:disable Metrics/MethodLength
+        return self if inited?
+
+        configuration.finalize
+
+        load_settings
+
+        @container = prepare_container
+        @deps_module = prepare_deps_module
+
+        load_slices
+        slices.values.each(&:init)
+        slices.freeze
+
+        if configuration.autoloader
+          configuration.autoloader.inflector = Autoloader::InflectorAdapter.new(inflector)
+          configuration.autoloader.setup
+        end
+
+        load_routes
+
+        @inited = true
+        self
+      end
+
+      def inited?
+        @inited
+      end
+
+      def container
+        raise "Application not init'ed" unless defined?(@container)
+
+        @container
+      end
+
+      def deps
+        raise "Application not init'ed" unless defined?(@deps_module)
+
+        @deps_module
+      end
+
+      def slices
+        @slices ||= {}
+      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
+      end
+
+      def register(*args, **opts, &block)
+        container.register(*args, **opts, &block)
+      end
+
+      def register_bootable(*args, **opts, &block)
+        container.boot(*args, **opts, &block)
+      end
+
+      def init_bootable(*args)
+        container.init(*args)
+      end
+
+      def start_bootable(*args)
+        container.start(*args)
+      end
+
+      def key?(*args)
+        container.key?(*args)
+      end
+
+      def keys
+        container.keys
+      end
+
+      def [](*args)
+        container[*args]
+      end
+
+      def resolve(*args)
+        container.resolve(*args)
+      end
+
+      def boot(&block)
+        return self if booted?
+
+        init
+
+        container.finalize!(&block)
+
+        slices.values.each(&:boot)
+
+        @booted = true
+        self
+      end
+
+      def booted?
+        @booted
+      end
+
+      def settings(&block) # rubocop:disable Metrics/MethodLength
+        if block
+          @_settings = Application::Settings.build(
+            configuration.settings_loader,
+            configuration.settings_loader_options,
+            &block
+          )
+        elsif instance_variable_defined?(:@_settings)
+          @_settings
+        else
+          # Load settings lazily so they can be used to configure the
+          # Hanami::Application subclass (before the application has inited)
+          load_settings
+          @_settings ||= nil
+        end
+      end
+
+      def routes(&block)
         @_mutex.synchronize do
-          if blk.nil?
+          if block.nil?
             raise "Hanami.application.routes not configured" unless defined?(@_routes)
 
             @_routes
           else
-            @_routes = Routes.new(&blk)
+            @_routes = block
+          end
+        end
+      end
+
+      MODULE_DELIMITER = "::"
+      private_constant :MODULE_DELIMITER
+
+      def namespace
+        inflector.constantize(name.split(MODULE_DELIMITER)[0..-2].join(MODULE_DELIMITER))
+      end
+
+      def namespace_path
+        inflector.underscore(namespace)
+      end
+
+      def application_name
+        inflector.underscore(namespace).to_sym
+      end
+
+      def root
+        configuration.root
+      end
+
+      def inflector
+        configuration.inflector
+      end
+
+      # @api private
+      def component_provider(component)
+        raise "Hanami.application must be inited before detecting providers" unless inited?
+
+        # [Admin, Main, MyApp] or [MyApp::Admin, MyApp::Main, MyApp]
+        providers = slices.values + [self]
+
+        component_class = component.is_a?(Class) ? component : component.class
+        component_name = component_class.name
+
+        return unless component_name
+
+        providers.detect { |provider| component_name.include?(provider.namespace.to_s) }
+      end
+
+      private
+
+      def prepare_base_load_path
+        base_path = File.join(root, "lib")
+        $LOAD_PATH.unshift base_path unless $LOAD_PATH.include?(base_path)
+      end
+
+      def prepare_container
+        define_container.tap do |container|
+          configure_container container
+        end
+      end
+
+      def prepare_deps_module
+        define_deps_module
+      end
+
+      def define_container
+        require "#{application_name}/container"
+        namespace.const_get :Container
+      rescue LoadError, NameError
+        namespace.const_set :Container, Class.new(Dry::System::Container)
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      def configure_container(container)
+        container.use :env, inferrer: -> { Hanami.env }
+        container.use :notifications
+
+        container.configure do |config|
+          config.inflector = configuration.inflector
+
+          config.root = configuration.root
+          config.bootable_dirs = [
+            "config/boot",
+            Pathname(__dir__).join("application/container/boot").realpath,
+          ]
+
+          if configuration.autoloader
+            require "dry/system/loader/autoloading"
+            config.component_dirs.loader = Dry::System::Loader::Autoloading
+            config.component_dirs.add_to_load_path = false
+          end
+
+          if root.join("lib").directory?
+            config.component_dirs.add "lib" do |dir|
+              dir.default_namespace = application_name.to_s
+            end
+
+            configuration.autoloader&.push_dir(root.join("lib"))
           end
         end
+
+        container
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+      def define_deps_module
+        require "#{application_name}/deps"
+        namespace.const_get :Deps
+      rescue LoadError, NameError
+        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)
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      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
+        end
+
+        register_slice(
+          slice_name,
+          namespace: slice_module,
+          root: slice_path.realpath
+        )
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      def load_routes
+        require File.join(configuration.root, configuration.router.routes)
+      rescue LoadError # rubocop:disable Lint/SuppressedException
+      end
+
+      def load_settings
+        prepare_base_load_path
+        require File.join(configuration.root, configuration.settings_path)
+      rescue LoadError # rubocop:disable Lint/SuppressedException
       end
     end
+    # rubocop:enable Metrics/ModuleLength
 
-    # Instance method interface
-    #
-    # @since 2.0.0
+    # Application instance interface
     module InstanceMethods
-      def initialize(configuration: self.class.configuration, routes: self.class.routes)
-        @app = Rack::Builder.new do
-          configuration.for_each_middleware do |m, *args|
-            use m, *args
-          end
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def initialize(application = self.class)
+        require_relative "application/router"
+
+        application.boot
+
+        resolver = application.config.router.resolver.new(
+          slices: application.slices,
+          inflector: application.inflector
+        )
 
-          run Hanami::Router.new(**configuration.router_settings, &routes)
+        router = Application::Router.new(
+          routes: application.routes,
+          resolver: resolver,
+          **application.configuration.router.options,
+        ) do
+          use application[:rack_monitor]
+
+          application.config.for_each_middleware do |m, *args, &block|
+            use(m, *args, &block)
+          end
         end
+
+        @app = router.to_rack_app
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
       def call(env)
         @app.call(env)