branston 0.6.1 → 0.6.2

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

@@ -1,249 +0,0 @@
-require 'state_machine/assertions'
-require 'state_machine/condition_proxy'
-
-module StateMachine
-  # A state defines a value that an attribute can be in after being transitioned
-  # 0 or more times.  States can represent a value of any type in Ruby, though
-  # the most common (and default) type is String.
-  # 
-  # In addition to defining the machine's value, a state can also define a
-  # behavioral context for an object when that object is in the state.  See
-  # StateMachine::Machine#state for more information about how state-driven
-  # behavior can be utilized.
-  class State
-    include Assertions
-    
-    # The state machine for which this state is defined
-    attr_accessor :machine
-    
-    # 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
-    
-    # Whether this state's value should be cached after being evaluated
-    attr_accessor :cache
-    
-    # Whether or not this state is the initial state to use for new objects
-    attr_accessor :initial
-    alias_method :initial?, :initial
-    
-    # A custom lambda block for determining whether a given value matches this
-    # state
-    attr_accessor :matcher
-    
-    # Tracks all of the methods that have been defined for the machine's owner
-    # class when objects are in this state.
-    # 
-    # Maps :method_name => UnboundMethod
-    attr_reader :methods
-    
-    # Creates a new state within the context of the given machine.
-    # 
-    # Configuration options:
-    # * <tt>:initial</tt> - Whether this state is the beginning state for the
-    #   machine. Default is false.
-    # * <tt>:value</tt> - The value to store when an object transitions to this
-    #   state.  Default is the name (stringified).
-    # * <tt>:cache</tt> - If a dynamic value (via a lambda block) is being used,
-    #   then setting this to true will cache the evaluated result
-    # * <tt>:if</tt> - Determines whether a value matches this state
-    #   (e.g. :value => lambda {Time.now}, :if => lambda {|state| !state.nil?}).
-    #   By default, the configured value is matched.
-    def initialize(machine, name, options = {}) #:nodoc:
-      assert_valid_keys(options, :initial, :value, :cache, :if)
-      
-      @machine = machine
-      @name = name
-      @qualified_name = name && machine.namespace ? :"#{machine.namespace}_#{name}" : name
-      @value = options.include?(:value) ? options[:value] : name && name.to_s
-      @cache = options[:cache]
-      @matcher = options[:if]
-      @methods = {}
-      @initial = options[:initial] == true
-      
-      add_predicate
-    end
-    
-    # Creates a copy of this state in addition to the list of associated
-    # methods to prevent conflicts across different states.
-    def initialize_copy(orig) #:nodoc:
-      super
-      @methods = methods.dup
-    end
-    
-    # Determines whether there are any states that can be transitioned to from
-    # this state.  If there are none, then this state is considered *final*.
-    # Any objects in a final state will remain so forever given the current
-    # machine's definition.
-    def final?
-      !machine.events.any? do |event|
-        event.guards.any? do |guard|
-          guard.state_requirements.any? do |requirement|
-            requirement[:from].matches?(name) && !requirement[:to].matches?(name, :from => name)
-          end
-        end
-      end
-    end
-    
-    # Generates a human-readable description of this state's name / value:
-    # 
-    # For example,
-    # 
-    #   State.new(machine, :parked).description                               # => "parked"
-    #   State.new(machine, :parked, :value => :parked).description            # => "parked"
-    #   State.new(machine, :parked, :value => nil).description                # => "parked (nil)"
-    #   State.new(machine, :parked, :value => 1).description                  # => "parked (1)"
-    #   State.new(machine, :parked, :value => lambda {Time.now}).description  # => "parked (*)
-    def description
-      description = name ? name.to_s : name.inspect
-      description << " (#{@value.is_a?(Proc) ? '*' : @value.inspect})" unless name.to_s == @value.to_s
-      description
-    end
-    
-    # The value that represents this state.  This will optionally evaluate the
-    # original block if it's a lambda block.  Otherwise, the static value is
-    # returned.
-    # 
-    # For example,
-    # 
-    #   State.new(machine, :parked, :value => 1).value                        # => 1
-    #   State.new(machine, :parked, :value => lambda {Time.now}).value        # => Tue Jan 01 00:00:00 UTC 2008
-    #   State.new(machine, :parked, :value => lambda {Time.now}).value(false) # => <Proc:0xb6ea7ca0@...>
-    def value(eval = true)
-      if @value.is_a?(Proc) && eval
-        if cache_value?
-          @value = @value.call
-          machine.states.update(self)
-          @value
-        else
-          @value.call
-        end
-      else
-        @value
-      end
-    end
-    
-    # Determines whether this state matches the given value.  If no matcher is
-    # configured, then this will check whether the values are equivalent.
-    # Otherwise, the matcher will determine the result.
-    # 
-    # For example,
-    # 
-    #   # Without a matcher
-    #   state = State.new(machine, :parked, :value => 1)
-    #   state.matches?(1)           # => true
-    #   state.matches?(2)           # => false
-    #   
-    #   # With a matcher
-    #   state = State.new(machine, :parked, :value => lambda {Time.now}, :if => lambda {|value| !value.nil?})
-    #   state.matches?(nil)         # => false
-    #   state.matches?(Time.now)    # => true
-    def matches?(other_value)
-      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.
-    # 
-    # 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
-      machine_name = machine.name
-      name = self.name
-      
-      # Evaluate the method definitions
-      context = ConditionProxy.new(owner_class, lambda {|object| object.class.state_machine(machine_name).states.matches?(object, name)})
-      context.class_eval(&block)
-      context.instance_methods.each do |method|
-        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(#{machine_name.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 { include context }
-      
-      context
-    end
-    
-    # Calls a method defined in this state's context on the given object.  All
-    # arguments and any block will be passed into the method defined.
-    # 
-    # If the method has never been defined for this state, then a NoMethodError
-    # will be raised.
-    def call(object, method, *args, &block)
-      if context_method = methods[method.to_sym]
-        # Method is defined by the state: proxy it through
-        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} with #{name || 'nil'} #{machine.name}"
-      end
-    end
-    
-    # Draws a representation of this state on the given machine.  This will
-    # create a new node on the graph with the following properties:
-    # * +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 a final
-    #   state, then "doublecircle", otherwise "ellipse".
-    # 
-    # The actual node generated on the graph will be returned.
-    def draw(graph)
-      node = graph.add_node(name ? name.to_s : 'nil',
-        :label => description,
-        :width => '1',
-        :height => '1',
-        :shape => final? ? 'doublecircle' : 'ellipse'
-      )
-      
-      # Add open arrow for initial state
-      graph.add_edge(graph.add_node('starting_state', :shape => 'point'), node) if initial?
-      
-      node
-    end
-    
-    # Generates a nicely formatted description of this state's contents.
-    # 
-    # For example,
-    # 
-    #   state = StateMachine::State.new(machine, :parked, :value => 1, :initial => true)
-    #   state   # => #<StateMachine::State name=:parked value=1 initial=true context=[]>
-    def inspect
-      attributes = [[:name, name], [:value, @value], [:initial, initial?], [:context, methods.keys]]
-      "#<#{self.class} #{attributes.map {|attr, value| "#{attr}=#{value.inspect}"} * ' '}>"
-    end
-    
-    private
-      # Should the value be cached after it's evaluated for the first time?
-      def cache_value?
-        @cache
-      end
-      
-      # Adds a predicate method to the owner class so long as a name has
-      # actually been configured for the state
-      def add_predicate
-        return unless name
-        
-        # Checks whether the current value matches this state
-        machine.define_instance_method("#{qualified_name}?") do |machine, object|
-          machine.states.matches?(object, name)
-        end
-      end
-  end
-end

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

@@ -1,112 +0,0 @@
-require 'state_machine/node_collection'
-
-module StateMachine
-  # Represents a collection of states in a state machine
-  class StateCollection < NodeCollection
-    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, :state))
-    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.
-    # 
-    # == 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)         # => nil
-    def match(object)
-      value = machine.read(object, :state)
-      self[value, :value] || detect {|state| state.matches?(value)}
-    end
-    
-    # Determines the current state of the given object as configured by this
-    # state machine.  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 = 'invalid'
-    #   states.match!(vehicle)        # => ArgumentError: "invalid" is not a known state value
-    def match!(object)
-      match(object) || raise(ArgumentError, "#{machine.read(object, :state).inspect} is not a known #{machine.name} value")
-    end
-    
-    # Gets the order in which states should be displayed based on where they
-    # were first referenced.  This will order states in the following priority:
-    # 
-    # 1. Initial state
-    # 2. Event transitions (:from, :except_from, :to, :except_to options)
-    # 3. States with behaviors
-    # 4. States referenced via +state+ or +other_states+
-    # 5. States referenced in callbacks
-    # 
-    # This order will determine how the GraphViz visualizations are rendered.
-    def by_priority
-      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
-    
-    private
-      # Gets the value for the given attribute on the node
-      def value(node, attribute)
-        attribute == :value ? node.value(false) : super
-      end
-  end
-end

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

@@ -1,394 +0,0 @@
-module StateMachine
-  # An invalid transition was attempted
-  class InvalidTransition < StandardError
-  end
-  
-  # A transition represents a state change for a specific attribute.
-  # 
-  # Transitions consist of:
-  # * An event
-  # * 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
-          
-          # Run after callbacks even when the actions failed. The :after option
-          # is ignored if the transitions were unsuccessful.
-          transitions.each {|transition| transition.after(results[transition.action], success)} unless options[:after] == false && success
-          
-          # 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
-    
-    # The state machine for which this transition is defined
-    attr_reader :machine
-    
-    # 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, read_state = true) #:nodoc:
-      @object = object
-      @machine = machine
-      @args = []
-      
-      # Event information
-      event = machine.events.fetch(event)
-      @event = event.name
-      @qualified_event = event.qualified_name
-      
-      # From state information
-      from_state = machine.states.fetch(from_name)
-      @from = read_state ? machine.read(object, :state) : from_state.value
-      @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
-    
-    # The attribute which this transition's machine is defined for
-    def attribute
-      machine.attribute
-    end
-    
-    # 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
-    # 
-    #   machine = StateMachine.new(Vehicle)
-    #   transition = StateMachine::Transition.new(Vehicle.new, machine, :ignite, :parked, :idling)
-    #   transition.attributes   # => {:object => #<Vehicle:0xb7d60ea4>, :attribute => :state, :event => :ignite, :from => 'parked', :to => 'idling'}
-    def attributes
-      @attributes ||= {:object => object, :attribute => attribute, :event => event, :from => from, :to => to}
-    end
-    
-    # Runs the actual transition and any before/after callbacks associated
-    # with the transition.  The action associated with the transition/machine
-    # can be skipped by passing in +false+.
-    # 
-    # == Examples
-    # 
-    #   class Vehicle
-    #     state_machine :action => :save do
-    #       ...
-    #     end
-    #   end
-    #   
-    #   vehicle = Vehicle.new
-    #   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(*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
-        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.
-    # 
-    # Once the callbacks are run, they cannot be run again until this transition
-    # is reset.
-    # 
-    # == 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
-        unless @before_run
-          callback(:before)
-          @before_run = true
-        end
-        
-        result = true
-      end
-      
-      result
-    end
-    
-    # Transitions the current value of the state to that specified by the
-    # transition.  Once the state is persisted, it cannot be persisted again
-    # until this transition is reset.
-    # 
-    # == 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
-      unless @persisted
-        machine.write(object, :state, to)
-        @persisted = true
-      end
-    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 can be used to indicate whether the associated machine action
-    # was executed successfully.
-    # 
-    # Once the callbacks are run, they cannot be run again until this transition
-    # is reset.
-    # 
-    # == 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, success = true)
-      @result = result
-      
-      catch(:halt) do
-        unless @after_run
-          callback(:after, :success => success)
-          @after_run = true
-        end
-      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
-      reset
-      machine.write(object, :state, from)
-    end
-    
-    # Resets any tracking of which callbacks have already been run and whether
-    # the state has already been persisted
-    def reset
-      @before_run = @persisted = @after_run = false
-    end
-    
-    # Generates a nicely formatted description of this transitions's contents.
-    # 
-    # For example,
-    # 
-    #   transition = StateMachine::Transition.new(object, machine, :ignite, :parked, :idling)
-    #   transition   # => #<StateMachine::Transition attribute=:state event=:ignite from="parked" from_name=:parked to="idling" to_name=:idling>
-    def inspect
-      "#<#{self.class} #{%w(attribute event from from_name to to_name).map {|attr| "#{attr}=#{send(attr).inspect}"} * ' '}>"
-    end
-    
-    protected
-      # Gets a hash of the context defining this unique transition (including
-      # event, from state, and to state).
-      # 
-      # == Example
-      # 
-      #   machine = StateMachine.new(Vehicle)
-      #   transition = StateMachine::Transition.new(Vehicle.new, machine, :ignite, :parked, :idling)
-      #   transition.context    # => {:on => :ignite, :from => :parked, :to => :idling}
-      def context
-        @context ||= {:on => event, :from => from_name, :to => to_name}
-      end
-      
-      # Runs the callbacks of the given type for this transition.  This will
-      # only invoke callbacks that exactly match the event, from state, and
-      # to state that describe this transition.
-      # 
-      # Additional callback parameters can be specified.  By default, this
-      # transition is also passed into callbacks.
-      def callback(type, context = {})
-        context = self.context.merge(context)
-        
-        machine.callbacks[type].each do |callback|
-          callback.call(object, context, self)
-        end
-      end
-  end
-end