hanami 1.3.5 → 2.0.0.alpha4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92d8362c387abfc24cda9234c81c671d544f03a2ae2680c9f71d492c7172410a
-  data.tar.gz: 57643cd0ca74fd851e800edbe62c18464dc5ca0dcd09c66189ed53b256beb5f0
+  metadata.gz: 2188bc3aee5a164b6610c6bc97fad9f0bba0384bf11a80be27228e7f19dad4e0
+  data.tar.gz: 7fa39987132cf6bfda0b0986a36894d08297c1df06b31354cfbeae934d73a813
 SHA512:
-  metadata.gz: 6570e1184cc95fe719bbb366f59f082ccafdc55dddae70496c98579cd53f4d46a31bd740030b500e5d2b7ed03e2df8f42148344170c1a90453209b2575960441
-  data.tar.gz: f2409cb5bc4d8bf3c7fe4bfa026eb03a9315fb6ccb80e95aa2b44e9b94600427cab0814a00d32035128a3ace49b42ed35644e1d0652ffc584be2ac5ea6564db5
+  metadata.gz: f7b1aad0186fcdaa94593ba4ff5d01cf4f8d4431aaffba173c3c795c2c0c76993a27da3aa503b0ce59fd67467615c86c50a4ab227986e38dd0986e91c30766a5
+  data.tar.gz: cd2d8b82bc7f98e906686fdab7299282b1c1be4b29278c9ee5b0f9b3cefbb7d31fa83013a840b2b9fa2b8e2b2f3f8c0582ca3587b35ced91f65db6f853d67cf7

data/CHANGELOG.md

@@ -1,13 +1,204 @@
 # Hanami
 The web, with simplicity.
 
-## v1.3.5 - 2021-10-18
-### Fixed
-- [Ivan Kabluchkov] Ensure to properly store exceptions in Rack environment
-- [Sean Collins] Explicitly limit in gemspec the supported rubies (>= 2.3 and < 3) for Hanami 1
+## 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`
+- [Luca Guidi] Implemented from scratch `hanami server`
+- [Luca Guidi] Main configuration is opinionated: when a setting is not specified in generated code, it uses a framework default.
+- [Luca Guidi] Main configuration setting `environment`: to yield env based settings (e.g. `config.environment(:production) { |c| c.logger = {...} }`)
+- [Luca Guidi] Main configuration setting `base_url`: to set the base URL of the app (e.g. `config.base_url = "https://example.com"`)
+- [Luca Guidi] Main configuration setting `logger`: to set the logger options (e.g. `config.logger = { level: :info, format: :json }`)
+- [Luca Guidi] Main configuration setting `routes`: to set the path to routes file (e.g. `config.routes = "path/to/routes"`)
+- [Luca Guidi] Main configuration setting `cookies`: to set cookies options (e.g. `config.cookies = { max_age: 300 }`)
+- [Luca Guidi] Main configuration setting `sessions`: to set session options (e.g. `config.sessions = :cookie, { secret: "abc" }`)
+- [Luca Guidi] Main configuration setting `default_request_format`: to set the fallback for request format (aka MIME Type) (e.g. `config.default_request_format = :json`)
+- [Luca Guidi] Main configuration setting `default_response_format`: to set the default response format (aka MIME Type) (e.g. `config.default_response_format = :json`)
+- [Luca Guidi] Main configuration setting `middleware` to mount Rack middleware (e.g. `config.middleware.use MyMiddleware, "argument"`)
+- [Luca Guidi] Main configuration setting `security` to set security settings (see below)
+- [Luca Guidi] Main configuration setting `inflections` to configure inflections (e.g. `config.inflections { |i| i.plural "virus", "viruses" }`)
+- [Luca Guidi] Main configuration security setting `x_frame_options`: defaults to `"deny"` (e.g. `config.security.x_frame_options = "sameorigin"`)
+- [Luca Guidi] Main configuration security setting `x_content_type_options`: defaults to `"nosniff"` (e.g. `config.security.x_content_type_options = nil`)
+- [Luca Guidi] Main configuration security setting `x_xss_protection`: defaults to `"1; mode=block"` (e.g. `config.security.x_xss_protection = "1"`)
+- [Luca Guidi] Main configuration security setting `content_security_policy`: defaults to `"form-action 'self'; frame-ancestors 'self'; base-uri 'self'; default-src 'none'; script-src 'self'; connect-src 'self'; img-src 'self' https: data:; style-src 'self' 'unsafe-inline' https:; font-src 'self'; object-src 'none'; plugin-types application/pdf; child-src 'self'; frame-src 'self'; media-src 'self'"`
+  (e.g. `config.security.content_security_policy[:style_src] += " https://my.cdn.example"` to add another source)
+  (e.g. `config.security.content_security_policy[:plugin_types] = nil` to override the settings)
 
 ### Changed
-- [Luca Guidi] Use JSON as default HTTP session serializer for cookie session storage
+- [Luca Guidi] Drop support for Ruby: MRI 2.3, and 2.4.
+- [Luca Guidi] `Hanami::Application` must be used as superclass for main application under `config/application.rb` (e.g. `Bookshelf::Application`)
+- [Luca Guidi] Main configuration is available at `config/application.rb` instead of `config/enviroment.rb`
+- [Luca Guidi] Removed `Hanami.configure` in favor of main application configuration (e.g. `Bookshelf::Application.config`)
+- [Luca Guidi] Removed DSL syntax for main configuration (from `cookies max_age: 600` to `config.cookies = { max_age: 600 }`)
+- [Luca Guidi] Per enviroment settings must be wrapped in a block (e.g. `config.enviroment(:production) { |c| c.logger = {} }`)
+- [Luca Guidi] Concrete applications are no longer supported (e.g. `Web::Application` in `apps/web/application.rb`)
+- [Luca Guidi] Main routes must be configured at `config/routes.rb`:
+```ruby
+# frozen_string_literal: true
+
+Hanami.application.routes do
+  mount :web, at: "/" do
+    root to: "home#index"
+  end
+
+  mount :admin, at: "/admin" do
+    root to: "home#index"
+  end
+end
+```
+- [Luca Guidi] Per application routes are no longer supported (e.g. `apps/web/config/routes.rb`)
+- [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

data/FEATURES.md

@@ -3,9 +3,7 @@
 
 ## Features
 
-## v1.3.5 - 2021-10-18
-
-## v1.3.4 - 2021-05-02
+## v2.0.0.alpha1 - 2019-01-30
 
 ## v1.3.3 - 2019-09-20
 

data/README.md

@@ -4,7 +4,7 @@ The web, with simplicity.
 
 ## Version
 
-**This branch contains the code for `hanami` 1.3.x.**
+**This branch contains the code for `hanami` 2.0.x.**
 
 ## Frameworks
 
@@ -29,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)
-[![CI](https://github.com/hanami/hanami/workflows/ci/badge.svg?branch=1.3.x)](https://github.com/hanami/hanami/actions?query=workflow%3Aci+branch%3A1.3.x)
-[![Test Coverage](https://codecov.io/gh/hanami/hanami/branch/1.3.x/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.3+
+__Hanami__ supports Ruby (MRI) 2.6+
 
 ```shell
 gem install hanami

data/hanami.gemspec

@@ -1,40 +1,37 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'hanami/version'
+require "hanami/version"
 
-Gem::Specification.new do |spec|
-  spec.name          = 'hanami'
+Gem::Specification.new do |spec| # rubocop:disable Metrics/BlockLength
+  spec.name          = "hanami"
   spec.version       = Hanami::VERSION
-  spec.authors       = ['Luca Guidi']
-  spec.email         = ['me@lucaguidi.com']
-  spec.summary       = 'The web, with simplicity'
-  spec.description   = 'Hanami is a web framework for Ruby'
-  spec.homepage      = 'http://hanamirb.org'
-  spec.license       = 'MIT'
+  spec.authors       = ["Luca Guidi"]
+  spec.email         = ["me@lucaguidi.com"]
+  spec.summary       = "The web, with simplicity"
+  spec.description   = "Hanami is a web framework for Ruby"
+  spec.homepage      = "http://hanamirb.org"
+  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.3.0', '< 3'
+  spec.require_paths = ["lib"]
+  spec.required_ruby_version = ">= 2.6.0"
 
-  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
 
-  spec.add_dependency 'hanami-utils',       '~> 1.3'
-  spec.add_dependency 'hanami-validations', '>= 1.3', '< 3'
-  spec.add_dependency 'hanami-router',      '~> 1.3'
-  spec.add_dependency 'hanami-controller',  '~> 1.3', '>= 1.3.3'
-  spec.add_dependency 'hanami-view',        '~> 1.3'
-  spec.add_dependency 'hanami-helpers',     '~> 1.3'
-  spec.add_dependency 'hanami-mailer',      '~> 1.3'
-  spec.add_dependency 'hanami-assets',      '~> 1.3'
-  spec.add_dependency 'dry-cli',            '~> 0.5'
-  spec.add_dependency 'concurrent-ruby',    '~> 1.0'
-  spec.add_dependency 'bundler',            '>= 1.6', '< 3'
+  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.19", ">= 0.21.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.7'
-  spec.add_development_dependency 'rack-test', '~> 1.1'
-  spec.add_development_dependency 'aruba',     '~> 0.14'
-  spec.add_development_dependency 'rake',      '~> 13.0'
+  spec.add_development_dependency "rspec",     "~> 3.8"
+  spec.add_development_dependency "rack-test", "~> 1.1"
+  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.filter_params
+    )
+
+    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:, stack: Routing::Middleware::Stack.new, **kwargs, &blk)
+        @stack = stack
+        instance_eval(&blk)
+        super(**kwargs, &routes)
+      end
+
+      # @since 2.0.0
+      # @api private
+      def freeze
+        return self if frozen?
+
+        remove_instance_variable(:@stack)
+        super
+      end
+
+      # @since 2.0.0
+      # @api private
+      def use(middleware, *args, &blk)
+        @stack.use(middleware, *args, &blk)
+      end
+
+      # @since 2.0.0
+      # @api private
+      def scope(*args, &blk)
+        @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 @stack.empty?
+
+        @stack.to_rack_app(self)
+      end
+    end
+  end
+end

data/lib/hanami/application/routes.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Application
+    # Application routes
+    #
+    # Users are expected to inherit from this class to define their application
+    # routes.
+    #
+    # @example
+    #   # config/routes.rb
+    #   # 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
+    #
+    #   See {Hanami::Application::Router} for the syntax allowed within the
+    #   `define` block.
+    #
+    # @see Hanami::Application::Router
+    # @since 2.0.0
+    class Routes
+      # Defines application routes
+      #
+      # @yield DSL syntax to define application routes executed in the context
+      # of {Hanami::Application::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"
+              end
+            end
+        MSG
+      end
+    end
+  end
+end

data/lib/hanami/application/routes_helper.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Application
+    # Hanami application routes helpers
+    #
+    # An instance of this class gets registered in the container
+    # (`routes_helper` key) once the Hanami application is booted. You can use
+    # it to get the route helpers for your application.
+    #
+    # @example
+    #   MyApp::Application["routes_helper"].path(:root) # => "/"
+    #
+    # @see Hanami::Router::UrlHelpers
+    # @since 2.0.0
+    class RoutesHelper
+      # @since 2.0.0
+      # @api private
+      def initialize(router)
+        @router = router
+      end
+
+      # @see Hanami::Router::UrlHelpers#path
+      def path(*args, **kwargs, &block)
+        @router.path(*args, **kwargs, &block)
+      end
+
+      # @see Hanami::Router::UrlHelpers#url
+      def url(*args, **kwargs, &block)
+        @router.url(*args, **kwargs, &block)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "rack/builder"
+
+module Hanami
+  class Application
+    module Routing
+      # Hanami::Applicatione::Router middleware stack
+      #
+      # @since 2.0.0
+      # @api private
+      module Middleware
+        # Middleware stack
+        #
+        # @since 2.0.0
+        # @api private
+        class Stack
+          # @since 2.0.0
+          # @api private
+          ROOT_PREFIX = "/"
+          private_constant :ROOT_PREFIX
+
+          # @since 2.0.0
+          # @api private
+          def initialize
+            @prefix = ROOT_PREFIX
+            @stack = Hash.new { |hash, key| hash[key] = [] }
+          end
+
+          # @since 2.0.0
+          # @api private
+          def use(middleware, *args, &blk)
+            @stack[@prefix].push([middleware, args, blk])
+          end
+
+          # @since 2.0.0
+          # @api private
+          def with(path)
+            prefix = @prefix
+            @prefix = path
+            yield
+          ensure
+            @prefix = prefix
+          end
+
+          # @since 2.0.0
+          # @api private
+          def to_rack_app(app) # rubocop:disable Metrics/MethodLength
+            s = self
+
+            Rack::Builder.new do
+              s.each do |prefix, stack|
+                s.mapped(self, prefix) do
+                  stack.each do |middleware, args, blk|
+                    use(middleware, *args, &blk)
+                  end
+                end
+
+                run app
+              end
+            end.to_app
+          end
+
+          # @since 2.0.0
+          # @api private
+          def empty?
+            @stack.empty?
+          end
+
+          # @since 2.0.0
+          # @api private
+          def each(&blk)
+            @stack.each(&blk)
+          end
+
+          # @since 2.0.0
+          # @api private
+          def mapped(builder, prefix, &blk)
+            if prefix == ROOT_PREFIX
+              builder.instance_eval(&blk)
+            else
+              builder.map(prefix, &blk)
+            end
+          end
+        end
+      end
+    end
+  end
+end