hanami 2.0.0.alpha1 → 2.0.0.alpha5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c197523a333228ef0596099b121a0f3a3e02c4a5a0da3f3f4fe837e794b7cf8
-  data.tar.gz: 5a7526ef47fc6f64ebffdae725d26a17944e390274dbc478ff52d593c7ba63b9
+  metadata.gz: 9c8875d3320057cffe3af1a7bb2ff781cd8ad2145c446fc9e9190d344a4a48e6
+  data.tar.gz: c003bc2117815e10f2c15f458fb3bc6d94b480dfe9f2ec98e6458804f8a0d06d
 SHA512:
-  metadata.gz: dd55bf77935140473affae77676eae8afe042f385dee3288dd9d80729fb887899f89950f26b83e2b793161545347cdc3dab8a5f6e0915013aa333c2caf2e080d
-  data.tar.gz: d254599b55640e0e3a27b718c1ae7141a40662c7291e60463d9620383cc419d49f06f5c8d1712b484f50ba758b71bf3f0ae79729452243532a0769e00478af8b
+  metadata.gz: 7b133de3c728132ef6255480b10068482d58cf1e2708df395f00cc5981cdccac70cbecdb2c8325cd822298d7c92c0ee0253ab1f8f9d95ddf84b0d6de556e7f3f
+  data.tar.gz: 42b525e3163e7bb73938b5e2fa444ccc15cc38def3e74225086f0e90bb0d805979e0a88a47703fcc73956d68598260ab366a1c155eb94b7114515b8ffc56671e

data/CHANGELOG.md

@@ -1,6 +1,276 @@
 # Hanami
 The web, with simplicity.
 
+## v2.0.0.alpha5 - 2022-01-12
+### Changed
+- [Luca Guidi] Sensible default configuration for application logger, with per-environment defaults:
+
+    The defaults are:
+
+    - In **production**, log for level `info`, send logs to `$stdout` in JSON format without colours
+    - In **development**, log for level `debug`, send logs to `$stdout` in single-line format with colours
+    - In **test**, log for level `debug`, send logs to `log/test.log` in single-line format without colours
+
+    To configure the logger:
+
+    ```ruby
+    module MyApp
+      class Application < Hanami::Application
+        config.logger.level = :info
+
+        config.logger.stream = $stdout
+        config.logger.stream = "/path/to/file"
+        config.logger.stream = StringIO.new
+
+        config.logger.format = :json
+        config.logger.format = MyCustomFormatter.new
+
+        config.logger.color = false # disable coloring
+        config.logger.color = MyCustomColorizer.new
+
+        config.logger.filters << "secret" # add
+        config.logger.filters += ["yet", "another"] # add
+        config.logger.filters = ["foo"] # replace
+
+        # See https://ruby-doc.org/stdlib/libdoc/logger/rdoc/Logger.html
+        config.logger.options = ["daily"] # time based log rotation
+        config.logger.options = [0, 1048576] # size based log rotation
+      end
+    end
+    ```
+
+    To configure the logger for specific environments:
+
+    ```ruby
+    module MyApp
+      class Application < Hanami::Application
+        config.environment(:staging) do
+          config.logger.level = :info
+        end
+      end
+    end
+    ```
+
+    To assign a custom replacement logger object:
+
+    ```ruby
+    module MyApp
+      class Application < Hanami::Application
+        config.logger = MyCustomLogger.new
+      end
+    end
+    ```
+- [Tim Riley] Comprehensive `config.source_dirs` setting
+
+    This replaces the previous `component_dir_paths` setting, and contains two nested settings:
+
+    - `config.source_dirs.component_dirs` (backed by `Dry::System::Config::ComponentDirs`), for directories of source files intended to be registered as components
+    - `config.source_dirs.autoload_paths`, for directories of source files not intended for registration as components, but still to be made accessible by the autoloader
+
+    To add and configure your own additional component dirs:
+
+    ```ruby
+    module MyApp
+      class Application < Hanami::Application
+        # Adding a simple component dir
+        config.source_dirs.component_dirs.add "serializers"
+
+        # Adding a component dir with custom configuration
+        config.source_dirs.component_dirs.add "serializers" do |dir|
+          dir.auto_register = proc { |component|
+            !component.identifier.start_with?("structs")
+          }
+        end
+      end
+    end
+    ```
+
+    To customize the configuration of the default component dirs ("lib", "actions", "repositories", "views"):
+
+    ```ruby
+    module MyApp
+      class Application < Hanami::Application
+        # Customising a default component dir
+        config.source_dirs.component_dirs.dir("lib").auto_register = proc { |component|
+          !component.identifier.start_with?("structs")
+        }
+
+        # Setting default config to apply to all component dirs
+        config.source_dirs.component_dirs.auto_register = proc { |component|
+          !component.identifier.start_with?("entities")
+        }
+
+        # Removing a default component dir
+        config.source_dirs.component_dirs.delete("views")
+      end
+    end
+    ```
+
+    To configure the autoload paths (defaulting to `["entities"]`):
+
+    ```ruby
+    module MyApp
+      class Application < Hanami::Application
+        # Adding your own autoload paths
+        config.source_dirs.autoload_paths << "structs"
+
+        # Or providing a full replacement
+        config.source_dirs.autoload_paths = ["structs"]
+      end
+    end
+    ```
+- [Tim Riley] Application router is lazy loaded (not requiring application to be fully booted) and now available via `Hanami.rack_app` or `Hanami.application.rack_app`, instead of the previous `Hanami.app` (which required the app to be booted first).
+
+## v2.0.0.alpha4 - 2021-12-07
+### Added
+- [Luca Guidi] Manage Content Security Policy (CSP) with "zero-defaults" policy. New API to change CSP values and to disable the feature.
+    ```ruby
+    # Read a CSP value
+
+    module MyApp
+      class Application < Hanami::Application
+        config.actions.content_security_policy[:base_uri] # => "'self'"
+      end
+    end
+    ```
+
+    ```ruby
+    # Override a default CSP value
+
+    module MyApp
+      class Application < Hanami::Application
+        # This line will generate the following CSP fragment
+        # plugin-types ;
+        config.actions.content_security_policy[:plugin_types] = nil
+      end
+    end
+    ```
+
+    ```ruby
+    # Append to a default CSP value
+
+    module MyApp
+      class Application < Hanami::Application
+        # This line will generate the following CSP fragment
+        # script-src 'self' https://my.cdn.test;
+        config.actions.content_security_policy[:script_src] += " https://my.cdn.test"
+      end
+    end
+    ```
+
+    ```ruby
+    # Add a custom CSP key. Useful when CSP standard evolves.
+
+    module MyApp
+      class Application < Hanami::Application
+        # This line will generate the following CSP fragment
+        # my-custom-setting 'self';
+        config.actions.content_security_policy[:my-custom-setting] = "'self'"
+      end
+    end
+    ```
+
+    ```ruby
+    # Delete a CSP key.
+
+    module MyApp
+      class Application < Hanami::Application
+        config.actions.content_security_policy.delete(:object_src)
+      end
+    end
+    ```
+
+    ```ruby
+    # Disable CSP feature.
+
+    module MyApp
+      class Application < Hanami::Application
+        config.actions.content_security_policy = false
+      end
+    end
+    ```
+
+## v2.0.0.alpha3 - 2021-11-09
+### Added
+- [Luca Guidi] Added `Hanami.shutdown` to stop all bootable components in the application container
+- [Tim Riley] Added `component_dir_paths` application setting to allow for components to be loaded from additional directories inside each slice directory. To begin with, this defaults to `%w[actions repositories views]`. Components inside these directories are expected to be namespaced to match the directory name; e.g. given a `main` slice, `slices/main/actions/home.rb` is expected to define `Main::Actions::Home`, and will be registered in the slice container as `"actions.home"`.
+
+### Changed
+- [Tim Riley] A slice's classes can now be defined directly inside `slices/[slice_name]/lib/`; e.g. given a `main` slice, `slices/main/lib/example.rb` is expected to define `Main::Example`, and will be registered in the slice container as `"example"`
+- [Tim Riley] The root `lib/` directory is no longer configured as a component dir, and classes inside `lib/[app_namespace]/` will no longer be auto-registered into the container. If you need to share components, create them in their own slices as appropriate, and import those slices into the other slices that require them.
+- [Tim Riley] `lib/[app_namespace]/` is configured for autoloading, and `lib/` is added to `$LOAD_PATH` to support explicit requires for source files outside `lib/[app_namespace]/`.
+- [Tim Riley] (Internal) Ported `Hanami::Configuration` and related classes to use dry-configurable
+- [Tim Riley] Application inflector can be entirely replaced, if required, via `Hanami::Configuration#inflector=`. Custom inflection rules can still be provided to the default inflector via `Hanami::Configuration#inflections`.
+- [Marc Busqué] App settings are defined within a concrete class rather than an anonymous block, to allow for users to leverage the typical behavior of Ruby classes, such as for defining their own types module to use for coercing setting values. This class also relies on dry-configurable for its settings implementation, so the standard dry-configurable `setting` API is available, such as the `constructor:` and `default:` options.
+    ```ruby
+    # frozen_string_literal: true
+
+    require "dry/types"
+    require "hanami/application/settings"
+
+    module TestApp
+      class Settings < Hanami::Application::Settings
+        # Example usage of a types module (previously not possible inside the anonymous block)
+        Types = Dry.Types()
+
+        setting :session_secret, constructor: Types::String.constrained(min_size: 20)
+
+        setting :some_bool, constructor: Types::Params::Bool, default: false
+      end
+    end
+    ```
+- [Marc Busqué] Application `settings_loader` and `settings_loader_options` have been replaced with `settings_store`, which is an updated abstraction for providing setting values to work with the new `Hanami::Application::Settings` implementation noted above (see `Application::Settings::DotenvStore` for the default store, which provides the same behavior as previously)
+- [Marc Busqué] Routes are defined within a concrete class rather than an anonymous block, to provide consistency with the settings (noted above), as well a place for additional behavior (in future releases):
+    ```ruby
+    # frozen_string_literal: true
+
+    require "hanami/application/routes"
+
+    module MyApp
+      class Routes < Hanami::Application::Routes
+        define do
+          slice :main, at: "/" do
+            root to: "home.show"
+          end
+        end
+      end
+    end
+    ```
+
+## 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 +320,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 +366,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 +483,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 +572,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 +711,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

@@ -2,6 +2,10 @@
 
 The web, with simplicity.
 
+## Version
+
+**This branch contains the code for `hanami` 2.0.x.**
+
 ## Frameworks
 
 Hanami is a **full-stack** Ruby web framework.
@@ -18,7 +22,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 +29,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=main)](https://github.com/hanami/hanami/actions?query=workflow%3Aci+branch%3Amain)
+[![Test Coverage](https://codecov.io/gh/hanami/hanami/branch/main/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
@@ -55,7 +58,7 @@ You can give back to Open Source, by supporting Hanami development via a [donati
 
 ### Supporters
 
-  * [Trung Lê](https://github.com/joneslee85)
+  * [Trung Lê](https://github.com/runlevel5)
   * [James Carlson](https://github.com/jxxcarlson)
   * [Creditas](https://www.creditas.com.br/)
 
@@ -137,4 +140,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,23 @@ 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-configurable",  "~> 0.12", ">= 0.12.1"
+  spec.add_dependency "dry-core",          "~> 0.4"
+  spec.add_dependency "dry-inflector",     "~> 0.2", ">= 0.2.1"
+  spec.add_dependency "dry-monitor"
+  spec.add_dependency "dry-system",        "~> 0.22", ">= 0.22.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/application/autoloader/inflector_adapter.rb

@@ -0,0 +1,22 @@
+module Hanami
+  class Application
+    module Autoloader
+      # Allows the Hanami standard inflector (from dry-inflector) to be used with Zeitwerk
+      class InflectorAdapter
+        def initialize(inflector)
+          @inflector = inflector
+        end
+
+        def camelize(basename, _abspath)
+          # Discard unused `_abspath` argument before calling our own inflector's
+          # `#camelize` (which takes only one argument)
+          inflector.camelize(basename)
+        end
+
+        private
+
+        attr_reader :inflector
+      end
+    end
+  end
+end

data/lib/hanami/application/container/boot/inflector.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+Hanami.application.register_bootable :inflector do
+  start do
+    register :inflector, Hanami.application.inflector
+  end
+end

data/lib/hanami/application/container/boot/logger.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+Hanami.application.register_bootable :logger do
+  start do
+    register :logger, Hanami.application.configuration.logger_instance
+  end
+end

data/lib/hanami/application/container/boot/rack_logger.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+Hanami.application.register_bootable :rack_logger do |container|
+  start do
+    require "hanami/web/rack_logger"
+
+    use :logger
+    use :rack_monitor
+
+    rack_logger = Hanami::Web::RackLogger.new(
+      container[:logger],
+      filter_params: Hanami.application.configuration.logger.filters
+    )
+
+    rack_logger.attach container[:rack_monitor]
+
+    register :rack_logger, rack_logger
+  end
+end

data/lib/hanami/application/container/boot/rack_monitor.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+Hanami.application.register_bootable :rack_monitor do |container|
+  start do
+    require "dry/monitor"
+    require "dry/monitor/rack/middleware"
+
+    middleware = Dry::Monitor::Rack::Middleware.new(container[:notifications])
+
+    register :rack_monitor, middleware
+  end
+end

data/lib/hanami/application/container/boot/routes_helper.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+Hanami.application.register_bootable :routes_helper do
+  start do
+    require "hanami/application/routes_helper"
+
+    register :routes_helper, Hanami::Application::RoutesHelper.new(Hanami.application.router)
+  end
+end

data/lib/hanami/application/container/boot/settings.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+Hanami.application.register_bootable :settings do
+  start do
+    register :settings, Hanami.application.settings
+  end
+end

data/lib/hanami/application/router.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "hanami/router"
+require "hanami/application/routing/middleware/stack"
+
+module Hanami
+  class Application
+    # Hanami application router
+    # @since 2.0.0
+    class Router < ::Hanami::Router
+      # @since 2.0.0
+      # @api private
+      def initialize(routes:, middleware_stack: Routing::Middleware::Stack.new, **kwargs, &blk)
+        @middleware_stack = middleware_stack
+        instance_eval(&blk)
+        super(**kwargs, &routes)
+      end
+
+      # @since 2.0.0
+      # @api private
+      def freeze
+        return self if frozen?
+
+        remove_instance_variable(:@middleware_stack)
+        super
+      end
+
+      # @since 2.0.0
+      # @api private
+      def use(middleware, *args, &blk)
+        @middleware_stack.use(middleware, *args, &blk)
+      end
+
+      # @since 2.0.0
+      # @api private
+      def scope(*args, &blk)
+        @middleware_stack.with(args.first) do
+          super
+        end
+      end
+
+      # @since 2.0.0
+      def slice(name, at:, &blk)
+        path = prefixed_path(at)
+        @resolver.register_slice_at_path(name, path)
+
+        scope(path, &blk)
+      end
+
+      # @since 2.0.0
+      # @api private
+      def to_rack_app
+        return self if @middleware_stack.empty?
+
+        @middleware_stack.to_rack_app(self)
+      end
+    end
+  end
+end