anchor.diff:  ;; Sign data
   (def signed-data (dumps {:userid 1} "my-secret-key"))
   
  -;; signed-data should contain string similar to:
  +;; signed-data should contain a string similar to:
   ;; "TlBZARlgGwAAAAIOAAAABnVzZXJpZCsAAAAAAAAAAQ:59d9e8063ad80f6abd3092b45857810b10f5..."
   
  -;; Unsign previosly signed data
  +;; Unsign previously signed data
   (def unsigned-data (loads signed-data "my-secret-key"))
   
   ;; unsigned-data should contain a original map: {:userid 1}
   ----
   
  -NOTE: it uses a clojure serialization library link:https://github.com/ptaoussanis/nippy[Nippy]
  -
  -INFO: at this moment only generic sign method is available, but I am workin on jwt (json web token)
  -implementation for buddy and it will be available on next releases
  -
  +NOTE: it uses a Clojure serialization library link:https://github.com/ptaoussanis/nippy[Nippy]
  +
  +INFO: Currently only a generic sign method is available, but I am
  +workin on a jwt (json web token) implementation for buddy. It will be
  +available in future releases.
   
   Hashers
   ~~~~~~~
   
  -An other main part of good authentication/authorization library is give you some facilities
  -for generate secure passwords. _buddy_ comes with few functions for generate and verify passwords
  -using widely used password derivation algorithms like bcrypt and pbkdf2(with sha256).
  -
  -_buddy_ hashers lives on `buddy.hashers.*` namespace and usually consists on two functions:
  -`make-password` and `check-password`.
  -
  -The purpose of these functions is obvious: creating new password, and verify incoming plain text
  -password with previously created hash.
  -
  -.Example create new hash and verify it
  +Another important part of a good authentication/authorization library
  +is providing some facilities for generating secure passwords. _buddy_
  +comes with a few functions for generating and verifying passwords like
  +the widely used password derivation algorithms bcrypt and pbkdf2 (with
  +sha256).
  +
  +_buddy_ hashers live in `buddy.hashers.*` and usually consist
  +of `make-password` and `check-password`.
  +
  +The purpose of these functions is obvious: creating a new password,
  +and verifying incoming plain text password with previously created
  +hash.
  +
  +.Example of creating and verifying a new hash
   [source,clojure]
   ----
   (require '[buddy.hashers.bcrypt :as hs])
  
positive.code:         (boolean (roles :admin))))))
  ----
  
  The handler function should receive a request and return: true, false or throw unauthorized
  exception. Throwing unauthorized exception is a fast return method and no other handler
  is excetured before it (only if handler is wraped with `wrap-authorization` middleware).
  
  In previous example we have seen a simple handler associated with one regular expression, but
  _buddy_ access rules system allows combine more handlers using logical `:and` & `:or` combinators
  with nesting support.
  
  Imagine the scenario when you want allow access to a set of urls to operators or administrators:
  
  [source,clojure]
  ----
  
negative.code: Like authentication system, authorization is also implemented using protocols. Taking advantage of
  it, all builtin authentication backends also implements this authorization protocol (`IAuthorization`).
  
  Some authentication backends require specific behavior in the
  authorization layer (like http-basic which should return
  `WWW-Authenticate` header when request is unauthorized) and by
  default, all backends come with an implementation. You can overwrite
  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:
  
  
  .Defining uathorized handler
  