anchor.diff:  
   So, if we wrap our handlers in +io.aviso.rook/namespace-middleware+:
   
  -[source,clojure]
   ----
   (-> (io.aviso.rook/rook-handler)
    (io.aviso.rook/namespace-middleware 'some.namespace))
  
positive.code: Please note, that when using +namespace-middleware+ in conjunction with +compojure.core/context+, the context has to wrap
  middleware to make the route path resolution work properly. Example:
  
  [source,clojure]
  ----
  
  (compojure.core/context "/merchants" []
    (->
     (io.aviso.rook/rook-handler)
  
negative.code: = Rook
  
  Rook is a set of middleware and handlers to enable metadata-based routing for https://github.com/ring-clojure/ring[Ring] web applications.
  
  The intention is to expose a Clojure _namespace_ as a web service _resource_; there's a default mapping of HTTP verbs
  and paths to function names; these can be extended or overridden by meta-data on the functions in the namespace.
  
  The end result is that a proper web service resource can be created in very little code.
  
  == Resource Handler Functions
  
  Rook analyzes the public functions of a namespace to determine which functions are invoked and under which circumstances.
  The circumstances are a combination of an HTTP verb (GET, POST, etc.) and a https://github.com/weavejester/clout[Clout] route. The
  route may include keywords. This is called the _path specification_.
  
  Rook applies a naming convention to functions, so simply naming a function with a particular name implies a certain
  path specification.
  
  .Default Handler Functions
  [options="header"]
  |===
  |Function Name|Verb|Path|Notes
  
  |create
  |POST
  |/
  |Create a new resource
  
  |destroy
  |DELETE
  |/:id
  |Delete existing resource
  
  |edit
  |GET
  |/:id/edit
  |Present HTML form to user to edit existing resource
  
  |index
  |GET
  |/
  |List all existing/matching resources
  
  |new
  |GET
  |/new
  |Present HTML form to user to create new resource
  
  |show
  |GET
  |/:id
  |Retrieve single resource by unique id
  
  |update
  |PUT or PATCH
  |/:id
  |Modify existing resource
  
  |===
  
  Rook's job is to help with routing to your functions; it also assists with passing information from the request path or query parameters
  into your function ... the implementation of the function is entirely yours.
  
  You are free to name your functions as you like; in which case, specify the `:path-spec` meta data on your functions to inform
  Rook:
  
  ----
  (defn active-users
    "List just users who are currently active."
    {:path-spec [:get "/active"]}
    [request]
    ...)
  ----
  
  The `+:path-spec` contains two values: the keyword for the verb (this may also be the value `:all`) and the path to match.
  
  == Middleware
  
  Ring is divided into two main pieces: a _middleware_ and a _handler_.
  
  The middleware analyzes the namespace and the incoming request; it will identify the matching resource handler function, storing
  the information about it under the `:rook` request key.
  
  The _handler_ checks for that information; if present it invokes the identified resource handler function.
  
  Applications will often add additional middleware in front of the handler; this allows for other concerns to be addressed,
  such as authentication, logging, error handling, etc.
  
  == Argument Resolution
  
  Ring will ...
  
  == Routing
  
  