hanami-router 1.3.1 → 2.0.0.alpha4

data/hanami-router.gemspec

@@ -1,30 +1,34 @@
-# 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/router/version'
+require "hanami/router/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = 'hanami-router'
+  spec.name          = "hanami-router"
   spec.version       = Hanami::Router::VERSION
-  spec.authors       = ['Luca Guidi']
-  spec.email         = ['me@lucaguidi.com']
-  spec.description   = %q{Rack compatible HTTP router for Ruby}
-  spec.summary       = %q{Rack compatible HTTP router for Ruby and Hanami}
-  spec.homepage      = 'http://hanamirb.org'
-  spec.license       = 'MIT'
+  spec.authors       = ["Luca Guidi"]
+  spec.email         = ["me@lucaguidi.com"]
+  spec.description   = "Rack compatible HTTP router for Ruby"
+  spec.summary       = "Rack compatible HTTP router for Ruby and Hanami"
+  spec.homepage      = "http://hanamirb.org"
+  spec.license       = "MIT"
 
   spec.files         = `git ls-files -- lib/* CHANGELOG.md LICENSE.md README.md hanami-router.gemspec`.split($/)
   spec.executables   = []
   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.add_dependency "rack",               "~> 2.0"
+  spec.add_dependency "mustermann",         "~> 1.0"
+  spec.add_dependency "mustermann-contrib", "~> 1.0"
 
-  spec.add_dependency 'rack',         '~> 2.0'
-  spec.add_dependency 'http_router',  '0.11.2'
-  spec.add_dependency 'hanami-utils', '~> 1.3'
+  spec.add_development_dependency "bundler",   ">= 1.6", "< 3"
+  spec.add_development_dependency "rake",      "~> 13"
+  spec.add_development_dependency "rack-test", "~> 1.0"
+  spec.add_development_dependency "rspec",     "~> 3.8"
 
-  spec.add_development_dependency 'bundler',   '>= 1.6', '< 3'
-  spec.add_development_dependency 'rake',      '~> 12'
-  spec.add_development_dependency 'rack-test', '~> 1.0'
-  spec.add_development_dependency 'rspec',     '~> 3.7'
+  spec.add_development_dependency "rubocop", "0.91"
+  spec.add_development_dependency "rubocop-performance", "1.8.1"
 end

data/lib/hanami/middleware/body_parser.rb

@@ -1,14 +1,19 @@
-require 'hanami/utils/hash'
-require_relative 'body_parser/class_interface'
+# frozen_string_literal: true
+
+require "hanami/router/params"
+require "hanami/middleware/error"
 
 module Hanami
   module Middleware
     # @since 1.3.0
     # @api private
     class BodyParser
+      require_relative "body_parser/class_interface"
+      require_relative "body_parser/parser"
+
       # @since 1.3.0
       # @api private
-      CONTENT_TYPE = 'CONTENT_TYPE'.freeze
+      CONTENT_TYPE = "CONTENT_TYPE"
 
       # @since 1.3.0
       # @api private
@@ -16,17 +21,17 @@ module Hanami
 
       # @since 1.3.0
       # @api private
-      RACK_INPUT = 'rack.input'.freeze
+      RACK_INPUT = "rack.input"
 
       # @since 1.3.0
       # @api private
-      ROUTER_PARAMS = 'router.params'.freeze
+      ROUTER_PARAMS = "router.params"
 
       # @api private
-      ROUTER_PARSED_BODY = 'router.parsed_body'.freeze
+      ROUTER_PARSED_BODY = "router.parsed_body"
 
       # @api private
-      FALLBACK_KEY = '_'.freeze
+      FALLBACK_KEY = "_"
 
       extend ClassInterface
 
@@ -55,21 +60,21 @@ module Hanami
         parser_names = Array(parser_names)
         return {} if parser_names.empty?
 
-        parser_names.each_with_object({}) { |name, parsers|
+        parser_names.each_with_object({}) do |name, parsers|
           parser = self.class.for(name)
 
           parser.mime_types.each do |mime|
             parsers[mime] = parser
           end
-        }
+        end
       end
 
       # @api private
       def _symbolize(body)
-        if body.is_a?(Hash)
-          Utils::Hash.deep_symbolize(body)
+        if body.is_a?(::Hash)
+          Router::Params.deep_symbolize(body)
         else
-          { FALLBACK_KEY => body }
+          {FALLBACK_KEY => body}
         end
       end
 
@@ -82,9 +87,10 @@ module Hanami
 
       # @api private
       def media_type(env)
-        if ct = content_type(env)
-          ct.split(MEDIA_TYPE_MATCHER, 2).first.downcase
-        end
+        ct = content_type(env)
+        return unless ct
+
+        ct.split(MEDIA_TYPE_MATCHER, 2).first.downcase
       end
 
       # @api private

data/lib/hanami/middleware/body_parser/class_interface.rb

@@ -1,56 +1,62 @@
-require 'hanami/utils/class'
-require 'hanami/utils/string'
-require_relative 'errors'
-
- module Hanami
-   module Middleware
-     class BodyParser
-       # @api private
-       # @since 1.3.0
-       module ClassInterface
-         # @api private
-         # @since 1.3.0
-         def for(parser)
-           parser =
-             case parser
-             when String, Symbol
-               require_parser(parser)
-             when Class
-               parser.new
-             else
-               parser
-             end
-
-           ensure_parser parser
-
-           parser
-         end
-
-         private
-
-         # @api private
-         # @since 1.3.0
-         PARSER_METHODS = %i[mime_types parse].freeze
-
-         # @api private
-         # @since 1.3.0
-         def ensure_parser(parser)
-           unless PARSER_METHODS.all? { |method| parser.respond_to?(method) }
-             raise InvalidParserError.new(parser)
-           end
-         end
-
-         # @api private
-         # @since 1.3.0
-         def require_parser(parser)
-           require "hanami/middleware/body_parser/#{parser}_parser"
-
-           parser = Utils::String.classify(parser)
-           Utils::Class.load!("Hanami::Middleware::BodyParser::#{parser}Parser").new
-         rescue LoadError, NameError
-           raise UnknownParserError.new(parser)
-         end
-       end
-     end
-   end
- end
+# frozen_string_literal: true
+
+require_relative "errors"
+
+module Hanami
+  module Middleware
+    # HTTP request body parser
+    class BodyParser
+      # @api private
+      # @since 1.3.0
+      module ClassInterface
+        # @api private
+        # @since 1.3.0
+        def for(parser)
+          parser =
+            case parser
+            when String, Symbol
+              require_parser(parser)
+            when Class
+              parser.new
+            else
+              parser
+            end
+
+          ensure_parser parser
+
+          parser
+        end
+
+        private
+
+        # @api private
+        # @since 1.3.0
+        PARSER_METHODS = %i[mime_types parse].freeze
+
+        # @api private
+        # @since 1.3.0
+        def ensure_parser(parser)
+          raise InvalidParserError.new(parser) unless PARSER_METHODS.all? { |method| parser.respond_to?(method) }
+        end
+
+        # @api private
+        # @since 1.3.0
+        def require_parser(parser)
+          require "hanami/middleware/body_parser/#{parser}_parser"
+
+          load_parser!("#{classify(parser)}Parser").new
+        rescue LoadError, NameError
+          raise UnknownParserError.new(parser)
+        end
+
+        def classify(parser)
+          parser.to_s.split(/_/).map(&:capitalize).join
+        end
+
+        def load_parser!(class_name)
+          Hanami::Middleware::BodyParser.const_get(class_name, false)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/middleware/body_parser/errors.rb

@@ -1,4 +1,4 @@
-require 'hanami/routing/error'
+# frozen_string_literal: true
 
 module Hanami
   module Middleware
@@ -9,14 +9,17 @@ module Hanami
       # This is raised when parser fails to parse the body
       #
       # @since 1.3.0
-      class BodyParsingError < Hanami::Routing::Parsing::BodyParsingError
+      class BodyParsingError < Hanami::Middleware::Error
       end
 
       # @since 1.3.0
-      class UnknownParserError < Hanami::Routing::Parsing::UnknownParserError
+      class UnknownParserError < Hanami::Middleware::Error
+        def initialize(name)
+          super("Unknown body parser: `#{name.inspect}'")
+        end
       end
 
-      class InvalidParserError < Hanami::Routing::Error
+      class InvalidParserError < Hanami::Middleware::Error
       end
     end
   end

data/lib/hanami/middleware/body_parser/json_parser.rb

@@ -1,16 +1,18 @@
-require 'hanami/utils/json'
-require_relative 'errors'
+# frozen_string_literal: true
+
+require "json"
+require_relative "parser"
 
 module Hanami
   module Middleware
     class BodyParser
       # @since 1.3.0
       # @api private
-      class JsonParser
+      class JsonParser < Parser
         # @since 1.3.0
         # @api private
         def mime_types
-          ['application/json', 'application/vnd.api+json']
+          ["application/json", "application/vnd.api+json"]
         end
 
         # Parse a json string
@@ -24,9 +26,9 @@ module Hanami
         # @since 1.3.0
         # @api private
         def parse(body)
-          Hanami::Utils::Json.parse(body)
-        rescue Hanami::Utils::Json::ParserError => e
-          raise BodyParsingError.new(e.message)
+          JSON.parse(body)
+        rescue StandardError => exception
+          raise BodyParsingError.new(exception.message)
         end
       end
     end

data/lib/hanami/middleware/body_parser/parser.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Middleware
+    class BodyParser
+      # Body parser abstract class
+      #
+      # @since 2.0.0
+      class Parser
+        # Declare supported MIME types
+        #
+        # @return [Array<String>] supported MIME types
+        #
+        # @abstract
+        # @since 2.0.0
+        #
+        # @example
+        #   require "hanami/middleware/body_parser"
+        #
+        #   class XMLParser < Hanami::Middleware::BodyParser::Parser
+        #     def mime_types
+        #       ["application/xml", "text/xml"]
+        #     end
+        #   end
+        def mime_types
+          raise NotImplementedError
+        end
+
+        # Parse raw HTTP request body
+        #
+        # @param body [String] HTTP request body
+        #
+        # @return [Hash] the result of the parsing
+        #
+        # @raise [Hanami::Middleware::BodyParser::BodyParsingError] the error
+        #   that must be raised if the parsing cannot be accomplished
+        #
+        # @abstract
+        # @since 2.0.0
+        #
+        # @example
+        #   require "hanami/middleware/body_parser"
+        #
+        #   class XMLParser < Hanami::Middleware::BodyParser::Parser
+        #     def parse(body)
+        #       # XML parsing
+        #       # ...
+        #     rescue => exception
+        #       raise Hanami::Middleware::BodyParser::BodyParsingError.new(exception.message)
+        #     end
+        #   end
+        def parse(body)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/hanami/middleware/error.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Hanami
+  # Hanami Rack middleware
+  #
+  # @since 1.3.0
+  module Middleware
+    unless defined?(Error)
+      # Base error for Rack middleware
+      #
+      # @since 2.0.0
+      class Error < ::StandardError
+      end
+    end
+  end
+end

data/lib/hanami/router.rb

@@ -1,131 +1,30 @@
-require 'rack/request'
-require 'hanami/routing/http_router'
-require 'hanami/routing/namespace'
-require 'hanami/routing/resource'
-require 'hanami/routing/resources'
-require 'hanami/routing/error'
-
-# Hanami
-#
-# @since 0.1.0
+# frozen_string_literal: true
+
+require "rack/utils"
+
 module Hanami
   # Rack compatible, lightweight and fast HTTP Router.
   #
   # @since 0.1.0
-  #
-  # @example It offers an intuitive DSL, that supports most of the HTTP verbs:
-  #   require 'hanami/router'
-  #
-  #   endpoint = ->(env) { [200, {}, ['Welcome to Hanami::Router!']] }
-  #   router = Hanami::Router.new do
-  #     get     '/', to: endpoint # => get and head requests
-  #     post    '/', to: endpoint
-  #     put     '/', to: endpoint
-  #     patch   '/', to: endpoint
-  #     delete  '/', to: endpoint
-  #     options '/', to: endpoint
-  #     trace   '/', to: endpoint
-  #   end
-  #
-  #
-  #
-  # @example Specify an endpoint with `:to` (Rack compatible object)
-  #   require 'hanami/router'
-  #
-  #   endpoint = ->(env) { [200, {}, ['Welcome to Hanami::Router!']] }
-  #   router = Hanami::Router.new do
-  #     get '/', to: endpoint
-  #   end
-  #
-  #   # :to is mandatory for the default resolver (`Hanami::Routing::EndpointResolver.new`),
-  #   # This behavior can be changed by passing a custom resolver to `Hanami::Router#initialize`
-  #
-  #
-  #
-  # @example Specify an endpoint with `:to` (controller and action string)
-  #   require 'hanami/router'
-  #
-  #   router = Hanami::Router.new do
-  #     get '/', to: 'articles#show' # => Articles::Show
-  #   end
-  #
-  #   # This is a builtin feature for a Hanami::Controller convention.
-  #
-  #
-  #
-  # @example Specify a named route with `:as`
-  #   require 'hanami/router'
-  #
-  #   endpoint = ->(env) { [200, {}, ['Welcome to Hanami::Router!']] }
-  #   router = Hanami::Router.new(scheme: 'https', host: 'hanamirb.org') do
-  #     get '/', to: endpoint, as: :root
-  #   end
-  #
-  #   router.path(:root) # => '/'
-  #   router.url(:root)  # => 'https://hanamirb.org/'
-  #
-  #   # This isn't mandatory for the default route class (`Hanami::Routing::Route`),
-  #   # This behavior can be changed by passing a custom route to `Hanami::Router#initialize`
-  #
-  # @example Mount an application
-  #   require 'hanami/router'
-  #
-  #   router = Hanami::Router.new do
-  #     mount Api::App, at: '/api'
-  #   end
-  #
-  #   # All the requests starting with "/api" will be forwarded to Api::App
   class Router
-    # This error is raised when <tt>#call</tt> is invoked on a non-routable
-    # recognized route.
-    #
-    # @since 0.5.0
-    #
-    # @see Hanami::Router#recognize
-    # @see Hanami::Routing::RecognizedRoute
-    # @see Hanami::Routing::RecognizedRoute#call
-    # @see Hanami::Routing::RecognizedRoute#routable?
-    class NotRoutableEndpointError < Hanami::Routing::Error
-      # @since 0.5.0
-      # @api private
-      REQUEST_METHOD = 'REQUEST_METHOD'.freeze
-
-      # @since 0.5.0
-      # @api private
-      PATH_INFO      = 'PATH_INFO'.freeze
-
-      # @since 0.5.0
-      def initialize(env)
-        super %(Cannot find routable endpoint for #{ env[REQUEST_METHOD] } "#{ env[PATH_INFO] }")
-      end
-    end
-
-    # Defines root path
+    require "hanami/router/version"
+    require "hanami/router/error"
+    require "hanami/router/segment"
+    require "hanami/router/redirect"
+    require "hanami/router/prefix"
+    require "hanami/router/params"
+    require "hanami/router/trie"
+    require "hanami/router/block"
+    require "hanami/router/url_helpers"
+
+    # URL helpers for other Hanami integrations
     #
-    # @since 0.7.0
     # @api private
-    #
-    # @see Hanami::Router#root
-    ROOT_PATH = '/'.freeze
+    # @since 2.0.0
+    attr_reader :url_helpers
 
     # Returns the given block as it is.
     #
-    # When Hanami::Router is used as a standalone gem and the routes are defined
-    # into a configuration file, some systems could raise an exception.
-    #
-    # Imagine the following file into a Ruby on Rails application:
-    #
-    #   get '/', to: 'api#index'
-    #
-    # Because Ruby on Rails in production mode use to eager load code and the
-    # routes file uses top level method calls, it crashes the application.
-    #
-    # If we wrap these routes with <tt>Hanami::Router.define</tt>, the block
-    # doesn't get yielded but just returned to the caller as it is.
-    #
-    # Usually the receiver of this block is <tt>Hanami::Router#initialize</tt>,
-    # which finally evaluates the block.
-    #
     # @param blk [Proc] a set of route definitions
     #
     # @return [Proc] the given block
@@ -135,888 +34,440 @@ module Hanami
     # @example
     #   # apps/web/config/routes.rb
     #   Hanami::Router.define do
-    #     get '/', to: 'home#index'
+    #     get "/", to: ->(*) { ... }
     #   end
     def self.define(&blk)
       blk
     end
 
-    # Initialize the router.
-    #
-    # @param options [Hash] the options to initialize the router
-    #
-    # @option options [String] :scheme The HTTP scheme (defaults to `"http"`)
-    # @option options [String] :host The URL host (defaults to `"localhost"`)
-    # @option options [String] :port The URL port (defaults to `"80"`)
-    # @option options [Object, #resolve, #find, #action_separator] :resolver
-    #   the route resolver (defaults to `Hanami::Routing::EndpointResolver.new`)
-    # @option options [Object, #generate] :route the route class
-    #   (defaults to `Hanami::Routing::Route`)
-    # @option options [String] :action_separator the separator between controller
-    #   and action name (eg. 'dashboard#show', where '#' is the :action_separator)
-    # @option options [Array<Symbol,String,Object #mime_types, parse>] :parsers
-    #   the body parsers for mime types
-    #
-    # @param blk [Proc] the optional block to define the routes
+    # Initialize the router
     #
-    # @return [Hanami::Router] self
+    # @param base_url [String] the base URL where the HTTP application is
+    #   deployed
+    # @param prefix [String] the relative URL prefix where the HTTP application
+    #   is deployed
+    # @param resolver [#call(path, to)] a resolver for route entpoints
+    # @param block_context [Hanami::Router::Block::Context)
+    # @param not_found [#call(env)] default handler when route is not matched
+    # @param blk [Proc] the route definitions
     #
     # @since 0.1.0
     #
-    # @example Basic example
-    #   require 'hanami/router'
-    #
-    #   endpoint = ->(env) { [200, {}, ['Welcome to Hanami::Router!']] }
-    #
-    #   router = Hanami::Router.new
-    #   router.get '/', to: endpoint
-    #
-    #   # or
-    #
-    #   router = Hanami::Router.new do
-    #     get '/', to: endpoint
-    #   end
-    #
-    # @example Body parsers
-    #   require 'json'
-    #   require 'hanami/router'
-    #
-    #   # It parses JSON body and makes the attributes available to the params
-    #
-    #   endpoint = ->(env) { [200, {},[env['router.params'].inspect]] }
-    #
-    #   router = Hanami::Router.new(parsers: [:json]) do
-    #     patch '/books/:id', to: endpoint
-    #   end
-    #
-    #   # From the shell
-    #
-    #   curl http://localhost:2300/books/1    \
-    #     -H "Content-Type: application/json" \
-    #     -H "Accept: application/json"       \
-    #     -d '{"published":"true"}'           \
-    #     -X PATCH
-    #
-    #   # It returns
+    # @return [Hanami::Router]
     #
-    #   [200, {}, ["{:published=>\"true\",:id=>\"1\"}"]]
+    # @example Base usage
+    #   require "hanami/router"
     #
-    # @example Custom body parser
-    #   require 'hanami/router'
-    #
-    #   class XmlParser
-    #     def mime_types
-    #       ['application/xml', 'text/xml']
-    #     end
-    #
-    #     # Parse body and return a Hash
-    #     def parse(body)
-    #       # ...
-    #     end
-    #   end
-    #
-    #   # It parses XML body and makes the attributes available to the params
-    #
-    #   endpoint = ->(env) { [200, {},[env['router.params'].inspect]] }
-    #
-    #   router = Hanami::Router.new(parsers: [XmlParser.new]) do
-    #     patch '/authors/:id', to: endpoint
-    #   end
-    #
-    #   # From the shell
-    #
-    #   curl http://localhost:2300/authors/1 \
-    #     -H "Content-Type: application/xml" \
-    #     -H "Accept: application/xml"       \
-    #     -d '<name>LG</name>'               \
-    #     -X PATCH
-    #
-    #   # It returns
-    #
-    #   [200, {}, ["{:name=>\"LG\",:id=>\"1\"}"]]
-    def initialize(options = {}, &blk)
-      @router = Routing::HttpRouter.new(options)
-      define(&blk)
+    #   Hanami::Router.new do
+    #     get "/", to: ->(*) { [200, {}, ["OK"]] }
+    #   end
+    def initialize(base_url: DEFAULT_BASE_URL, prefix: DEFAULT_PREFIX, resolver: DEFAULT_RESOLVER, not_found: NOT_FOUND, block_context: nil, &blk) # rubocop:disable Layout/LineLength
+      # TODO: verify if Prefix can handle both name and path prefix
+      @path_prefix = Prefix.new(prefix)
+      @name_prefix = Prefix.new("")
+      @url_helpers = UrlHelpers.new(base_url)
+      @resolver = resolver
+      @not_found = not_found
+      @block_context = block_context
+      @fixed = {}
+      @variable = {}
+      @globbed = {}
+      @mounted = {}
+      instance_eval(&blk) if blk
     end
 
-    # Returns self
+    # Resolve the given Rack env to a registered endpoint and invokes it.
     #
-    # This is a duck-typing trick for compatibility with `Hanami::Application`.
-    # It's used by `Hanami::Routing::RoutesInspector` to inspect both apps and
-    # routers.
+    # @param env [Hash] a Rack env
     #
-    # @return [self]
+    # @return [Array] a finalized Rack env response
     #
-    # @since 0.2.0
-    # @api private
-    def routes
-      self
+    # @since 0.1.0
+    def call(env)
+      endpoint, params = lookup(env)
+
+      unless endpoint
+        return not_allowed(env) ||
+               not_found(env)
+      end
+
+      endpoint.call(
+        _params(env, params)
+      ).to_a
     end
 
-    # To support defining routes in the `define` wrapper.
-    #
-    # @param blk [Proc] the block to define the routes
+    # Defines a named root route (a GET route for "/")
     #
-    # @return [Hanami::Routing::Route]
+    # @param to [#call] the Rack endpoint
+    # @param blk [Proc] the anonymous proc to be used as endpoint for the route
     #
-    # @since 0.2.0
+    # @since 0.7.0
     #
-    # @example In Hanami framework
-    #   class Application < Hanami::Application
-    #     configure do
-    #       routes 'config/routes'
-    #     end
-    #   end
+    # @see #get
+    # @see #path
+    # @see #url
     #
-    #   # In `config/routes`
+    # @example Proc endpoint
+    #   require "hanami/router"
     #
-    #   define do
-    #     get # ...
+    #   router = Hanami::Router.new do
+    #     root to: ->(env) { [200, {}, ["Hello from Hanami!"]] }
     #   end
-    def define(&blk)
-      instance_eval(&blk) if block_given?
-    end
-
-    # Check if there are defined routes
     #
-    # @return [TrueClass,FalseClass] the result of the check
+    # @example Block endpoint
+    #   require "hanami/router"
     #
-    # @since 0.2.0
-    # @api private
+    #   router = Hanami::Router.new do
+    #     root do
+    #       "Hello from Hanami!"
+    #     end
+    #   end
     #
-    # @example
+    # @example URL helpers
+    #   require "hanami/router"
     #
-    #   router = Hanami::Router.new
-    #   router.defined? # => false
+    #   router = Hanami::Router.new(base_url: "https://hanamirb.org") do
+    #     root do
+    #       "Hello from Hanami!"
+    #     end
+    #   end
     #
-    #   router = Hanami::Router.new { get '/', to: ->(env) { } }
-    #   router.defined? # => true
-    def defined?
-      @router.routes.any?
+    #   router.path(:root) # => "/"
+    #   router.url(:root)  # => "https://hanamirb.org"
+    def root(to: nil, &blk)
+      get("/", to: to, as: :root, &blk)
     end
 
-    # Defines a route that accepts a GET request for the given path.
+    # Defines a route that accepts GET requests for the given path.
+    # It also defines a route to accept HEAD requests.
     #
     # @param path [String] the relative URL to be matched
-    #
-    # @param options [Hash] the options to customize the route
-    # @option options [String,Proc,Class,Object#call] :to the endpoint
-    #
+    # @param to [#call] the Rack endpoint
+    # @param as [Symbol] a unique name for the route
+    # @param constraints [Hash] a set of constraints for path variables
     # @param blk [Proc] the anonymous proc to be used as endpoint for the route
     #
-    # @return [Hanami::Routing::Route] this may vary according to the :route
-    #   option passed to the constructor
-    #
     # @since 0.1.0
     #
-    # @example Fixed matching string
-    #   require 'hanami/router'
-    #
-    #   router = Hanami::Router.new
-    #   router.get '/hanami', to: ->(env) { [200, {}, ['Hello from Hanami!']] }
-    #
-    # @example String matching with variables
-    #   require 'hanami/router'
-    #
-    #   router = Hanami::Router.new
-    #   router.get '/flowers/:id',
-    #     to: ->(env) {
-    #       [
-    #         200,
-    #         {},
-    #         ["Hello from Flower no. #{ env['router.params'][:id] }!"]
-    #       ]
-    #     }
+    # @see #initialize
+    # @see #path
+    # @see #url
     #
-    # @example Variables Constraints
-    #   require 'hanami/router'
+    # @example Proc endpoint
+    #   require "hanami/router"
     #
-    #   router = Hanami::Router.new
-    #   router.get '/flowers/:id',
-    #     id: /\d+/,
-    #     to: ->(env) { [200, {}, [":id must be a number!"]] }
-    #
-    # @example String matching with globbling
-    #   require 'hanami/router'
-    #
-    #   router = Hanami::Router.new
-    #   router.get '/*',
-    #     to: ->(env) {
-    #       [
-    #         200,
-    #         {},
-    #         ["This is catch all: #{ env['router.params'].inspect }!"]
-    #       ]
-    #     }
-    #
-    # @example String matching with optional tokens
-    #   require 'hanami/router'
-    #
-    #   router = Hanami::Router.new
-    #   router.get '/hanami(.:format)',
-    #     to: ->(env) {
-    #       [200, {}, ["You've requested #{ env['router.params'][:format] }!"]]
-    #     }
-    #
-    # @example Named routes
-    #   require 'hanami/router'
-    #
-    #   router = Hanami::Router.new(scheme: 'https', host: 'hanamirb.org')
-    #   router.get '/hanami',
-    #     to: ->(env) { [200, {}, ['Hello from Hanami!']] },
-    #     as: :hanami
-    #
-    #   router.path(:hanami) # => "/hanami"
-    #   router.url(:hanami)  # => "https://hanamirb.org/hanami"
-    #
-    # @example Duck typed endpoints (Rack compatible objects)
-    #   require 'hanami/router'
-    #
-    #   router = Hanami::Router.new
-    #
-    #   router.get '/hanami',      to: ->(env) { [200, {}, ['Hello from Hanami!']] }
-    #   router.get '/middleware', to: Middleware
-    #   router.get '/rack-app',   to: RackApp.new
-    #   router.get '/method',     to: ActionControllerSubclass.action(:new)
-    #
-    #   # Everything that responds to #call is invoked as it is
-    #
-    # @example Duck typed endpoints (strings)
-    #   require 'hanami/router'
-    #
-    #   class RackApp
-    #     def call(env)
-    #       # ...
-    #     end
+    #   Hanami::Router.new do
+    #     get "/", to: ->(*) { [200, {}, ["OK"]] }
     #   end
     #
-    #   router = Hanami::Router.new
-    #   router.get '/hanami', to: 'rack_app' # it will map to RackApp.new
-    #
-    # @example Duck typed endpoints (string: controller + action)
-    #   require 'hanami/router'
+    # @example Block endpoint
+    #   require "hanami/router"
     #
-    #   module Flowers
-    #     class Index
-    #       def call(env)
-    #         # ...
-    #       end
+    #   Hanami::Router.new do
+    #     get "/" do
+    #       "OK"
     #     end
     #   end
     #
-    #    router = Hanami::Router.new
-    #    router.get '/flowers', to: 'flowers#index'
-    #
-    #    # It will map to Flowers::Index.new, which is the
-    #    # Hanami::Controller convention.
-    def get(path, options = {}, &blk)
-      @router.get(path, options, &blk)
-    end
-
-    # Defines a route that accepts a POST request for the given path.
-    #
-    # @param path [String] the relative URL to be matched
-    #
-    # @param options [Hash] the options to customize the route
-    # @option options [String,Proc,Class,Object#call] :to the endpoint
+    # @example Named route
+    #   require "hanami/router"
     #
-    # @param blk [Proc] the anonymous proc to be used as endpoint for the route
+    #   router = Hanami::Router.new do
+    #     get "/", to: ->(*) { [200, {}, ["OK"]] }, as: :welcome
+    #   end
     #
-    # @return [Hanami::Routing::Route] this may vary according to the :route
-    #   option passed to the constructor
+    #   router.path(:welcome) # => "/"
+    #   router.url(:welcome)  # => "http://localhost/"
     #
-    # @see Hanami::Router#get
+    # @example Constraints
+    #   require "hanami/router"
     #
-    # @since 0.1.0
-    def post(path, options = {}, &blk)
-      @router.post(path, options, &blk)
+    #   Hanami::Router.new do
+    #     get "/users/:id", to: ->(*) { [200, {}, ["OK"]] }, id: /\d+/
+    #   end
+    def get(path, to: nil, as: nil, **constraints, &blk)
+      add_route("GET", path, to, as, constraints, &blk)
+      add_route("HEAD", path, to, as, constraints, &blk)
     end
 
-    # Defines a route that accepts a PUT request for the given path.
+    # Defines a route that accepts POST requests for the given path.
     #
     # @param path [String] the relative URL to be matched
-    #
-    # @param options [Hash] the options to customize the route
-    # @option options [String,Proc,Class,Object#call] :to the endpoint
-    #
+    # @param to [#call] the Rack endpoint
+    # @param as [Symbol] a unique name for the route
+    # @param constraints [Hash] a set of constraints for path variables
     # @param blk [Proc] the anonymous proc to be used as endpoint for the route
     #
-    # @return [Hanami::Routing::Route] this may vary according to the :route
-    #   option passed to the constructor
-    #
-    # @see Hanami::Router#get
-    #
     # @since 0.1.0
-    def put(path, options = {}, &blk)
-      @router.put(path, options, &blk)
+    #
+    # @see #get
+    # @see #initialize
+    # @see #path
+    # @see #url
+    def post(path, to: nil, as: nil, **constraints, &blk)
+      add_route("POST", path, to, as, constraints, &blk)
     end
 
-    # Defines a route that accepts a PATCH request for the given path.
+    # Defines a route that accepts PATCH requests for the given path.
     #
     # @param path [String] the relative URL to be matched
-    #
-    # @param options [Hash] the options to customize the route
-    # @option options [String,Proc,Class,Object#call] :to the endpoint
-    #
+    # @param to [#call] the Rack endpoint
+    # @param as [Symbol] a unique name for the route
+    # @param constraints [Hash] a set of constraints for path variables
     # @param blk [Proc] the anonymous proc to be used as endpoint for the route
     #
-    # @return [Hanami::Routing::Route] this may vary according to the :route
-    #   option passed to the constructor
-    #
-    # @see Hanami::Router#get
-    #
     # @since 0.1.0
-    def patch(path, options = {}, &blk)
-      @router.patch(path, options, &blk)
+    #
+    # @see #get
+    # @see #initialize
+    # @see #path
+    # @see #url
+    def patch(path, to: nil, as: nil, **constraints, &blk)
+      add_route("PATCH", path, to, as, constraints, &blk)
     end
 
-    # Defines a route that accepts a DELETE request for the given path.
+    # Defines a route that accepts PUT requests for the given path.
     #
     # @param path [String] the relative URL to be matched
-    #
-    # @param options [Hash] the options to customize the route
-    # @option options [String,Proc,Class,Object#call] :to the endpoint
-    #
+    # @param to [#call] the Rack endpoint
+    # @param as [Symbol] a unique name for the route
+    # @param constraints [Hash] a set of constraints for path variables
     # @param blk [Proc] the anonymous proc to be used as endpoint for the route
     #
-    # @return [Hanami::Routing::Route] this may vary according to the :route
-    #   option passed to the constructor
-    #
-    # @see Hanami::Router#get
-    #
     # @since 0.1.0
-    def delete(path, options = {}, &blk)
-      @router.delete(path, options, &blk)
+    #
+    # @see #get
+    # @see #initialize
+    # @see #path
+    # @see #url
+    def put(path, to: nil, as: nil, **constraints, &blk)
+      add_route("PUT", path, to, as, constraints, &blk)
     end
 
-    # Defines a route that accepts a TRACE request for the given path.
+    # Defines a route that accepts DELETE requests for the given path.
     #
     # @param path [String] the relative URL to be matched
-    #
-    # @param options [Hash] the options to customize the route
-    # @option options [String,Proc,Class,Object#call] :to the endpoint
-    #
+    # @param to [#call] the Rack endpoint
+    # @param as [Symbol] a unique name for the route
+    # @param constraints [Hash] a set of constraints for path variables
     # @param blk [Proc] the anonymous proc to be used as endpoint for the route
     #
-    # @return [Hanami::Routing::Route] this may vary according to the :route
-    #   option passed to the constructor
-    #
-    # @see Hanami::Router#get
-    #
     # @since 0.1.0
-    def trace(path, options = {}, &blk)
-      @router.trace(path, options, &blk)
+    #
+    # @see #get
+    # @see #initialize
+    # @see #path
+    # @see #url
+    def delete(path, to: nil, as: nil, **constraints, &blk)
+      add_route("DELETE", path, to, as, constraints, &blk)
     end
 
-    # Defines a route that accepts a LINK request for the given path.
+    # Defines a route that accepts TRACE requests for the given path.
     #
     # @param path [String] the relative URL to be matched
-    #
-    # @param options [Hash] the options to customize the route
-    # @option options [String,Proc,Class,Object#call] :to the endpoint
-    #
+    # @param to [#call] the Rack endpoint
+    # @param as [Symbol] a unique name for the route
+    # @param constraints [Hash] a set of constraints for path variables
     # @param blk [Proc] the anonymous proc to be used as endpoint for the route
     #
-    # @return [Hanami::Routing::Route] this may vary according to the :route
-    #   option passed to the constructor
-    #
-    # @see Hanami::Router#get
+    # @since 0.1.0
     #
-    # @since 0.8.0
-    def link(path, options = {}, &blk)
-      @router.link(path, options, &blk)
+    # @see #get
+    # @see #initialize
+    # @see #path
+    # @see #url
+    def trace(path, to: nil, as: nil, **constraints, &blk)
+      add_route("TRACE", path, to, as, constraints, &blk)
     end
 
-    # Defines a route that accepts an UNLINK request for the given path.
+    # Defines a route that accepts OPTIONS requests for the given path.
     #
     # @param path [String] the relative URL to be matched
-    #
-    # @param options [Hash] the options to customize the route
-    # @option options [String,Proc,Class,Object#call] :to the endpoint
-    #
+    # @param to [#call] the Rack endpoint
+    # @param as [Symbol] a unique name for the route
+    # @param constraints [Hash] a set of constraints for path variables
     # @param blk [Proc] the anonymous proc to be used as endpoint for the route
     #
-    # @return [Hanami::Routing::Route] this may vary according to the :route
-    #   option passed to the constructor
-    #
-    # @see Hanami::Router#get
+    # @since 0.1.0
     #
-    # @since 0.8.0
-    def unlink(path, options = {}, &blk)
-      @router.unlink(path, options, &blk)
+    # @see #get
+    # @see #initialize
+    # @see #path
+    # @see #url
+    def options(path, to: nil, as: nil, **constraints, &blk)
+      add_route("OPTIONS", path, to, as, constraints, &blk)
     end
 
-    # Defines a root route (a GET route for '/')
-    #
-    # @param options [Hash] the options to customize the route
-    # @option options [String,Proc,Class,Object#call] :to the endpoint
+    # Defines a route that accepts LINK requests for the given path.
     #
+    # @param path [String] the relative URL to be matched
+    # @param to [#call] the Rack endpoint
+    # @param as [Symbol] a unique name for the route
+    # @param constraints [Hash] a set of constraints for path variables
     # @param blk [Proc] the anonymous proc to be used as endpoint for the route
     #
-    # @return [Hanami::Routing::Route] this may vary according to the :route
-    #   option passed to the constructor
-    #
-    # @since 0.7.0
-    #
-    # @example Fixed matching string
-    #   require 'hanami/router'
-    #
-    #   router = Hanami::Router.new
-    #   router.root to: ->(env) { [200, {}, ['Hello from Hanami!']] }
-    #
-    # @example Included names as `root` (for path and url helpers)
-    #   require 'hanami/router'
-    #
-    #   router = Hanami::Router.new(scheme: 'https', host: 'hanamirb.org')
-    #   router.root to: ->(env) { [200, {}, ['Hello from Hanami!']] }
+    # @since 0.1.0
     #
-    #   router.path(:root) # => "/"
-    #   router.url(:root)  # => "https://hanamirb.org/"
-    def root(options = {}, &blk)
-      @router.get(ROOT_PATH, options.merge(as: :root), &blk)
+    # @see #get
+    # @see #initialize
+    # @see #path
+    # @see #url
+    def link(path, to: nil, as: nil, **constraints, &blk)
+      add_route("LINK", path, to, as, constraints, &blk)
     end
 
-    # Defines a route that accepts a OPTIONS request for the given path.
+    # Defines a route that accepts UNLINK requests for the given path.
     #
     # @param path [String] the relative URL to be matched
-    #
-    # @param options [Hash] the options to customize the route
-    # @option options [String,Proc,Class,Object#call] :to the endpoint
-    #
+    # @param to [#call] the Rack endpoint
+    # @param as [Symbol] a unique name for the route
+    # @param constraints [Hash] a set of constraints for path variables
     # @param blk [Proc] the anonymous proc to be used as endpoint for the route
     #
-    # @return [Hanami::Routing::Route] this may vary according to the :route
-    #   option passed to the constructor
-    #
-    # @see Hanami::Router#get
-    #
-    # @since 0.1.0
-    def options(path, options = {}, &blk)
-      @router.options(path, options, &blk)
-    end
-
-    # Defines an HTTP redirect
-    #
-    # @param path [String] the path that needs to be redirected
-    # @param options [Hash] the options to customize the redirect behavior
-    # @option options [Fixnum] the HTTP status to return (defaults to `301`)
-    #
-    # @return [Hanami::Routing::Route] the generated route.
-    #   This may vary according to the `:route` option passed to the initializer
-    #
     # @since 0.1.0
     #
-    # @see Hanami::Router
-    #
-    # @example
-    #   require 'hanami/router'
-    #
-    #   Hanami::Router.new do
-    #     redirect '/legacy',  to: '/new_endpoint'
-    #     redirect '/legacy2', to: '/new_endpoint2', code: 302
-    #   end
-    #
-    # @example
-    #   require 'hanami/router'
-    #
-    #   router = Hanami::Router.new
-    #   router.redirect '/legacy',  to: '/new_endpoint'
-    def redirect(path, options = {}, &endpoint)
-      destination_path = @router.find(options)
-      get(path).redirect(destination_path, options[:code] || 301).tap do |route|
-        route.dest = Hanami::Routing::RedirectEndpoint.new(destination_path, route.dest)
-      end
+    # @see #get
+    # @see #initialize
+    # @see #path
+    # @see #url
+    def unlink(path, to: nil, as: nil, **constraints, &blk)
+      add_route("UNLINK", path, to, as, constraints, &blk)
     end
 
-    # Defines a Ruby block: all the routes defined within it will be namespaced
-    # with the given relative path.
-    #
-    # Namespaces blocks can be nested multiple times.
+    # Defines a route that redirects the incoming request to another path.
     #
-    # @param namespace [String] the relative path where the nested routes will
-    #   be mounted
-    # @param blk [Proc] the block that defines the resources
-    #
-    # @return [Hanami::Routing::Namespace] the generated namespace.
+    # @param path [String] the relative URL to be matched
+    # @param to [#call] the Rack endpoint
+    # @param as [Symbol] a unique name for the route
+    # @param code [Integer] a HTTP status code to use for the redirect
     #
     # @since 0.1.0
     #
-    # @see Hanami::Router
-    #
-    # @example Basic example
-    #   require 'hanami/router'
-    #
-    #   Hanami::Router.new do
-    #     namespace 'trees' do
-    #       get '/sequoia', to: endpoint # => '/trees/sequoia'
-    #     end
-    #   end
-    #
-    # @example Nested namespaces
-    #   require 'hanami/router'
-    #
-    #   Hanami::Router.new do
-    #     namespace 'animals' do
-    #       namespace 'mammals' do
-    #         get '/cats', to: endpoint # => '/animals/mammals/cats'
-    #       end
-    #     end
-    #   end
-    #
-    # @example
-    #   require 'hanami/router'
-    #
-    #   router = Hanami::Router.new
-    #   router.namespace 'trees' do
-    #     get '/sequoia', to: endpoint # => '/trees/sequoia'
-    #   end
-    def namespace(namespace, &blk)
-      Routing::Namespace.new(self, namespace, &blk)
+    # @see #get
+    # @see #initialize
+    def redirect(path, to: nil, as: nil, code: DEFAULT_REDIRECT_CODE)
+      get(path, to: _redirect(to, code), as: as)
     end
 
-    # Defines a set of named routes for a single RESTful resource.
-    # It has a built-in integration for Hanami::Controller.
-    #
-    # @param name [String] the name of the resource
-    # @param options [Hash] a set of options to customize the routes
-    # @option options [Array<Symbol>] :only a subset of the default routes
-    #   that we want to generate
-    # @option options [Array<Symbol>] :except prevent the given routes to be
-    #   generated
-    # @param blk [Proc] a block of code to generate additional routes
-    #
-    # @return [Hanami::Routing::Resource]
-    #
-    # @since 0.1.0
-    #
-    # @see Hanami::Routing::Resource
-    # @see Hanami::Routing::Resource::Action
-    # @see Hanami::Routing::Resource::Options
-    #
-    # @example Default usage
-    #   require 'hanami/router'
-    #
-    #   Hanami::Router.new do
-    #     resource 'identity'
-    #   end
-    #
-    #   # It generates:
-    #   #
-    #   # +--------+----------------+-------------------+----------+----------------+
-    #   # | Verb   | Path           | Action            | Name     | Named Route    |
-    #   # +--------+----------------+-------------------+----------+----------------+
-    #   # | GET    | /identity      | Identity::Show    | :show    | :identity      |
-    #   # | GET    | /identity/new  | Identity::New     | :new     | :new_identity  |
-    #   # | POST   | /identity      | Identity::Create  | :create  | :identity      |
-    #   # | GET    | /identity/edit | Identity::Edit    | :edit    | :edit_identity |
-    #   # | PATCH  | /identity      | Identity::Update  | :update  | :identity      |
-    #   # | DELETE | /identity      | Identity::Destroy | :destroy | :identity      |
-    #   # +--------+----------------+-------------------+----------+----------------+
-    #
-    #
-    #
-    # @example Limit the generated routes with :only
-    #   require 'hanami/router'
-    #
-    #   Hanami::Router.new do
-    #     resource 'identity', only: [:show, :new, :create]
-    #   end
-    #
-    #   # It generates:
-    #   #
-    #   # +--------+----------------+------------------+----------+----------------+
-    #   # | Verb   | Path           | Action           | Name     | Named Route    |
-    #   # +--------+----------------+------------------+----------+----------------+
-    #   # | GET    | /identity      | Identity::Show   | :show    | :identity      |
-    #   # | GET    | /identity/new  | Identity::New    | :new     | :new_identity  |
-    #   # | POST   | /identity      | Identity::Create | :create  | :identity      |
-    #   # +--------+----------------+------------------+----------+----------------+
-    #
-    #
-    #
-    # @example Limit the generated routes with :except
-    #   require 'hanami/router'
-    #
-    #   Hanami::Router.new do
-    #     resource 'identity', except: [:edit, :update, :destroy]
-    #   end
+    # Defines a routing scope. Routes defined in the context of a scope,
+    # inherit the given path as path prefix and as a named routes prefix.
     #
-    #   # It generates:
-    #   #
-    #   # +--------+----------------+------------------+----------+----------------+
-    #   # | Verb   | Path           | Action           | Name     | Named Route    |
-    #   # +--------+----------------+------------------+----------+----------------+
-    #   # | GET    | /identity      | Identity::Show   | :show    | :identity      |
-    #   # | GET    | /identity/new  | Identity::New    | :new     | :new_identity  |
-    #   # | POST   | /identity      | Identity::Create | :create  | :identity      |
-    #   # +--------+----------------+------------------+----------+----------------+
+    # @param path [String] the scope path to be used as a path prefix
+    # @param blk [Proc] the routes definitions withing the scope
     #
+    # @since 2.0.0
     #
+    # @see #path
     #
-    # @example Additional single routes
-    #   require 'hanami/router'
-    #
-    #   Hanami::Router.new do
-    #     resource 'identity', only: [] do
-    #       member do
-    #         patch 'activate'
-    #       end
-    #     end
-    #   end
-    #
-    #   # It generates:
-    #   #
-    #   # +--------+--------------------+--------------------+------+--------------------+
-    #   # | Verb   | Path               | Action             | Name | Named Route        |
-    #   # +--------+--------------------+--------------------+------+--------------------+
-    #   # | PATCH  | /identity/activate | Identity::Activate |      | :activate_identity |
-    #   # +--------+--------------------+--------------------+------+--------------------+
-    #
-    #
-    #
-    # @example Additional collection routes
-    #   require 'hanami/router'
+    # @example
+    #   require "hanami/router"
     #
-    #   Hanami::Router.new do
-    #     resource 'identity', only: [] do
-    #       collection do
-    #         get 'keys'
-    #       end
+    #   router = Hanami::Router.new do
+    #     scope "v1" do
+    #       get "/users", to: ->(*) { ... }, as: :users
     #     end
     #   end
     #
-    #   # It generates:
-    #   #
-    #   # +------+----------------+----------------+------+----------------+
-    #   # | Verb | Path           | Action         | Name | Named Route    |
-    #   # +------+----------------+----------------+------+----------------+
-    #   # | GET  | /identity/keys | Identity::Keys |      | :keys_identity |
-    #   # +------+----------------+----------------+------+----------------+
-    def resource(name, options = {}, &blk)
-      Routing::Resource.new(self, name, options.merge(separator: @router.action_separator), &blk)
-    end
+    #   router.path(:v1_users) # => "/v1/users"
+    def scope(path, &blk)
+      path_prefix = @path_prefix
+      name_prefix = @name_prefix
 
-    # Defines a set of named routes for a plural RESTful resource.
-    # It has a built-in integration for Hanami::Controller.
-    #
-    # @param name [String] the name of the resource
-    # @param options [Hash] a set of options to customize the routes
-    # @option options [Array<Symbol>] :only a subset of the default routes
-    #   that we want to generate
-    # @option options [Array<Symbol>] :except prevent the given routes to be
-    #   generated
-    # @param blk [Proc] a block of code to generate additional routes
-    #
-    # @return [Hanami::Routing::Resources]
-    #
-    # @since 0.1.0
-    #
-    # @see Hanami::Routing::Resources
-    # @see Hanami::Routing::Resources::Action
-    # @see Hanami::Routing::Resource::Options
-    #
-    # @example Default usage
-    #   require 'hanami/router'
-    #
-    #   Hanami::Router.new do
-    #     resources 'articles'
-    #   end
-    #
-    #   # It generates:
-    #   #
-    #   # +--------+--------------------+-------------------+----------+----------------+
-    #   # | Verb   | Path               | Action            | Name     | Named Route    |
-    #   # +--------+--------------------+-------------------+----------+----------------+
-    #   # | GET    | /articles          | Articles::Index   | :index   | :articles      |
-    #   # | GET    | /articles/:id      | Articles::Show    | :show    | :articles      |
-    #   # | GET    | /articles/new      | Articles::New     | :new     | :new_articles  |
-    #   # | POST   | /articles          | Articles::Create  | :create  | :articles      |
-    #   # | GET    | /articles/:id/edit | Articles::Edit    | :edit    | :edit_articles |
-    #   # | PATCH  | /articles/:id      | Articles::Update  | :update  | :articles      |
-    #   # | DELETE | /articles/:id      | Articles::Destroy | :destroy | :articles      |
-    #   # +--------+--------------------+-------------------+----------+----------------+
-    #
-    #
-    #
-    # @example Limit the generated routes with :only
-    #   require 'hanami/router'
-    #
-    #   Hanami::Router.new do
-    #     resources 'articles', only: [:index]
-    #   end
-    #
-    #   # It generates:
-    #   #
-    #   # +------+-----------+-----------------+--------+-------------+
-    #   # | Verb | Path      | Action          | Name   | Named Route |
-    #   # +------+-----------+-----------------+--------+-------------+
-    #   # | GET  | /articles | Articles::Index | :index | :articles   |
-    #   # +------+-----------+-----------------+--------+-------------+
-    #
-    #
-    #
-    # @example Limit the generated routes with :except
-    #   require 'hanami/router'
-    #
-    #   Hanami::Router.new do
-    #     resources 'articles', except: [:edit, :update]
-    #   end
-    #
-    #   # It generates:
-    #   #
-    #   # +--------+--------------------+-------------------+----------+----------------+
-    #   # | Verb   | Path               | Action            | Name     | Named Route    |
-    #   # +--------+--------------------+-------------------+----------+----------------+
-    #   # | GET    | /articles          | Articles::Index   | :index   | :articles      |
-    #   # | GET    | /articles/:id      | Articles::Show    | :show    | :articles      |
-    #   # | GET    | /articles/new      | Articles::New     | :new     | :new_articles  |
-    #   # | POST   | /articles          | Articles::Create  | :create  | :articles      |
-    #   # | DELETE | /articles/:id      | Articles::Destroy | :destroy | :articles      |
-    #   # +--------+--------------------+-------------------+----------+----------------+
-    #
-    #
-    #
-    # @example Additional single routes
-    #   require 'hanami/router'
-    #
-    #   Hanami::Router.new do
-    #     resources 'articles', only: [] do
-    #       member do
-    #         patch 'publish'
-    #       end
-    #     end
-    #   end
-    #
-    #   # It generates:
-    #   #
-    #   # +--------+-----------------------+-------------------+------+-------------------+
-    #   # | Verb   | Path                  | Action            | Name | Named Route       |
-    #   # +--------+-----------------------+-------------------+------+-------------------+
-    #   # | PATCH  | /articles/:id/publish | Articles::Publish |      | :publish_articles |
-    #   # +--------+-----------------------+-------------------+------+-------------------+
-    #
-    #
-    #
-    # @example Additional collection routes
-    #   require 'hanami/router'
-    #
-    #   Hanami::Router.new do
-    #     resources 'articles', only: [] do
-    #       collection do
-    #         get 'search'
-    #       end
-    #     end
-    #   end
-    #
-    #   # It generates:
-    #   #
-    #   # +------+------------------+------------------+------+------------------+
-    #   # | Verb | Path             | Action           | Name | Named Route      |
-    #   # +------+------------------+------------------+------+------------------+
-    #   # | GET  | /articles/search | Articles::Search |      | :search_articles |
-    #   # +------+------------------+------------------+------+------------------+
-    def resources(name, options = {}, &blk)
-      Routing::Resources.new(self, name, options.merge(separator: @router.action_separator), &blk)
+      begin
+        @path_prefix = @path_prefix.join(path.to_s)
+        @name_prefix = @name_prefix.join(path.to_s)
+        instance_eval(&blk)
+      ensure
+        @path_prefix = path_prefix
+        @name_prefix = name_prefix
+      end
     end
 
     # Mount a Rack application at the specified path.
     # All the requests starting with the specified path, will be forwarded to
     # the given application.
     #
-    # All the other methods (eg #get) support callable objects, but they
+    # All the other methods (eg `#get`) support callable objects, but they
     # restrict the range of the acceptable HTTP verb. Mounting an application
     # with #mount doesn't apply this kind of restriction at the router level,
     # but let the application to decide.
     #
     # @param app [#call] a class or an object that responds to #call
-    # @param options [Hash] the options to customize the mount
-    # @option options [:at] the relative path where to mount the app
+    # @param at [String] the relative path where to mount the app
+    # @param constraints [Hash] a set of constraints for path variables
     #
     # @since 0.1.1
     #
-    # @example Basic usage
-    #   require 'hanami/router'
+    # @example
+    #   require "hanami/router"
     #
     #   Hanami::Router.new do
-    #     mount Api::App.new, at: '/api'
+    #     mount MyRackApp.new, at: "/foo"
     #   end
+    def mount(app, at:, **constraints)
+      path = prefixed_path(at)
+      prefix = Segment.fabricate(path, **constraints)
+      @mounted[prefix] = @resolver.call(path, app)
+    end
+
+    # Generate an relative URL for a specified named route.
+    # The additional arguments will be used to compose the relative URL - in
+    #   case it has tokens to match - and for compose the query string.
     #
-    #   # Requests:
-    #   #
-    #   # GET  /api          # => 200
-    #   # GET  /api/articles # => 200
-    #   # POST /api/articles # => 200
-    #   # GET  /api/unknown  # => 404
-    #
-    # @example Difference between #get and #mount
-    #   require 'hanami/router'
+    # @param name [Symbol] the route name
     #
-    #   Hanami::Router.new do
-    #     get '/rack1',      to: RackOne.new
-    #     mount RackTwo.new, at: '/rack2'
-    #   end
+    # @return [String]
     #
-    #   # Requests:
-    #   #
-    #   # # /rack1 will only accept GET
-    #   # GET  /rack1        # => 200 (RackOne.new)
-    #   # POST /rack1        # => 405
-    #   #
-    #   # # /rack2 accepts all the verbs and delegate the decision to RackTwo
-    #   # GET  /rack2        # => 200 (RackTwo.new)
-    #   # POST /rack2        # => 200 (RackTwo.new)
-    #
-    # @example Types of mountable applications
-    #   require 'hanami/router'
-    #
-    #   class RackOne
-    #     def self.call(env)
-    #     end
-    #   end
+    # @raise [Hanami::Routing::InvalidRouteException] when the router fails to
+    #   recognize a route, because of the given arguments.
     #
-    #   class RackTwo
-    #     def call(env)
-    #     end
-    #   end
+    # @since 0.1.0
     #
-    #   class RackThree
-    #     def call(env)
-    #     end
-    #   end
+    # @see #url
     #
-    #   module Dashboard
-    #     class Index
-    #       def call(env)
-    #       end
-    #     end
-    #   end
+    # @example
+    #   require "hanami/router"
     #
-    #   Hanami::Router.new do
-    #     mount RackOne,                             at: '/rack1'
-    #     mount RackTwo,                             at: '/rack2'
-    #     mount RackThree.new,                       at: '/rack3'
-    #     mount ->(env) {[200, {}, ['Rack Four']]},  at: '/rack4'
-    #     mount 'dashboard#index',                   at: '/dashboard'
+    #   router = Hanami::Router.new(base_url: "https://hanamirb.org") do
+    #     get "/login", to: ->(*) { ... }, as: :login
+    #     get "/:name", to: ->(*) { ... }, as: :framework
     #   end
     #
-    #   # 1. RackOne is used as it is (class), because it respond to .call
-    #   # 2. RackTwo is initialized, because it respond to #call
-    #   # 3. RackThree is used as it is (object), because it respond to #call
-    #   # 4. That Proc is used as it is, because it respond to #call
-    #   # 5. That string is resolved as Dashboard::Index (Hanami::Controller)
-    def mount(app, options)
-      @router.mount(app, options)
+    #   router.path(:login)                          # => "/login"
+    #   router.path(:login, return_to: "/dashboard") # => "/login?return_to=%2Fdashboard"
+    #   router.path(:framework, name: "router")      # => "/router"
+    def path(name, variables = {})
+      @url_helpers.path(name, variables)
     end
 
-    # Resolve the given Rack env to a registered endpoint and invoke it.
+    # Generate an absolute URL for a specified named route.
+    # The additional arguments will be used to compose the relative URL - in
+    #   case it has tokens to match - and for compose the query string.
     #
-    # @param env [Hash] a Rack env instance
+    # @param name [Symbol] the route name
     #
-    # @return [Rack::Response, Array]
+    # @return [String]
+    #
+    # @raise [Hanami::Routing::InvalidRouteException] when the router fails to
+    #   recognize a route, because of the given arguments.
     #
     # @since 0.1.0
-    def call(env)
-      @router.call(env)
+    #
+    # @see #path
+    #
+    # @example
+    #   require "hanami/router"
+    #
+    #   router = Hanami::Router.new(base_url: "https://hanamirb.org") do
+    #     get "/login", to: ->(*) { ... }, as: :login
+    #     get "/:name", to: ->(*) { ... }, as: :framework
+    #   end
+    #
+    #   router.url(:login)                          # => "https://hanamirb.org/login"
+    #   router.url(:login, return_to: "/dashboard") # => "https://hanamirb.org/login?return_to=%2Fdashboard"
+    #   router.url(:framework, name: "router")      # => "https://hanamirb.org/router"
+    def url(name, variables = {})
+      @url_helpers.url(name, variables)
     end
 
     # Recognize the given env, path, or name and return a route for testing
@@ -1037,34 +488,34 @@ module Hanami
     # @see Hanami::Routing::RecognizedRoute
     #
     # @example Successful Path Recognition
-    #   require 'hanami/router'
+    #   require "hanami/router"
     #
     #   router = Hanami::Router.new do
-    #     get '/books/:id', to: 'books#show', as: :book
+    #     get "/books/:id", to: ->(*) { ... }, as: :book
     #   end
     #
-    #   route = router.recognize('/books/23')
+    #   route = router.recognize("/books/23")
     #   route.verb      # => "GET" (default)
     #   route.routable? # => true
     #   route.params    # => {:id=>"23"}
     #
     # @example Successful Rack Env Recognition
-    #   require 'hanami/router'
+    #   require "hanami/router"
     #
     #   router = Hanami::Router.new do
-    #     get '/books/:id', to: 'books#show', as: :book
+    #     get "/books/:id", to: ->(*) { ... }, as: :book
     #   end
     #
-    #   route = router.recognize(Rack::MockRequest.env_for('/books/23'))
+    #   route = router.recognize(Rack::MockRequest.env_for("/books/23"))
     #   route.verb      # => "GET" (default)
     #   route.routable? # => true
     #   route.params    # => {:id=>"23"}
     #
     # @example Successful Named Route Recognition
-    #   require 'hanami/router'
+    #   require "hanami/router"
     #
     #   router = Hanami::Router.new do
-    #     get '/books/:id', to: 'books#show', as: :book
+    #     get "/books/:id", to: ->(*) { ... }, as: :book
     #   end
     #
     #   route = router.recognize(:book, id: 23)
@@ -1073,43 +524,43 @@ module Hanami
     #   route.params    # => {:id=>"23"}
     #
     # @example Failing Recognition For Unknown Path
-    #   require 'hanami/router'
+    #   require "hanami/router"
     #
     #   router = Hanami::Router.new do
-    #     get '/books/:id', to: 'books#show', as: :book
+    #     get "/books/:id", to: ->(*) { ... }, as: :book
     #   end
     #
-    #   route = router.recognize('/books')
+    #   route = router.recognize("/books")
     #   route.verb      # => "GET" (default)
     #   route.routable? # => false
     #
     # @example Failing Recognition For Path With Wrong HTTP Verb
-    #   require 'hanami/router'
+    #   require "hanami/router"
     #
     #   router = Hanami::Router.new do
-    #     get '/books/:id', to: 'books#show', as: :book
+    #     get "/books/:id", to: ->(*) { ... }, as: :book
     #   end
     #
-    #   route = router.recognize('/books/23', method: :post)
+    #   route = router.recognize("/books/23", method: :post)
     #   route.verb      # => "POST"
     #   route.routable? # => false
     #
     # @example Failing Recognition For Rack Env With Wrong HTTP Verb
-    #   require 'hanami/router'
+    #   require "hanami/router"
     #
     #   router = Hanami::Router.new do
-    #     get '/books/:id', to: 'books#show', as: :book
+    #     get "/books/:id", to: ->(*) { ... }, as: :book
     #   end
     #
-    #   route = router.recognize(Rack::MockRequest.env_for('/books/23', method: :post))
+    #   route = router.recognize(Rack::MockRequest.env_for("/books/23", method: :post))
     #   route.verb      # => "POST"
     #   route.routable? # => false
     #
     # @example Failing Recognition Named Route With Wrong Params
-    #   require 'hanami/router'
+    #   require "hanami/router"
     #
     #   router = Hanami::Router.new do
-    #     get '/books/:id', to: 'books#show', as: :book
+    #     get "/books/:id", to: ->(*) { ... }, as: :book
     #   end
     #
     #   route = router.recognize(:book)
@@ -1117,105 +568,79 @@ module Hanami
     #   route.routable? # => false
     #
     # @example Failing Recognition Named Route With Wrong HTTP Verb
-    #   require 'hanami/router'
+    #   require "hanami/router"
     #
     #   router = Hanami::Router.new do
-    #     get '/books/:id', to: 'books#show', as: :book
+    #     get "/books/:id", to: ->(*) { ... }, as: :book
     #   end
     #
     #   route = router.recognize(:book, {method: :post}, {id: 1})
     #   route.verb      # => "POST"
     #   route.routable? # => false
     #   route.params    # => {:id=>"1"}
-    def recognize(env, options = {}, params = nil)
-      require 'hanami/routing/recognized_route'
+    def recognize(env, params = {}, options = {})
+      require "hanami/router/recognized_route"
+      env = env_for(env, params, options)
+      endpoint, params = lookup(env)
+
+      RecognizedRoute.new(
+        endpoint, _params(env, params)
+      )
+    end
 
-      env          = env_for(env, options, params)
-      responses, _ = *@router.recognize(env)
+    # @since 2.0.0
+    # @api private
+    def fixed(env)
+      @fixed.dig(env["REQUEST_METHOD"], env["PATH_INFO"])
+    end
 
-      Routing::RecognizedRoute.new(
-        responses.nil? ? responses : responses.first,
-        env, @router)
+    # @since 2.0.0
+    # @api private
+    def variable(env)
+      @variable[env["REQUEST_METHOD"]]&.find(env["PATH_INFO"])
     end
 
-    # Generate an relative URL for a specified named route.
-    # The additional arguments will be used to compose the relative URL - in
-    #   case it has tokens to match - and for compose the query string.
-    #
-    # @param route [Symbol] the route name
-    #
-    # @return [String]
-    #
-    # @raise [Hanami::Routing::InvalidRouteException] when the router fails to
-    #   recognize a route, because of the given arguments.
-    #
-    # @since 0.1.0
-    #
-    # @example
-    #   require 'hanami/router'
-    #
-    #   router = Hanami::Router.new(scheme: 'https', host: 'hanamirb.org')
-    #   router.get '/login', to: 'sessions#new',    as: :login
-    #   router.get '/:name', to: 'frameworks#show', as: :framework
-    #
-    #   router.path(:login)                          # => "/login"
-    #   router.path(:login, return_to: '/dashboard') # => "/login?return_to=%2Fdashboard"
-    #   router.path(:framework, name: 'router')      # => "/router"
-    def path(route, *args)
-      @router.path(route, *args)
+    # @since 2.0.0
+    # @api private
+    def globbed(env)
+      @globbed[env["REQUEST_METHOD"]]&.each do |path, to|
+        if (match = path.match(env["PATH_INFO"]))
+          return [to, match.named_captures]
+        end
+      end
+
+      nil
     end
 
-    # Generate a URL for a specified named route.
-    # The additional arguments will be used to compose the relative URL - in
-    #   case it has tokens to match - and for compose the query string.
-    #
-    # @param route [Symbol] the route name
-    #
-    # @return [String]
-    #
-    # @raise [Hanami::Routing::InvalidRouteException] when the router fails to
-    #   recognize a route, because of the given arguments.
-    #
-    # @since 0.1.0
-    #
-    # @example
-    #   require 'hanami/router'
-    #
-    #   router = Hanami::Router.new(scheme: 'https', host: 'hanamirb.org')
-    #   router.get '/login', to: 'sessions#new', as: :login
-    #   router.get '/:name', to: 'frameworks#show', as: :framework
-    #
-    #   router.url(:login)                          # => "https://hanamirb.org/login"
-    #   router.url(:login, return_to: '/dashboard') # => "https://hanamirb.org/login?return_to=%2Fdashboard"
-    #   router.url(:framework, name: 'router')      # => "https://hanamirb.org/router"
-    def url(route, *args)
-      @router.url(route, *args)
+    # @since 2.0.0
+    # @api private
+    def mounted(env)
+      @mounted.each do |prefix, app|
+        next unless (match = prefix.peek_match(env["PATH_INFO"]))
+
+        # TODO: ensure compatibility with existing env["SCRIPT_NAME"]
+        # TODO: cleanup this code
+        env["SCRIPT_NAME"] = env["SCRIPT_NAME"].to_s + prefix.to_s
+        env["PATH_INFO"] = env["PATH_INFO"].sub(prefix.to_s, "")
+        env["PATH_INFO"] = "/" if env["PATH_INFO"] == ""
+
+        return [app, match.named_captures]
+      end
+
+      nil
     end
 
-    # Returns an routes inspector
-    #
-    # @since 0.2.0
-    #
-    # @see Hanami::Routing::RoutesInspector
-    #
-    # @example
-    #   require 'hanami/router'
-    #
-    #   router = Hanami::Router.new do
-    #     get    '/',       to: 'home#index'
-    #     get    '/login',  to: 'sessions#new',     as: :login
-    #     post   '/login',  to: 'sessions#create'
-    #     delete '/logout', to: 'sessions#destroy', as: :logout
-    #   end
-    #
-    #   puts router.inspector
-    #     # =>        GET, HEAD  /                        Home::Index
-    #          login  GET, HEAD  /login                   Sessions::New
-    #                 POST       /login                   Sessions::Create
-    #          logout GET, HEAD  /logout                  Sessions::Destroy
-    def inspector
-      require 'hanami/routing/routes_inspector'
-      Routing::RoutesInspector.new(@router.routes, @router.prefix)
+    # @since 2.0.0
+    # @api private
+    def not_allowed(env)
+      (_not_allowed_fixed(env) ||
+       _not_allowed_variable(env)) and return [405, {"Content-Length" => "11"}, ["Not Allowed"]]
+    end
+
+    # @since 2.0.0
+    # @api private
+    def not_found(env)
+      @not_found.call(env)
     end
 
     protected
@@ -1233,20 +658,186 @@ module Hanami
     #
     # @see Hanami::Router#recognize
     # @see http://www.rubydoc.info/github/rack/rack/Rack%2FMockRequest.env_for
-    def env_for(env, options = {}, params = nil)
-      env = case env
-      when String
-        Rack::MockRequest.env_for(env, options)
-      when Symbol
+    def env_for(env, params = {}, options = {})
+      require "rack/mock"
+
+      case env
+      when ::String
+        ::Rack::MockRequest.env_for(env, options)
+      when ::Symbol
         begin
-          url = path(env, params || options)
-          return env_for(url, options)
-        rescue Hanami::Routing::InvalidRouteException
-          {}
+          url = path(env, params)
+          return env_for(url, params, options) # rubocop:disable Style/RedundantReturn
+        rescue Hanami::Router::InvalidRouteException
+          {} # Empty Rack env
         end
       else
         env
       end
     end
+
+    private
+
+    # @since 2.0.0
+    # @api private
+    DEFAULT_BASE_URL = "http://localhost"
+
+    # @since 2.0.0
+    # @api private
+    DEFAULT_PREFIX = "/"
+
+    # @since 2.0.0
+    # @api private
+    DEFAULT_RESOLVER = ->(_, to) { to }
+
+    # @since 2.0.0
+    # @api private
+    DEFAULT_REDIRECT_CODE = 301
+
+    # @since 2.0.0
+    # @api private
+    PARAMS = "router.params"
+
+    # Default response when no route was matched
+    #
+    # @api private
+    # @since 2.0.0
+    NOT_FOUND = ->(*) { [404, {"Content-Length" => "9"}, ["Not Found"]] }.freeze
+
+    # @since 2.0.0
+    # @api private
+    def lookup(env)
+      endpoint = fixed(env)
+      return [endpoint, {}] if endpoint
+
+      variable(env) || globbed(env) || mounted(env)
+    end
+
+    # @since 2.0.0
+    # @api private
+    def add_route(http_method, path, to, as, constraints, &blk)
+      path = prefixed_path(path)
+      to = resolve_endpoint(path, to, blk)
+
+      if globbed?(path)
+        add_globbed_route(http_method, path, to, constraints)
+      elsif variable?(path)
+        add_variable_route(http_method, path, to, constraints)
+      else
+        add_fixed_route(http_method, path, to)
+      end
+
+      add_named_route(path, as, constraints) if as
+    end
+
+    # @since 2.0.0
+    # @api private
+    def resolve_endpoint(path, to, blk)
+      (to || blk) or raise MissingEndpointError.new(path)
+      to = Block.new(@block_context, blk) if to.nil?
+
+      @resolver.call(path, to)
+    end
+
+    # @since 2.0.0
+    # @api private
+    def add_globbed_route(http_method, path, to, constraints)
+      @globbed[http_method] ||= []
+      @globbed[http_method] << [Segment.fabricate(path, **constraints), to]
+    end
+
+    # @since 2.0.0
+    # @api private
+    def add_variable_route(http_method, path, to, constraints)
+      @variable[http_method] ||= Trie.new
+      @variable[http_method].add(path, to, constraints)
+    end
+
+    # @since 2.0.0
+    # @api private
+    def add_fixed_route(http_method, path, to)
+      @fixed[http_method] ||= {}
+      @fixed[http_method][path] = to
+    end
+
+    # @since 2.0.0
+    # @api private
+    def add_named_route(path, as, constraints)
+      @url_helpers.add(prefixed_name(as), Segment.fabricate(path, **constraints))
+    end
+
+    # @since 2.0.0
+    # @api private
+    def variable?(path)
+      /:/.match?(path)
+    end
+
+    # @since 2.0.0
+    # @api private
+    def globbed?(path)
+      /\*/.match?(path)
+    end
+
+    # @since 2.0.0
+    # @api private
+    def prefixed_path(path)
+      @path_prefix.join(path).to_s
+    end
+
+    # @since 2.0.0
+    # @api private
+    def prefixed_name(name)
+      @name_prefix.relative_join(name, "_").to_sym
+    end
+
+    # @since 2.0.0
+    # @api private
+    def _redirect(to, code)
+      body = Rack::Utils::HTTP_STATUS_CODES.fetch(code) do
+        raise UnknownHTTPStatusCodeError.new(code)
+      end
+
+      destination = prefixed_path(to)
+      Redirect.new(destination, ->(*) { [code, {"Location" => destination}, [body]] })
+    end
+
+    # @since 2.0.0
+    # @api private
+    def _params(env, params)
+      params ||= {}
+      env[PARAMS] ||= {}
+      env[PARAMS].merge!(Rack::Utils.parse_nested_query(env["QUERY_STRING"]))
+      env[PARAMS].merge!(params)
+      env[PARAMS] = Params.deep_symbolize(env[PARAMS])
+      env
+    end
+
+    # @since 2.0.0
+    # @api private
+    def _not_allowed_fixed(env)
+      found = false
+
+      @fixed.each_value do |routes|
+        break if found
+
+        found = routes.key?(env["PATH_INFO"])
+      end
+
+      found
+    end
+
+    # @since 2.0.0
+    # @api private
+    def _not_allowed_variable(env)
+      found = false
+
+      @variable.each_value do |routes|
+        break if found
+
+        found = routes.find(env["PATH_INFO"])
+      end
+
+      found
+    end
   end
 end