anchor.diff:  Someone reviews the article, and then either accepts or rejects it.
   Here is the expression of this workflow using the API:
   
  -    class Article
  -      include Workflow
  -      workflow do
  -        state :new do
  -          event :submit, :transitions_to => :awaiting_review
  -        end
  -        state :awaiting_review do
  -          event :review, :transitions_to => :being_reviewed
  -        end
  -        state :being_reviewed do
  -          event :accept, :transitions_to => :accepted
  -          event :reject, :transitions_to => :rejected
  -        end
  -        state :accepted
  -        state :rejected
  -      end
  -    end
  +```rb
  +class Article
  +  include Workflow
  +  workflow do
  +    state :new do
  +      event :submit, :transitions_to => :awaiting_review
  +    end
  +    state :awaiting_review do
  +      event :review, :transitions_to => :being_reviewed
  +    end
  +    state :being_reviewed do
  +      event :accept, :transitions_to => :accepted
  +      event :reject, :transitions_to => :rejected
  +    end
  +    state :accepted
  +    state :rejected
  +  end
  +end
  +```
   
   Nice, isn't it!
   
  
positive.code: You can also check, whether a state comes before or after another state (by the
  order they were defined):
  
      article.current_state
      => being_reviewed
      article.current_state < :accepted
      => true
      article.current_state >= :accepted
      => false
      article.current_state.between? :awaiting_review, :rejected
      => true
  
  Now we can call the submit event, which transitions to the
  <tt>:awaiting_review</tt> state:
  
      article.submit!
      article.awaiting_review? # => true
  
  Events are actually instance methods on a workflow, and depending on the
  state you're in, you'll have a different set of events used to
  
negative.code: overrides the persistence methods `load_workflow_state` and
  `persist_workflow_state`. Example:
  
  ```rb
  module Workflow
    module SuperCoolDb
      module InstanceMethods
        def load_workflow_state
          # Load and return the workflow_state from some storage.
          # You can use self.class.workflow_column configuration.
        end
  
        def persist_workflow_state(new_value)
          # save the new_value workflow state
        end
      end
  
      module ClassMethods
        # class methods of your adapter go here
      end
  
      def self.included(klass)
        klass.send :include, InstanceMethods
        klass.extend ClassMethods
      end
    end
  end
  ```
  
  The user of the adapter can use it then as:
  
  ```rb
  class Article
    include Workflow
    include Workflow:SuperCoolDb
    workflow do
      state :submitted
      # ...
    end
  end
  ```
  
  I can then link to your implementation from this README. Please let me
  also know, if you need any interface beyond `load_workflow_state` and
  