lib/state_machine.rb lib/state_machine/event.rb lib/state_machine/machine.rb lib/state_machine/transition.rb test/app_root/app/models/toggle_switch.rb test/factory.rb test/functional/state_machine_test.rb test/unit/machine_test.rb test/unit/state_machine_test.rb test/unit/transition_test.rb @@ -1,5 +1,23 @@ *SVN* +*0.1.0* (May 5th, 2008) + +* Completely rewritten from scratch + +* Renamed to state_machine + +* Removed database dependencies + +* Removed models in favor of an attribute-agnostic design + +* Use ActiveSupport::Callbacks instead of eval_call + +* Remove dry_transaction_rollbacks dependencies + +* Added functional tests + +* Updated documentation + *0.0.1* (September 26th, 2007) * Add dependency on custom_callbacks CHANGELOG @@ -1,4 +1,4 @@ -Copyright (c) 2006 Scott Barron, 2006-2007 Aaron Pfefier & Neil Abraham +Copyright (c) 2006 Scott Barron, 2006-2008 Aaron Pfefier Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the MIT-LICENSE @@ -1,29 +1,24 @@ -== has_states +== state_machine -+has_states+ adds support for managing states, events, and transitions within a -model. ++state_machine+ support for creating state machines for attributes within a model. == Resources -Announcement - -* http://www.pluginaweek.org - Wiki -* http://wiki.pluginaweek.org/Has_states +* http://wiki.pluginaweek.org/State_machine API -* http://api.pluginaweek.org/has_states +* http://api.pluginaweek.org/state_machine Development -* http://dev.pluginaweek.org/browser/trunk/plugins/active_record/has/has_states +* http://dev.pluginaweek.org/browser/trunk/state_machine Source -* http://svn.pluginaweek.org/trunk/plugins/active_record/has/has_states +* http://svn.pluginaweek.org/trunk/state_machine == Description @@ -33,30 +28,53 @@ and deciding how to behave based on the values in those columns. This can becom cumbersome and difficult to maintain when the complexity of your models starts to increase. -+has_states+ simplifies this design by introducing the various parts of a state ++state_machine+ simplifies this design by introducing the various parts of a state machine, including states, events, and transitions. However, its api is designed to be similar to ActiveRecord in terms of validations and callbacks, making it so simple you don't even need to know what a state machine is :) == Usage -=== Running migrations - -To migrate the tables required for has_states, you can either run the -migration from the command line like so: - - rake db:migrate:plugins PLUGIN=has_states - -or (more ideally) generate a migration file that will integrate into your main -application's migration path: - - ruby script/generate plugin_migration has_states - -== Testing - -Before you can run any tests, the following gems must be installed: -* plugin_test_helper[http://wiki.pluginaweek.org/Plugin_test_helper] -* dry_validity_assertions[http://wiki.pluginaweek.org/Dry_validity_assertions] +=== Example + + class Vehicle < ActiveRecord::Base + state_machine :state, :initial => 'idling' do + before_exit 'parked', :put_on_seatbelt + after_enter 'parked', Proc.new {|vehicle| vehicle.update_attribute(:seatbelt_on, false)} + + event :park do + transition :to => 'parked', :from => %w(idling first_gear) + end + + event :ignite do + transition :to => 'stalled', :from => 'stalled' + transition :to => 'idling', :from => 'parked' + end + + event :idle do + transition :to => 'idling', :from => 'first_gear' + end + + event :shift_up do + transition :to => 'first_gear', :from => 'idling' + transition :to => 'second_gear', :from => 'first_gear' + transition :to => 'third_gear', :from => 'second_gear' + end + + event :shift_down do + transition :to => 'second_gear', :from => 'third_gear' + transition :to => 'first_gear', :from => 'second_gear' + end + + event :crash, :after => :tow! do + transition :to => 'stalled', :from => %w(first_gear second_gear third_gear), :unless => :auto_shop_busy? + end + + event :repair, :after => :fix! do + transition :to => 'parked', :from => 'stalled', :if => :auto_shop_busy? + end + end + end == Tools @@ -67,23 +85,12 @@ events for your models. It is cross-platform, written in Java. == Dependencies -This plugin depends on the presence of the following plugins: -* class_associations[http://wiki.pluginaweek.org/Class_associations] -* custom_callbacks[http://wiki.pluginaweek.org/Custom_callbacks] -* dry_transaction_rollbacks[http://wiki.pluginaweek.org/Dry_transaction_callbacks] -* eval_call[http://wiki.pluginaweek.org/Eval_call] - -This plugin is also plugin+. That means that it contains a slice of an -application, such as models and migrations. To test or use a plugin+, you -must have the following plugins/gems installed: -* plugin_dependencies[http://wiki.pluginaweek.org/Plugin_dependencies] -* loaded_plugins[http://wiki.pluginaweek.org/Loaded_plugins] -* appable_plugins[http://wiki.pluginaweek.org/Appable_plugins] -* plugin_migrations[http://wiki.pluginaweek.org/Plugin_migrations] - -Instead of installing each individual plugin+ feature, you can install them all -at once using the plugins+[http://wiki.pluginaweek.org/Plugins_plus] meta package, -which contains all additional features. +None. + +== Testing + +Before you can run any tests, the following gem must be installed: +* plugin_test_helper[http://wiki.pluginaweek.org/Plugin_test_helper] == References README @@ -3,25 +3,25 @@ require 'rake/rdoctask' require 'rake/gempackagetask' require 'rake/contrib/sshpublisher' -PKG_NAME = 'has_states' -PKG_VERSION = '0.0.1' +PKG_NAME = 'state_machine' +PKG_VERSION = '0.1.0' PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}" RUBY_FORGE_PROJECT = 'pluginaweek' desc 'Default: run unit tests.' task :default => :test -desc 'Test the has_states plugin.' +desc 'Test the state_machine plugin.' Rake::TestTask.new(:test) do |t| t.libs << 'lib' - t.pattern = 'test/unit/**/*_test.rb' + t.pattern = 'test/**/*_test.rb' t.verbose = true end -desc 'Generate documentation for the has_states plugin.' +desc 'Generate documentation for the state_machine plugin.' Rake::RDocTask.new(:rdoc) do |rdoc| rdoc.rdoc_dir = 'rdoc' - rdoc.title = 'HasStates' + rdoc.title = 'StateMachine' rdoc.options << '--line-numbers' << '--inline-source' rdoc.rdoc_files.include('README') rdoc.rdoc_files.include('lib/**/*.rb') @@ -31,18 +31,15 @@ spec = Gem::Specification.new do |s| s.name = PKG_NAME s.version = PKG_VERSION s.platform = Gem::Platform::RUBY - s.summary = 'Adds support for managing states, events, and transitions within a model' + s.summary = 'Adds support for creating state machines for attributes within a model' - s.files = FileList['{app,db,lib,test}/**/*'].to_a + %w(CHANGELOG init.rb MIT-LICENSE Rakefile README) + s.files = FileList['{lib,test}/**/*'].to_a + %w(CHANGELOG init.rb MIT-LICENSE Rakefile README) s.require_path = 'lib' - s.autorequire = 'has_states' + s.autorequire = 'state_machine' s.has_rdoc = true - s.test_files = Dir['test/unit/**/*_test.rb'] - s.add_dependency 'class_associations', '>= 0.0.1' - s.add_dependency 'custom_callbacks', '>= 0.0.1' - s.add_dependency 'eval_call', '>= 0.0.1' + s.test_files = Dir['test/**/*_test.rb'] - s.author = 'Aaron Pfeifer, Neil Abraham' + s.author = 'Aaron Pfeifer' s.email = 'info@pluginaweek.org' s.homepage = 'http://www.pluginaweek.org' end Rakefile @@ -1 +1 @@ -require 'has_states' \ No newline at end of file +require 'state_machine' init.rb @@ -1,24 +1,34 @@ class AutoShop < ActiveRecord::Base - has_states :initial => :available, :record_changes => false - - state :available, - :after_exit => :increment_customers - state :busy, - :after_exit => :decrement_customers + state_machine :state, :initial => 'available' do + after_exit 'available', :increment_customers + after_exit 'busy', :decrement_customers + + event :tow_vehicle do + transition :to => 'busy', :from => 'available' + end + + event :fix_vehicle do + transition :to => 'available', :from => 'busy' + end + end - event :tow_vehicle do - transition_to :busy, :from => :available + # Is the Auto Shop available for new customers? + def available? + state == 'available' end - event :fix_vehicle do - transition_to :available, :from => :busy + # Is the Auto Shop currently not taking new customers? + def busy? + state == 'busy' end + # Increments the number of customers in service def increment_customers - update_attribute(:num_customers, self.num_customers + 1) + update_attribute(:num_customers, num_customers + 1) end + # Decrements the number of customers in service def decrement_customers - update_attribute(:num_customers, self.num_customers - 1) + update_attribute(:num_customers, num_customers - 1) end -end \ No newline at end of file +end test/app_root/app/models/auto_shop.rb @@ -1,19 +1,19 @@ class Car < Vehicle - state :backing_up - - event :reverse do - transition_to :backing_up, :from => [:parked, :idling, :first_gear] + state_machine :state do + event :reverse do + transition :to => 'backing_up', :from => %w(parked idling first_gear) + end + + event :park do + transition :to => 'parked', :from => 'backing_up' + end + + event :idle do + transition :to => 'idling', :from => 'backing_up' + end + + event :shift_up do + transition :to => 'first_gear', :from => 'backing_up' + end end - - event :park do - transition_to :parked, :from => :backing_up - end - - event :idle do - transition_to :idling, :from => :backing_up - end - - event :shift_up do - transition_to :first_gear, :from => :backing_up - end -end \ No newline at end of file +end test/app_root/app/models/car.rb @@ -1,3 +1,3 @@ class Motorcycle < Vehicle - self.initial_state = :idling -end \ No newline at end of file + state_machine :state, :initial => 'idling' +end test/app_root/app/models/motorcycle.rb @@ -1,54 +1,12 @@ class Switch < ActiveRecord::Base - cattr_accessor :active_states - cattr_accessor :record_state_changes - attr_accessor :state - attr_reader :callbacks, :state_id, :recorded_event, :recorded_from_state, :recorded_to_state + # Tracks the callbacks that were invoked + attr_reader :callbacks - def initialize - @callbacks = [] - end - - def before_turn_on - @callbacks << 'before_turn_on' - end - - def after_turn_on - @callbacks << 'after_turn_on' - end + # Dynamic sets the initial state + attr_accessor :initial_state - def turn_key - @callbacks << 'turn_key' - end - - def remove_key - @callbacks << 'remove_key' - end - - def return_false - false - end - - def return_true - true - end - - def return_param(param) - param - end - - def callback(method) - @callbacks << method + def initialize(attributes = nil) + @callbacks = [] super end - - def update_attributes!(attrs) - @state_id = attrs[:state_id] - end - - private - def record_state_change(event, from_state, to_state) - @recorded_event = event.record if event - @recorded_from_state = from_state.record if from_state - @recorded_to_state = to_state.record if to_state - end end test/app_root/app/models/switch.rb @@ -1,71 +1,71 @@ class Vehicle < ActiveRecord::Base - has_states :initial => Proc.new {|vehicle| vehicle.force_idle? ? :idling : :parked} - belongs_to :auto_shop - delegate :tow_vehicle!, :fix_vehicle!, :to => :auto_shop + belongs_to :highway attr_accessor :force_idle - validates_presence_of :highway_id - - state :parked, - :before_exit => :put_on_seatbelt, - :after_enter => Proc.new {|vehicle| vehicle.update_attribute(:seatbelt_on, false)} - state :idling, - :first_gear, - :second_gear, - :third_gear - state :stalled, - :before_enter => :increase_insurance_premium - - event :park do - transition_to :parked, :from => [:idling, :first_gear] - end - - event :ignite do - transition_to :stalled, :from => :stalled - transition_to :idling, :from => :parked - end - - event :idle do - transition_to :idling, :from => :first_gear - end - - event :shift_up do - transition_to :first_gear, :from => :idling - transition_to :second_gear, :from => :first_gear - transition_to :third_gear, :from => :second_gear + # Defines the state machine for the state of the vehicle + 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 + + event :park do + transition :to => 'parked', :from => %w(idling first_gear) + end + + event :ignite do + transition :to => 'stalled', :from => 'stalled' + transition :to => 'idling', :from => 'parked' + end + + event :idle do + transition :to => 'idling', :from => 'first_gear' + end + + event :shift_up do + transition :to => 'first_gear', :from => 'idling' + transition :to => 'second_gear', :from => 'first_gear' + transition :to => 'third_gear', :from => 'second_gear' + end + + event :shift_down do + transition :to => 'second_gear', :from => 'third_gear' + 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?} + end + + event :repair, :after => :fix! do + transition :to => 'parked', :from => 'stalled', :if => :auto_shop_busy? + end end - event :shift_down do - transition_to :second_gear, :from => :third_gear - transition_to :first_gear, :from => :second_gear + # Tows the vehicle to the auto shop + def tow! + auto_shop.tow_vehicle! end - event :crash, :after => :tow_vehicle! do - transition_to :stalled, :from => [:first_gear, :second_gear, :third_gear], - :if => Proc.new {|vehicle| vehicle.auto_shop.available?} - end - - event :repair, :after => :fix_vehicle! do - transition_to :parked, :from => :stalled, - :if => :auto_shop_busy? - end - - def force_idle? - @force_idle + # Fixes the vehicle; it will no longer be in the auto shop + def fix! + auto_shop.fix_vehicle! end private - def put_on_seatbelt - self.seatbelt_on = true - end - - def increase_insurance_premium - update_attribute(:insurance_premium, self.insurance_premium + 100) - end - - def auto_shop_busy? - auto_shop.busy? - end -end \ No newline at end of file + # Safety first! Puts on our seatbelt + def put_on_seatbelt + self.seatbelt_on = true + end + + # We crashed! Increase the insurance premium on the vehicle + def increase_insurance_premium + update_attribute(:insurance_premium, self.insurance_premium + 100) + end + + # Is the auto shop currently servicing another customer? + def auto_shop_busy? + auto_shop.busy? + end +end test/app_root/app/models/vehicle.rb @@ -1,15 +1,12 @@ class CreateSwitches < ActiveRecord::Migration def self.up create_table :switches do |t| - t.column :device, :string, :null => false, :default => 'light' + t.string :state, :null => false + t.string :kind end - - PluginAWeek::Has::States.migrate_up(:switches) end def self.down - PluginAWeek::Has::States.migrate_down(:switches) - drop_table :switches end -end \ No newline at end of file +end test/app_root/db/migrate/001_create_switches.rb @@ -1,16 +1,13 @@ class CreateAutoShops < ActiveRecord::Migration def self.up create_table :auto_shops do |t| - t.column :name, :string, :null => false - t.column :num_customers, :integer, :null => false, :default => 0 + t.string :name, :null => false + t.integer :num_customers, :null => false + t.string :state, :null => false end - - PluginAWeek::Has::States.migrate_up(:auto_shops) end def self.down - PluginAWeek::Has::States.migrate_down(:switches) - drop_table :auto_shops end -end \ No newline at end of file +end test/app_root/db/migrate/002_create_auto_shops.rb @@ -1,11 +1,11 @@ class CreateHighways < ActiveRecord::Migration def self.up create_table :highways do |t| - t.column :name, :string, :null => false + t.string :name, :null => false end end def self.down drop_table :highways end -end \ No newline at end of file +end test/app_root/db/migrate/003_create_highways.rb @@ -1,19 +1,16 @@ class CreateVehicles < ActiveRecord::Migration def self.up create_table :vehicles do |t| - t.column :highway_id, :integer, :null => false, :default => 1 - t.column :auto_shop_id, :integer, :null => false, :default => 1 - t.column :seatbelt_on, :boolean, :null => false, :default => true - t.column :insurance_premium, :integer, :null => false, :default => 50 - t.column :type, :string + t.references :highway, :null => false + t.references :auto_shop, :null => false + t.boolean :seatbelt_on, :null => false + t.integer :insurance_premium, :null => false + t.string :state, :null => false + t.string :type end - - PluginAWeek::Has::States.migrate_up(:vehicles) end def self.down - PluginAWeek::Has::States.migrate_down(:vehicles) - drop_table :vehicles end -end \ No newline at end of file +end test/app_root/db/migrate/004_create_vehicles.rb @@ -1,25 +1,13 @@ -# Load local repository plugin paths -$:.unshift("#{File.dirname(__FILE__)}/../../../associations/class_associations/lib") -$:.unshift("#{File.dirname(__FILE__)}/../../../miscellaneous/custom_callbacks/lib") -$:.unshift("#{File.dirname(__FILE__)}/../../../miscellaneous/dry_transaction_rollbacks/lib") -$:.unshift("#{File.dirname(__FILE__)}/../../../../ruby/object/eval_call/lib") - # Load the plugin testing framework -$:.unshift("#{File.dirname(__FILE__)}/../../../../test/plugin_test_helper/lib") +$:.unshift("#{File.dirname(__FILE__)}/../../plugin_test_helper/lib") require 'rubygems' require 'plugin_test_helper' -PluginAWeek::PluginMigrations.migrate('has_states') - # Run the migrations ActiveRecord::Migrator.migrate("#{RAILS_ROOT}/db/migrate") +# Mixin the factory helper +require File.expand_path("#{File.dirname(__FILE__)}/factory") class Test::Unit::TestCase #:nodoc: - fixtures :states, :events - - def self.require_fixture_classes(table_names=nil) - # Don't allow fixture classes to be required because classes like Switch are - # going to throw an error since the states and events have not yet been - # loaded - end + include Factory end test/test_helper.rb @@ -1,40 +1,234 @@ -require File.dirname(__FILE__) + '/../test_helper' +require File.expand_path(File.dirname(__FILE__) + '/../test_helper') class EventTest < Test::Unit::TestCase - fixtures :state_changes + def setup + @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off') + @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on') + end + + def test_should_have_a_machine + assert_equal @machine, @event.machine + end + + def test_should_have_a_name + assert_equal 'turn_on', @event.name + end + + def test_should_define_an_event_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_be_valid - assert_valid events(:switch_turn_on) + def test_should_define_before_event_callbacks + assert Switch.respond_to?(:before_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') + end + + def test_should_raise_exception + assert_raise(ArgumentError) {PluginAWeek::StateMachine::Event.new(@machine, 'turn_on', :invalid => true)} + end +end + +class EventWithTransitionsTest < Test::Unit::TestCase + def setup + @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off') + @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on') end - def test_should_require_name - assert_invalid events(:switch_turn_on), :name, nil + def test_should_raise_exception_if_invalid_option_specified + assert_raise(ArgumentError) {@event.transition(:invalid => true)} end - def test_should_require_unique_name - assert_invalid events(:switch_turn_on).clone, :name + def test_should_raise_exception_if_to_option_not_specified + assert_raise(ArgumentError) {@event.transition(:from => 'off')} + end + + def test_should_not_raise_exception_if_from_option_not_specified + assert_nothing_raised {@event.transition(:to => 'on')} + end + + def test_should_allow_transitioning_from_a_single_state + assert_equal [%w(off on)], @event.transition(:to => 'on', :from => 'off').map {|t| [t.from_state, t.to_state]} + end + + def test_should_allow_transitioning_from_multiple_states + assert_equal [%w(off on), %w(on on)], @event.transition(:to => 'on', :from => %w(off on)).map {|t| [t.from_state, t.to_state]} + end + + def teardown + Switch.class_eval do + @transition_on_turn_on_callbacks = nil + end + end +end + +class EventAfterBeingFiredWithNoTransitionsTest < 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_fire + assert !@event.fire!(@switch) + end + + def test_should_not_change_the_current_state + @event.fire!(@switch) + assert_equal 'off', @switch.state + end +end + +class EventAfterBeingFiredWithTransitionsTest < Test::Unit::TestCase + def setup + @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off') + @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on') + @event.transition :to => 'error', :from => 'on' + @switch = create_switch(:state => 'off') end - def test_should_have_state_changes_association - event = events(:project_design) - expected = [ - state_changes(:rss_reader_design) - ] + def test_should_not_fire_if_no_transitions_are_matched + assert !@event.fire!(@switch) + assert_equal 'off', @switch.state + end + + def test_should_fire_if_transition_is_matched + @event.transition :to => 'on', :from => 'off' + assert @event.fire!(@switch) + assert_equal 'on', @switch.state + end + + def teardown + Switch.class_eval do + @transition_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') + @event.transition :to => 'if_not_evaluated', :from => 'off', :if => Proc.new {false} + @event.transition :to => 'unless_not_evaluated', :from => 'off', :unless => Proc.new {true} + @event.transition :to => 'no_record', :from => 'off', :if => Proc.new {|record, value| record.nil?} + @event.transition :to => 'no_arguments', :from => 'off', :if => Proc.new {|record, value| value.nil?} + + @switch = create_switch(:state => 'off') + end + + def test_should_not_fire_of_no_transitions_are_matched + assert !@event.fire!(@switch, 1) + assert_equal 'off', @switch.state + end + + def test_should_fire_if_transition_is_matched + @event.transition :to => 'on', :from => 'off', :if => Proc.new {|record, value| value == 1} + assert @event.fire!(@switch, 1) + assert_equal 'on', @switch.state + end + + def teardown + Switch.class_eval do + @transition_on_turn_on_callbacks = nil + end + end +end + +class EventWithinTransactionTest < Test::Unit::TestCase + def setup + @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off') + @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on') + @event.transition :to => 'on', :from => 'off' + @switch = create_switch(:state => 'off') + + Switch.define_callbacks :after_enter_state_on + end + + def test_should_save_all_records_within_transaction_if_performed + Switch.after_enter_state_on Proc.new {|record| Switch.create(:state => 'pending'); true} + assert @event.fire!(@switch) + assert_equal 'on', @switch.state + assert_equal 'pending', Switch.find(:all).last.state + end + + uses_transaction :test_should_rollback_all_records_within_transaction_if_not_performed + def test_should_rollback_all_records_within_transaction_if_not_performed + Switch.after_enter_state_on Proc.new {|record| Switch.create(:state => 'pending'); false} + assert !@event.fire!(@switch) + assert_equal 1, Switch.count + ensure + Switch.destroy_all + end + + def teardown + Switch.class_eval do + @transition_on_turn_on_callbacks = nil + @after_enter_state_on_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') - assert_equal expected, event.state_changes + Switch.define_callbacks :before_turn_on, :after_turn_on end - def test_should_use_name_as_default_human_name - event = Event.new(:name => 'test') - assert_equal 'Test', event.human_name + 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 %w(), @record.callbacks + end + + def test_should_not_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_use_custom_human_name_if_specified - event = Event.new(:name => 'test', :human_name => 'Custom') - assert_equal 'Custom', event.human_name + 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 test_should_convert_to_symbol - assert_equal :turn_on, events(:switch_turn_on).to_sym + def teardown + Switch.class_eval do + @before_turn_on_callbacks = nil + @after_turn_on_callbacks = nil + @transition_on_turn_on_callbacks = nil + end end -end \ No newline at end of file +end test/unit/event_test.rb app/models/event.rb app/models/state.rb app/models/state_change.rb db/migrate/001_create_states.rb db/migrate/002_create_events.rb db/migrate/003_create_state_changes.rb lib/has_states.rb lib/has_states/active_event.rb lib/has_states/active_state.rb lib/has_states/state_transition.rb test/app_root/app/models/message.rb test/app_root/app/models/project.rb test/app_root/app/models/task.rb test/app_root/config/environment.rb test/app_root/db/migrate/005_create_messages.rb test/app_root/db/migrate/006_create_projects.rb test/app_root/db/migrate/007_create_tasks.rb test/fixtures/auto_shops.yml test/fixtures/events.yml test/fixtures/highways.yml test/fixtures/messages.yml test/fixtures/projects.yml test/fixtures/state_changes.yml test/fixtures/states.yml test/fixtures/switches.yml test/fixtures/vehicles.yml test/unit/active_event_test.rb test/unit/active_state_test.rb test/unit/event_not_active_test.rb test/unit/event_not_found_test.rb test/unit/has_states_test.rb test/unit/no_initial_state_test.rb test/unit/state_already_active_test.rb test/unit/state_change_test.rb test/unit/state_not_active_test.rb test/unit/state_not_found_test.rb test/unit/state_test.rb test/unit/state_transition_test.rb 1c257492a5efdd15e92d4239a4e94b6a19e4e709 Aaron Pfeifer aaron.pfeifer@gmail.com http://github.com/pluginaweek/state_machine/commit/f3565041379fdcfd94cce18438c361e942bcdddb f3565041379fdcfd94cce18438c361e942bcdddb 2008-05-04T15:58:57-07:00 2008-05-04T15:58:57-07:00 Completely rewritten from scratch Renamed to state_machine Removed database dependencies Removed models in favor of an attribute-agnostic design Use ActiveSupport::Callbacks instead of eval_call Remove dry_transaction_rollbacks dependencies Added functional tests Updated documentation ee1f6486117baa3ffe86be24beac10a1d7755eec Aaron Pfeifer aaron.pfeifer@gmail.com