state_machine 0.6.3 → 0.7.0

data/lib/state_machine/machine_collection.rb

@@ -0,0 +1,145 @@
+module StateMachine
+  # Represents a collection of state machines for a class
+  class MachineCollection < Hash
+    # Initializes the state of each machine in the given object.  Initial
+    # values are only set if the machine's attribute doesn't already exist
+    # (which must mean the defaults are being skipped)
+    def initialize_states(object)
+      each do |attribute, machine|
+        value = machine.read(object)
+        machine.write(object, machine.initial_state(object).value) if value.nil? || value.respond_to?(:empty?) && value.empty?
+      end
+    end
+    
+    # Runs one or more events in parallel on the given object.  See
+    # StateMachine::InstanceMethods#fire_events for more information.
+    def fire_events(object, *events)
+      run_action = [true, false].include?(events.last) ? events.pop : true
+      
+      # Generate the transitions to run for each event
+      transitions = events.collect do |name|
+        # Find the actual event being run
+        event = nil
+        detect do |attribute, machine|
+          event = machine.events[name, :qualified_name]
+        end
+        
+        raise InvalidEvent, "#{name.inspect} is an unknown state machine event" unless event
+        
+        # Get the transition that will be performed for the event
+        unless transition = event.transition_for(object)
+          machine = event.machine
+          machine.invalidate(object, machine.attribute, :invalid_transition, [[:event, name]])
+        end
+        
+        transition
+      end.compact
+      
+      # Run the events in parallel only if valid transitions were found for
+      # all of them
+      if events.length == transitions.length
+        Transition.perform_within_transaction(transitions, :action => run_action)
+      else
+        false
+      end
+    end
+    
+    # Runs one or more attribute events in parallel during the invocation of
+    # an action on the given object.  After transition callbacks can be
+    # optionally disabled if the events are being only partially fired (for
+    # example, when validating records in ORM integrations).
+    # 
+    # The attribute events that will be fired are based on which machines
+    # match the action that is being invoked.
+    # 
+    # == Examples
+    # 
+    #   class Vehicle
+    #     include DataMapper::Resource
+    #     property :id, Integer, :serial => true
+    #     
+    #     state_machine :initial => :parked do
+    #       event :ignite do
+    #         transition :parked => :idling
+    #       end
+    #     end
+    #     
+    #     state_machine :alarm_state, :namespace => 'alarm', :initial => :active do
+    #       event :disable do
+    #         transition all => :off
+    #       end
+    #     end
+    #   end
+    # 
+    # With valid events:
+    # 
+    #   vehicle = Vehicle.create                      # => #<Vehicle id=1 state="parked" alarm_state="active">
+    #   vehicle.state_event = 'ignite'
+    #   vehicle.alarm_state_event = 'disable'
+    #   
+    #   Vehicle.state_machines.fire_attribute_events(vehicle, :save) { true }
+    #   vehicle.state                                 # => "idling"
+    #   vehicle.state_event                           # => nil
+    #   vehicle.alarm_state                           # => "off"
+    #   vehicle.alarm_state_event                     # => nil
+    # 
+    # With invalid events:
+    #   
+    #   vehicle = Vehicle.create                      # => #<Vehicle id=1 state="parked" alarm_state="active">
+    #   vehicle.state_event = 'park'
+    #   vehicle.alarm_state_event = 'disable'
+    #   
+    #   Vehicle.state_machines.fire_attribute_events(vehicle, :save) { true }
+    #   vehicle.state                                 # => "parked"
+    #   vehicle.state_event                           # => nil
+    #   vehicle.alarm_state                           # => "active"
+    #   vehicle.alarm_state_event                     # => nil
+    #   vehicle.errors                                # => #<DataMapper::Validate::ValidationErrors:0xb7af9abc @errors={"state_event"=>["is invalid"]}>
+    # 
+    # With partial firing:
+    # 
+    #   vehicle = Vehicle.create                      # => #<Vehicle id=1 state="parked" alarm_state="active">
+    #   vehicle.state_event = 'ignite'
+    #   
+    #   Vehicle.state_machines.fire_attribute_events(vehicle, :save, false) { true }
+    #   vehicle.state                                 # => "idling"
+    #   vehicle.state_event                           # => "ignite"
+    #   vehicle.state_event_transition                # => #<StateMachine::Transition attribute=:state event=:ignite from="parked" from_name=:parked to="idling" to_name=:idling>
+    def fire_attribute_events(object, action, complete = true)
+      # Get the transitions to fire for each applicable machine
+      transitions = map {|attribute, machine| machine.action == action ? machine.events.attribute_transition_for(object, true) : nil}.compact
+      return yield if transitions.empty?
+      
+      # Make sure all events were valid
+      if result = transitions.all? {|transition| transition != false}
+        begin
+          result = Transition.perform(transitions, :after => complete) do
+            # Prevent events from being evaluated multiple times if actions are nested
+            transitions.each {|transition| object.send("#{transition.attribute}_event=", nil)}
+            yield
+          end
+        rescue Exception
+          # Revert attribute modifications
+          transitions.each do |transition|
+            object.send("#{transition.attribute}_event=", transition.event)
+            object.send("#{transition.attribute}_event_transition=", nil) if complete
+          end
+          
+          raise
+        end
+        
+        transitions.each do |transition|
+          attribute = transition.attribute
+          
+          # Revert event unless transition was successful
+          object.send("#{attribute}_event=", transition.event) unless complete && result
+          
+          # Track transition if partial transition completed successfully
+          object.send("#{attribute}_event_transition=", !complete && result ? transition : nil)
+        end
+      end
+      
+      result
+    end
+  end
+end

data/lib/state_machine/matcher.rb

@@ -29,7 +29,7 @@ module StateMachine
     # 
     # == Examples
     # 
-    #   matcher = StateMachine::AllMatcher.new - [:parked, :idling]
+    #   matcher = StateMachine::AllMatcher.instance - [:parked, :idling]
     #   matcher.matches?(:parked)       # => false
     #   matcher.matches?(:first_gear)   # => true
     def -(blacklist)
@@ -108,7 +108,7 @@ module StateMachine
     # 
     # == Examples
     # 
-    #   matcher = StateMachine::LoopbackMatcher.new
+    #   matcher = StateMachine::LoopbackMatcher.instance
     #   matcher.matches?(:parked, :from => :parked)   # => true
     #   matcher.matches?(:parked, :from => :idling)   # => false
     def matches?(value, context)

data/lib/state_machine/node_collection.rb

@@ -6,6 +6,9 @@ module StateMachine
     include Enumerable
     include Assertions
     
+    # The machine associated with the nodes
+    attr_reader :machine
+    
     # Creates a new collection of nodes for the given state machine.  By default,
     # the collection is empty.
     # 
@@ -13,10 +16,11 @@ module StateMachine
     # * <tt>:index</tt> - One or more attributes to automatically generate
     #   hashed indices for in order to perform quick lookups.  Default is to
     #   index by the :name attribute
-    def initialize(options = {})
+    def initialize(machine, options = {})
       assert_valid_keys(options, :index)
       options = {:index => :name}.merge(options)
       
+      @machine = machine
       @nodes = []
       @indices = Array(options[:index]).inject({}) {|indices, attribute| indices[attribute] = {}; indices}
       @default_index = Array(options[:index]).first
@@ -36,6 +40,7 @@ module StateMachine
     # Changes the current machine associated with the collection.  In turn, this
     # will change the state machine associated with each node in the collection.
     def machine=(new_machine)
+      @machine = new_machine
       each {|node| node.machine = new_machine}
     end
     
@@ -62,7 +67,7 @@ module StateMachine
     # will be replaced with the updated ones.
     def update(node)
       @indices.each do |attribute, index|
-        old_key = index.respond_to?(:key) ? index.key(node) : index.index(node)
+        old_key = RUBY_VERSION < '1.9' ? index.index(node) : index.key(node)
         new_key = node.send(attribute)
         
         # Only replace the key if it's changed
@@ -74,7 +79,7 @@ module StateMachine
     end
     
     # Calls the block once for each element in self, passing that element as a
-    # parameters.
+    # parameter.
     # 
     #   states = StateMachine::NodeCollection.new
     #   states << StateMachine::State.new(machine, :parked)
@@ -128,7 +133,7 @@ module StateMachine
     # 
     #   collection['invalid', :value]   # => IndexError: "invalid" is an invalid value
     def fetch(key, index_name = @default_index)
-      self[key, index_name] || raise(ArgumentError, "#{key.inspect} is an invalid #{index_name}")
+      self[key, index_name] || raise(IndexError, "#{key.inspect} is an invalid #{index_name}")
     end
     
     private

data/lib/state_machine/state.rb

@@ -19,6 +19,10 @@ module StateMachine
     # The unique identifier for the state used in event and callback definitions
     attr_reader :name
     
+    # The fully-qualified identifier for the state, scoped by the machine's
+    # namespace
+    attr_reader :qualified_name
+    
     # The value that is written to a machine's attribute when an object
     # transitions into this state
     attr_writer :value
@@ -52,10 +56,11 @@ module StateMachine
       
       @machine = machine
       @name = name
+      @qualified_name = name && machine.namespace ? :"#{machine.namespace}_#{name}" : name
       @value = options.include?(:value) ? options[:value] : name && name.to_s
       @matcher = options[:if]
       @methods = {}
-      @initial = options.include?(:initial) && options[:initial]
+      @initial = options[:initial] == true
       
       add_predicate
     end
@@ -127,11 +132,11 @@ module StateMachine
       matcher ? matcher.call(other_value) : other_value == value
     end
     
-    # Defines a context for the state which will be enabled on instances of the
-    # owner class when the machine is in this state.
+    # Defines a context for the state which will be enabled on instances of
+    # the owner class when the machine is in this state.
     # 
-    # This can be called multiple times.  Each time a new context is created, a
-    # new module will be included in the owner class.
+    # This can be called multiple times.  Each time a new context is created,
+    # a new module will be included in the owner class.
     def context(&block)
       owner_class = machine.owner_class
       attribute = machine.attribute
@@ -140,32 +145,20 @@ module StateMachine
       # Evaluate the method definitions
       context = ConditionProxy.new(owner_class, lambda {|object| object.send("#{attribute}_name") == name})
       context.class_eval(&block)
-      
-      # Define all of the methods that were created in the module so that they
-      # don't override the core behavior (i.e. calling the state method)
       context.instance_methods.each do |method|
-        unless owner_class.instance_methods.include?(method)
-          # Calls the method defined by the current state of the machine.  This
-          # is done using string evaluation so that any block passed into the
-          # method can then be passed to the state's context method, which is
-          # not possible with lambdas in Ruby 1.8.6.
-          owner_class.class_eval <<-end_eval, __FILE__, __LINE__
-            def #{method}(*args, &block)
-              self.class.state_machines[#{attribute.inspect}].state_for(self).call(self, #{method.inspect}, *args, &block)
-            end
-          end_eval
-        end
-        
-        # Track the method defined for the context so that it can be invoked
-        # at a later point in time
         methods[method.to_sym] = context.instance_method(method)
+        
+        # Calls the method defined by the current state of the machine
+        context.class_eval <<-end_eval, __FILE__, __LINE__
+          def #{method}(*args, &block)
+            self.class.state_machine(#{attribute.inspect}).states.match(self).call(self, #{method.inspect}, *args, &block)
+          end
+        end_eval
       end
       
       # Include the context so that it can be bound to the owner class (the
       # context is considered an ancestor, so it's allowed to be bound)
-      owner_class.class_eval do
-        include context
-      end
+      owner_class.class_eval { include context }
       
       context
     end
@@ -181,7 +174,7 @@ module StateMachine
         context_method.bind(object).call(*args, &block)
       else
         # Raise exception as if the method never existed on the original object
-        raise NoMethodError, "undefined method '#{method}' for #{object} in state #{machine.state_for(object).name.inspect}"
+        raise NoMethodError, "undefined method '#{method}' for #{object} in state #{machine.states.match(object).name.inspect}"
       end
     end
     
@@ -190,8 +183,8 @@ module StateMachine
     # * +label+ - The human-friendly description of the state.
     # * +width+ - The width of the node.  Always 1.
     # * +height+ - The height of the node.  Always 1.
-    # * +shape+ - The actual shape of the node.  If the state is the initial
-    #   state, then "doublecircle", otherwise "circle".
+    # * +shape+ - The actual shape of the node.  If the state is a final
+    #   state, then "doublecircle", otherwise "ellipse".
     # 
     # The actual node generated on the graph will be returned.
     def draw(graph)
@@ -225,12 +218,9 @@ module StateMachine
       def add_predicate
         return unless name
         
-        qualified_name = name = self.name
-        qualified_name = "#{machine.namespace}_#{name}" if machine.namespace
-        
         # Checks whether the current value matches this state
         machine.define_instance_method("#{qualified_name}?") do |machine, object|
-          machine.state?(object, name)
+          machine.states.matches?(object, name)
         end
       end
   end

data/lib/state_machine/state_collection.rb

@@ -3,8 +3,62 @@ require 'state_machine/node_collection'
 module StateMachine
   # Represents a collection of states in a state machine
   class StateCollection < NodeCollection
-    def initialize #:nodoc:
-      super(:index => [:name, :value])
+    def initialize(machine) #:nodoc:
+      super(machine, :index => [:name, :value])
+    end
+    
+    # Determines whether the given object is in a specific state.  If the
+    # object's current value doesn't match the state, then this will return
+    # false, otherwise true.  If the given state is unknown, then an IndexError
+    # will be raised.
+    # 
+    # == Examples
+    # 
+    #   class Vehicle
+    #     state_machine :initial => :parked do
+    #       other_states :idling
+    #     end
+    #   end
+    #   
+    #   states = Vehicle.state_machine.states
+    #   vehicle = Vehicle.new               # => #<Vehicle:0xb7c464b0 @state="parked">
+    #   
+    #   states.matches?(vehicle, :parked)   # => true
+    #   states.matches?(vehicle, :idling)   # => false
+    #   states.matches?(vehicle, :invalid)  # => IndexError: :invalid is an invalid key for :name index
+    def matches?(object, name)
+      fetch(name).matches?(machine.read(object))
+    end
+    
+    # Determines the current state of the given object as configured by this
+    # state machine.  This will attempt to find a known state that matches
+    # the value of the attribute on the object.  If no state is found, then
+    # an ArgumentError will be raised.
+    # 
+    # == Examples
+    # 
+    #   class Vehicle
+    #     state_machine :initial => :parked do
+    #       other_states :idling
+    #     end
+    #   end
+    #   
+    #   states = Vehicle.state_machine.states
+    #   
+    #   vehicle = Vehicle.new         # => #<Vehicle:0xb7c464b0 @state="parked">
+    #   states.match(vehicle)         # => #<StateMachine::State name=:parked value="parked" initial=true>
+    #   
+    #   vehicle.state = 'idling'
+    #   states.match(vehicle)         # => #<StateMachine::State name=:idling value="idling" initial=true>
+    #   
+    #   vehicle.state = 'invalid'
+    #   states.match(vehicle)         # => ArgumentError: "invalid" is not a known state value
+    def match(object)
+      value = machine.read(object)
+      state = self[value, :value] || detect {|state| state.matches?(value)}
+      raise ArgumentError, "#{value.inspect} is not a known #{machine.attribute} value" unless state
+      
+      state
     end
     
     # Gets the order in which states should be displayed based on where they
@@ -18,21 +72,16 @@ module StateMachine
     # 
     # This order will determine how the GraphViz visualizations are rendered.
     def by_priority
-      if first = @nodes.first
-        machine = first.machine
-        order = select {|state| state.initial}.map {|state| state.name}
-        
-        machine.events.each {|event| order += event.known_states}
-        order += select {|state| state.methods.any?}.map {|state| state.name}
-        order += keys(:name) - machine.callbacks.values.flatten.map {|callback| callback.known_states}.flatten
-        order += keys(:name)
-        
-        order.uniq!
-        order.map! {|name| self[name]}
-        order
-      else
-        []
-      end
+      order = select {|state| state.initial}.map {|state| state.name}
+      
+      machine.events.each {|event| order += event.known_states}
+      order += select {|state| state.methods.any?}.map {|state| state.name}
+      order += keys(:name) - machine.callbacks.values.flatten.map {|callback| callback.known_states}.flatten
+      order += keys(:name)
+      
+      order.uniq!
+      order.map! {|name| self[name]}
+      order
     end
   end
 end

data/lib/state_machine/transition.rb

@@ -10,6 +10,82 @@ module StateMachine
   # * A starting state
   # * An ending state
   class Transition
+    class << self
+      # Runs one or more transitions in parallel.  All transitions will run
+      # through the following steps:
+      # 1. Before callbacks
+      # 2. Persist state
+      # 3. Invoke action
+      # 4. After callbacks if configured
+      # 5. Rollback if action is unsuccessful
+      # 
+      # Configuration options:
+      # * <tt>:action</tt> - Whether to run the action configured for each transition
+      # * <tt>:after</tt> - Whether to run after callbacks
+      # 
+      # If a block is passed to this method, that block will be called instead
+      # of invoking each transition's action.
+      def perform(transitions, options = {})
+        # Validate that the transitions are for separate machines / attributes
+        attributes = transitions.map {|transition| transition.attribute}.uniq
+        raise ArgumentError, 'Cannot perform multiple transitions in parallel for the same state machine attribute' if attributes.length != transitions.length
+        
+        success = false
+        
+        # Run before callbacks.  If any callback halts, then the entire chain
+        # is halted for every transition.
+        if transitions.all? {|transition| transition.before}
+          # Persist the new state for each attribute
+          transitions.each {|transition| transition.persist}
+          
+          # Run the actions associated with each machine
+          begin
+            results = {}
+            success =
+              if block_given?
+                # Block was given: use the result for each transition
+                result = yield
+                transitions.each {|transition| results[transition.action] = result}
+                result
+              elsif options[:action] == false
+                # Skip the action
+                true
+              else
+                # Run each transition's action (only once)
+                object = transitions.first.object
+                transitions.all? do |transition|
+                  action = transition.action
+                  action && !results.include?(action) ? results[action] = object.send(action) : true
+                end
+              end
+          rescue Exception
+            # Action failed: rollback 
+            transitions.each {|transition| transition.rollback}
+            raise
+          end
+          
+          # Always run after callbacks regardless of whether the actions failed
+          transitions.each {|transition| transition.after(results[transition.action])} unless options[:after] == false
+          
+          # Rollback the transitions if the transaction was unsuccessful
+          transitions.each {|transition| transition.rollback} unless success
+        end
+        
+        success
+      end
+      
+      # Runs one or more transitions within a transaction.  See StateMachine::Transition.perform
+      # for more information.
+      def perform_within_transaction(transitions, options = {})
+        success = false
+        transitions.first.within_transaction do
+          success = perform(transitions, options)
+        end
+        
+        success
+      end
+    end
+    
     # The object being transitioned
     attr_reader :object
     
@@ -19,36 +95,84 @@ module StateMachine
     # The event that triggered the transition
     attr_reader :event
     
+    # The fully-qualified name of the event that triggered the transition
+    attr_reader :qualified_event
+    
     # The original state value *before* the transition
     attr_reader :from
     
     # The original state name *before* the transition
     attr_reader :from_name
     
+    # The original fully-qualified state name *before* transition
+    attr_reader :qualified_from_name
+    
     # The new state value *after* the transition
     attr_reader :to
     
     # The new state name *after* the transition
     attr_reader :to_name
     
+    # The new fully-qualified state name *after* the transition
+    attr_reader :qualified_to_name
+    
+    # The arguments passed in to the event that triggered the transition
+    # (does not include the +run_action+ boolean argument if specified)
+    attr_accessor :args
+    
+    # The result of invoking the action associated with the machine
+    attr_reader :result
+    
     # Creates a new, specific transition
     def initialize(object, machine, event, from_name, to_name) #:nodoc:
       @object = object
       @machine = machine
-      @event = event
-      @from = object.send(machine.attribute)
-      @from_name = from_name
-      @to = machine.states[to_name].value
-      @to_name = to_name
+      @args = []
+      
+      # Event information (no-ops don't have events)
+      if event
+        event = machine.events.fetch(event)
+        @event = event.name
+        @qualified_event = event.qualified_name
+      end
+      
+      # From state information
+      from_state = machine.states.fetch(from_name)
+      @from = machine.read(object)
+      @from_name = from_state.name
+      @qualified_from_name = from_state.qualified_name
+      
+      # To state information
+      to_state = machine.states.fetch(to_name)
+      @to = to_state.value
+      @to_name = to_state.name
+      @qualified_to_name = to_state.qualified_name
     end
     
-    # Gets the attribute which this transition's machine is defined for
+    # The attribute which this transition's machine is defined for
     def attribute
       machine.attribute
     end
     
-    # Gets a hash of all the core attributes defined for this transition with
-    # their names as keys and values of the attributes as values.
+    # The action that will be run when this transition is performed
+    def action
+      machine.action
+    end
+    
+    # Does this transition represent a loopback (i.e. the from and to state
+    # are the same)
+    # 
+    # == Example
+    # 
+    #   machine = StateMachine.new(Vehicle)
+    #   StateMachine::Transition.new(Vehicle.new, machine, :park, :parked, :parked).loopback?   # => true
+    #   StateMachine::Transition.new(Vehicle.new, machine, :park, :idling, :parked).loopback?   # => false
+    def loopback?
+      from_name == to_name
+    end
+    
+    # A hash of all the core attributes defined for this transition with their
+    # names as keys and values of the attributes as values.
     # 
     # == Example
     # 
@@ -75,31 +199,138 @@ module StateMachine
     #   transition = StateMachine::Transition.new(vehicle, machine, :ignite, :parked, :idling)
     #   transition.perform          # => Runs the +save+ action after setting the state attribute
     #   transition.perform(false)   # => Only sets the state attribute
-    def perform(run_action = true)
-      result = false
+    def perform(*args)
+      run_action = [true, false].include?(args.last) ? args.pop : true
+      self.args = args
       
+      # Run the transition
+      self.class.perform_within_transaction([self], :action => run_action)
+    end
+    
+    # Runs a block within a transaction for the object being transitioned.
+    # By default, transactions are a no-op unless otherwise defined by the
+    # machine's integration.
+    def within_transaction
       machine.within_transaction(object) do
-        catch(:halt) do
-          # Run before callbacks
-          callback(:before)
-          
-          # Updates the object's attribute to the ending state
-          object.send("#{attribute}=", to)
-          result = run_action && machine.action ? object.send(machine.action) != false : true
-          
-          # Always run after callbacks regardless of whether the action failed.
-          # Result is included in case the callback depends on this value
-          callback(:after, result)
-        end
-        
-        # Make sure the transaction gets the correct return value for determining
-        # whether it should rollback or not
-        result = result != false
+        yield
+      end
+    end
+    
+    # Runs the machine's +before+ callbacks for this transition.  Only
+    # callbacks that are configured to match the event, from state, and to
+    # state will be invoked.
+    # 
+    # == Example
+    # 
+    #   class Vehicle
+    #     state_machine do
+    #       before_transition :on => :ignite, :do => lambda {|vehicle| ...}
+    #     end
+    #   end
+    #   
+    #   vehicle = Vehicle.new
+    #   transition = StateMachine::Transition.new(vehicle, machine, :ignite, :parked, :idling)
+    #   transition.before
+    def before
+      result = false
+      
+      catch(:halt) do
+        callback(:before)
+        result = true
       end
       
       result
     end
     
+    # Transitions the current value of the state to that specified by the
+    # transition.
+    # 
+    # == Example
+    # 
+    #   class Vehicle
+    #     state_machine do
+    #       event :ignite do
+    #         transition :parked => :idling
+    #       end
+    #     end
+    #   end
+    #   
+    #   vehicle = Vehicle.new
+    #   transition = StateMachine::Transition.new(vehicle, Vehicle.state_machine, :ignite, :parked, :idling)
+    #   transition.persist
+    #   
+    #   vehicle.state   # => 'idling'
+    def persist
+      machine.write(object, to)
+    end
+    
+    # Runs the machine's +after+ callbacks for this transition.  Only
+    # callbacks that are configured to match the event, from state, and to
+    # state will be invoked.
+    # 
+    # The result is used to indicate whether the associated machine action
+    # was executed successfully.
+    # 
+    # == Halting
+    # 
+    # If any callback throws a <tt>:halt</tt> exception, it will be caught
+    # and the callback chain will be automatically stopped.  However, this
+    # exception will not bubble up to the caller since +after+ callbacks
+    # should never halt the execution of a +perform+.
+    # 
+    # == Example
+    # 
+    #   class Vehicle
+    #     state_machine do
+    #       after_transition :on => :ignite, :do => lambda {|vehicle| ...}
+    #       
+    #       event :ignite do
+    #         transition :parked => :idling
+    #       end
+    #     end
+    #   end
+    #   
+    #   vehicle = Vehicle.new
+    #   transition = StateMachine::Transition.new(vehicle, Vehicle.state_machine, :ignite, :parked, :idling)
+    #   transition.after(true)
+    def after(result = nil)
+      @result = result
+      
+      catch(:halt) do
+        callback(:after)
+      end
+      
+      true
+    end
+    
+    # Rolls back changes made to the object's state via this transition.  This
+    # will revert the state back to the +from+ value.
+    # 
+    # == Example
+    # 
+    #   class Vehicle
+    #     state_machine :initial => :parked do
+    #       event :ignite do
+    #         transition :parked => :idling
+    #       end
+    #     end
+    #   end
+    #   
+    #   vehicle = Vehicle.new     # => #<Vehicle:0xb7b7f568 @state="parked">
+    #   transition = StateMachine::Transition.new(vehicle, Vehicle.state_machine, :ignite, :parked, :idling)
+    #   
+    #   # Persist the new state
+    #   vehicle.state             # => "parked"
+    #   transition.persist
+    #   vehicle.state             # => "idling"
+    #   
+    #   # Roll back to the original state
+    #   transition.rollback
+    #   vehicle.state             # => "parked"
+    def rollback
+      machine.write(object, from)
+    end
+    
     # Generates a nicely formatted description of this transitions's contents.
     # 
     # For example,
@@ -129,9 +360,9 @@ module StateMachine
       # 
       # Additional callback parameters can be specified.  By default, this
       # transition is also passed into callbacks.
-      def callback(type, *args)
+      def callback(type)
         machine.callbacks[type].each do |callback|
-          callback.call(object, context, self, *args)
+          callback.call(object, context, self)
         end
       end
   end