hanami-router 1.3.2 → 2.0.0.alpha1

data/hanami-router.gemspec

@@ -1,30 +1,33 @@
-# 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.files         = `git ls-files -- lib/* CHANGELOG.md LICENSE.md README.md hanami-router.gemspec`.split($INPUT_RECORD_SEPARATOR)
   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.5.0"
 
-  spec.add_dependency 'rack',         '~> 2.0'
-  spec.add_dependency 'http_router',  '0.11.2'
-  spec.add_dependency 'hanami-utils', '~> 1.3'
+  spec.add_dependency "rack",               "~> 2.0"
+  spec.add_dependency "mustermann",         "~> 1.0"
+  spec.add_dependency "mustermann-contrib", "~> 1.0"
+  spec.add_dependency "hanami-utils",       "~> 2.0.alpha"
+  spec.add_dependency "dry-inflector",      "~> 0.1"
 
-  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.7'
+  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"
 end

data/lib/hanami/middleware/body_parser.rb

@@ -1,5 +1,8 @@
-require 'hanami/utils/hash'
-require_relative 'body_parser/class_interface'
+# frozen_string_literal: true
+
+require "hanami/utils/hash"
+require "hanami/middleware/error"
+require_relative "body_parser/class_interface"
 
 module Hanami
   module Middleware
@@ -8,7 +11,7 @@ module Hanami
     class BodyParser
       # @since 1.3.0
       # @api private
-      CONTENT_TYPE = 'CONTENT_TYPE'.freeze
+      CONTENT_TYPE = "CONTENT_TYPE"
 
       # @since 1.3.0
       # @api private
@@ -16,17 +19,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,18 +58,18 @@ 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)
+        if body.is_a?(::Hash)
           Utils::Hash.deep_symbolize(body)
         else
           { FALLBACK_KEY => body }
@@ -82,9 +85,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,56 @@
-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 "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) # rubocop:disable Metrics/MethodLength
+          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"
+
+          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

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,5 +1,7 @@
-require 'hanami/utils/json'
-require_relative 'errors'
+# frozen_string_literal: true
+
+require "hanami/utils/json"
+require_relative "errors"
 
 module Hanami
   module Middleware
@@ -10,7 +12,7 @@ module Hanami
         # @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

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,9 +1,9 @@
-require 'rack/request'
-require 'hanami/routing/http_router'
-require 'hanami/routing/namespace'
-require 'hanami/routing/resource'
-require 'hanami/routing/resources'
-require 'hanami/routing/error'
+# frozen_string_literal: true
+
+require "rack/request"
+require "dry/inflector"
+require "hanami/routing"
+require "hanami/utils/hash"
 
 # Hanami
 #
@@ -75,7 +75,12 @@ module Hanami
   #   end
   #
   #   # All the requests starting with "/api" will be forwarded to Api::App
-  class Router
+  #
+  class Router # rubocop:disable Metrics/ClassLength
+    # @since 2.0.0
+    # @api private
+    attr_reader :inflector
+
     # This error is raised when <tt>#call</tt> is invoked on a non-routable
     # recognized route.
     #
@@ -88,15 +93,15 @@ module Hanami
     class NotRoutableEndpointError < Hanami::Routing::Error
       # @since 0.5.0
       # @api private
-      REQUEST_METHOD = 'REQUEST_METHOD'.freeze
+      REQUEST_METHOD = "REQUEST_METHOD"
 
       # @since 0.5.0
       # @api private
-      PATH_INFO      = 'PATH_INFO'.freeze
+      PATH_INFO      = "PATH_INFO"
 
       # @since 0.5.0
       def initialize(env)
-        super %(Cannot find routable endpoint for #{ env[REQUEST_METHOD] } "#{ env[PATH_INFO] }")
+        super %(Cannot find routable endpoint for #{env[REQUEST_METHOD]} "#{env[PATH_INFO]}")
       end
     end
 
@@ -106,7 +111,7 @@ module Hanami
     # @api private
     #
     # @see Hanami::Router#root
-    ROOT_PATH = '/'.freeze
+    ROOT_PATH = "/"
 
     # Returns the given block as it is.
     #
@@ -154,8 +159,8 @@ module Hanami
     #   (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
+    # @option options [Object, #pluralize, #singularize] :inflector
+    #   the inflector class (defaults to `Dry::Inflector.new`)
     #
     # @param blk [Proc] the optional block to define the routes
     #
@@ -178,51 +183,53 @@ module Hanami
     #   end
     #
     # @example Body parsers
-    #   require 'json'
-    #   require 'hanami/router'
     #
-    #   # It parses JSON body and makes the attributes available to the params
+    #  require 'hanami/router'
+    #  require 'hanami/middleware/body_parser'
     #
-    #   endpoint = ->(env) { [200, {},[env['router.params'].inspect]] }
+    #  app = Hanami::Router.new do
+    #    patch '/books/:id', to: ->(env) { [200, {},[env['router.params'].inspect]] }
+    #  end
     #
-    #   router = Hanami::Router.new(parsers: [:json]) do
-    #     patch '/books/:id', to: endpoint
-    #   end
+    #  use Hanami::Middleware::BodyParser, :json
+    #  run app
     #
-    #   # From the shell
+    #  # From the shell
     #
-    #   curl http://localhost:2300/books/1    \
-    #     -H "Content-Type: application/json" \
-    #     -H "Accept: application/json"       \
-    #     -d '{"published":"true"}'           \
-    #     -X PATCH
+    #  curl http://localhost:2300/books/1    \
+    #    -H "Content-Type: application/json" \
+    #    -H "Accept: application/json"       \
+    #    -d '{"published":"true"}'           \
+    #    -X PATCH
     #
     #   # It returns
     #
     #   [200, {}, ["{:published=>\"true\",:id=>\"1\"}"]]
     #
     # @example Custom body parser
-    #   require 'hanami/router'
     #
-    #   class XmlParser
-    #     def mime_types
-    #       ['application/xml', 'text/xml']
-    #     end
+    #  require 'hanami/router'
+    #  require 'hanami/middleware/body_parser'
     #
-    #     # Parse body and return a Hash
-    #     def parse(body)
-    #       # ...
-    #     end
-    #   end
     #
-    #   # It parses XML body and makes the attributes available to the params
+    #  class XmlParser < Hanami::Middleware::BodyParser::Parser
+    #    def mime_types
+    #      ['application/xml', 'text/xml']
+    #    end
     #
-    #   endpoint = ->(env) { [200, {},[env['router.params'].inspect]] }
+    #    # Parse body and return a Hash
+    #    def parse(body)
+    #      # parse xml
+    #    end
+    #  end
     #
-    #   router = Hanami::Router.new(parsers: [XmlParser.new]) do
-    #     patch '/authors/:id', to: endpoint
+    #   app = Hanami::Router.new do
+    #     patch '/authors/:id', to: ->(env) { [200, {},[env['router.params'].inspect]] }
     #   end
     #
+    #   use Hanami::Middleware::BodyParser, XmlParser
+    #   run app
+    #
     #   # From the shell
     #
     #   curl http://localhost:2300/authors/1 \
@@ -234,9 +241,29 @@ module Hanami
     #   # It returns
     #
     #   [200, {}, ["{:name=>\"LG\",:id=>\"1\"}"]]
-    def initialize(options = {}, &blk)
-      @router = Routing::HttpRouter.new(options)
-      define(&blk)
+    #
+    # rubocop:disable Metrics/MethodLength
+    def initialize(scheme: "http", host: "localhost", port: 80, prefix: "", namespace: nil, configuration: nil, inflector: Dry::Inflector.new, not_found: NOT_FOUND, not_allowed: NOT_ALLOWED, &blk)
+      @routes        = []
+      @named         = {}
+      @namespace     = namespace
+      @configuration = configuration
+      @base          = Routing::Uri.build(scheme: scheme, host: host, port: port)
+      @prefix        = Utils::PathPrefix.new(prefix)
+      @inflector     = inflector
+      @not_found     = not_found
+      @not_allowed   = not_allowed
+      instance_eval(&blk) unless blk.nil?
+      freeze
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # Freeze the router
+    #
+    # @since 2.0.0
+    def freeze
+      @routes.freeze
+      super
     end
 
     # Returns self
@@ -253,30 +280,6 @@ module Hanami
       self
     end
 
-    # To support defining routes in the `define` wrapper.
-    #
-    # @param blk [Proc] the block to define the routes
-    #
-    # @return [Hanami::Routing::Route]
-    #
-    # @since 0.2.0
-    #
-    # @example In Hanami framework
-    #   class Application < Hanami::Application
-    #     configure do
-    #       routes 'config/routes'
-    #     end
-    #   end
-    #
-    #   # In `config/routes`
-    #
-    #   define do
-    #     get # ...
-    #   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
@@ -292,7 +295,7 @@ module Hanami
     #   router = Hanami::Router.new { get '/', to: ->(env) { } }
     #   router.defined? # => true
     def defined?
-      @router.routes.any?
+      @routes.any?
     end
 
     # Defines a route that accepts a GET request for the given path.
@@ -409,8 +412,8 @@ module Hanami
     #
     #    # It will map to Flowers::Index.new, which is the
     #    # Hanami::Controller convention.
-    def get(path, options = {}, &blk)
-      @router.get(path, options, &blk)
+    def get(path, to: nil, as: nil, namespace: nil, configuration: nil, **constraints, &blk)
+      add_route(GET, path, to, as, namespace, configuration, constraints, &blk)
     end
 
     # Defines a route that accepts a POST request for the given path.
@@ -428,8 +431,8 @@ module Hanami
     # @see Hanami::Router#get
     #
     # @since 0.1.0
-    def post(path, options = {}, &blk)
-      @router.post(path, options, &blk)
+    def post(path, to: nil, as: nil, namespace: nil, configuration: nil, **constraints, &blk)
+      add_route(POST, path, to, as, namespace, configuration, constraints, &blk)
     end
 
     # Defines a route that accepts a PUT request for the given path.
@@ -447,8 +450,8 @@ module Hanami
     # @see Hanami::Router#get
     #
     # @since 0.1.0
-    def put(path, options = {}, &blk)
-      @router.put(path, options, &blk)
+    def put(path, to: nil, as: nil, namespace: nil, configuration: nil, **constraints, &blk)
+      add_route(PUT, path, to, as, namespace, configuration, constraints, &blk)
     end
 
     # Defines a route that accepts a PATCH request for the given path.
@@ -466,8 +469,8 @@ module Hanami
     # @see Hanami::Router#get
     #
     # @since 0.1.0
-    def patch(path, options = {}, &blk)
-      @router.patch(path, options, &blk)
+    def patch(path, to: nil, as: nil, namespace: nil, configuration: nil, **constraints, &blk)
+      add_route(PATCH, path, to, as, namespace, configuration, constraints, &blk)
     end
 
     # Defines a route that accepts a DELETE request for the given path.
@@ -485,8 +488,8 @@ module Hanami
     # @see Hanami::Router#get
     #
     # @since 0.1.0
-    def delete(path, options = {}, &blk)
-      @router.delete(path, options, &blk)
+    def delete(path, to: nil, as: nil, namespace: nil, configuration: nil, **constraints, &blk)
+      add_route(DELETE, path, to, as, namespace, configuration, constraints, &blk)
     end
 
     # Defines a route that accepts a TRACE request for the given path.
@@ -504,8 +507,8 @@ module Hanami
     # @see Hanami::Router#get
     #
     # @since 0.1.0
-    def trace(path, options = {}, &blk)
-      @router.trace(path, options, &blk)
+    def trace(path, to: nil, as: nil, namespace: nil, configuration: nil, **constraints, &blk)
+      add_route(TRACE, path, to, as, namespace, configuration, constraints, &blk)
     end
 
     # Defines a route that accepts a LINK request for the given path.
@@ -523,8 +526,8 @@ module Hanami
     # @see Hanami::Router#get
     #
     # @since 0.8.0
-    def link(path, options = {}, &blk)
-      @router.link(path, options, &blk)
+    def link(path, to: nil, as: nil, namespace: nil, configuration: nil, **constraints, &blk)
+      add_route(LINK, path, to, as, namespace, configuration, constraints, &blk)
     end
 
     # Defines a route that accepts an UNLINK request for the given path.
@@ -542,8 +545,27 @@ module Hanami
     # @see Hanami::Router#get
     #
     # @since 0.8.0
-    def unlink(path, options = {}, &blk)
-      @router.unlink(path, options, &blk)
+    def unlink(path, to: nil, as: nil, namespace: nil, configuration: nil, **constraints, &blk)
+      add_route(UNLINK, path, to, as, namespace, configuration, constraints, &blk)
+    end
+
+    # Defines a route that accepts a OPTIONS 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
+    #
+    # @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, to: nil, as: nil, namespace: nil, configuration: nil, **constraints, &blk)
+      add_route(OPTIONS, path, to, as, namespace, configuration, constraints, &blk)
     end
 
     # Defines a root route (a GET route for '/')
@@ -572,27 +594,8 @@ module Hanami
     #
     #   router.path(:root) # => "/"
     #   router.url(:root)  # => "https://hanamirb.org/"
-    def root(options = {}, &blk)
-      @router.get(ROOT_PATH, options.merge(as: :root), &blk)
-    end
-
-    # Defines a route that accepts a OPTIONS 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
-    #
-    # @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)
+    def root(to: nil, as: :root, prefix: Utils::PathPrefix.new, namespace: nil, configuration: nil, &blk)
+      add_route(GET, prefix.join(ROOT_PATH), to, as, namespace, configuration, &blk)
     end
 
     # Defines an HTTP redirect
@@ -621,57 +624,75 @@ module Hanami
     #
     #   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
+    def redirect(path, to:, code: 301)
+      to = Routing::Redirect.new(@prefix.join(to).to_s, code)
+      add_route(GET, path, to)
     end
 
-    # Defines a Ruby block: all the routes defined within it will be namespaced
+    # Defines a Ruby block: all the routes defined within it will be prefixed
     # with the given relative path.
     #
-    # Namespaces blocks can be nested multiple times.
+    # Prefix blocks can be nested multiple times.
     #
-    # @param namespace [String] the relative path where the nested routes will
+    # @param path [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.
+    # @return [void]
     #
-    # @since 0.1.0
+    # @since 2.0.0
     #
     # @see Hanami::Router
     #
     # @example Basic example
-    #   require 'hanami/router'
+    #   require "hanami/router"
     #
     #   Hanami::Router.new do
-    #     namespace 'trees' do
-    #       get '/sequoia', to: endpoint # => '/trees/sequoia'
+    #     prefix "trees" do
+    #       get "/sequoia", to: endpoint # => "/trees/sequoia"
     #     end
     #   end
     #
-    # @example Nested namespaces
-    #   require 'hanami/router'
+    # @example Nested prefix
+    #   require "hanami/router"
     #
     #   Hanami::Router.new do
-    #     namespace 'animals' do
-    #       namespace 'mammals' do
-    #         get '/cats', to: endpoint # => '/animals/mammals/cats'
+    #     prefix "animals" do
+    #       prefix "mammals" do
+    #         get "/cats", to: endpoint # => "/animals/mammals/cats"
     #       end
     #     end
     #   end
+    def prefix(path, namespace: nil, configuration: nil, &blk)
+      Routing::Prefix.new(self, path, namespace, configuration, &blk)
+    end
+
+    # Defines a scope for routes.
+    #
+    # A scope is a combination of a path prefix and a Ruby namespace.
+    #
+    # @param prefix [String] the path prefix
+    # @param namespace [Module] the Ruby namespace where to lookup endpoints
+    # @param configuration [Hanami::Controller::Configuration] the action
+    #   configuration
+    # @param blk [Proc] the routes definition block
+    #
+    # @since 2.0.0
+    # @api private
     #
     # @example
-    #   require 'hanami/router'
+    #   require "hanami/router"
+    #   require "hanami/controller"
     #
-    #   router = Hanami::Router.new
-    #   router.namespace 'trees' do
-    #     get '/sequoia', to: endpoint # => '/trees/sequoia'
+    #   configuration = Hanami::Controller::Configuration.new
+    #
+    #   Hanami::Router.new do
+    #     scope "/admin", namespace: Admin::Controllers, configuration: configuration do
+    #       root to: "home#index"
+    #     end
     #   end
-    def namespace(namespace, &blk)
-      Routing::Namespace.new(self, namespace, &blk)
+    def scope(prefix, namespace:, configuration:, &blk)
+      Routing::Scope.new(self, prefix, namespace, configuration, &blk)
     end
 
     # Defines a set of named routes for a single RESTful resource.
@@ -793,7 +814,7 @@ module Hanami
     #   # | GET  | /identity/keys | Identity::Keys |      | :keys_identity |
     #   # +------+----------------+----------------+------+----------------+
     def resource(name, options = {}, &blk)
-      Routing::Resource.new(self, name, options.merge(separator: @router.action_separator), &blk)
+      Routing::Resource.new(self, name, options.merge(separator: Routing::Endpoint::ACTION_SEPARATOR), &blk)
     end
 
     # Defines a set of named routes for a plural RESTful resource.
@@ -916,7 +937,7 @@ module Hanami
     #   # | GET  | /articles/search | Articles::Search |      | :search_articles |
     #   # +------+------------------+------------------+------+------------------+
     def resources(name, options = {}, &blk)
-      Routing::Resources.new(self, name, options.merge(separator: @router.action_separator), &blk)
+      Routing::Resources.new(self, name, options.merge(separator: Routing::Endpoint::ACTION_SEPARATOR), &blk)
     end
 
     # Mount a Rack application at the specified path.
@@ -1004,8 +1025,9 @@ module Hanami
     #   # 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)
+    def mount(app, at:, host: nil)
+      app = App.new(@prefix.join(at).to_s, Routing::Endpoint.find(app, @namespace), host: host)
+      @routes.push(app)
     end
 
     # Resolve the given Rack env to a registered endpoint and invoke it.
@@ -1016,7 +1038,15 @@ module Hanami
     #
     # @since 0.1.0
     def call(env)
-      @router.call(env)
+      (@routes.find { |r| r.match?(env) } || fallback(env)).call(env)
+    end
+
+    def fallback(env)
+      if @routes.find { |r| r.match_path?(env) }
+        @not_allowed
+      else
+        @not_found
+      end
     end
 
     # Recognize the given env, path, or name and return a route for testing
@@ -1128,14 +1158,11 @@ module Hanami
     #   route.routable? # => false
     #   route.params    # => {:id=>"1"}
     def recognize(env, options = {}, params = nil)
-      require 'hanami/routing/recognized_route'
-
-      env          = env_for(env, options, params)
-      responses, _ = *@router.recognize(env)
+      env   = env_for(env, options, params)
+      # FIXME: this finder is shared with #call and should be extracted
+      route = @routes.find { |r| r.match?(env) }
 
-      Routing::RecognizedRoute.new(
-        responses.nil? ? responses : responses.first,
-        env, @router)
+      Routing::RecognizedRoute.new(route, env, @namespace)
     end
 
     # Generate an relative URL for a specified named route.
@@ -1161,8 +1188,10 @@ module Hanami
     #   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)
+    def path(route, args = {})
+      @named.fetch(route).path(args)
+    rescue KeyError
+      raise Hanami::Routing::InvalidRouteException.new("No route could be generated for #{route.inspect} - please check given arguments")
     end
 
     # Generate a URL for a specified named route.
@@ -1188,8 +1217,8 @@ module Hanami
     #   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)
+    def url(route, args = {})
+      @base + path(route, args)
     end
 
     # Returns an routes inspector
@@ -1214,8 +1243,8 @@ module Hanami
     #                 POST       /login                   Sessions::Create
     #          logout GET, HEAD  /logout                  Sessions::Destroy
     def inspector
-      require 'hanami/routing/routes_inspector'
-      Routing::RoutesInspector.new(@router.routes, @router.prefix)
+      require "hanami/routing/routes_inspector"
+      Routing::RoutesInspector.new(@routes, @prefix)
     end
 
     protected
@@ -1233,8 +1262,8 @@ 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
+    def env_for(env, options = {}, params = nil) # rubocop:disable Metrics/MethodLength
+      case env
       when String
         Rack::MockRequest.env_for(env, options)
       when Symbol
@@ -1248,5 +1277,89 @@ module Hanami
         env
       end
     end
+
+    private
+
+    PATH_INFO      = "PATH_INFO"
+    SCRIPT_NAME    = "SCRIPT_NAME"
+    SERVER_NAME    = "SERVER_NAME"
+    REQUEST_METHOD = "REQUEST_METHOD"
+
+    PARAMS = "router.params"
+
+    GET     = "GET"
+    HEAD    = "HEAD"
+    POST    = "POST"
+    PUT     = "PUT"
+    PATCH   = "PATCH"
+    DELETE  = "DELETE"
+    TRACE   = "TRACE"
+    OPTIONS = "OPTIONS"
+    LINK    = "LINK"
+    UNLINK  = "UNLINK"
+
+    NOT_FOUND   = ->(_) { [404, { "Content-Length" => "9" }, ["Not Found"]] }.freeze
+    NOT_ALLOWED = ->(_) { [405, { "Content-Length" => "18" }, ["Method Not Allowed"]] }.freeze
+    ROOT = "/"
+
+    BODY = 2
+
+    attr_reader :configuration
+
+    # Application
+    #
+    # @since 2.0.0
+    # @api private
+    class App
+      def initialize(path, endpoint, host: nil)
+        @path     = Mustermann.new(path, type: :rails, version: "5.0")
+        @prefix   = path.to_s
+        @endpoint = endpoint
+        @host     = host
+        freeze
+      end
+
+      def match?(env)
+        match_path?(env)
+      end
+
+      def match_path?(env)
+        result   = env[PATH_INFO].start_with?(@prefix)
+        result &&= @host == env[SERVER_NAME] unless @host.nil?
+
+        result
+      end
+
+      def call(env)
+        env[PARAMS] ||= {}
+        env[PARAMS].merge!(Utils::Hash.deep_symbolize(@path.params(env[PATH_INFO]) || {}))
+
+        env[SCRIPT_NAME] = @prefix
+        env[PATH_INFO]   = env[PATH_INFO].sub(@prefix, "")
+        env[PATH_INFO]   = "/" if env[PATH_INFO] == ""
+
+        @endpoint.call(env)
+      end
+    end
+
+    def add_route(verb, path, to, as = nil, namespace = nil, config = nil, constraints = {}, &blk)
+      to     ||= blk
+      config ||= configuration
+
+      path     = path.to_s
+      endpoint = Routing::Endpoint.find(to, namespace || @namespace, config)
+      route    = Routing::Route.new(verb_for(verb), @prefix.join(path).to_s, endpoint, constraints)
+
+      @routes.push(route)
+      @named[as] = route unless as.nil?
+    end
+
+    def verb_for(value)
+      if value == GET
+        [GET, HEAD]
+      else
+        [value]
+      end
+    end
   end
 end