0
@@ -1,5 +1,8 @@
0
 == master
0
 
0
+* Allow creating transitions with no from state (effectively allowing the transition for *any* from state)
0
+* Reduce the number of objects created for each transition
0
+
0
 == 0.2.0 / 2008-06-29
0
 
0
 * Add a non-bang version of events (e.g. park) that will return a boolean value for success

0
@@ -31,12 +31,13 @@ module PluginAWeek #:nodoc:
0
       # 
0
       # Configuration options:
0
       # * +to+ - The state that being transitioned to
0
-      # * +from+ - A state or array of states that can be transitioned from
0
+      # * +from+ - A state or array of states that can be transitioned from. If not specified, then the transition can occur for *any* from state
0
       # * +if+ - Specifies a method, proc or string to call to determine if the validation 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.
0
       # * +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.
0
       # 
0
       # == Examples
0
       # 
0
+      #   transition :to => 'parked'
0
       #   transition :to => 'parked', :from => 'first_gear'
0
       #   transition :to => 'parked', :from => %w(first_gear reverse)
0
       #   transition :to => 'parked', :from => 'first_gear', :if => :moving?
0
@@ -50,21 +51,19 @@ module PluginAWeek #:nodoc:
0
         to_state = options.delete(:to)
0
         from_states = Array(options.delete(:from))
0
         
0
-        from_states.collect do |from_state|
0
-          # Create the actual transition that will update records when performed
0
-          transition = Transition.new(self, from_state, to_state)
0
-          
0
-          # Add the callback to the model. If the callback fails, then the next
0
-          # available callback for the event will run until one is successful.
0
-          callback = Proc.new {|record, *args| try_transition(transition, false, record, *args)}
0
-          owner_class.send("transition_on_#{name}", callback, options)
0
-          
0
-          # Add the callback! to the model similar to above
0
-          callback = Proc.new {|record, *args| try_transition(transition, true, record, *args)}
0
-          owner_class.send("transition_bang_on_#{name}", callback, options)
0
-          
0
-          transition
0
-        end
0
+        # Create the actual transition that will update records when performed
0
+        transition = Transition.new(self, to_state, *from_states)
0
+        
0
+        # Add the callback to the model. If the callback fails, then the next
0
+        # available callback for the event will run until one is successful.
0
+        callback = Proc.new {|record, *args| try_transition(transition, false, record, *args)}
0
+        owner_class.send("transition_on_#{name}", callback, options)
0
+        
0
+        # Add the callback! to the model similar to above
0
+        callback = Proc.new {|record, *args| try_transition(transition, true, record, *args)}
0
+        owner_class.send("transition_bang_on_#{name}", callback, options)
0
+        
0
+        transition
0
       end
0
       
0
       # Attempts to perform one of the event's transitions for the given record

0
@@ -7,38 +7,37 @@ module PluginAWeek #:nodoc:
0
     # A transition indicates a state change and is described by a condition
0
     # that would need to be fulfilled to enable the transition.  Transitions
0
     # consist of:
0
-    # * The starting state
0
+    # * The starting state(s)
0
     # * The ending state
0
     # * A guard to check if the transition is allowed
0
     class Transition
0
-      # The state from which the transition is being made
0
-      attr_reader :from_state
0
-      
0
       # The state to which the transition is being made
0
       attr_reader :to_state
0
       
0
+      # The states from which the transition can be made
0
+      attr_reader :from_states
0
+      
0
       # The event that caused the transition
0
       attr_reader :event
0
       
0
       delegate  :machine,
0
                   :to => :event
0
       
0
-      def initialize(event, from_state, to_state) #:nodoc:
0
+      def initialize(event, to_state, *from_states) #:nodoc:
0
         @event = event
0
-        @from_state = from_state
0
         @to_state = to_state
0
-        @loopback = from_state == to_state
0
+        @from_states = from_states
0
       end
0
       
0
       # Whether or not this is a loopback transition (i.e. from and to state are the same)
0
-      def loopback?(state = from_state)
0
-        state == to_state
0
+      def loopback?(from_state)
0
+        from_state == to_state
0
       end
0
       
0
       # Determines whether or not this transition can be performed on the given
0
       # states
0
       def can_perform_on?(record)
0
-        !from_state || from_state == record.send(machine.attribute)
0
+        from_states.empty? || from_states.include?(record.send(machine.attribute))
0
       end
0
       
0
       # Runs the actual transition and any callbacks associated with entering

0
@@ -69,12 +69,16 @@ class EventWithTransitionsTest < Test::Unit::TestCase
0
     assert_nothing_raised {@event.transition(:to => 'on')}
0
   end
0
   
0
+  def test_should_allow_transitioning_without_a_state
0
+    assert @event.transition(:to => 'on')
0
+  end
0
+  
0
   def test_should_allow_transitioning_from_a_single_state
0
-    assert_equal [%w(off on)], @event.transition(:to => 'on', :from => 'off').map {|t| [t.from_state, t.to_state]}
0
+    assert @event.transition(:to => 'on', :from => 'off')
0
   end
0
   
0
   def test_should_allow_transitioning_from_multiple_states
0
-    assert_equal [%w(off on), %w(on on)], @event.transition(:to => 'on', :from => %w(off on)).map {|t| [t.from_state, t.to_state]}
0
+    assert @event.transition(:to => 'on', :from => %w(off on))
0
   end
0
   
0
   def teardown
0
@@ -124,12 +128,24 @@ class EventAfterBeingFiredWithTransitionsTest < Test::Unit::TestCase
0
     assert_equal 'off', @switch.state
0
   end
0
   
0
-  def test_should_fire_if_transition_is_matched
0
+  def test_should_fire_if_transition_with_no_from_state_is_matched
0
+    @event.transition :to => 'on'
0
+    assert @event.fire(@switch)
0
+    assert_equal 'on', @switch.state
0
+  end
0
+  
0
+  def test_should_fire_if_transition_with_from_state_is_matched
0
     @event.transition :to => 'on', :from => 'off'
0
     assert @event.fire(@switch)
0
     assert_equal 'on', @switch.state
0
   end
0
   
0
+  def test_should_fire_if_transition_with_multiple_from_states_is_matched
0
+    @event.transition :to => 'on', :from => %w(off on)
0
+    assert @event.fire(@switch)
0
+    assert_equal 'on', @switch.state
0
+  end
0
+  
0
   def test_should_not_fire_if_validation_failed
0
     @event.transition :to => 'on', :from => 'off'
0
     @switch.fail_validation = true

0
@@ -4,34 +4,39 @@ class TransitionTest < Test::Unit::TestCase
0
   def setup
0
     @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
0
     @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
0
-    @transition = PluginAWeek::StateMachine::Transition.new(@event, 'off', 'on')
0
+    @transition = PluginAWeek::StateMachine::Transition.new(@event, 'on')
0
   end
0
   
0
-  def test_should_have_a_from_state
0
-    assert_equal 'off', @transition.from_state
0
+  def test_should_not_have_any_from_states
0
+    assert @transition.from_states.empty?
0
   end
0
   
0
-  def test_should_have_a_to_state
0
-    assert_equal 'on', @transition.to_state
0
+  def test_should_not_be_a_loopback_if_from_state_is_different
0
+    assert !@transition.loopback?('off')
0
   end
0
   
0
-  def test_should_not_be_a_loopback
0
-    assert !@transition.loopback?
0
+  def test_should_have_a_to_state
0
+    assert_equal 'on', @transition.to_state
0
   end
0
   
0
-  def test_should_not_be_able_to_perform_if_record_state_is_not_from_state
0
-    record = new_switch(:state => 'on')
0
-    assert !@transition.can_perform_on?(record)
0
+  def test_should_be_loopback_if_from_state_is_same
0
+    assert @transition.loopback?('on')
0
   end
0
   
0
-  def test_should_be_able_to_perform_if_record_state_is_from_state
0
+  def test_should_be_able_to_perform_on_all_states
0
     record = new_switch(:state => 'off')
0
     assert @transition.can_perform_on?(record)
0
+    
0
+    record = new_switch(:state => 'on')
0
+    assert @transition.can_perform_on?(record)
0
   end
0
   
0
-  def test_should_perform_for_valid_from_state
0
+  def test_should_perform_for_all_states
0
     record = new_switch(:state => 'off')
0
     assert @transition.perform(record)
0
+    
0
+    record = new_switch(:state => 'on')
0
+    assert @transition.perform(record)
0
   end
0
   
0
   def test_should_not_raise_exception_if_not_valid_during_perform
0
@@ -63,58 +68,81 @@ class TransitionTest < Test::Unit::TestCase
0
   end
0
 end
0
 
0
-class TransitionWithoutFromStateTest < Test::Unit::TestCase
0
+class TransitionWithLoopbackTest < Test::Unit::TestCase
0
   def setup
0
     @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
0
     @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
0
-    @transition = PluginAWeek::StateMachine::Transition.new(@event, nil, 'on')
0
+    @transition = PluginAWeek::StateMachine::Transition.new(@event, 'on', 'on')
0
   end
0
   
0
-  def test_should_not_have_a_from_state
0
-    assert_nil @transition.from_state
0
+  def test_should_be_able_to_perform
0
+    record = new_switch(:state => 'on')
0
+    assert @transition.can_perform_on?(record)
0
   end
0
   
0
-  def test_should_be_able_to_perform_on_all_states
0
-    record = new_switch(:state => 'off')
0
-    assert @transition.can_perform_on?(record)
0
-    
0
+  def test_should_perform_for_valid_from_state
0
     record = new_switch(:state => 'on')
0
-    assert @transition.can_perform_on?(record)
0
+    assert @transition.perform(record)
0
   end
0
 end
0
 
0
-class TransitionWithLoopbackTest < Test::Unit::TestCase
0
+class TransitionWithFromStateTest < Test::Unit::TestCase
0
   def setup
0
     @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
0
     @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
0
-    @transition = PluginAWeek::StateMachine::Transition.new(@event, 'on', 'on')
0
+    @transition = PluginAWeek::StateMachine::Transition.new(@event, 'on', 'off')
0
   end
0
   
0
   def test_should_have_a_from_state
0
-    assert_equal 'on', @transition.from_state
0
+    assert_equal ['off'], @transition.from_states
0
   end
0
   
0
-  def test_should_have_a_to_state
0
-    assert_equal 'on', @transition.to_state
0
+  def test_should_not_be_able_to_perform_if_record_state_is_not_from_state
0
+    record = new_switch(:state => 'on')
0
+    assert !@transition.can_perform_on?(record)
0
   end
0
   
0
-  def test_should_be_a_loopback
0
-    assert @transition.loopback?
0
+  def test_should_be_able_to_perform_if_record_state_is_from_state
0
+    record = new_switch(:state => 'off')
0
+    assert @transition.can_perform_on?(record)
0
   end
0
   
0
-  def test_should_not_be_able_to_perform_if_record_state_is_not_from_state
0
+  def test_should_perform_for_valid_from_state
0
     record = new_switch(:state => 'off')
0
+    assert @transition.perform(record)
0
+  end
0
+end
0
+
0
+class TransitionWithMultipleFromStatesTest < Test::Unit::TestCase
0
+  def setup
0
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
0
+    @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
0
+    @transition = PluginAWeek::StateMachine::Transition.new(@event, 'on', 'off', 'on')
0
+  end
0
+  
0
+  def test_should_have_multiple_from_states
0
+    assert_equal ['off', 'on'], @transition.from_states
0
+  end
0
+  
0
+  def test_should_not_be_able_to_perform_if_record_state_is_not_from_state
0
+    record = new_switch(:state => 'unknown')
0
     assert !@transition.can_perform_on?(record)
0
   end
0
   
0
-  def test_should_be_able_to_perform_if_record_is_in_from_state
0
+  def test_should_be_able_to_perform_if_record_state_is_any_from_state
0
+    record = new_switch(:state => 'off')
0
+    assert @transition.can_perform_on?(record)
0
+    
0
     record = new_switch(:state => 'on')
0
     assert @transition.can_perform_on?(record)
0
   end
0
   
0
-  def test_should_perform_for_valid_from_state
0
-    record = new_switch(:state => 'on')
0
+  def test_should_perform_for_any_valid_from_state
0
+    record = new_switch(:state => 'off')
0
     assert @transition.perform(record)
0
+    
0
+    record = new_switch(:state => 'on')
0
+    assert @transition.can_perform_on?(record)
0
   end
0
 end
0
 
0
@@ -122,7 +150,7 @@ class TransitionAfterBeingPerformedTest < Test::Unit::TestCase
0
   def setup
0
     @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
0
     @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
0
-    @transition = PluginAWeek::StateMachine::Transition.new(@event, 'off', 'on')
0
+    @transition = PluginAWeek::StateMachine::Transition.new(@event, 'on', 'off')
0
     
0
     @record = create_switch(:state => 'off')
0
     @transition.perform(@record)
0
@@ -162,7 +190,7 @@ class TransitionWithCallbacksTest < Test::Unit::TestCase
0
   def setup
0
     @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
0
     @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
0
-    @transition = PluginAWeek::StateMachine::Transition.new(@event, 'off', 'on')
0
+    @transition = PluginAWeek::StateMachine::Transition.new(@event, 'on', 'off')
0
     @record = create_switch(:state => 'off')
0
     
0
     Switch.define_callbacks :before_exit_state_off, :before_enter_state_on, :after_exit_state_off, :after_enter_state_on
0
@@ -295,7 +323,7 @@ class TransitionWithoutFromStateAndCallbacksTest < Test::Unit::TestCase
0
   def setup
0
     @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
0
     @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
0
-    @transition = PluginAWeek::StateMachine::Transition.new(@event, nil, 'on')
0
+    @transition = PluginAWeek::StateMachine::Transition.new(@event, 'on')
0
     @record = create_switch(:state => 'off')
0
     
0
     Switch.define_callbacks :before_exit_state_off, :before_enter_state_on, :after_exit_state_off, :after_enter_state_on