hanami-router 1.3.2 → 2.0.0.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e266df3fe2a5a32cea6a813fb6806810e752a3b2c78e1699a7ff78b90d597ae0
-  data.tar.gz: 02617f20d71d090f2cecf7af765d3b03af487aa38d5da6c8c2f993773ce0174a
+  metadata.gz: aa833cfc2bc3e9d0f796738dc3c8c649f001afdee01662094f387aabc3afa496
+  data.tar.gz: c7f7314b65e6ab36fee40e4a8d2037b4086c0f5a6ae9ddf5002e4d42007826b9
 SHA512:
-  metadata.gz: 1ed45a0595d20e01dd302164d0e5f9855b57eff54e75febf6bf34a26d05f9c544af825f7407bfaec468d11a4bb024e29d9edcb193dfd2bef08ce3e8495ac23f1
-  data.tar.gz: 7ca9c8a1a8c14e2895196be0aaaa49e1e2f951a4fdea9bd64602237bf82c87607d525ce0660694c8ceea148ba35a87c227f1893307f8b42a876e87bda80579ab
+  metadata.gz: fd5ca50885e99302376c13c8d0ccdc48db6e59b97d64ca8c3740f976ecfdf0687c6c2f841273286b92af16d880051216e8888353ef24e92285f918c31d67a65f
+  data.tar.gz: b9107bc2be7289893809d2837c37fb5cc6642715239b6c510b76af47a86c71daa186f167f8890a2f7b59292be1eeadaf0aca90bb358e2951563b0414c17245c7

data/CHANGELOG.md

@@ -1,10 +1,21 @@
 # Hanami::Router
 Rack compatible HTTP router for Ruby
 
-## v1.3.2 - 2019-02-13
+## v2.0.0.alpha1 - 2019-01-30
 ### Added
-- [Luca Guidi] Official support for Ruby: MRI 2.7
-- [Luca Guidi] Support `rack` 2.1
+- [Luca Guidi] Introduce `Hanami::Router#scope` to support single routing tier for Hanami
+- [Semyon Pupkov] Added `inflector:` option for `Hanami::Router#initialize` based on `dry-inflector`
+
+### Changed
+- [Luca Guidi] Drop support for Ruby: MRI 2.3, and 2.4.
+- [Luca Guidi] Renamed `Hanami::Router#namespace` => `#prefix`
+- [Gustavo Caso] Remove body cleanup for `HEAD` requests
+- [Semyon Pupkov] Remove the ability to force SSL (`force_ssl:` option for `Hanami::Router#initialize`)
+- [Gustavo Caso] Remove router body parsers (`parsers:` option for `Hanami::Router#initialize`)
+- [Luca Guidi] Globbed path requires named capture (was `get "/files/*"`, now is `get "/files/*names"`)
+- [Luca Guidi] Router is frozen after initialization
+- [Luca Guidi] All the code base respects the frozen string pragma
+- [Luca Guidi] `Hanami::Router#initialize` requires `configuration:` option if routes endpoints are `Hanami::Action` subclasses
 
 ## v1.3.1 - 2019-01-18
 ### Added

data/README.md

@@ -5,7 +5,7 @@ Rack compatible, lightweight and fast HTTP Router for Ruby and [Hanami](http://h
 ## Status
 
 [![Gem Version](https://badge.fury.io/rb/hanami-router.svg)](https://badge.fury.io/rb/hanami-router)
-[![Build Status](https://ci.hanamirb.org/api/badges/hanami/router/status.svg)](https://ci.hanamirb.org/hanami/router)
+[![TravisCI](https://travis-ci.org/hanami/router.svg?branch=master)](https://travis-ci.org/hanami/router)
 [![CircleCI](https://circleci.com/gh/hanami/router/tree/master.svg?style=svg)](https://circleci.com/gh/hanami/router/tree/master)
 [![Test Coverage](https://codecov.io/gh/hanami/router/branch/master/graph/badge.svg)](https://codecov.io/gh/hanami/router)
 [![Depfu](https://badges.depfu.com/badges/5f6b8e8fa3b0d082539f0b0f84d55960/overview.svg)](https://depfu.com/github/hanami/router?project=Bundler)
@@ -22,7 +22,7 @@ Rack compatible, lightweight and fast HTTP Router for Ruby and [Hanami](http://h
 
 ## Rubies
 
-__Hanami::Router__ supports Ruby (MRI) 2.3+, JRuby 9.1.5.0+
+__Hanami::Router__ supports Ruby (MRI) 2.5+
 
 
 ## Installation
@@ -47,14 +47,23 @@ $ gem install hanami-router
 
 ## Getting Started
 
+Create a file named `config.ru`
+
 ```ruby
-require 'hanami/router'
+# frozen_string_literal: true
+require "hanami/router"
 
 app = Hanami::Router.new do
-  get '/', to: ->(env) { [200, {}, ['Welcome to Hanami::Router!']] }
+  get "/", to: ->(env) { [200, {}, ["Welcome to Hanami!"]] }
 end
 
-Rack::Server.start app: app, Port: 2300
+run app
+```
+
+From the shell:
+
+```shell
+$ bundle exec rackup
 ```
 
 ## Usage
@@ -68,38 +77,38 @@ For the standalone usage, it supports neat features:
 
 ```ruby
 Hanami::Router.new do
-  root                to: ->(env) { [200, {}, ['Hello']] }
-  get '/lambda',      to: ->(env) { [200, {}, ['World']] }
-  get '/dashboard',   to: Dashboard::Index
-  get '/rack-app',    to: RackApp.new
-  get '/flowers',     to: 'flowers#index'
-  get '/flowers/:id', to: 'flowers#show'
+  root                to: ->(env) { [200, {}, ["Hello"]] }
+  get "/lambda",      to: ->(env) { [200, {}, ["World"]] }
+  get "/dashboard",   to: Dashboard::Index
+  get "/rack-app",    to: RackApp.new
+  get "/flowers",     to: "flowers#index"
+  get "/flowers/:id", to: "flowers#show"
 
-  redirect '/legacy', to: '/'
+  redirect "/legacy", to: "/"
 
-  mount Api::App, at: '/api'
+  mount Api::App, at: "/api"
 
-  namespace 'admin' do
-    get '/users', to: Users::Index
+  prefix "admin" do
+    get "/users", to: Users::Index
   end
 
-  resource 'identity' do
+  resource "identity" do
     member do
-      get '/avatar'
+      get "/avatar"
     end
 
     collection do
-      get '/api_keys'
+      get "/api_keys"
     end
   end
 
-  resources 'robots' do
+  resources "robots" do
     member do
-      patch '/activate'
+      patch "/activate"
     end
 
     collection do
-      get '/search'
+      get "/search"
     end
   end
 end
@@ -110,8 +119,9 @@ end
 ### Fixed string matching:
 
 ```ruby
-router = Hanami::Router.new
-router.get '/hanami', to: ->(env) { [200, {}, ['Hello from Hanami!']] }
+Hanami::Router.new do
+  get "/hanami", to: ->(env) { [200, {}, ["Hello from Hanami!"]] }
+end
 ```
 
 
@@ -119,8 +129,9 @@ router.get '/hanami', to: ->(env) { [200, {}, ['Hello from Hanami!']] }
 ### String matching with variables:
 
 ```ruby
-router = Hanami::Router.new
-router.get '/flowers/:id', to: ->(env) { [200, {}, ["Hello from Flower no. #{ env['router.params'][:id] }!"]] }
+Hanami::Router.new do
+  get "/flowers/:id", to: ->(env) { [200, {}, ["Hello from Flower no. #{ env["router.params"][:id] }!"]] }
+end
 ```
 
 
@@ -128,8 +139,9 @@ router.get '/flowers/:id', to: ->(env) { [200, {}, ["Hello from Flower no. #{ en
 ### Variables Constraints:
 
 ```ruby
-router = Hanami::Router.new
-router.get '/flowers/:id', id: /\d+/, to: ->(env) { [200, {}, [":id must be a number!"]] }
+Hanami::Router.new do
+  get "/flowers/:id", id: /\d+/, to: ->(env) { [200, {}, [":id must be a number!"]] }
+end
 ```
 
 
@@ -137,8 +149,9 @@ router.get '/flowers/:id', id: /\d+/, to: ->(env) { [200, {}, [":id must be a nu
 ### String matching with globbing:
 
 ```ruby
-router = Hanami::Router.new
-router.get '/*', to: ->(env) { [200, {}, ["This is catch all: #{ env['router.params'].inspect }!"]] }
+Hanami::Router.new do
+  get "/*match", to: ->(env) { [200, {}, ["This is catch all: #{ env["router.params"].inspect }!"]] }
+end
 ```
 
 
@@ -146,8 +159,9 @@ router.get '/*', to: ->(env) { [200, {}, ["This is catch all: #{ env['router.par
 ### String matching with optional tokens:
 
 ```ruby
-router = Hanami::Router.new
-router.get '/hanami(.:format)' to: ->(env) { [200, {}, ["You've requested #{ env['router.params'][:format] }!"]] }
+Hanami::Router.new do
+  get "/hanami(.:format)" to: ->(env) { [200, {}, ["You"ve requested #{ env["router.params"][:format] }!"]] }
+end
 ```
 
 
@@ -155,15 +169,17 @@ router.get '/hanami(.:format)' to: ->(env) { [200, {}, ["You've requested #{ env
 ### Support for the most common HTTP methods:
 
 ```ruby
-router   = Hanami::Router.new
-endpoint = ->(env) { [200, {}, ['Hello from Hanami!']] }
+endpoint = ->(env) { [200, {}, ["Hello from Hanami!"]] }
 
-router.get    '/hanami', to: endpoint
-router.post   '/hanami', to: endpoint
-router.put    '/hanami', to: endpoint
-router.patch  '/hanami', to: endpoint
-router.delete '/hanami', to: endpoint
-router.trace  '/hanami', to: endpoint
+Hanami::Router.new do
+  get     "/hanami", to: endpoint
+  post    "/hanami", to: endpoint
+  put     "/hanami", to: endpoint
+  patch   "/hanami", to: endpoint
+  delete  "/hanami", to: endpoint
+  trace   "/hanami", to: endpoint
+  options "/hanami", to: endpoint
+end
 ```
 
 
@@ -171,8 +187,9 @@ router.trace  '/hanami', to: endpoint
 ### Root:
 
 ```ruby
-router = Hanami::Router.new
-router.root to: ->(env) { [200, {}, ['Hello from Hanami!']] }
+Hanami::Router.new do
+  root to: ->(env) { [200, {}, ["Hello from Hanami!"]] }
+end
 ```
 
 
@@ -180,9 +197,10 @@ router.root to: ->(env) { [200, {}, ['Hello from Hanami!']] }
 ### Redirect:
 
 ```ruby
-router = Hanami::Router.new
-router.get '/redirect_destination', to: ->(env) { [200, {}, ['Redirect destination!']] }
-router.redirect '/legacy', to: '/redirect_destination'
+Hanami::Router.new do
+  get "/redirect_destination", to: ->(env) { [200, {}, ["Redirect destination!"]] }
+  redirect "/legacy",          to: "/redirect_destination"
+end
 ```
 
 
@@ -190,8 +208,9 @@ router.redirect '/legacy', to: '/redirect_destination'
 ### Named routes:
 
 ```ruby
-router = Hanami::Router.new(scheme: 'https', host: 'hanamirb.org')
-router.get '/hanami', to: ->(env) { [200, {}, ['Hello from Hanami!']] }, as: :hanami
+router = Hanami::Router.new(scheme: "https", host: "hanamirb.org") do
+  get "/hanami", to: ->(env) { [200, {}, ["Hello from Hanami!"]] }, as: :hanami
+end
 
 router.path(:hanami) # => "/hanami"
 router.url(:hanami)  # => "https://hanamirb.org/hanami"
@@ -199,13 +218,14 @@ router.url(:hanami)  # => "https://hanamirb.org/hanami"
 
 
 
-### Namespaced routes:
+### Prefixed routes:
 
 ```ruby
-router = Hanami::Router.new
-router.namespace 'animals' do
-  namespace 'mammals' do
-    get '/cats', to: ->(env) { [200, {}, ['Meow!']] }, as: :cats
+router = Hanami::Router.new do
+  prefix "animals" do
+    prefix "mammals" do
+      get "/cats", to: ->(env) { [200, {}, ["Meow!"]] }, as: :cats
+    end
   end
 end
 
@@ -220,11 +240,11 @@ router.path(:animals_mammals_cats) # => "/animals/mammals/cats"
 
 ```ruby
 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'
+  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"
 end
 ```
 
@@ -241,11 +261,12 @@ end
 Everything that responds to `#call` is invoked as it is:
 
 ```ruby
-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)
+Hanami::Router.new do
+  get "/hanami",     to: ->(env) { [200, {}, ["Hello from Hanami!"]] }
+  get "/middleware", to: Middleware
+  get "/rack-app",   to: RackApp.new
+  get "/method",     to: ActionControllerSubclass.action(:new)
+end
 ```
 
 
@@ -258,23 +279,25 @@ class RackApp
   end
 end
 
-router = Hanami::Router.new
-router.get '/hanami', to: 'rack_app' # it will map to RackApp.new
+Hanami::Router.new do
+  get "/hanami", to: "rack_app" # it will map to RackApp.new
+end
 ```
 
 It also supports Controller + Action syntax:
 
 ```ruby
 module Flowers
-  class Index
-    def call(env)
+  class Index < Hanami::Action
+    def handle(*)
       # ...
     end
   end
 end
 
-router = Hanami::Router.new
-router.get '/flowers', to: 'flowers#index' # it will map to Flowers::Index.new
+Hanami::Router.new do
+  get "/flowers", to: "flowers#index" # it will map to Flowers::Index.new
+end
 ```
 
 
@@ -283,7 +306,7 @@ router.get '/flowers', to: 'flowers#index' # it will map to Flowers::Index.new
 
 ```ruby
 router = Hanami::Router.new
-router.call(Rack::MockRequest.env_for('/unknown')).status # => 404
+router.call(Rack::MockRequest.env_for("/unknown")).status # => 404
 ```
 
 ### Controllers:
@@ -293,7 +316,7 @@ It allows to declare an action as an endpoint, with a special syntax: `<controll
 
 ```ruby
 Hanami::Router.new do
-  get '/', to: 'welcome#index'
+  get "/", to: "welcome#index"
 end
 ```
 
@@ -310,7 +333,7 @@ controllers are available under `Bookshelf::Controllers`.
 
 ```ruby
 Hanami::Router.new(namespace: Bookshelf::Controllers) do
-  get '/', to: 'welcome#index'
+  get "/", to: "welcome#index"
 end
 ```
 
@@ -319,8 +342,9 @@ In the example above, the router will look for the `Bookshelf::Controllers::Welc
 ### RESTful Resource:
 
 ```ruby
-router = Hanami::Router.new
-router.resource 'identity'
+Hanami::Router.new do
+  resource "identity"
+end
 ```
 
 It will map:
@@ -380,41 +404,46 @@ It will map:
 If you don't need all the default endpoints, just do:
 
 ```ruby
-router = Hanami::Router.new
-router.resource 'identity', only: [:edit, :update]
+Hanami::Router.new do
+  resource "identity", only: [:edit, :update]
+end
 
 #### which is equivalent to:
 
-router.resource 'identity', except: [:show, :new, :create, :destroy]
+Hanami::Router.new do
+  resource "identity", except: [:show, :new, :create, :destroy]
+end
 ```
 
 
 If you need extra endpoints:
 
 ```ruby
-router = Hanami::Router.new
-router.resource 'identity' do
-  member do
-    get 'avatar'           # maps to Identity::Avatar
-  end
+router = Hanami::Router.new do
+           resource "identity" do
+             member do
+               get "avatar"           # maps to Identity::Avatar
+             end
 
-  collection do
-    get 'authorizations'   # maps to Identity::Authorizations
-  end
-end
+             collection do
+               get "authorizations"   # maps to Identity::Authorizations
+             end
+           end
+         end
 
-router.path(:avatar_identity)         # => /identity/avatar
-router.path(:authorizations_identity) # => /identity/authorizations
+router.path(:avatar_identity)         # => "/identity/avatar"
+router.path(:authorizations_identity) # => "/identity/authorizations"
 ```
 
 
 Configure controller:
 
 ```ruby
-router = Hanami::Router.new
-router.resource 'profile', controller: 'identity'
+router = Hanami::Router.new do
+  resource "profile", controller: "identity"
+end
 
-router.path(:profile) # => /profile # Will route to Identity::Show
+router.path(:profile) # => "/profile" # Will route to Identity::Show
 ```
 
 #### Nested Resources
@@ -422,20 +451,21 @@ router.path(:profile) # => /profile # Will route to Identity::Show
 We can nest resource(s):
 
 ```ruby
-router = Hanami::Router.new
-router.resource :identity do
-  resource  :avatar
-  resources :api_keys
-end
+router = Hanami::Router.new do
+           resource :identity do
+             resource  :avatar
+             resources :api_keys
+           end
+         end
 
-router.path(:identity_avatar)       # => /identity/avatar
-router.path(:new_identity_avatar)   # => /identity/avatar/new
-router.path(:edit_identity_avatar)  # => /identity/avatar/new
+router.path(:identity_avatar)       # => "/identity/avatar"
+router.path(:new_identity_avatar)   # => "/identity/avatar/new"
+router.path(:edit_identity_avatar)  # => "/identity/avatar/new"
 
-router.path(:identity_api_keys)            # => /identity/api_keys
-router.path(:identity_api_key, id: 1)      # => /identity/api_keys/:id
-router.path(:new_identity_api_key)         # => /identity/api_keys/new
-router.path(:edit_identity_api_key, id: 1) # => /identity/api_keys/:id/edit
+router.path(:identity_api_keys)            # => "/identity/api_keys"
+router.path(:identity_api_key, id: 1)      # => "/identity/api_keys/:id"
+router.path(:new_identity_api_key)         # => "/identity/api_keys/new"
+router.path(:edit_identity_api_key, id: 1) # => "/identity/api_keys/:id/edit"
 ```
 
 
@@ -443,8 +473,9 @@ router.path(:edit_identity_api_key, id: 1) # => /identity/api_keys/:id/edit
 ### RESTful Resources:
 
 ```ruby
-router = Hanami::Router.new
-router.resources 'flowers'
+Hanami::Router.new do
+  resources "flowers"
+end
 ```
 
 It will map:
@@ -510,9 +541,9 @@ It will map:
 
 
 ```ruby
-router.path(:flowers)             # => /flowers
-router.path(:flower, id: 23)      # => /flowers/23
-router.path(:edit_flower, id: 23) # => /flowers/23/edit
+router.path(:flowers)             # => "/flowers"
+router.path(:flower, id: 23)      # => "/flowers/23"
+router.path(:edit_flower, id: 23) # => "/flowers/23/edit"
 ```
 
 
@@ -520,41 +551,46 @@ router.path(:edit_flower, id: 23) # => /flowers/23/edit
 If you don't need all the default endpoints, just do:
 
 ```ruby
-router = Hanami::Router.new
-router.resources 'flowers', only: [:new, :create, :show]
+Hanami::Router.new do
+  resources "flowers", only: [:new, :create, :show]
+end
 
 #### which is equivalent to:
 
-router.resources 'flowers', except: [:index, :edit, :update, :destroy]
+Hanami::Router.new do
+  resources "flowers", except: [:index, :edit, :update, :destroy]
+end
 ```
 
 
 If you need extra endpoints:
 
 ```ruby
-router = Hanami::Router.new
-router.resources 'flowers' do
-  member do
-    get 'toggle' # maps to Flowers::Toggle
-  end
+router = Hanami::Router.new do
+           resources "flowers" do
+             member do
+               get "toggle" # maps to Flowers::Toggle
+             end
 
-  collection do
-    get 'search' # maps to Flowers::Search
-  end
-end
+             collection do
+               get "search" # maps to Flowers::Search
+             end
+           end
+         end
 
-router.path(:toggle_flower, id: 23)  # => /flowers/23/toggle
-router.path(:search_flowers)         # => /flowers/search
+router.path(:toggle_flower, id: 23) # => "/flowers/23/toggle"
+router.path(:search_flowers)        # => "/flowers/search"
 ```
 
 
 Configure controller:
 
 ```ruby
-router = Hanami::Router.new
-router.resources 'blossoms', controller: 'flowers'
+router = Hanami::Router.new do
+           resources "blossoms", controller: "flowers"
+         end
 
-router.path(:blossom, id: 23) # => /blossoms/23 # Will route to Flowers::Show
+router.path(:blossom, id: 23) # => "/blossoms/23" # Will route to Flowers::Show
 ```
 
 #### Nested Resources
@@ -562,20 +598,21 @@ router.path(:blossom, id: 23) # => /blossoms/23 # Will route to Flowers::Show
 We can nest resource(s):
 
 ```ruby
-router = Hanami::Router.new
-router.resources :users do
-  resource  :avatar
-  resources :favorites
-end
+router = Hanami::Router.new do
+           resources :users do
+             resource  :avatar
+             resources :favorites
+           end
+         end
 
-router.path(:user_avatar,      user_id: 1)  # => /users/1/avatar
-router.path(:new_user_avatar,  user_id: 1)  # => /users/1/avatar/new
-router.path(:edit_user_avatar, user_id: 1)  # => /users/1/avatar/edit
+router.path(:user_avatar,      user_id: 1)  # => "/users/1/avatar"
+router.path(:new_user_avatar,  user_id: 1)  # => "/users/1/avatar/new"
+router.path(:edit_user_avatar, user_id: 1)  # => "/users/1/avatar/edit"
 
-router.path(:user_favorites, user_id: 1)             # => /users/1/favorites
-router.path(:user_favorite, user_id: 1, id: 2)       # => /users/1/favorites/2
-router.path(:new_user_favorites, user_id: 1)         # => /users/1/favorites/new
-router.path(:edit_user_favorites, user_id: 1, id: 2) # => /users/1/favorites/2/edit
+router.path(:user_favorites, user_id: 1)             # => "/users/1/favorites"
+router.path(:user_favorite, user_id: 1, id: 2)       # => "/users/1/favorites/2"
+router.path(:new_user_favorites, user_id: 1)         # => "/users/1/favorites/new"
+router.path(:edit_user_favorites, user_id: 1, id: 2) # => "/users/1/favorites/2/edit"
 ```
 
 ### Body Parsers
@@ -593,11 +630,13 @@ It comes with a built-in JSON parser and allows to pass custom parsers.
 #### JSON Parsing
 
 ```ruby
-require 'hanami/router'
-require 'hanami/middleware/body_parser'
+# frozen_string_literal: true
+
+require "hanami/router"
+require "hanami/middleware/body_parser"
 
 app = Hanami::Router.new do
-  patch '/books/:id', to: ->(env) { [200, {},[env['router.params'].inspect]] }
+  patch "/books/:id", to: ->(env) { [200, {}, [env["router.params"].inspect]] }
 end
 
 use Hanami::Middleware::BodyParser, :json
@@ -627,13 +666,15 @@ If you want to use a different JSON backend, include `multi_json` in your `Gemfi
 #### Custom Parsers
 
 ```ruby
-require 'hanami/router'
-require 'hanami/middleware/body_parser'
+# frozen_string_literal: true
+
+require "hanami/router"
+require "hanami/middleware/body_parser"
 
-# See Hanami::Routing::Parsing::Parser
-class XmlParser < Hanami::Routing::Parsing::Parser
+# See Hanami::Middleware::BodyParser::Parser
+class XmlParser < Hanami::Middleware::BodyParser::Parser
   def mime_types
-    ['application/xml', 'text/xml']
+    ["application/xml", "text/xml"]
   end
 
   # Parse body and return a Hash
@@ -645,7 +686,7 @@ class XmlParser < Hanami::Routing::Parsing::Parser
 end
 
 app = Hanami::Router.new do
-  patch '/authors/:id', to: ->(env) { [200, {},[env['router.params'].inspect]] }
+  patch "/authors/:id", to: ->(env) { [200, {}, [env["router.params"].inspect]] }
 end
 
 use Hanami::Middleware::BodyParser, XmlParser
@@ -665,13 +706,15 @@ curl http://localhost:2300/authors/1 \
 ## Testing
 
 ```ruby
-require 'hanami/router'
+# frozen_string_literal: true
+
+require "hanami/router"
 
 router = Hanami::Router.new do
-  get '/books/:id', to: 'books#show', as: :book
+  get "/books/:id", to: "books#show", as: :book
 end
 
-route = router.recognize('/books/23')
+route = router.recognize("/books/23")
 route.verb      # "GET"
 route.action    # => "books#show"
 route.params    # => {:id=>"23"}
@@ -683,7 +726,7 @@ route.action    # => "books#show"
 route.params    # => {:id=>"23"}
 route.routable? # => true
 
-route = router.recognize('/books/23', method: :post)
+route = router.recognize("/books/23", method: :post)
 route.verb      # "POST"
 route.routable? # => false
 ```
@@ -700,13 +743,8 @@ __Hanami::Router__ uses [Semantic Versioning 2.0.0](http://semver.org)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
 
-## Acknowledgements
-
-Thanks to Joshua Hull ([@joshbuddy](https://github.com/joshbuddy)) for his
-[http_router](http://rubygems.org/gems/http_router).
-
 ## Copyright
 
-Copyright © 2014-2017 Luca Guidi – Released under MIT License
+Copyright © 2014-2019 Luca Guidi – Released under MIT License
 
 This project was formerly known as Lotus (`lotus-router`).