anchor.diff:    (response "Hello World"))
   ----
   
  -Just like the authentication system, authorization is also implemented using protocols. All built-in authentication backends implement the protocol `IAuthorization`:
  -
  -[NOTE]
  -====
  -Some authentication backends require specific behavior in the authorization layer (like http-basic
  -which should return a `WWW-Authenticate` header when the request is unauthorized). By default, all backends
  -ships with a default implementation.
  -
  -You can override the default behavior by passing your own exception handler through the
  -`:unauthorized-handler` keyword parameter in the backend constructor.
  -====
  -
  -Below is a complete example setting up a basic/generic authorization
  -system for your ring compatible web application:
  -
  -.Define the final handler
  +Just like the authentication system, authorization is also implemented using protocols.
  +
  +All built-in backends are already implements the autorization protocol with default behavior. The
  +default behavior can be overwritted passing the `:unauthorized-handler` option to the backend
  +constructor:
  +
   [source,clojure]
   ----
   (require '[buddy.auth.backends.httpbasic :refer [http-basic-backend]])
   (require '[buddy.auth.middleware :refer [wrap-authentication wrap-authorization]])
   
  -;; Define the final handler wrapping it in the authentication and
  -;; authorization handlers. Use the same backend and override
  -;; the default unauthorized request behavior with your own defined function
  -
  -(def app
  -  (let [backend (http-basic-backend
  -                 {:realm "API"
  -                  :authfn my-auth-fn
  -                  :unauthorized-handler my-unauthorized-handler})]
  -    (-> handler
  -        (wrap-authentication backend)
  -        (wrap-authorization backend))))
  +;; Simple self difined handler for unauthorized requests.
  +(defn my-unauthorized-handler
  +  [request metadata]
  +  (-> (response "Unauthorized request")
  +      (assoc :status 403)))
  +
  +(def backend (http-basic-backend
  +              {:realm "API"
  +               :authfn my-auth-fn
  +               :unauthorized-handler my-unauthorized-handler}))
  +
  +(def app (-> your-handler
  +             (wrap-authentication backend)
  +             (wrap-authorization backend)))
   ----
   
   [[access-rules]]
  -== Access Rules
  -
  -=== Introduction
  +=== Access Rules
   
   The access rules system is another part of authorization. It consists of matching an url to
   specific access rules logic.
  
positive.code: 
  === Token
  
  This backend works much like the basic auth backend with the major difference being that this assumes
  the use of tokens.
  
  It parses a token header instead of http basic and passes it to _authfn_ for authentication.
  
  Let's see an example:
  
  
negative.code: separated. This helps a lot if you want use only one part of it (ex:
  authentication only) without including the other.
  
  In summary: yes, you can use _buddy-auth_ with liberator.
  
  
  == How to Contribute?
  