hanami 1.3.4 → 2.0.0.alpha3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97ed1063935d45a4613fd2361498251b968a462f4b01df368fbea563903958b7
-  data.tar.gz: 475fbab907b3f7f09988ac0872da11341133be9606796d8f9cb99ea6a8cea9fe
+  metadata.gz: f322cd4a751d83369d2d20f0f209bfb1dca92a78f6a3dd7c4027ea672df84e36
+  data.tar.gz: 801be572c3df6e61bfaee8b72f0a164dcbe83216f33c72972c67334f9b2619cf
 SHA512:
-  metadata.gz: edeec9fbca157fe6b6a368d7be2a71d622071e5aa0aee19fb23b4180f344c1aaccad5cdf00c488d0cd7fcff04e661338272a19ee9d5a0358893510e3ac0bfa57
-  data.tar.gz: c52ec459e71ed05d2624a8007a9c7252ab397cf4f496a5b72cd2c4c56d66b88f4d9e33129681a2c9d3876c0ff4bca74be1de2dc63aa5aa25e0966cba1323ab3b
+  metadata.gz: 244ab662705c248857bc4d4e3f42b1de6dc92003fb3c8fe6d3cd006194be272d1aac36f570baa319a971dfcdd6f24eb691c270fa57b852fdbc4da863bc1908d1
+  data.tar.gz: 3d6b72d227de112fbedefb7f8f6fbcb1e010fb37bf3d97e5826b6fe134dc0facd2a36bba0ad5e2118f731ee2bb1d18ae4f7307377c0fd31e5b81a3e307c56ae0

data/CHANGELOG.md

@@ -1,6 +1,136 @@
 # Hanami
 The web, with simplicity.
 
+## 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] 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
 - [Slava Kardakov] Fix generated `config.ru` `require_relative` statement

data/FEATURES.md

@@ -3,6 +3,8 @@
 
 ## Features
 
+## 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)

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.
@@ -25,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=master)](https://github.com/hanami/hanami/actions?query=workflow%3Aci+branch%3Amaster)
-[![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.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'
+  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'
-  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/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,54 @@
+# 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}
+      # @returns [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/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

data/lib/hanami/application/routing/resolver/node.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Application
+    module Routing
+      class Resolver
+        # Endpoint resolver node to register slices in a tree
+        #
+        # @api private
+        # @since 2.0.0
+        class Node
+          # @api private
+          # @since 2.0.0
+          attr_reader :slice
+
+          # @api private
+          # @since 2.0.0
+          def initialize
+            @slice = nil
+            @children = {}
+          end
+
+          # @api private
+          # @since 2.0.0
+          def put(segment)
+            @children[segment] ||= self.class.new
+          end
+
+          # @api private
+          # @since 2.0.0
+          def get(segment)
+            @children.fetch(segment) { self if leaf? }
+          end
+
+          # @api private
+          # @since 2.0.0
+          def leaf!(slice)
+            @slice = slice
+          end
+
+          # @api private
+          # @since 2.0.0
+          def leaf?
+            @slice
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/application/routing/resolver/trie.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "hanami/application/routing/resolver/node"
+
+module Hanami
+  class Application
+    module Routing
+      class Resolver
+        # Endpoint resolver trie to register slices
+        #
+        # @api private
+        # @since 2.0.0
+        class Trie
+          # @api private
+          # @since 2.0.0
+          def initialize
+            @root = Node.new
+          end
+
+          # @api private
+          # @since 2.0.0
+          def add(path, name)
+            node = @root
+            for_each_segment(path) do |segment|
+              node = node.put(segment)
+            end
+
+            node.leaf!(name)
+          end
+
+          # @api private
+          # @since 2.0.0
+          def find(path)
+            node = @root
+
+            for_each_segment(path) do |segment|
+              break unless node
+
+              node = node.get(segment)
+            end
+
+            return node.slice if node&.leaf?
+
+            nil
+          end
+
+          private
+
+          # @api private
+          # @since 2.0.0
+          def for_each_segment(path, &blk)
+            _, *segments = path.split(/\//)
+            segments.each(&blk)
+          end
+        end
+      end
+    end
+  end
+end