state_machine 0.2.1 → 0.3.0

data/test/app_root/app/models/auto_shop.rb

@@ -1,7 +1,7 @@
 class AutoShop < ActiveRecord::Base
   state_machine :state, :initial => 'available' do
-    after_exit 'available', :increment_customers
-    after_exit 'busy', :decrement_customers
+    after_transition :from => 'available', :do => :increment_customers
+    after_transition :from => 'busy', :do => :decrement_customers
     
     event :tow_vehicle do
       transition :to => 'busy', :from => 'available'

data/test/app_root/app/models/switch_observer.rb

@@ -0,0 +1,20 @@
+class SwitchObserver < ActiveRecord::Observer
+  cattr_accessor :notifications
+  self.notifications = []
+  
+  def before_turn_on(switch, from_state, to_state)
+    notifications << ['before_turn_on', switch, from_state, to_state]
+  end
+  
+  def after_turn_on(switch, from_state, to_state)
+    notifications << ['after_turn_on', switch, from_state, to_state]
+  end
+  
+  def before_transition(switch, attribute, event, from_state, to_state)
+    notifications << ['before_transition', switch, attribute, event, from_state, to_state]
+  end
+  
+  def after_transition(switch, attribute, event, from_state, to_state)
+    notifications << ['after_transition', switch, attribute, event, from_state, to_state]
+  end
+end

data/test/app_root/app/models/vehicle.rb

@@ -3,12 +3,19 @@ class Vehicle < ActiveRecord::Base
   belongs_to :highway
   
   attr_accessor :force_idle
+  attr_accessor :callbacks
   
-  # Defines the state machine for the state of the vehicle
+  # Defines the state machine for the state of the vehicled
   state_machine :state, :initial => Proc.new {|vehicle| vehicle.force_idle ? 'idling' : 'parked'} do
-    before_exit   'parked', :put_on_seatbelt
-    after_enter   'parked', Proc.new {|vehicle| vehicle.update_attribute(:seatbelt_on, false)}
-    before_enter  'stalled', :increase_insurance_premium
+    before_transition :from => 'parked', :do => :put_on_seatbelt
+    before_transition :to => 'stalled', :do => :increase_insurance_premium
+    after_transition :to => 'parked', :do => lambda {|vehicle| vehicle.update_attribute(:seatbelt_on, false)}
+    after_transition :on => 'crash', :do => :tow!
+    after_transition :on => 'repair', :do => :fix!
+    
+    # Callback tracking for initial state callbacks
+    after_transition :to => 'parked', :do => lambda {|vehicle| (vehicle.callbacks ||= []) << 'before_enter_parked'}
+    before_transition :to => 'idling', :do => lambda {|vehicle| (vehicle.callbacks ||= []) << 'before_enter_idling'}
     
     event :park do
       transition :to => 'parked', :from => %w(idling first_gear)
@@ -34,11 +41,11 @@ class Vehicle < ActiveRecord::Base
       transition :to => 'first_gear', :from => 'second_gear'
     end
     
-    event :crash, :after => :tow! do
-      transition :to => 'stalled', :from => %w(first_gear second_gear third_gear), :if => Proc.new {|vehicle| vehicle.auto_shop.available?}
+    event :crash do
+      transition :to => 'stalled', :from => %w(first_gear second_gear third_gear), :if => lambda {|vehicle| vehicle.auto_shop.available?}
     end
     
-    event :repair, :after => :fix! do
+    event :repair do
       transition :to => 'parked', :from => 'stalled', :if => :auto_shop_busy?
     end
   end

data/test/app_root/config/environment.rb

@@ -0,0 +1,7 @@
+require 'config/boot'
+
+Rails::Initializer.run do |config|
+  config.cache_classes = false
+  config.whiny_nils = true
+  config.active_record.observers = :switch_observer
+end

data/test/factory.rb

@@ -56,6 +56,12 @@ module Factory
     )
   end
   
+  build ToggleSwitch do |attributes|
+    attributes.reverse_merge!(
+      :state => 'off'
+    )
+  end
+  
   build Vehicle do |attributes|
     attributes[:highway] = create_highway unless attributes.include?(:highway)
     attributes[:auto_shop] = create_auto_shop unless attributes.include?(:auto_shop)

data/test/functional/state_machine_test.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 class VehicleTest < Test::Unit::TestCase
   def setup
-    @vehicle = create_vehicle
+    @vehicle = new_vehicle
   end
   
   def test_should_not_allow_access_to_subclass_events
@@ -10,6 +10,58 @@ class VehicleTest < Test::Unit::TestCase
   end
 end
 
+class VehicleUnsavedTest < Test::Unit::TestCase
+  def setup
+    @vehicle = new_vehicle
+  end
+  
+  def test_should_be_in_parked_state
+    assert_equal 'parked', @vehicle.state
+  end
+  
+  def test_should_not_be_able_to_park
+    assert !@vehicle.can_park?
+  end
+  
+  def test_should_not_allow_park
+    assert !@vehicle.park
+  end
+  
+  def test_should_be_able_to_ignite
+    assert @vehicle.can_ignite?
+  end
+  
+  def test_should_allow_ignite
+    assert @vehicle.ignite
+    assert_equal 'idling', @vehicle.state
+  end
+  
+  def test_should_be_saved_after_successful_event
+    @vehicle.ignite
+    assert !@vehicle.new_record?
+  end
+  
+  def test_should_not_allow_idle
+    assert !@vehicle.idle
+  end
+  
+  def test_should_not_allow_shift_up
+    assert !@vehicle.shift_up
+  end
+  
+  def test_should_not_allow_shift_down
+    assert !@vehicle.shift_down
+  end
+  
+  def test_should_not_allow_crash
+    assert !@vehicle.crash
+  end
+  
+  def test_should_not_allow_repair
+    assert !@vehicle.repair
+  end
+end
+
 class VehicleParkedTest < Test::Unit::TestCase
   def setup
     @vehicle = create_vehicle

data/test/unit/event_test.rb

@@ -2,8 +2,10 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 class EventTest < Test::Unit::TestCase
   def setup
-    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
     @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
+    
+    @switch = new_switch
   end
   
   def test_should_have_a_machine
@@ -19,43 +21,23 @@ class EventTest < Test::Unit::TestCase
   end
   
   def test_should_define_an_event_action_on_the_owner_class
-    switch = new_switch
-    assert switch.respond_to?(:turn_on)
+    assert @switch.respond_to?(:turn_on)
   end
   
   def test_should_define_an_event_bang_action_on_the_owner_class
-    switch = new_switch
-    assert switch.respond_to?(:turn_on!)
-  end
-  
-  def test_should_define_transition_callbacks
-    assert Switch.respond_to?(:transition_on_turn_on)
-  end
-  
-  def test_should_define_transition_bang_callbacks
-    assert Switch.respond_to?(:transition_bang_on_turn_on)
-  end
-  
-  def test_should_define_before_event_callbacks
-    assert Switch.respond_to?(:before_turn_on)
+    assert @switch.respond_to?(:turn_on!)
   end
   
-  def test_should_define_after_event_callbacks
-    assert Switch.respond_to?(:after_turn_on)
-  end
-end
-
-class EventWithInvalidOptionsTest < Test::Unit::TestCase
-  def setup
-    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
+  def test_should_define_an_event_predicate_on_the_owner_class
+    assert @switch.respond_to?(:can_turn_on?)
   end
   
-  def test_should_raise_exception
+  def test_should_raise_exception_if_invalid_option_specified
     assert_raise(ArgumentError) {PluginAWeek::StateMachine::Event.new(@machine, 'turn_on', :invalid => true)}
   end
 end
 
-class EventWithTransitionsTest < Test::Unit::TestCase
+class EventDefiningTransitionsTest < Test::Unit::TestCase
   def setup
     @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
     @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
@@ -73,7 +55,7 @@ class EventWithTransitionsTest < Test::Unit::TestCase
     assert_nothing_raised {@event.transition(:to => 'on')}
   end
   
-  def test_should_allow_transitioning_without_a_state
+  def test_should_allow_transitioning_without_a_from_state
     assert @event.transition(:to => 'on')
   end
   
@@ -86,25 +68,34 @@ class EventWithTransitionsTest < Test::Unit::TestCase
   end
   
   def test_should_have_transitions
-    @event.transition(:to => 'on')
-    assert @event.transitions.any?
+    transition = @event.transition(:to => 'on')
+    assert_equal [transition], @event.transitions
+  end
+end
+
+class EventAfterBeingCopiedTest < Test::Unit::TestCase
+  def setup
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
+    @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
+    @copied_event = @event.dup
   end
   
-  def teardown
-    Switch.class_eval do
-      @transition_on_turn_on_callbacks = nil
-      @transition_bang_on_turn_on_callbacks = nil
-    end
+  def test_should_not_have_the_same_collection_of_transitions
+    assert_not_same @copied_event.transitions, @event.transitions
   end
 end
 
-class EventAfterBeingFiredWithNoTransitionsTest < Test::Unit::TestCase
+class EventWithoutTransitionsTest < Test::Unit::TestCase
   def setup
     @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
     @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
     @switch = create_switch(:state => 'off')
   end
   
+  def test_should_not_be_able_to_fire
+    assert !@event.can_fire?(@switch)
+  end
+  
   def test_should_not_fire
     assert !@event.fire(@switch)
   end
@@ -119,7 +110,7 @@ class EventAfterBeingFiredWithNoTransitionsTest < Test::Unit::TestCase
   end
 end
 
-class EventAfterBeingFiredWithTransitionsTest < Test::Unit::TestCase
+class EventWithTransitionsTest < Test::Unit::TestCase
   def setup
     @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
     @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
@@ -127,6 +118,10 @@ class EventAfterBeingFiredWithTransitionsTest < Test::Unit::TestCase
     @switch = create_switch(:state => 'off')
   end
   
+  def test_should_not_be_able_to_fire_if_no_transitions_are_matched
+    assert !@event.can_fire?(@switch)
+  end
+  
   def test_should_not_fire_if_no_transitions_are_matched
     assert !@event.fire(@switch)
     assert_equal 'off', @switch.state
@@ -137,7 +132,12 @@ class EventAfterBeingFiredWithTransitionsTest < Test::Unit::TestCase
     assert_equal 'off', @switch.state
   end
   
-  def test_should_fire_if_transition_with_no_from_state_is_matched
+  def test_should_be_able_to_fire_if_transition_is_matched
+    @event.transition :to => 'on'
+    assert @event.can_fire?(@switch)
+  end
+  
+  def test_should_fire_if_transition_is_matched
     @event.transition :to => 'on'
     assert @event.fire(@switch)
     assert_equal 'on', @switch.state
@@ -190,81 +190,6 @@ class EventAfterBeingFiredWithTransitionsTest < Test::Unit::TestCase
     assert @event.fire!(@switch)
     assert_equal 'on', @switch.state
   end
-  
-  def teardown
-    Switch.class_eval do
-      @transition_on_turn_on_callbacks = nil
-      @transition_bang_on_turn_on_callbacks = nil
-    end
-  end
-end
-
-class EventAfterBeingFiredWithConditionalTransitionsTest < Test::Unit::TestCase
-  def setup
-    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
-    @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
-    @switch = create_switch(:state => 'off')
-  end
-  
-  def test_should_fire_if_if_is_true
-    @event.transition :to => 'on', :from => 'off', :if => Proc.new {true}
-    assert @event.fire(@switch)
-  end
-  
-  def test_should_not_fire_if_if_is_false
-    @event.transition :to => 'on', :from => 'off', :if => Proc.new {false}
-    assert !@event.fire(@switch)
-  end
-  
-  def test_should_fire_if_unless_is_false
-    @event.transition :to => 'on', :from => 'off', :unless => Proc.new {false}
-    assert @event.fire(@switch)
-  end
-  
-  def test_should_not_fire_if_unless_is_true
-    @event.transition :to => 'on', :from => 'off', :unless => Proc.new {true}
-    assert !@event.fire(@switch)
-  end
-  
-  def test_should_pass_in_record_as_argument
-    @event.transition :to => 'on', :from => 'off', :if => Proc.new {|record, value| !record.nil?}
-    assert @event.fire(@switch)
-  end
-  
-  def test_should_pass_in_value_as_argument
-    @event.transition :to => 'on', :from => 'off', :if => Proc.new {|record, value| value == 1}
-    assert @event.fire(@switch, 1)
-  end
-  
-  def test_should_fire_if_method_evaluates_to_true
-    @switch.data = true
-    @event.transition :to => 'on', :from => 'off', :if => :data
-    assert @event.fire(@switch)
-  end
-  
-  def test_should_not_fire_if_method_evaluates_to_false
-    @switch.data = false
-    @event.transition :to => 'on', :from => 'off', :if => :data
-    assert !@event.fire(@switch)
-  end
-  
-  def test_should_raise_exception_if_no_transitions_are_matched
-    assert_raise(PluginAWeek::StateMachine::InvalidTransition) {@event.fire!(@switch, 1)}
-    assert_equal 'off', @switch.state
-  end
-  
-  def test_should_not_raise_exception_if_transition_is_matched
-    @event.transition :to => 'on', :from => 'off', :if => Proc.new {true}
-    assert @event.fire!(@switch)
-    assert_equal 'on', @switch.state
-  end
-  
-  def teardown
-    Switch.class_eval do
-      @transition_on_turn_on_callbacks = nil
-      @transition_bang_on_turn_on_callbacks = nil
-    end
-  end
 end
 
 class EventWithinTransactionTest < Test::Unit::TestCase
@@ -274,11 +199,11 @@ class EventWithinTransactionTest < Test::Unit::TestCase
     @event.transition :to => 'on', :from => 'off'
     @switch = create_switch(:state => 'off')
     
-    Switch.define_callbacks :before_exit_state_off
+    Switch.define_callbacks :before_transition_state
   end
   
   def test_should_save_all_records_within_transaction_if_performed
-    Switch.before_exit_state_off Proc.new {|record| Switch.create(:state => 'pending'); true}
+    Switch.before_transition_state lambda {|record| Switch.create(:state => 'pending'); true}, :from => 'off'
     assert @event.fire(@switch)
     assert_equal 'on', @switch.state
     assert_equal 'pending', Switch.find(:all).last.state
@@ -286,7 +211,7 @@ class EventWithinTransactionTest < Test::Unit::TestCase
   
   uses_transaction :test_should_rollback_all_records_within_transaction_if_not_performed
   def test_should_rollback_all_records_within_transaction_if_not_performed
-    Switch.before_exit_state_off Proc.new {|record| Switch.create(:state => 'pending'); false}
+    Switch.before_transition_state lambda {|record| Switch.create(:state => 'pending'); false}, :from => 'off'
     assert !@event.fire(@switch)
     assert_equal 1, Switch.count
   ensure
@@ -295,7 +220,7 @@ class EventWithinTransactionTest < Test::Unit::TestCase
   
   uses_transaction :test_should_rollback_all_records_within_transaction_if_not_performed!
   def test_should_rollback_all_records_within_transaction_if_not_performed!
-    Switch.before_exit_state_off Proc.new {|record| Switch.create(:state => 'pending'); false}
+    Switch.before_transition_state lambda {|record| Switch.create(:state => 'pending'); false}, :from => 'off'
     assert_raise(PluginAWeek::StateMachine::InvalidTransition) {@event.fire!(@switch)}
     assert_equal 1, Switch.count
   ensure
@@ -304,77 +229,7 @@ class EventWithinTransactionTest < Test::Unit::TestCase
   
   def teardown
     Switch.class_eval do
-      @transition_on_turn_on_callbacks = nil
-      @transition_bang_on_turn_on_callbacks = nil
-      @before_exit_state_off_callbacks = nil
-    end
-  end
-end
-
-class EventWithCallbacksTest < Test::Unit::TestCase
-  def setup
-    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
-    @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
-    @event.transition :from => 'off', :to => 'on'
-    @record = create_switch(:state => 'off')
-    
-    Switch.define_callbacks :before_turn_on, :after_turn_on
-  end
-  
-  def test_should_not_perform_if_before_callback_fails
-    Switch.before_turn_on Proc.new {|record| false}
-    Switch.after_turn_on Proc.new {|record| record.callbacks << 'after'; true}
-    
-    assert !@event.fire(@record)
-    assert_equal [], @record.callbacks
-  end
-  
-  def test_should_raise_exception_if_before_callback_fails_during_perform!
-    Switch.before_turn_on Proc.new {|record| false}
-    Switch.after_turn_on Proc.new {|record| record.callbacks << 'after'; true}
-    
-    assert_raise(PluginAWeek::StateMachine::InvalidTransition) {@event.fire!(@record)}
-    assert_equal [], @record.callbacks
-  end
-  
-  def test_should_perform_if_after_callback_fails
-    Switch.before_turn_on Proc.new {|record| record.callbacks << 'before'; true}
-    Switch.after_turn_on Proc.new {|record| false}
-    
-    assert @event.fire(@record)
-    assert_equal %w(before), @record.callbacks
-  end
-  
-  def test_should_not_raise_exception_if_after_callback_fails_during_perform!
-    Switch.before_turn_on Proc.new {|record| record.callbacks << 'before'; true}
-    Switch.after_turn_on Proc.new {|record| false}
-    
-    assert @event.fire!(@record)
-    assert_equal %w(before), @record.callbacks
-  end
-  
-  def test_should_perform_if_all_callbacks_are_successful
-    Switch.before_turn_on Proc.new {|record| record.callbacks << 'before'; true}
-    Switch.after_turn_on Proc.new {|record| record.callbacks << 'after'; true}
-    
-    assert @event.fire(@record)
-    assert_equal %w(before after), @record.callbacks
-  end
-  
-  def test_should_pass_additional_arguments_to_callbacks
-    Switch.before_turn_on Proc.new {|record, value| record.callbacks << "before-#{value}"; true}
-    Switch.after_turn_on Proc.new {|record, value| record.callbacks << "after-#{value}"; true}
-    
-    assert @event.fire(@record, 'light')
-    assert_equal %w(before-light after-light), @record.callbacks
-  end
-  
-  def teardown
-    Switch.class_eval do
-      @before_turn_on_callbacks = nil
-      @after_turn_on_callbacks = nil
-      @transition_on_turn_on_callbacks = nil
-      @transition_bang_on_turn_on_callbacks = nil
+      @before_transition_state_callbacks = nil
     end
   end
 end