lotus-router 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ded3effb55d8697f3a45666539825d205771161
-  data.tar.gz: ac9b49d12b41b64e694998e4c663895f81279921
+  metadata.gz: df4ff4f67074d725ad10fc58dcdf1f647ad91255
+  data.tar.gz: 6d4fdaa8a6817a4acff0c9ccd0d2499205f4c0fb
 SHA512:
-  metadata.gz: 1542eba77ef0f590dd88f9abe472760f09e14375796867dd031bd360bf2e19b4056c8b89c03b32bb45542a23616f6c502df2382a8dc19441b16b5eb0dc657223
-  data.tar.gz: ea54e84f9c8507fd70d0c5c3e7f946930444d612dfc89012215d56a7ab55518658599dd0707dbb4da2358f1904d2717b27165f1ce9f77c9f40fdfc1626adb44e
+  metadata.gz: a9c7db01db9f64ff99083a34e610f56151264474b95619361bf143748d1298c84d97eef44212843c1de10c40e016d76d00f086fe17e3df1d2dcee8c62308a499
+  data.tar.gz: 73788060a4bc7b8062e4a0508bbe427bd32314cc4b5c003f04e8dc3674723ba2364aa00c3a70ec7a06428330b058e2e5ef60923c5c5cb49e74c0bc5f7808ae41

data/CHANGELOG.md

@@ -1,45 +1,52 @@
-## v0.1.1
-### Jun 23, 2014
+# Lotus::Router
+Rack compatible HTTP router for Ruby
 
-6f0ea8b 2014-06-12 **Luca Guidi** Introduced Lotus::Router#mount
-8457e1c 2014-06-08 **Luca Guidi** Use composition over inheritance for Lotus::Routing::Resource::Options
-9426099 2014-05-13 **Luca Guidi** Let specify a pattern for Lotus::Routing::EndpointResolver
-340ce17 2014-05-10 **Luca Guidi** Enable Ruby 2.1.2 on Travis CI
-42b83b8 2014-02-24 **Luca Guidi** Added support for Ruby 2.1.1
-6a5daf9 2014-02-15 **Luca Guidi** Make Lotus::Routing::Endpoint::EndpointNotFound to inherit from StandardError, instead of Exception. This make it compatible with Rack::ShowExceptions.
+## v0.2.0 - 2014-12-23
+### Added
+- [Luca Guidi & Alfonso Uceda Pompa] Introduced routes inspector for CLI
+- [Luca Guidi & Janko Marohnić] Introduced body parser for JSON
+- [Luca Guidi] Introduced request body parsers: they parse body and turn into params.
+- [Fred Wu] Introduced Router#define
 
-## v0.1.0
-### Jan 23, 2014
+### Fixed
+- [Luca Guidi] Fix for member/collection actions in RESTful resource(s): allow to take actions with a leading slash.
+- [Janko Marohnić] Fix for nested namespaces and RESTful resource(s) under namespace. They were generating wrong route names.
+- [Luca Guidi] Made InvalidRouteException to inherit from StandardError so it can be catched from anonymous `rescue` clause
+- [Luca Guidi] Fix RESTful resource(s) to respect :only/:except options
 
-594e332 2014-01-23 **Luca Guidi** Added support for OPTIONS HTTP verb
-10af04b 2014-01-17 **Luca Guidi** Added Lotus::Routing::EndpointNotFound when a lazy endpoint can't be found
-72165e5 2014-01-17 **Luca Guidi** Make action separator customizable via Lotus::Router options.
-ca7ea8d 2014-01-17 **Luca Guidi** Catch http_router exceptions and re-raise them with names under Lotus::Routing. This helps to have a stable public API.
-3d678e3 2014-01-16 **Luca Guidi** Lotus::Router now encapsulates Lotus::Routing::HttpRouter, instead of directly inherit from HttpRouter. This will protect our public API against HttpRouter changes.
-8e8f7f9 2014-01-16 **Luca Guidi** Lotus::Routing::Resource::CollectionAction use configurable controller and action name separator over the hardcoded value
-0bc8e54 2014-01-10 **Luca Guidi** Implemented Lotus::Routing::Namespace#resource
-e134e5c 2014-01-08 **Luca Guidi** Simplify Lotus::Router public API: removed .draw and let .new to accept a block
-815391a 2014-01-07 **Luca Guidi** When resetting the router, allow the default values for scheme, host and port to be reinitialized as http_router does
-bc763a8 2013-08-07 **Luca Guidi** Lotus::Routing::EndpointResolver now accepts options to inject namespace and suffix
-153047f 2013-08-07 **Luca Guidi** Allow resolver and route class to be injected via options. Added options argument to .draw
-cd1128f 2013-08-07 **Luca Guidi** Lotus::EndpointResolver => Lotus::Routing::EndpointResolver
-96a67c1 2013-07-09 **Luca Guidi** Return 404 for not found and 405 for unacceptable HTTP method
-7450883 2013-07-05 **Luca Guidi** Allow non-finished Rack responses to be used
-aa92524 2013-06-24 **Luca Guidi** Ensure .draw to always return a Lotus::Router instance
-30029af 2013-06-22 **Luca Guidi** Implemented lazy loading for endpoints
-962fbdf 2013-06-21 **Luca Guidi** Implemented Lotus::Router.draw
-982d95a 2013-06-20 **Luca Guidi** Gemified
-bac478a 2013-06-20 **Luca Guidi** Massive cleanup
-aaf46a1 2013-06-20 **Luca Guidi** Add support for resource
-41ee67d 2013-06-20 **Luca Guidi** Drastically reduced LOCs :heart_eyes:
-6b245bf 2013-06-19 **Luca Guidi** Support for resource's member and collection
-727e997 2013-06-19 **Luca Guidi** Add support for namespaces
-4950777 2013-06-18 **Luca Guidi** Added support for RESTful resources
-c494c85 2013-06-18 **Luca Guidi** Add support for POST, DELETE, PUT, PATCH, TRACE
-71fb4a1 2013-06-17 **Luca Guidi** Routes constraints
-86d696a 2013-06-17 **Luca Guidi** Named urls
-423cf2c 2013-06-17 **Luca Guidi** Ensure redirect works properly
-1ee662a 2013-06-17 **Luca Guidi** Run all the test suite
-e2382a0 2013-06-16 **Luca Guidi** Add support for Procs:
-f397aac 2013-06-16 **Luca Guidi** Implemented redirect
-dded0c5 2013-06-14 **Luca Guidi** Initial mess
+### Changed
+- [Luca Guidi] Aligned naming conventions with Lotus::Controller: no more BooksController::Index. Use Books::Index instead.
+- [Luca Guidi] Removed `:prefix` option for routes. Use `#namespace` blocks instead.
+- [Janko Marohnić] Make 301 the default redirect status
+
+## v0.1.1 - 2014-06-23
+### Added
+- [Luca Guidi] Introduced Lotus::Router#mount
+- [Luca Guidi] Let specify a pattern for Lotus::Routing::EndpointResolver
+- [Luca Guidi] Make Lotus::Routing::Endpoint::EndpointNotFound to inherit from StandardError, instead of Exception. This make it compatible with Rack::ShowExceptions.
+
+## v0.1.0 - 2014-01-23
+### Added
+- [Luca Guidi] Official support for Ruby 2.1
+- [Luca Guidi] Added support for OPTIONS HTTP verb
+- [Luca Guidi] Added Lotus::Routing::EndpointNotFound when a lazy endpoint can't be found
+- [Luca Guidi] Make action separator customizable via Lotus::Router options.
+- [Luca Guidi] Catch http_router exceptions and re-raise them with names under Lotus::Routing. This helps to have a stable public API.
+- [Luca Guidi] Lotus::Routing::Resource::CollectionAction use configurable controller and action name separator over the hardcoded value
+- [Luca Guidi] Implemented Lotus::Routing::Namespace#resource
+- [Luca Guidi] Lotus::Routing::EndpointResolver now accepts options to inject namespace and suffix
+- [Luca Guidi] Allow resolver and route class to be injected via options
+- [Luca Guidi] Return 404 for not found and 405 for unacceptable HTTP method
+- [Luca Guidi] Allow non-finished Rack responses to be used
+- [Luca Guidi] Implemented lazy loading for endpoints
+- [Luca Guidi] Implemented Lotus::Router.new to take a block and define routes
+- [Luca Guidi] Add support for resource
+- [Luca Guidi] Support for resource's member and collection
+- [Luca Guidi] Add support for namespaces
+- [Luca Guidi] Added support for RESTful resources
+- [Luca Guidi] Add support for POST, DELETE, PUT, PATCH, TRACE
+- [Luca Guidi] Routes constraints
+- [Luca Guidi] Named urls
+- [Luca Guidi] Added support for Procs as endpoints
+- [Luca Guidi] Implemented redirect
+- [Luca Guidi] Basic routing

data/README.md

@@ -1,6 +1,6 @@
 # Lotus::Router
 
-Rack compatible, lightweight and fast HTTP Router for [Lotus](http://lotusrb.org).
+Rack compatible, lightweight and fast HTTP Router for Ruby and [Lotus](http://lotusrb.org).
 
 ## Status
 
@@ -22,7 +22,7 @@ Rack compatible, lightweight and fast HTTP Router for [Lotus](http://lotusrb.org
 
 ## Rubies
 
-__Lotus::Router__ supports Ruby (MRI) 2+
+__Lotus::Router__ supports Ruby (MRI) 2+, JRuby 1.7 (with 2.0 mode)
 
 
 ## Installation
@@ -54,7 +54,7 @@ app = Lotus::Router.new do
   get '/', to: ->(env) { [200, {}, ['Welcome to Lotus::Router!']] }
 end
 
-Rack::Server.start app: app, Port: 2306
+Rack::Server.start app: app, Port: 2300
 ```
 
 ## Usage
@@ -69,17 +69,17 @@ For the standalone usage, it supports neat features:
 ```ruby
 Lotus::Router.new do
   get '/', to: ->(env) { [200, {}, ['Hi!']] }
-  get '/dashboard',   to: DashboardController::Index
+  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, to: '/api'
+  mount Api::App, at: '/api'
 
   namespace 'admin' do
-    get '/users', to: UsersController::Index
+    get '/users', to: Users::Index
   end
 
   resource 'identity' do
@@ -199,10 +199,6 @@ router.namespace 'animals' do
   end
 end
 
-# or
-
-router.get '/cats', prefix: '/animals/mammals', to:->(env) { [200, {}, ['Meow!']] }, as: :cats
-
 # and it generates:
 
 router.path(:animals_mammals_cats) # => "/animals/mammals/cats"
@@ -226,7 +222,7 @@ end
 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 `DashboardController::Index` ([Lotus::Controller](https://github.com/lotus/controller) integration)
+5. That string is resolved as `Dashboard::Index` ([Lotus::Controller](https://github.com/lotus/controller) integration)
 
 
 
@@ -259,7 +255,7 @@ router.get '/lotus', to: 'rack_app' # it will map to RackApp.new
 It also supports Controller + Action syntax:
 
 ```ruby
-class FlowersController
+module Flowers
   class Index
     def call(env)
       # ...
@@ -268,7 +264,7 @@ class FlowersController
 end
 
 router = Lotus::Router.new
-router.get '/flowers', to: 'flowers#index' # it will map to FlowersController::Index.new
+router.get '/flowers', to: 'flowers#index' # it will map to Flowers::Index.new
 ```
 
 
@@ -280,7 +276,35 @@ router = Lotus::Router.new
 router.call(Rack::MockRequest.env_for('/unknown')).status # => 404
 ```
 
+### Controllers:
+
+`Lotus::Router` has a special convention for controllers naming.
+It allows to declare an action as an endpoint, with a special syntax: `<controller>#<action>`.
+
+```ruby
+Lotus::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, `Lotus::Router` can accept a `:namespace` option, which defines the
+Ruby namespace where to look for actions.
+
+For instance, given a Lotus full stack application called `Bookshelf`, the
+controllers are available under `Bookshelf::Controllers`.
+
+```ruby
+Lotus::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:
 
@@ -302,42 +326,42 @@ It will map:
   <tr>
     <td>GET</td>
     <td>/identity</td>
-    <td>IdentityController::Show</td>
+    <td>Identity::Show</td>
     <td>:show</td>
     <td>:identity</td>
   </tr>
   <tr>
     <td>GET</td>
     <td>/identity/new</td>
-    <td>IdentityController::New</td>
+    <td>Identity::New</td>
     <td>:new</td>
     <td>:new_identity</td>
   </tr>
   <tr>
     <td>POST</td>
     <td>/identity</td>
-    <td>IdentityController::Create</td>
+    <td>Identity::Create</td>
     <td>:create</td>
     <td>:identity</td>
   </tr>
   <tr>
     <td>GET</td>
     <td>/identity/edit</td>
-    <td>IdentityController::Edit</td>
+    <td>Identity::Edit</td>
     <td>:edit</td>
     <td>:edit_identity</td>
   </tr>
   <tr>
     <td>PATCH</td>
     <td>/identity</td>
-    <td>IdentityController::Update</td>
+    <td>Identity::Update</td>
     <td>:update</td>
     <td>:identity</td>
   </tr>
   <tr>
     <td>DELETE</td>
     <td>/identity</td>
-    <td>IdentityController::Destroy</td>
+    <td>Identity::Destroy</td>
     <td>:destroy</td>
     <td>:identity</td>
   </tr>
@@ -361,11 +385,11 @@ If you need extra endpoints:
 router = Lotus::Router.new
 router.resource 'identity' do
   member do
-   get '/avatar'            # maps to IdentityController::Avatar
+    get 'avatar'           # maps to Identity::Avatar
   end
 
   collection do
-    get '/authorizations'   # maps to IdentityController::Authorizations
+    get 'authorizations'   # maps to Identity::Authorizations
   end
 end
 
@@ -395,49 +419,49 @@ It will map:
   <tr>
     <td>GET</td>
     <td>/flowers</td>
-    <td>FlowersController::Index</td>
+    <td>Flowers::Index</td>
     <td>:index</td>
     <td>:flowers</td>
   </tr>
   <tr>
     <td>GET</td>
     <td>/flowers/:id</td>
-    <td>FlowersController::Show</td>
+    <td>Flowers::Show</td>
     <td>:show</td>
     <td>:flowers</td>
   </tr>
   <tr>
     <td>GET</td>
     <td>/flowers/new</td>
-    <td>FlowersController::New</td>
+    <td>Flowers::New</td>
     <td>:new</td>
     <td>:new_flowers</td>
   </tr>
   <tr>
     <td>POST</td>
     <td>/flowers</td>
-    <td>FlowersController::Create</td>
+    <td>Flowers::Create</td>
     <td>:create</td>
     <td>:flowers</td>
   </tr>
   <tr>
     <td>GET</td>
     <td>/flowers/:id/edit</td>
-    <td>FlowersController::Edit</td>
+    <td>Flowers::Edit</td>
     <td>:edit</td>
     <td>:edit_flowers</td>
   </tr>
   <tr>
     <td>PATCH</td>
     <td>/flowers/:id</td>
-    <td>FlowersController::Update</td>
+    <td>Flowers::Update</td>
     <td>:update</td>
     <td>:flowers</td>
   </tr>
   <tr>
     <td>DELETE</td>
     <td>/flowers/:id</td>
-    <td>FlowersController::Destroy</td>
+    <td>Flowers::Destroy</td>
     <td>:destroy</td>
     <td>:flowers</td>
   </tr>
@@ -470,10 +494,11 @@ If you need extra endpoints:
 router = Lotus::Router.new
 router.resources 'flowers' do
   member do
-    get '/toggle' # maps to FlowersController::Toggle
+    get 'toggle' # maps to Flowers::Toggle
   end
+
   collection do
-    get '/search' # maps to FlowersController::Search
+    get 'search' # maps to Flowers::Search
   end
 end
 

data/lib/lotus/router.rb

@@ -42,26 +42,13 @@ module Lotus
   #   require 'lotus/router'
   #
   #   router = Lotus::Router.new do
-  #     get '/', to: 'articles#show' # => ArticlesController::Show
+  #     get '/', to: 'articles#show' # => Articles::Show
   #   end
   #
   #   # This is a builtin feature for a Lotus::Controller convention.
   #
   #
   #
-  # @example Specify a prefix with `:prefix`
-  #   require 'lotus/router'
-  #
-  #   endpoint = ->(env) { [200, {}, ['Welcome to Lotus::Router!']] }
-  #   router = Lotus::Router.new do
-  #     get '/welcome', to: endpoint, prefix: 'dashboard' # => '/dashboard/welcome'
-  #   end
-  #
-  #   # :prefix isn't mandatory for the default resolver (`Lotus::Routing::EndpointResolver.new`),
-  #   # This behavior can be changed by passing a custom resolver to `Lotus::Router#initialize`
-  #
-  #
-  #
   # @example Specify a named route with `:as`
   #   require 'lotus/router'
   #
@@ -98,6 +85,8 @@ module Lotus
     #   (defaults to `Lotus::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
     #
@@ -105,7 +94,7 @@ module Lotus
     #
     # @since 0.1.0
     #
-    # @example
+    # @example Basic example
     #   require 'lotus/router'
     #
     #   endpoint = ->(env) { [200, {}, ['Welcome to Lotus::Router!']] }
@@ -118,22 +107,135 @@ module Lotus
     #   router = Lotus::Router.new do
     #     get '/', to: endpoint
     #   end
+    #
+    # @example Body parsers
+    #   require 'json'
+    #   require 'lotus/router'
+    #
+    #   # It parses JSON body and makes the attributes available to the params
+    #
+    #   endpoint = ->(env) { [200, {},[env['router.params'].inspect]] }
+    #
+    #   router = Lotus::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
+    #
+    #   [200, {}, ["{:published=>\"true\",:id=>\"1\"}"]]
+    #
+    # @example Custom body parser
+    #   require 'lotus/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 = Lotus::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)
+    end
+
+    # Returns self
+    #
+    # This is a duck-typing trick for compatibility with `Lotus::Application`.
+    # It's used by `Lotus::Routing::RoutesInspector` to inspect both apps and
+    # routers.
+    #
+    # @return [self]
+    #
+    # @since 0.2.0
+    # @api private
+    def routes
+      self
+    end
+
+    # To support defining routes in the `define` wrapper.
+    #
+    # @param blk [Proc] the block to define the routes
+    #
+    # @return [Lotus::Routing::Route]
+    #
+    # @since 0.2.0
+    #
+    # @example In Lotus framework
+    #   class Application < Lotus::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
+    #
+    # @since 0.2.0
+    # @api private
+    #
+    # @example
+    #
+    #   router = Lotus::Router.new
+    #   router.defined? # => false
+    #
+    #   router = Lotus::Router.new { get '/', to: ->(env) { } }
+    #   router.defined? # => true
+    def defined?
+      @router.routes.any?
+    end
+
     # Defines a route that accepts a GET 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
-    # @option options [String] :prefix an optional path prefix
     #
     # @param blk [Proc] the anonymous proc to be used as endpoint for the route
     #
-    # @return [Lotus::Roting::Route] this may vary according to the :route
+    # @return [Lotus::Routing::Route] this may vary according to the :route
     #   option passed to the constructor
     #
     # @since 0.1.0
@@ -198,17 +300,6 @@ module Lotus
     #   router.path(:lotus) # => "/lotus"
     #   router.url(:lotus)  # => "https://lotusrb.org/lotus"
     #
-    # @example Prefixed routes
-    #   require 'lotus/router'
-    #
-    #   router = Lotus::Router.new
-    #   router.get '/cats',
-    #     prefix: '/animals/mammals',
-    #     to: ->(env) { [200, {}, ['Meow!']] },
-    #     as: :cats
-    #
-    #   router.path(:animals_mammals_cats) # => "/animals/mammals/cats"
-    #
     # @example Duck typed endpoints (Rack compatible objects)
     #   require 'lotus/router'
     #
@@ -236,18 +327,18 @@ module Lotus
     # @example Duck typed endpoints (string: controller + action)
     #   require 'lotus/router'
     #
-    #   class FlowersController
+    #   module Flowers
     #     class Index
     #       def call(env)
     #         # ...
     #       end
     #     end
-    #    end
+    #   end
     #
     #    router = Lotus::Router.new
     #    router.get '/flowers', to: 'flowers#index'
     #
-    #    # It will map to FlowersController::Index.new, which is the
+    #    # It will map to Flowers::Index.new, which is the
     #    # Lotus::Controller convention.
     def get(path, options = {}, &blk)
       @router.get(path, options, &blk)
@@ -259,11 +350,10 @@ module Lotus
     #
     # @param options [Hash] the options to customize the route
     # @option options [String,Proc,Class,Object#call] :to the endpoint
-    # @option options [String] :prefix an optional path prefix
     #
     # @param blk [Proc] the anonymous proc to be used as endpoint for the route
     #
-    # @return [Lotus::Roting::Route] this may vary according to the :route
+    # @return [Lotus::Routing::Route] this may vary according to the :route
     #   option passed to the constructor
     #
     # @see Lotus::Router#get
@@ -279,11 +369,10 @@ module Lotus
     #
     # @param options [Hash] the options to customize the route
     # @option options [String,Proc,Class,Object#call] :to the endpoint
-    # @option options [String] :prefix an optional path prefix
     #
     # @param blk [Proc] the anonymous proc to be used as endpoint for the route
     #
-    # @return [Lotus::Roting::Route] this may vary according to the :route
+    # @return [Lotus::Routing::Route] this may vary according to the :route
     #   option passed to the constructor
     #
     # @see Lotus::Router#get
@@ -299,11 +388,10 @@ module Lotus
     #
     # @param options [Hash] the options to customize the route
     # @option options [String,Proc,Class,Object#call] :to the endpoint
-    # @option options [String] :prefix an optional path prefix
     #
     # @param blk [Proc] the anonymous proc to be used as endpoint for the route
     #
-    # @return [Lotus::Roting::Route] this may vary according to the :route
+    # @return [Lotus::Routing::Route] this may vary according to the :route
     #   option passed to the constructor
     #
     # @see Lotus::Router#get
@@ -319,11 +407,10 @@ module Lotus
     #
     # @param options [Hash] the options to customize the route
     # @option options [String,Proc,Class,Object#call] :to the endpoint
-    # @option options [String] :prefix an optional path prefix
     #
     # @param blk [Proc] the anonymous proc to be used as endpoint for the route
     #
-    # @return [Lotus::Roting::Route] this may vary according to the :route
+    # @return [Lotus::Routing::Route] this may vary according to the :route
     #   option passed to the constructor
     #
     # @see Lotus::Router#get
@@ -339,11 +426,10 @@ module Lotus
     #
     # @param options [Hash] the options to customize the route
     # @option options [String,Proc,Class,Object#call] :to the endpoint
-    # @option options [String] :prefix an optional path prefix
     #
     # @param blk [Proc] the anonymous proc to be used as endpoint for the route
     #
-    # @return [Lotus::Roting::Route] this may vary according to the :route
+    # @return [Lotus::Routing::Route] this may vary according to the :route
     #   option passed to the constructor
     #
     # @see Lotus::Router#get
@@ -359,11 +445,10 @@ module Lotus
     #
     # @param options [Hash] the options to customize the route
     # @option options [String,Proc,Class,Object#call] :to the endpoint
-    # @option options [String] :prefix an optional path prefix
     #
     # @param blk [Proc] the anonymous proc to be used as endpoint for the route
     #
-    # @return [Lotus::Roting::Route] this may vary according to the :route
+    # @return [Lotus::Routing::Route] this may vary according to the :route
     #   option passed to the constructor
     #
     # @see Lotus::Router#get
@@ -377,7 +462,7 @@ module Lotus
     #
     # @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 `302`)
+    # @option options [Fixnum] the HTTP status to return (defaults to `301`)
     #
     # @return [Lotus::Routing::Route] the generated route.
     #   This may vary according to the `:route` option passed to the initializer
@@ -391,7 +476,7 @@ module Lotus
     #
     #   Lotus::Router.new do
     #     redirect '/legacy',  to: '/new_endpoint'
-    #     redirect '/legacy2', to: '/new_endpoint2', code: 301
+    #     redirect '/legacy2', to: '/new_endpoint2', code: 302
     #   end
     #
     # @example
@@ -400,15 +485,16 @@ module Lotus
     #   router = Lotus::Router.new
     #   router.redirect '/legacy',  to: '/new_endpoint'
     def redirect(path, options = {}, &endpoint)
-      get(path).redirect @router.find(options), options[:code] || 302
+      get(path).redirect @router.find(options), options[:code] || 301
     end
 
     # Defines a Ruby block: all the routes defined within it will be namespaced
-    #   with the given prefix.
+    # with the given relative path.
     #
     # Namespaces blocks can be nested multiple times.
     #
-    # @param prefix [String] the path prefix
+    # @param namespace [String] the relative path where the nested routes will
+    #   be mounted
     # @param blk [Proc] the block that defines the resources
     #
     # @return [Lotus::Routing::Namespace] the generated namespace.
@@ -424,10 +510,6 @@ module Lotus
     #     namespace 'trees' do
     #       get '/sequoia', to: endpoint # => '/trees/sequoia'
     #     end
-    #
-    #     # equivalent to
-    #
-    #     get '/sequoia', to: endpoint, prefix: 'trees' # => '/trees/sequoia'
     #   end
     #
     # @example Nested namespaces
@@ -448,8 +530,8 @@ module Lotus
     #   router.namespace 'trees' do
     #     get '/sequoia', to: endpoint # => '/trees/sequoia'
     #   end
-    def namespace(prefix, &blk)
-      Routing::Namespace.new(self, prefix, &blk)
+    def namespace(namespace, &blk)
+      Routing::Namespace.new(self, namespace, &blk)
     end
 
     # Defines a set of named routes for a single RESTful resource.
@@ -480,16 +562,16 @@ module Lotus
     #
     #   # It generates:
     #   #
-    #   # +--------+----------------+-----------------------------+----------+----------------+
-    #   # | Verb   | Path           | Action                      | Name     | Named Route    |
-    #   # +--------+----------------+-----------------------------+----------+----------------+
-    #   # | GET    | /identity      | IdentityController::Show    | :show    | :identity      |
-    #   # | GET    | /identity/new  | IdentityController::New     | :new     | :new_identity  |
-    #   # | POST   | /identity      | IdentityController::Create  | :create  | :identity      |
-    #   # | GET    | /identity/edit | IdentityController::Edit    | :edit    | :edit_identity |
-    #   # | PATCH  | /identity      | IdentityController::Update  | :update  | :identity      |
-    #   # | DELETE | /identity      | IdentityController::Destroy | :destroy | :identity      |
-    #   # +--------+----------------+-----------------------------+----------+----------------+
+    #   # +--------+----------------+-------------------+----------+----------------+
+    #   # | 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      |
+    #   # +--------+----------------+-------------------+----------+----------------+
     #
     #
     #
@@ -502,13 +584,13 @@ module Lotus
     #
     #   # It generates:
     #   #
-    #   # +--------+----------------+-----------------------------+----------+----------------+
-    #   # | Verb   | Path           | Action                      | Name     | Named Route    |
-    #   # +--------+----------------+-----------------------------+----------+----------------+
-    #   # | GET    | /identity      | IdentityController::Show    | :show    | :identity      |
-    #   # | GET    | /identity/new  | IdentityController::New     | :new     | :new_identity  |
-    #   # | POST   | /identity      | IdentityController::Create  | :create  | :identity      |
-    #   # +--------+----------------+-----------------------------+----------+----------------+
+    #   # +--------+----------------+------------------+----------+----------------+
+    #   # | 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      |
+    #   # +--------+----------------+------------------+----------+----------------+
     #
     #
     #
@@ -521,13 +603,13 @@ module Lotus
     #
     #   # It generates:
     #   #
-    #   # +--------+----------------+-----------------------------+----------+----------------+
-    #   # | Verb   | Path           | Action                      | Name     | Named Route    |
-    #   # +--------+----------------+-----------------------------+----------+----------------+
-    #   # | GET    | /identity      | IdentityController::Show    | :show    | :identity      |
-    #   # | GET    | /identity/new  | IdentityController::New     | :new     | :new_identity  |
-    #   # | POST   | /identity      | IdentityController::Create  | :create  | :identity      |
-    #   # +--------+----------------+-----------------------------+----------+----------------+
+    #   # +--------+----------------+------------------+----------+----------------+
+    #   # | 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      |
+    #   # +--------+----------------+------------------+----------+----------------+
     #
     #
     #
@@ -544,11 +626,11 @@ module Lotus
     #
     #   # It generates:
     #   #
-    #   # +--------+--------------------+------------------------------+------+--------------------+
-    #   # | Verb   | Path               | Action                       | Name | Named Route        |
-    #   # +--------+--------------------+------------------------------+------+--------------------+
-    #   # | PATCH  | /identity/activate | IdentityController::Activate |      | :activate_identity |
-    #   # +--------+--------------------+------------------------------+------+--------------------+
+    #   # +--------+--------------------+--------------------+------+--------------------+
+    #   # | Verb   | Path               | Action             | Name | Named Route        |
+    #   # +--------+--------------------+--------------------+------+--------------------+
+    #   # | PATCH  | /identity/activate | Identity::Activate |      | :activate_identity |
+    #   # +--------+--------------------+--------------------+------+--------------------+
     #
     #
     #
@@ -565,11 +647,11 @@ module Lotus
     #
     #   # It generates:
     #   #
-    #   # +------+----------------+--------------------------+------+----------------+
-    #   # | Verb | Path           | Action                   | Name | Named Route    |
-    #   # +------+----------------+--------------------------+------+----------------+
-    #   # | GET  | /identity/keys | IdentityController::Keys |      | :keys_identity |
-    #   # +------+----------------+--------------------------+------+----------------+
+    #   # +------+----------------+----------------+------+----------------+
+    #   # | 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
@@ -602,17 +684,17 @@ module Lotus
     #
     #   # It generates:
     #   #
-    #   # +--------+--------------------+-----------------------------+----------+----------------+
-    #   # | Verb   | Path               | Action                      | Name     | Named Route    |
-    #   # +--------+--------------------+-----------------------------+----------+----------------+
-    #   # | GET    | /articles          | ArticlesController::Index   | :index   | :articles      |
-    #   # | GET    | /articles/:id      | ArticlesController::Show    | :show    | :articles      |
-    #   # | GET    | /articles/new      | ArticlesController::New     | :new     | :new_articles  |
-    #   # | POST   | /articles          | ArticlesController::Create  | :create  | :articles      |
-    #   # | GET    | /articles/:id/edit | ArticlesController::Edit    | :edit    | :edit_articles |
-    #   # | PATCH  | /articles/:id      | ArticlesController::Update  | :update  | :articles      |
-    #   # | DELETE | /articles/:id      | ArticlesController::Destroy | :destroy | :articles      |
-    #   # +--------+--------------------+-----------------------------+----------+----------------+
+    #   # +--------+--------------------+-------------------+----------+----------------+
+    #   # | 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      |
+    #   # +--------+--------------------+-------------------+----------+----------------+
     #
     #
     #
@@ -625,11 +707,11 @@ module Lotus
     #
     #   # It generates:
     #   #
-    #   # +------+-----------+---------------------------+--------+-------------+
-    #   # | Verb | Path      | Action                    | Name   | Named Route |
-    #   # +------+-----------+---------------------------+--------+-------------+
-    #   # | GET  | /articles | ArticlesController::Index | :index | :articles   |
-    #   # +------+-----------+---------------------------+--------+-------------+
+    #   # +------+-----------+-----------------+--------+-------------+
+    #   # | Verb | Path      | Action          | Name   | Named Route |
+    #   # +------+-----------+-----------------+--------+-------------+
+    #   # | GET  | /articles | Articles::Index | :index | :articles   |
+    #   # +------+-----------+-----------------+--------+-------------+
     #
     #
     #
@@ -642,15 +724,15 @@ module Lotus
     #
     #   # It generates:
     #   #
-    #   # +--------+--------------------+-----------------------------+----------+----------------+
-    #   # | Verb   | Path               | Action                      | Name     | Named Route    |
-    #   # +--------+--------------------+-----------------------------+----------+----------------+
-    #   # | GET    | /articles          | ArticlesController::Index   | :index   | :articles      |
-    #   # | GET    | /articles/:id      | ArticlesController::Show    | :show    | :articles      |
-    #   # | GET    | /articles/new      | ArticlesController::New     | :new     | :new_articles  |
-    #   # | POST   | /articles          | ArticlesController::Create  | :create  | :articles      |
-    #   # | DELETE | /articles/:id      | ArticlesController::Destroy | :destroy | :articles      |
-    #   # +--------+--------------------+-----------------------------+----------+----------------+
+    #   # +--------+--------------------+-------------------+----------+----------------+
+    #   # | 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      |
+    #   # +--------+--------------------+-------------------+----------+----------------+
     #
     #
     #
@@ -667,11 +749,11 @@ module Lotus
     #
     #   # It generates:
     #   #
-    #   # +--------+-----------------------+-----------------------------+------+-------------------+
-    #   # | Verb   | Path                  | Action                      | Name | Named Route       |
-    #   # +--------+-----------------------+-----------------------------+------+-------------------+
-    #   # | PATCH  | /articles/:id/publish | ArticlesController::Publish |      | :publish_articles |
-    #   # +--------+-----------------------+-----------------------------+------+-------------------+
+    #   # +--------+-----------------------+-------------------+------+-------------------+
+    #   # | Verb   | Path                  | Action            | Name | Named Route       |
+    #   # +--------+-----------------------+-------------------+------+-------------------+
+    #   # | PATCH  | /articles/:id/publish | Articles::Publish |      | :publish_articles |
+    #   # +--------+-----------------------+-------------------+------+-------------------+
     #
     #
     #
@@ -688,11 +770,11 @@ module Lotus
     #
     #   # It generates:
     #   #
-    #   # +------+------------------+----------------------------+------+------------------+
-    #   # | Verb | Path             | Action                     | Name | Named Route      |
-    #   # +------+------------------+----------------------------+------+------------------+
-    #   # | GET  | /articles/search | ArticlesController::Search |      | :search_articles |
-    #   # +------+------------------+----------------------------+------+------------------+
+    #   # +------+------------------+------------------+------+------------------+
+    #   # | 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)
     end
@@ -708,7 +790,7 @@ module Lotus
     #
     # @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 path prefix where to mount the app
+    # @option options [:at] the relative path where to mount the app
     #
     # @since 0.1.1
     #
@@ -762,7 +844,7 @@ module Lotus
     #     end
     #   end
     #
-    #   class DashboardController
+    #   module Dashboard
     #     class Index
     #       def call(env)
     #       end
@@ -781,7 +863,7 @@ module Lotus
     #   # 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 DashboardController::Index (Lotus::Controller)
+    #   # 5. That string is resolved as Dashboard::Index (Lotus::Controller)
     def mount(app, options)
       @router.mount(app, options)
     end
@@ -850,5 +932,31 @@ module Lotus
     def url(route, *args)
       @router.url(route, *args)
     end
+
+    # Returns an routes inspector
+    #
+    # @since 0.2.0
+    #
+    # @see Lotus::Routing::RoutesInspector
+    #
+    # @example
+    #   require 'lotus/router'
+    #
+    #   router = Lotus::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 'lotus/routing/routes_inspector'
+      Routing::RoutesInspector.new(@router.routes)
+    end
   end
 end