spree-enriquez 0.9.4

data/vendor/plugins/state_machine/Rakefile

@@ -0,0 +1,88 @@
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/contrib/sshpublisher'
+
+spec = Gem::Specification.new do |s|
+  s.name              = 'state_machine'
+  s.version           = '0.3.0'
+  s.platform          = Gem::Platform::RUBY
+  s.summary           = 'Adds support for creating state machines for attributes within a model'
+  
+  s.files             = FileList['{lib,test}/**/*'] + %w(CHANGELOG.rdoc init.rb LICENSE Rakefile README.rdoc) - FileList['test/app_root/{log,log/*,script,script/*}']
+  s.require_path      = 'lib'
+  s.has_rdoc          = true
+  s.test_files        = Dir['test/**/*_test.rb']
+  
+  s.author            = 'Aaron Pfeifer'
+  s.email             = 'aaron@pluginaweek.org'
+  s.homepage          = 'http://www.pluginaweek.org'
+  s.rubyforge_project = 'pluginaweek'
+end
+
+desc 'Default: run all tests.'
+task :default => :test
+
+desc "Test the #{spec.name} plugin."
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.test_files = spec.test_files
+  t.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  namespace :test do
+    desc "Test the #{spec.name} plugin with Rcov."
+    Rcov::RcovTask.new(:rcov) do |t|
+      t.libs << 'lib'
+      t.test_files = spec.test_files
+      t.rcov_opts << '--exclude="^(?!lib/)"'
+      t.verbose = true
+    end
+  end
+rescue LoadError
+end
+
+desc "Generate documentation for the #{spec.name} plugin."
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = spec.name
+  rdoc.template = '../rdoc_template.rb'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc', 'CHANGELOG.rdoc', 'LICENSE', 'lib/**/*.rb')
+end
+  
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+desc 'Publish the beta gem.'
+task :pgem => [:package] do
+  Rake::SshFilePublisher.new('aaron@pluginaweek.org', '/home/aaron/gems.pluginaweek.org/public/gems', 'pkg', "#{spec.name}-#{spec.version}.gem").upload
+end
+
+desc 'Publish the API documentation.'
+task :pdoc => [:rdoc] do
+  Rake::SshDirPublisher.new('aaron@pluginaweek.org', "/home/aaron/api.pluginaweek.org/public/#{spec.name}", 'rdoc').upload
+end
+
+desc 'Publish the API docs and gem'
+task :publish => [:pgem, :pdoc, :release]
+
+desc 'Publish the release files to RubyForge.'
+task :release => [:gem, :package] do
+  require 'rubyforge'
+  
+  ruby_forge = RubyForge.new.configure
+  ruby_forge.login
+  
+  %w(gem tgz zip).each do |ext|
+    file = "pkg/#{spec.name}-#{spec.version}.#{ext}"
+    puts "Releasing #{File.basename(file)}..."
+    
+    ruby_forge.add_release(spec.rubyforge_project, spec.name, spec.version, file)
+  end
+end

data/vendor/plugins/state_machine/init.rb

@@ -0,0 +1 @@
+require 'state_machine'

data/vendor/plugins/state_machine/lib/state_machine.rb

@@ -0,0 +1,129 @@
+require 'state_machine/machine'
+
+module PluginAWeek #:nodoc:
+  # A state machine is a model of behavior composed of states, events, and
+  # transitions.  This helper adds support for defining this type of
+  # functionality within ActiveRecord models.
+  module StateMachine
+    def self.included(base) #:nodoc:
+      base.class_eval do
+        extend PluginAWeek::StateMachine::MacroMethods
+      end
+    end
+    
+    module MacroMethods
+      # Creates a state machine for the given attribute.  The default attribute
+      # is "state".
+      # 
+      # Configuration options:
+      # * +initial+ - The initial value of the attribute.  This can either be the actual value or a Proc for dynamic initial states.
+      # 
+      # This also requires a block which will be used to actually configure the
+      # events and transitions for the state machine.  *Note* that this block
+      # will be executed within the context of the state machine.  As a result,
+      # you will not be able to access any class methods on the model unless you
+      # refer to them directly (i.e. specifying the class name).
+      # 
+      # For examples on the types of configured state machines and blocks, see
+      # the section below.
+      # 
+      # == Examples
+      # 
+      # With the default attribute and no initial state:
+      # 
+      #   class Switch < ActiveRecord::Base
+      #     state_machine do
+      #       event :park do
+      #         ...
+      #       end
+      #     end
+      #   end
+      # 
+      # The above example will define a state machine for the attribute "state"
+      # on the model.  Every switch will start with no initial state.
+      # 
+      # With a custom attribute:
+      # 
+      #   class Switch < ActiveRecord::Base
+      #     state_machine :status do
+      #       ...
+      #     end
+      #   end
+      # 
+      # With a static initial state:
+      # 
+      #   class Switch < ActiveRecord::Base
+      #     state_machine :status, :initial => 'off' do
+      #       ...
+      #     end
+      #   end
+      # 
+      # With a dynamic initial state:
+      # 
+      #   class Switch < ActiveRecord::Base
+      #     state_machine :status, :initial => lambda {|switch| (8..22).include?(Time.now.hour) ? 'on' : 'off'} do
+      #       ...
+      #     end
+      #   end
+      # 
+      # == Events and Transitions
+      # 
+      # For more information about how to configure an event and its associated
+      # transitions, see PluginAWeek::StateMachine::Machine#event
+      # 
+      # == Defining callbacks
+      # 
+      # Within the +state_machine+ block, you can also define callbacks for
+      # particular states.  For more information about defining these callbacks,
+      # see PluginAWeek::StateMachine::Machine#before_transition and
+      # PluginAWeek::StateMachine::Machine#after_transition.
+      def state_machine(*args, &block)
+        unless included_modules.include?(PluginAWeek::StateMachine::InstanceMethods)
+          write_inheritable_attribute :state_machines, {}
+          class_inheritable_reader :state_machines
+          
+          include PluginAWeek::StateMachine::InstanceMethods
+        end
+        
+        options = args.extract_options!
+        attribute = args.any? ? args.first.to_s : 'state'
+        
+        # Creates the state machine for this class.  If a superclass has already
+        # defined the machine, then a copy of it will be used with its context
+        # changed to this class.  If no machine has been defined before for the
+        # attribute, a new one will be created.
+        original = state_machines[attribute]
+        machine = state_machines[attribute] = original ? original.within_context(self, options) : PluginAWeek::StateMachine::Machine.new(self, attribute, options)
+        machine.instance_eval(&block) if block
+        
+        machine
+      end
+    end
+    
+    module InstanceMethods
+      def self.included(base) #:nodoc:
+        base.class_eval do
+          alias_method_chain :initialize, :state_machine
+        end
+      end
+      
+      # Defines the initial values for state machine attributes
+      def initialize_with_state_machine(attributes = nil)
+        initialize_without_state_machine(attributes)
+        
+        # Set the initial value of each state machine as long as the value wasn't
+        # included in the initial attributes
+        attributes = (attributes || {}).stringify_keys
+        self.class.state_machines.each do |attribute, machine|
+          send("#{attribute}=", machine.initial_state(self)) unless attributes.include?(attribute)
+        end
+        
+        yield self if block_given?
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  include PluginAWeek::StateMachine
+end

data/vendor/plugins/state_machine/lib/state_machine/event.rb

@@ -0,0 +1,116 @@
+require 'state_machine/transition'
+
+module PluginAWeek #:nodoc:
+  module StateMachine
+    # An event defines an action that transitions an attribute from one state to
+    # another
+    class Event
+      # The state machine for which this event is defined
+      attr_accessor :machine
+      
+      # The name of the action that fires the event
+      attr_reader :name
+      
+      # The list of transitions that can be made for this event
+      attr_reader :transitions
+      
+      delegate  :owner_class,
+                  :to => :machine
+      
+      # Creates a new event within the context of the given machine
+      def initialize(machine, name)
+        @machine = machine
+        @name = name
+        @transitions = []
+        
+        add_actions
+      end
+      
+      # Creates a copy of this event in addition to the list of associated
+      # transitions to prevent conflicts across different events.
+      def initialize_copy(orig) #:nodoc:
+        super
+        @transitions = @transitions.dup
+      end
+      
+      # Creates a new transition to the specified state.
+      # 
+      # Configuration options:
+      # * +to+ - The state that being transitioned to
+      # * +from+ - A state or array of states that can be transitioned from. If not specified, then the transition can occur for *any* from state
+      # * +except_from+ - A state or array of states that *cannot* be transitioned from.
+      # * +if+ - Specifies a method, proc or string to call to determine if the transition should occur (e.g. :if => :moving?, or :if => Proc.new {|car| car.speed > 60}). The method, proc or string should return or evaluate to a true or false value.
+      # * +unless+ - Specifies a method, proc or string to call to determine if the transition should not occur (e.g. :unless => :stopped?, or :unless => Proc.new {|car| car.speed <= 60}). The method, proc or string should return or evaluate to a true or false value.
+      # 
+      # == Examples
+      # 
+      #   transition :to => 'parked'
+      #   transition :to => 'parked', :from => 'first_gear'
+      #   transition :to => 'parked', :from => %w(first_gear reverse)
+      #   transition :to => 'parked', :from => 'first_gear', :if => :moving?
+      #   transition :to => 'parked', :from => 'first_gear', :unless => :stopped?
+      #   transition :to => 'parked', :except_from => 'parked'
+      def transition(options)
+        transitions << transition = Transition.new(self, options)
+        transition
+      end
+      
+      # Determines whether any transitions can be performed for this event based
+      # on the current state of the given record.
+      # 
+      # If the event can't be fired, then this will return false, otherwise true.
+      def can_fire?(record)
+        transitions.any? {|transition| transition.can_perform?(record)}
+      end
+      
+      # Attempts to perform one of the event's transitions for the given record.
+      # Any additional arguments will be passed to the event's callbacks.
+      def fire(record)
+        run(record, false) || false
+      end
+      
+      # Attempts to perform one of the event's transitions for the given record.
+      # If the transition cannot be made, then a PluginAWeek::StateMachine::InvalidTransition
+      # error will be raised.
+      def fire!(record)
+        run(record, true) || raise(PluginAWeek::StateMachine::InvalidTransition, "Cannot transition via :#{name} from \"#{record.send(machine.attribute)}\"")
+      end
+      
+      private
+        # Add the various instance methods that can transition the record using
+        # the current event
+        def add_actions
+          attribute = machine.attribute
+          name = self.name
+          
+          owner_class.class_eval do
+            define_method(name) {self.class.state_machines[attribute].events[name].fire(self)}
+            define_method("#{name}!") {self.class.state_machines[attribute].events[name].fire!(self)}
+            define_method("can_#{name}?") {self.class.state_machines[attribute].events[name].can_fire?(self)}
+          end
+        end
+        
+        # Attempts to find a transition that can be performed for this event.
+        # 
+        # +bang+ indicates whether +perform+ or <tt>perform!</tt> will be
+        # invoked on transitions.
+        def run(record, bang)
+          result = false
+          
+          record.class.transaction do
+            transitions.each do |transition|
+              if transition.can_perform?(record)
+                result = bang ? transition.perform!(record) : transition.perform(record)
+                break
+              end
+            end
+            
+            # Rollback any changes if the transition failed
+            raise ActiveRecord::Rollback unless result
+          end
+          
+          result
+        end
+    end
+  end
+end

data/vendor/plugins/state_machine/lib/state_machine/machine.rb

@@ -0,0 +1,412 @@
+require 'state_machine/event'
+
+module PluginAWeek #:nodoc:
+  module StateMachine
+    # Represents a state machine for a particular attribute.  State machines
+    # consist of events (a.k.a. actions) and a set of transitions that define
+    # how the state changes after a particular event is fired.
+    # 
+    # A state machine may not necessarily know all of the possible states for
+    # an object since they can be any arbitrary value.  As a result, anything
+    # that relies on a list of all possible states should keep in mind that if
+    # a state has not been referenced *anywhere* in the state machine definition,
+    # then it will *not* be a known state.
+    # 
+    # == Callbacks
+    # 
+    # Callbacks are supported for hooking before and after every possible
+    # transition in the machine.  Each callback is invoked in the order in which
+    # it was defined.  See PluginAWeek::StateMachine::Machine#before_transition
+    # and PluginAWeek::StateMachine::Machine#after_transition for documentation
+    # on how to define new callbacks.
+    # 
+    # === Cancelling callbacks
+    # 
+    # If a +before+ callback returns +false+, all the later callbacks and
+    # associated transition are cancelled.  If an +after+ callback returns false,
+    # the later callbacks are cancelled, but the transition is still successful.
+    # This is the same behavior as exposed by ActiveRecord's callback support.
+    # 
+    # *Note* that if a +before+ callback fails and the bang version of an event
+    # was invoked, an exception will be raised instead of returning false.
+    # 
+    # == Observers
+    # 
+    # ActiveRecord observers can also hook into state machines in addition to
+    # the conventional before_save, after_save, etc. behaviors.  The following
+    # types of behaviors can be observed:
+    # * events (e.g. before_park/after_park, before_ignite/after_ignite)
+    # * transitions (before_transition/after_transition)
+    # 
+    # Each method takes a set of parameters that provides additional information
+    # about the transition that caused the observer to be notified.  Below are
+    # examples of defining observers for the following state machine:
+    # 
+    #   class Vehicle < ActiveRecord::Base
+    #     state_machine do
+    #       event :park do
+    #         transition :to => 'parked', :from => 'idling'
+    #       end
+    #       ...
+    #     end
+    #     ...
+    #   end
+    # 
+    # Event behaviors:
+    # 
+    #   class VehicleObserver < ActiveRecord::Observer
+    #     def before_park(vehicle, from_state, to_state)
+    #       logger.info "Vehicle #{vehicle.id} instructed to park... state is: #{from_state}, state will be: #{to_state}"
+    #     end
+    #     
+    #     def after_park(vehicle, from_state, to_state)
+    #       logger.info "Vehicle #{vehicle.id} instructed to park... state was: #{from_state}, state is: #{to_state}"
+    #     end
+    #   end
+    # 
+    # Transition behaviors:
+    # 
+    #   class VehicleObserver < ActiveRecord::Observer
+    #     def before_transition(vehicle, attribute, event, from_state, to_state)
+    #       logger.info "Vehicle #{vehicle.id} instructed to #{event}... #{attribute} is: #{from_state}, #{attribute} will be: #{to_state}"
+    #     end
+    #     
+    #     def after_transition(vehicle, attribute, event, from_state, to_state)
+    #       logger.info "Vehicle #{vehicle.id} instructed to #{event}... #{attribute} was: #{from_state}, #{attribute} is: #{to_state}"
+    #     end
+    #   end
+    # 
+    # One common callback is to record transitions for all models in the system
+    # for audit/debugging purposes.  Below is an example of an observer that can
+    # easily automate this process for all models:
+    # 
+    #   class StateMachineObserver < ActiveRecord::Observer
+    #     observe Vehicle, Switch, AutoShop
+    #     
+    #     def before_transition(record, attribute, event, from_state, to_state)
+    #       transition = StateTransition.build(:record => record, :attribute => attribute, :event => event, :from_state => from_state, :to_state => to_state)
+    #       transition.save # Will cancel rollback/cancel transition if this fails
+    #     end
+    #   end
+    class Machine
+      # The class that the machine is defined for
+      attr_reader :owner_class
+      
+      # The attribute for which the state machine is being defined
+      attr_reader :attribute
+      
+      # The initial state that the machine will be in when a record is created
+      attr_reader :initial_state
+      
+      # A list of the states defined in the transitions of all of the events
+      attr_reader :states
+      
+      # The events that trigger transitions
+      attr_reader :events
+      
+      # Creates a new state machine for the given attribute
+      # 
+      # Configuration options:
+      # * +initial+ - The initial value to set the attribute to. This can be an actual value or a proc, which will be evaluated at runtime.
+      # 
+      # == Scopes
+      # 
+      # This will automatically create a named scope called with_#{attribute}
+      # that will find all records that have the attribute set to a given value.
+      # For example,
+      # 
+      #   Switch.with_state('on') # => Finds all switches where the state is on
+      #   Switch.with_states('on', 'off') # => Finds all switches where the state is either on or off
+      # 
+      # *Note* that if class methods already exist with those names (i.e. "with_state"
+      # or "with_states"), then a scope will not be defined for that name.
+      def initialize(owner_class, attribute = 'state', options = {})
+        set_context(owner_class, options)
+        
+        @attribute = attribute.to_s
+        @states = []
+        @events = {}
+        
+        add_transition_callbacks
+        add_named_scopes
+      end
+      
+      # Creates a copy of this machine in addition to copies of each associated
+      # event, so that the list of transitions for each event don't conflict
+      # with different machines
+      def initialize_copy(orig) #:nodoc:
+        super
+        
+        @states = @states.dup
+        @events = @events.inject({}) do |events, (name, event)|
+          event = event.dup
+          event.machine = self
+          events[name] = event
+          events
+        end
+      end
+      
+      # Creates a copy of this machine within the context of the given class.
+      # This should be used for inheritance support of state machines.
+      def within_context(owner_class, options = {}) #:nodoc:
+        machine = dup
+        machine.set_context(owner_class, options)
+        machine
+      end
+      
+      # Changes the context of this machine to the given class so that new
+      # events and transitions are created in the proper context.
+      def set_context(owner_class, options = {}) #:nodoc:
+        options.assert_valid_keys(:initial)
+        
+        @owner_class = owner_class
+        @initial_state = options[:initial] if options[:initial]
+      end
+      
+      # Gets the initial state of the machine for the given record. If a record
+      # is specified a and a dynamic initial state was configured for the machine,
+      # then that record will be passed into the proc to help determine the actual
+      # value of the initial state.
+      # 
+      # == Examples
+      # 
+      # With normal initial state:
+      # 
+      #   class Vehicle < ActiveRecord::Base
+      #     state_machine :initial => 'parked' do
+      #       ...
+      #     end
+      #   end
+      #   
+      #   Vehicle.state_machines['state'].initial_state(@vehicle)   # => "parked"
+      # 
+      # With dynamic initial state:
+      # 
+      #   class Vehicle < ActiveRecord::Base
+      #     state_machine :initial => lambda {|vehicle| vehicle.force_idle ? 'idling' : 'parked'} do
+      #       ...
+      #     end
+      #   end
+      #   
+      #   Vehicle.state_machines['state'].initial_state(@vehicle)   # => "idling"
+      def initial_state(record)
+        @initial_state.is_a?(Proc) ? @initial_state.call(record) : @initial_state
+      end
+      
+      # Defines an event of the system
+      # 
+      # == Instance methods
+      # 
+      # The following instance methods are generated when a new event is defined
+      # (the "park" event is used as an example):
+      # * <tt>park</tt> - Fires the "park" event, transitioning from the current state to the next valid state.
+      # * <tt>park!</tt> - Fires the "park" event, transitioning from the current state to the next valid state.  If the transition cannot happen (for validation, database, etc. reasons), then an error will be raised.
+      # * <tt>can_park?</tt> - Checks whether the "park" event can be fired given the current state of the record.
+      # 
+      # == Defining transitions
+      # 
+      # +event+ requires a block which allows you to define the possible
+      # transitions that can happen as a result of that event.  For example,
+      # 
+      #   event :park do
+      #     transition :to => 'parked', :from => 'idle'
+      #   end
+      #   
+      #   event :first_gear do
+      #     transition :to => 'first_gear', :from => 'parked', :if => :seatbelt_on?
+      #   end
+      # 
+      # See PluginAWeek::StateMachine::Event#transition for more information on
+      # the possible options that can be passed in.
+      # 
+      # *Note* that this block is executed within the context of the actual event
+      # object.  As a result, you will not be able to reference any class methods
+      # on the model without referencing the class itself.  For example,
+      # 
+      #   class Car < ActiveRecord::Base
+      #     def self.safe_states
+      #       %w(parked idling stalled)
+      #     end
+      #     
+      #     state_machine :state do
+      #       event :park do
+      #         transition :to => 'parked', :from => Car.safe_states
+      #       end
+      #     end
+      #   end 
+      # 
+      # == Example
+      # 
+      #   class Car < ActiveRecord::Base
+      #     state_machine(:state, :initial => 'parked') do
+      #       event :park, :after => :release_seatbelt do
+      #         transition :to => 'parked', :from => %w(first_gear reverse)
+      #       end
+      #       ...
+      #     end
+      #   end
+      def event(name, &block)
+        name = name.to_s
+        event = events[name] ||= Event.new(self, name)
+        event.instance_eval(&block)
+        
+        # Record the states so that the machine can keep a list of all known
+        # states that have been defined
+        event.transitions.each do |transition|
+          @states |= [transition.options[:to]] + Array(transition.options[:from]) + Array(transition.options[:except_from])
+          @states.sort!
+        end
+        
+        event
+      end
+      
+      # Creates a callback that will be invoked *before* a transition has been
+      # performed, so long as the given configuration options match the transition.
+      # Each part of the transition (to state, from state, and event) must match
+      # in order for the callback to get invoked.
+      # 
+      # Configuration options:
+      # * +to+ - One or more states being transitioned to.  If none are specified, then all states will match.
+      # * +from+ - One or more states being transitioned from.  If none are specified, then all states will match.
+      # * +on+ - One or more events that fired the transition.  If none are specified, then all events will match.
+      # * +except_to+ - One more states *not* being transitioned to
+      # * +except_from+ - One or more states *not* being transitioned from
+      # * +except_on+ - One or more events that *did not* fire the transition
+      # * +do+ - The callback to invoke when a transition matches. This can be a method, proc or string.
+      # * +if+ - A method, proc or string to call to determine if the callback should occur (e.g. :if => :allow_callbacks, or :if => lambda {|user| user.signup_step > 2}). The method, proc or string should return or evaluate to a true or false value. 
+      # * +unless+ - A method, proc or string to call to determine if the callback should not occur (e.g. :unless => :skip_callbacks, or :unless => lambda {|user| user.signup_step <= 2}). The method, proc or string should return or evaluate to a true or false value. 
+      # 
+      # The +except+ group of options (+except_to+, +exception_from+, and
+      # +except_on+) acts as the +unless+ equivalent of their counterparts (+to+,
+      # +from+, and +on+, respectively)
+      # 
+      # == The callback
+      # 
+      # When defining additional configuration options, callbacks must be defined
+      # in the :do option like so:
+      # 
+      #   class Vehicle < ActiveRecord::Base
+      #     state_machine do
+      #       before_transition :to => 'parked', :do => :set_alarm
+      #       ...
+      #     end
+      #   end
+      # 
+      # == Examples
+      # 
+      # Below is an example of a model with one state machine and various types
+      # of +before+ transitions defined for it:
+      # 
+      #   class Vehicle < ActiveRecord::Base
+      #     state_machine do
+      #       # Before all transitions
+      #       before_transition :update_dashboard
+      #       
+      #       # Before specific transition:
+      #       before_transition :to => 'parked', :from => %w(first_gear idling), :on => 'park', :do => :take_off_seatbelt
+      #       
+      #       # With conditional callback:
+      #       before_transition :to => 'parked', :do => :take_off_seatbelt, :if => :seatbelt_on?
+      #       
+      #       # Using :except counterparts:
+      #       before_transition :except_to => 'stalled', :except_from => 'stalled', :except_on => 'crash', :do => :update_dashboard
+      #       ...
+      #     end
+      #   end
+      # 
+      # As can be seen, any number of transitions can be created using various
+      # combinations of configuration options.
+      def before_transition(options = {})
+        add_transition_callback(:before, options)
+      end
+      
+      # Creates a callback that will be invoked *after* a transition has been
+      # performed, so long as the given configuration options match the transition.
+      # Each part of the transition (to state, from state, and event) must match
+      # in order for the callback to get invoked.
+      # 
+      # Configuration options:
+      # * +to+ - One or more states being transitioned to.  If none are specified, then all states will match.
+      # * +from+ - One or more states being transitioned from.  If none are specified, then all states will match.
+      # * +on+ - One or more events that fired the transition.  If none are specified, then all events will match.
+      # * +except_to+ - One more states *not* being transitioned to
+      # * +except_from+ - One or more states *not* being transitioned from
+      # * +except_on+ - One or more events that *did not* fire the transition
+      # * +do+ - The callback to invoke when a transition matches. This can be a method, proc or string.
+      # * +if+ - A method, proc or string to call to determine if the callback should occur (e.g. :if => :allow_callbacks, or :if => lambda {|user| user.signup_step > 2}). The method, proc or string should return or evaluate to a true or false value. 
+      # * +unless+ - A method, proc or string to call to determine if the callback should not occur (e.g. :unless => :skip_callbacks, or :unless => lambda {|user| user.signup_step <= 2}). The method, proc or string should return or evaluate to a true or false value. 
+      # 
+      # The +except+ group of options (+except_to+, +exception_from+, and
+      # +except_on+) acts as the +unless+ equivalent of their counterparts (+to+,
+      # +from+, and +on+, respectively)
+      # 
+      # == The callback
+      # 
+      # When defining additional configuration options, callbacks must be defined
+      # in the :do option like so:
+      # 
+      #   class Vehicle < ActiveRecord::Base
+      #     state_machine do
+      #       after_transition :to => 'parked', :do => :set_alarm
+      #       ...
+      #     end
+      #   end
+      # 
+      # == Examples
+      # 
+      # Below is an example of a model with one state machine and various types
+      # of +after+ transitions defined for it:
+      # 
+      #   class Vehicle < ActiveRecord::Base
+      #     state_machine do
+      #       # After all transitions
+      #       after_transition :update_dashboard
+      #       
+      #       # After specific transition:
+      #       after_transition :to => 'parked', :from => %w(first_gear idling), :on => 'park', :do => :take_off_seatbelt
+      #       
+      #       # With conditional callback:
+      #       after_transition :to => 'parked', :do => :take_off_seatbelt, :if => :seatbelt_on?
+      #       
+      #       # Using :except counterparts:
+      #       after_transition :except_to => 'stalled', :except_from => 'stalled', :except_on => 'crash', :do => :update_dashboard
+      #       ...
+      #     end
+      #   end
+      # 
+      # As can be seen, any number of transitions can be created using various
+      # combinations of configuration options.
+      def after_transition(options = {})
+        add_transition_callback(:after, options)
+      end
+      
+      private
+        # Adds the given callback to the callback chain during a state transition
+        def add_transition_callback(type, options)
+          options = {:do => options} unless options.is_a?(Hash)
+          options.assert_valid_keys(:to, :from, :on, :except_to, :except_from, :except_on, :do, :if, :unless)
+          
+          # The actual callback (defined in the :do option) must be defined
+          raise ArgumentError, ':do callback must be specified' unless options[:do]
+          
+          # Create the callback
+          owner_class.send("#{type}_transition_#{attribute}", options.delete(:do), options)
+        end
+        
+        # Add before/after callbacks for when the attribute transitions to a
+        # different value
+        def add_transition_callbacks
+          %w(before after).each {|type| owner_class.define_callbacks("#{type}_transition_#{attribute}") }
+        end
+        
+        # Add named scopes for finding records with a particular value or values
+        # for the attribute
+        def add_named_scopes
+          [attribute, attribute.pluralize].uniq.each do |name|
+            name = "with_#{name}"
+            owner_class.named_scope name.to_sym, lambda {|*values| {:conditions => {attribute => values.flatten}}} unless owner_class.respond_to?(name)
+          end
+        end
+    end
+  end
+end