hanami-router 1.3.2 → 2.0.0.alpha5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e266df3fe2a5a32cea6a813fb6806810e752a3b2c78e1699a7ff78b90d597ae0
-  data.tar.gz: 02617f20d71d090f2cecf7af765d3b03af487aa38d5da6c8c2f993773ce0174a
+  metadata.gz: d72d9efd8d4b3b0df52796170481b05878e531b2aee3ea09894e6eeccb5562e6
+  data.tar.gz: 2078b5956054db900fe4d2f097b62901499ceb1622a57baae326fa921ef62f48
 SHA512:
-  metadata.gz: 1ed45a0595d20e01dd302164d0e5f9855b57eff54e75febf6bf34a26d05f9c544af825f7407bfaec468d11a4bb024e29d9edcb193dfd2bef08ce3e8495ac23f1
-  data.tar.gz: 7ca9c8a1a8c14e2895196be0aaaa49e1e2f951a4fdea9bd64602237bf82c87607d525ce0660694c8ceea148ba35a87c227f1893307f8b42a876e87bda80579ab
+  metadata.gz: 5409a722ae69fc035fcbe54138ecfe504d97d9dcd62f0c3ce04a93f2fa5ca40aa833813b491a3a13d1db972e8e352e9d7e89948dfa3f522d99beafae4908e961
+  data.tar.gz: 55505b92589cb74795bd01a6062d32effce16a56d0405b98e726d0ba9d3b54ca301fb464cf0826fdac7e45f1de23a15913a211359c2f908117b1e972684b90d7

data/CHANGELOG.md

@@ -1,6 +1,49 @@
 # Hanami::Router
 Rack compatible HTTP router for Ruby
 
+## v2.0.0.alpha5 - 2021-05-04
+### Added
+- [Luca Guidi] Introduced `Hanami::Router#to_inspect` which returns a string blob with all the routes formatted for human readability
+
+## v2.0.0.alpha4 - 2021-01-16
+### Added
+- [Luca Guidi] Official support for MRI 3.0
+- [Luca Guidi] Introduced `Hanami::Middleware::BodyParser::Parser` as superclass for body parsers
+- [Paweł Świątkowski] Added `not_found:` option to `Hanami::Router#initialize` to customize HTTP 404 status
+
+## v2.0.0.alpha3 - 2020-05-20
+### Fixed
+- [Luca Guidi] `Hanami::Router#initialize` do not yield block if not given
+- [Luca Guidi] Ensure to not accidentally cache response headers for HTTP 404 and 405
+- [Luca Guidi] Ensure scoped root to not be added as trailing slash
+
+## v2.0.0.alpha2 - 2020-02-19
+### Added
+- [Luca Guidi] Block syntax. Routes definition accept a block which returning value is the body of the Rack response.
+- [Luca Guidi] Added `resolver:` option to `Hanami::Router#initialize` to provide your own strategy to load endpoints.
+
+### Changed
+- [Luca Guidi] Removed `Hanami::Router#resource` and `#resources`.
+- [Luca Guidi] Removed loading of routes endpoints.
+- [Luca Guidi] Removed `inflector:` from `Hanami::Router#initialize`
+- [Luca Guidi] Removed `scheme:`, `host:`, `port:` from `Hanami::Router#initialize`, use `base_url:` instead.
+
+## v2.0.0.alpha1 - 2019-01-30
+### Added
+- [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.2 - 2019-02-13
 ### Added
 - [Luca Guidi] Official support for Ruby: MRI 2.7

data/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright © 2014-2017 Luca Guidi
+Copyright © 2014-2021 Luca Guidi
 
 MIT License
 

data/README.md

@@ -5,9 +5,8 @@ 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)
-[![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)
+[![CI](https://github.com/hanami/router/workflows/ci/badge.svg?branch=unstable)](https://github.com/hanami/router/actions?query=workflow%3Aci+branch%3Aunstable)
+[![Test Coverage](https://codecov.io/gh/hanami/router/branch/unstable/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)
 [![Inline Docs](http://inch-ci.org/github/hanami/router.svg)](http://inch-ci.org/github/hanami/router)
 
@@ -22,7 +21,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.6+
 
 
 ## Installation
@@ -30,7 +29,7 @@ __Hanami::Router__ supports Ruby (MRI) 2.3+, JRuby 9.1.5.0+
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'hanami-router'
+gem "hanami-router"
 ```
 
 And then execute:
@@ -47,14 +46,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,144 +76,114 @@ 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'
-
-  redirect '/legacy', to: '/'
-
-  mount Api::App, at: '/api'
-
-  namespace 'admin' do
-    get '/users', to: Users::Index
-  end
-
-  resource 'identity' do
-    member do
-      get '/avatar'
-    end
+  root                to: ->(env) { [200, {}, ["Hello"]] }
+  get "/lambda",      to: ->(env) { [200, {}, ["World"]] }
+  get "/dashboard",   to: Dashboard::Index
+  get "/rack-app",    to: RackApp.new
 
-    collection do
-      get '/api_keys'
-    end
-  end
+  redirect "/legacy", to: "/"
 
-  resources 'robots' do
-    member do
-      patch '/activate'
-    end
+  mount Api::App, at: "/api"
 
-    collection do
-      get '/search'
-    end
+  scope "admin" do
+    get "/users", to: Users::Index
   end
 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
 ```
 
-
-
 ### 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
 ```
 
-
-
 ### 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
 ```
 
-
-
 ### 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
 ```
 
-
-
 ### 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
 ```
 
-
-
 ### Support for the most common HTTP methods:
 
 ```ruby
-router   = Hanami::Router.new
-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
-```
-
+endpoint = ->(env) { [200, {}, ["Hello from Hanami!"]] }
 
+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
+```
 
 ### 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
 ```
 
-
-
 ### 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
 ```
 
-
-
 ### 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"
 ```
 
 
-
-### Namespaced routes:
+### Scopes:
 
 ```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
+  scope "animals" do
+    scope "mammals" do
+      get "/cats", to: ->(env) { [200, {}, ["Meow!"]] }, as: :cats
+    end
   end
 end
 
@@ -218,364 +196,39 @@ router.path(:animals_mammals_cats) # => "/animals/mammals/cats"
 
 ### Mount Rack applications:
 
+Mounting a Rack application will forward all kind of HTTP requests to the app,
+when the request path matches the `at:` path.
+
 ```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 MyRackApp.new, at: "/foo"
 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](https://github.com/hanami/controller) integration)
-
-
-
 ### Duck typed endpoints:
 
 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)
-```
-
-
-If it's a string, it tries to instantiate a class from it:
-
-```ruby
-class RackApp
-  def call(env)
-    # ...
-  end
-end
-
-router = Hanami::Router.new
-router.get '/hanami', to: 'rack_app' # it will map to RackApp.new
-```
-
-It also supports Controller + Action syntax:
-
-```ruby
-module Flowers
-  class Index
-    def call(env)
-      # ...
-    end
-  end
-end
-
-router = Hanami::Router.new
-router.get '/flowers', to: 'flowers#index' # it will map to Flowers::Index.new
-```
-
-
-
-### Implicit Not Found (404):
-
-```ruby
-router = Hanami::Router.new
-router.call(Rack::MockRequest.env_for('/unknown')).status # => 404
-```
-
-### Controllers:
-
-`Hanami::Router` has a special convention for controllers naming.
-It allows to declare an action as an endpoint, with a special syntax: `<controller>#<action>`.
-
 ```ruby
 Hanami::Router.new do
-  get '/', to: 'welcome#index'
-end
-```
-
-In the example above, the router will look for the `Welcome::Index` action.
-
-#### Namespaces
-
-In applications where for maintainability or technical reasons, this convention
-can't work, `Hanami::Router` can accept a `:namespace` option, which defines the
-Ruby namespace where to look for actions.
-
-For instance, given a Hanami full stack application called `Bookshelf`, the
-controllers are available under `Bookshelf::Controllers`.
-
-```ruby
-Hanami::Router.new(namespace: Bookshelf::Controllers) do
-  get '/', to: 'welcome#index'
-end
-```
-
-In the example above, the router will look for the `Bookshelf::Controllers::Welcome::Index` action.
-
-### RESTful Resource:
-
-```ruby
-router = Hanami::Router.new
-router.resource 'identity'
-```
-
-It will map:
-
-<table>
-  <tr>
-    <th>Verb</th>
-    <th>Path</th>
-    <th>Action</th>
-    <th>Name</th>
-    <th>Named Route</th>
-  </tr>
-  <tr>
-    <td>GET</td>
-    <td>/identity</td>
-    <td>Identity::Show</td>
-    <td>:show</td>
-    <td>:identity</td>
-  </tr>
-  <tr>
-    <td>GET</td>
-    <td>/identity/new</td>
-    <td>Identity::New</td>
-    <td>:new</td>
-    <td>:new_identity</td>
-  </tr>
-  <tr>
-    <td>POST</td>
-    <td>/identity</td>
-    <td>Identity::Create</td>
-    <td>:create</td>
-    <td>:identity</td>
-  </tr>
-  <tr>
-    <td>GET</td>
-    <td>/identity/edit</td>
-    <td>Identity::Edit</td>
-    <td>:edit</td>
-    <td>:edit_identity</td>
-  </tr>
-  <tr>
-    <td>PATCH</td>
-    <td>/identity</td>
-    <td>Identity::Update</td>
-    <td>:update</td>
-    <td>:identity</td>
-  </tr>
-  <tr>
-    <td>DELETE</td>
-    <td>/identity</td>
-    <td>Identity::Destroy</td>
-    <td>:destroy</td>
-    <td>:identity</td>
-  </tr>
-</table>
-
-If you don't need all the default endpoints, just do:
-
-```ruby
-router = Hanami::Router.new
-router.resource 'identity', only: [:edit, :update]
-
-#### which is equivalent to:
-
-router.resource 'identity', except: [:show, :new, :create, :destroy]
-```
-
-
-If you need extra endpoints:
-
-```ruby
-router = Hanami::Router.new
-router.resource 'identity' do
-  member do
-    get 'avatar'           # maps to Identity::Avatar
-  end
-
-  collection do
-    get 'authorizations'   # maps to Identity::Authorizations
-  end
-end
-
-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.path(:profile) # => /profile # Will route to Identity::Show
-```
-
-#### Nested Resources
-
-We can nest resource(s):
-
-```ruby
-router = Hanami::Router.new
-router.resource :identity do
-  resource  :avatar
-  resources :api_keys
-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_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
-```
-
-
-
-### RESTful Resources:
-
-```ruby
-router = Hanami::Router.new
-router.resources 'flowers'
-```
-
-It will map:
-
-<table>
-  <tr>
-    <th>Verb</th>
-    <th>Path</th>
-    <th>Action</th>
-    <th>Name</th>
-    <th>Named Route</th>
-  </tr>
-  <tr>
-    <td>GET</td>
-    <td>/flowers</td>
-    <td>Flowers::Index</td>
-    <td>:index</td>
-    <td>:flowers</td>
-  </tr>
-  <tr>
-    <td>GET</td>
-    <td>/flowers/:id</td>
-    <td>Flowers::Show</td>
-    <td>:show</td>
-    <td>:flower</td>
-  </tr>
-  <tr>
-    <td>GET</td>
-    <td>/flowers/new</td>
-    <td>Flowers::New</td>
-    <td>:new</td>
-    <td>:new_flower</td>
-  </tr>
-  <tr>
-    <td>POST</td>
-    <td>/flowers</td>
-    <td>Flowers::Create</td>
-    <td>:create</td>
-    <td>:flowers</td>
-  </tr>
-  <tr>
-    <td>GET</td>
-    <td>/flowers/:id/edit</td>
-    <td>Flowers::Edit</td>
-    <td>:edit</td>
-    <td>:edit_flower</td>
-  </tr>
-  <tr>
-    <td>PATCH</td>
-    <td>/flowers/:id</td>
-    <td>Flowers::Update</td>
-    <td>:update</td>
-    <td>:flower</td>
-  </tr>
-  <tr>
-    <td>DELETE</td>
-    <td>/flowers/:id</td>
-    <td>Flowers::Destroy</td>
-    <td>:destroy</td>
-    <td>:flower</td>
-  </tr>
-</table>
-
-
-```ruby
-router.path(:flowers)             # => /flowers
-router.path(:flower, id: 23)      # => /flowers/23
-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]
-
-#### which is equivalent to:
-
-router.resources 'flowers', except: [:index, :edit, :update, :destroy]
-```
-
-
-If you need extra endpoints:
-
-```ruby
-router = Hanami::Router.new
-router.resources 'flowers' do
-  member do
-    get 'toggle' # maps to Flowers::Toggle
-  end
-
-  collection do
-    get 'search' # maps to Flowers::Search
-  end
+  get "/hanami",     to: ->(env) { [200, {}, ["Hello from Hanami!"]] }
+  get "/rack-app",   to: RackApp.new
+  get "/method",     to: ActionControllerSubclass.action(:new)
 end
-
-router.path(:toggle_flower, id: 23)  # => /flowers/23/toggle
-router.path(:search_flowers)         # => /flowers/search
 ```
 
-
-Configure controller:
+### Implicit Not Found (404):
 
 ```ruby
 router = Hanami::Router.new
-router.resources 'blossoms', controller: 'flowers'
-
-router.path(:blossom, id: 23) # => /blossoms/23 # Will route to Flowers::Show
+router.call(Rack::MockRequest.env_for("/unknown")).status # => 404
 ```
 
-#### Nested Resources
-
-We can nest resource(s):
+### Explicit Not Found:
 
 ```ruby
-router = Hanami::Router.new
-router.resources :users do
-  resource  :avatar
-  resources :favorites
-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_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 = Hanami::Router.new(not_found: ->(_) { [499, {}, []]})
+router.call(Rack::MockRequest.env_for("/unknown")).status # => 499
 ```
 
 ### Body Parsers
@@ -593,11 +246,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 +282,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 +302,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 +322,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 +342,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 +359,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-2021 Luca Guidi – Released under MIT License
 
 This project was formerly known as Lotus (`lotus-router`).