state_machine 0.8.0 → 0.8.1

data/lib/state_machine/machine_collection.rb

@@ -5,10 +5,14 @@ module StateMachine
     # 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, options = {})
+      if ignore = options[:ignore]
+        ignore.map! {|attribute| attribute.to_sym}
+      end
+      
       each_value do |machine|
-        if !options.include?(:dynamic) || machine.dynamic_initial_state? == options[:dynamic]
+        if (!ignore || !ignore.include?(machine.attribute)) && (!options.include?(:dynamic) || machine.dynamic_initial_state? == options[:dynamic])
           value = machine.read(object, :state)
-          machine.write(object, :state, machine.initial_state(object).value) if value.nil? || value.respond_to?(:empty?) && value.empty?
+          machine.write(object, :state, machine.initial_state(object).value) if ignore || value.nil? || value.respond_to?(:empty?) && value.empty?
         end
       end
     end
@@ -117,28 +121,31 @@ module StateMachine
       
       # Make sure all events were valid
       if result = transitions.all? {|transition| transition != false}
+        # Clear any traces of the event since transitions are available and to
+        # prevent from being evaluated multiple times if actions are nested
+        transitions.each do |transition|
+          transition.machine.write(object, :event, nil)
+          transition.machine.write(object, :event_transition, nil)
+        end
+        
+        # Perform the transitions
         begin
-          result = Transition.perform(transitions, :after => complete) do
-            # Prevent events from being evaluated multiple times if actions are nested
-            transitions.each {|transition| transition.machine.write(object, :event, nil)}
-            action_value = yield
-          end
+          result = Transition.perform(transitions, :after => complete) { action_value = yield }
         rescue Exception
-          # Revert object modifications
+          # Reset the event attribute so it can be re-evaluated if attempted again
           transitions.each do |transition|
             transition.machine.write(object, :event, transition.event)
-            transition.machine.write(object, :event_transition, nil) if complete
           end
           
           raise
         end
         
         transitions.each do |transition|
-          # Revert event unless transition was successful
-          transition.machine.write(object, :event, transition.event) unless complete && result
+          # Revert event if failed (to allow for more attempts)
+          transition.machine.write(object, :event, transition.event) unless result
           
-          # Track transition if partial transition completed successfully
-          transition.machine.write(object, :event_transition, !complete && result ? transition : nil)
+          # Track transition if partial transition was successful
+          transition.machine.write(object, :event_transition, transition) if !complete && result
         end
       end
       

data/lib/state_machine/state.rb

@@ -168,7 +168,7 @@ module StateMachine
         # 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)
+            self.class.state_machine(#{machine_name.inspect}).states.match!(self).call(self, #{method.inspect}, lambda {super}, *args, &block)
           end
         end_eval
       end
@@ -185,13 +185,13 @@ module StateMachine
     # 
     # If the method has never been defined for this state, then a NoMethodError
     # will be raised.
-    def call(object, method, *args, &block)
+    def call(object, method, method_missing = nil, *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}"
+        # Dispatch to the superclass since this state doesn't handle the method
+        method_missing.call if method_missing
       end
     end
     

data/{tasks → lib/tasks}/state_machine.rb

@@ -2,7 +2,7 @@ namespace :state_machine do
   desc 'Draws a set of state machines using GraphViz. Target files to load with FILE=x,y,z; Machine class with CLASS=x,y,z; Font name with FONT=x; Image format with FORMAT=x; Orientation with ORIENTATION=x'
   task :draw do
     # Load the library
-    $:.unshift(File.dirname(__FILE__) + '/lib')
+    $:.unshift(File.dirname(__FILE__) + '/..')
     require 'state_machine'
     
     # Build drawing options

data/test/functional/state_machine_test.rb

@@ -131,6 +131,10 @@ class Vehicle < ModelBase
     auto_shop.fix_vehicle
   end
   
+  def decibels
+    0.0
+  end
+  
   private
     # Safety first! Puts on our seatbelt
     def put_on_seatbelt
@@ -169,7 +173,13 @@ class Car < Vehicle
 end
 
 class Motorcycle < Vehicle
-  state_machine :initial => :idling
+  state_machine :initial => :idling do
+    state :first_gear do
+      def decibels
+        1.0
+      end
+    end
+  end
 end
 
 class TrafficLight
@@ -765,6 +775,16 @@ class MotorcycleTest < Test::Unit::TestCase
   def test_should_not_allow_repair
     assert !@motorcycle.repair
   end
+  
+  def test_should_inherit_decibels_from_superclass
+    @motorcycle.park
+    assert_equal 0.0, @motorcycle.decibels
+  end
+  
+  def test_should_use_decibels_defined_in_state
+    @motorcycle.shift_up
+    assert_equal 1.0, @motorcycle.decibels
+  end
 end
 
 class CarTest < Test::Unit::TestCase

data/test/unit/event_collection_test.rb

@@ -174,11 +174,20 @@ class EventCollectionAttributeWithMachineActionTest < Test::Unit::TestCase
   end
   
   def test_should_have_valid_transition_if_already_defined_in_transition_cache
+    @ignite.transition :parked => :idling
     @object.state_event = nil
     @object.send(:state_event_transition=, transition = @ignite.transition_for(@object))
     
     assert_equal transition, @events.attribute_transition_for(@object)
   end
+  
+  def test_should_use_transition_cache_if_both_event_and_transition_are_present
+    @ignite.transition :parked => :idling
+    @object.state_event = 'ignite'
+    @object.send(:state_event_transition=, transition = @ignite.transition_for(@object))
+    
+    assert_equal transition, @events.attribute_transition_for(@object)
+  end
 end
 
 class EventCollectionAttributeWithNamespacedMachineTest < Test::Unit::TestCase

data/test/unit/event_test.rb

@@ -663,6 +663,50 @@ class EventWithInvalidCurrentStateTest < Test::Unit::TestCase
   end
 end
 
+class EventWithMarshallingTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new do
+      def save
+        true
+      end
+    end
+    self.class.const_set('Example', @klass)
+    
+    @machine = StateMachine::Machine.new(@klass, :action => :save)
+    @machine.state :parked, :idling
+    
+    @machine.events << @event = StateMachine::Event.new(@machine, :ignite)
+    @event.transition(:parked => :idling)
+    
+    @object = @klass.new
+    @object.state = 'parked'
+  end
+  
+  def test_should_marshal_during_before_callbacks
+    @machine.before_transition {|object, transition| Marshal.dump(object)}
+    assert_nothing_raised { @event.fire(@object) }
+  end
+  
+  def test_should_marshal_during_action
+    @klass.class_eval do
+      def save
+        Marshal.dump(self)
+      end
+    end
+    
+    assert_nothing_raised { @event.fire(@object) }
+  end
+  
+  def test_should_marshal_during_after_callbacks
+    @machine.after_transition {|object, transition| Marshal.dump(object)}
+    assert_nothing_raised { @event.fire(@object) }
+  end
+  
+  def teardown
+    self.class.send(:remove_const, 'Example')
+  end
+end
+
 begin
   # Load library
   require 'rubygems'
@@ -691,7 +735,7 @@ begin
     end
     
     def test_should_use_event_name_for_edge_label
-      assert_equal 'park', @edges.first['label']
+      assert_equal 'park', @edges.first['label'].to_s.gsub('"', '')
     end
   end
 rescue LoadError

data/test/unit/guard_test.rb

@@ -803,7 +803,7 @@ begin
     end
     
     def test_should_use_event_name_as_label
-      assert_equal 'park', @edges.first['label']
+      assert_equal 'park', @edges.first['label'].to_s.gsub('"', '')
     end
   end
   

data/test/unit/integrations/active_record_test.rb

@@ -4,7 +4,7 @@ begin
   # Load library
   require 'rubygems'
   
-  gem 'activerecord', ENV['AR_VERSION'] ? "=#{ENV['AR_VERSION']}" : '>=2.1.0'
+  gem 'activerecord', ENV['AR_VERSION'] ? "=#{ENV['AR_VERSION']}" : '>=2.0.0'
   require 'active_record'
   
   FIXTURES_ROOT = File.dirname(__FILE__) + '/../../fixtures/'
@@ -12,44 +12,59 @@ begin
   # Load TestCase helpers
   require 'active_support/test_case'
   require 'active_record/fixtures'
-  require 'active_record/test_case'
+  
+  require 'active_record/version'
+  if ActiveRecord::VERSION::STRING >= '2.1.0'
+    require 'active_record/test_case'
+  else
+    class ActiveRecord::TestCase < ActiveSupport::TestCase
+      self.fixture_path = FIXTURES_ROOT
+      self.use_instantiated_fixtures = false
+      self.use_transactional_fixtures = true
+    end
+  end
   
   # Establish database connection
   ActiveRecord::Base.establish_connection({'adapter' => 'sqlite3', 'database' => ':memory:'})
   ActiveRecord::Base.logger = Logger.new("#{File.dirname(__FILE__)}/../../active_record.log")
   
-  # Add model/observer creation helpers
-  ActiveRecord::TestCase.class_eval do
-    # Creates a new ActiveRecord model (and the associated table)
-    def new_model(create_table = true, &block)
-      model = Class.new(ActiveRecord::Base) do
-        connection.create_table(:foo, :force => true) {|t| t.string(:state)} if create_table
-        set_table_name('foo')
-        
-        def self.name; 'ActiveRecordTest::Foo'; end
-      end
-      model.class_eval(&block) if block_given?
-      model
-    end
-    
-    # Creates a new ActiveRecord observer
-    def new_observer(model, &block)
-      observer = Class.new(ActiveRecord::Observer) do
-        attr_accessor :notifications
+  module ActiveRecordTest
+    class BaseTestCase < ActiveRecord::TestCase
+      def default_test
+      end
+      
+      protected
+        # Creates a new ActiveRecord model (and the associated table)
+        def new_model(create_table = :foo, &block)
+          table_name = create_table || :foo
+          
+          model = Class.new(ActiveRecord::Base) do
+            connection.create_table(table_name, :force => true) {|t| t.string(:state)} if create_table
+            set_table_name(table_name.to_s)
+            
+            def self.name; "ActiveRecordTest::#{table_name.capitalize}"; end
+          end
+          model.class_eval(&block) if block_given?
+          model
+        end
         
-        def initialize
-          super
-          @notifications = []
+        # Creates a new ActiveRecord observer
+        def new_observer(model, &block)
+          observer = Class.new(ActiveRecord::Observer) do
+            attr_accessor :notifications
+            
+            def initialize
+              super
+              @notifications = []
+            end
+          end
+          observer.observe(model)
+          observer.class_eval(&block) if block_given?
+          observer
         end
-      end
-      observer.observe(model)
-      observer.class_eval(&block) if block_given?
-      observer
     end
-  end
-  
-  module ActiveRecordTest
-    class IntegrationTest < ActiveRecord::TestCase
+    
+    class IntegrationTest < BaseTestCase
       def test_should_match_if_class_inherits_from_active_record
         assert StateMachine::Integrations::ActiveRecord.matches?(new_model)
       end
@@ -57,150 +72,13 @@ begin
       def test_should_not_match_if_class_does_not_inherit_from_active_record
         assert !StateMachine::Integrations::ActiveRecord.matches?(Class.new)
       end
-    end
-    
-    class MachineByDefaultTest < ActiveRecord::TestCase
-      def setup
-        @model = new_model
-        @machine = StateMachine::Machine.new(@model)
-      end
-      
-      def test_should_use_save_as_action
-        assert_equal :save, @machine.action
-      end
-      
-      def test_should_use_transactions
-        assert_equal true, @machine.use_transactions
-      end
-      
-      def test_should_create_notifier_before_callback
-        assert_equal 1, @machine.callbacks[:before].size
-      end
-      
-      def test_should_create_notifier_after_callback
-        assert_equal 1, @machine.callbacks[:after].size
-      end
-    end
-    
-    class MachineTest < ActiveRecord::TestCase
-      def setup
-        @model = new_model
-        @machine = StateMachine::Machine.new(@model)
-        @machine.state :parked, :first_gear
-        @machine.state :idling, :value => lambda {'idling'}
-      end
-      
-      def test_should_create_singular_with_scope
-        assert @model.respond_to?(:with_state)
-      end
-      
-      def test_should_only_include_records_with_state_in_singular_with_scope
-        parked = @model.create :state => 'parked'
-        idling = @model.create :state => 'idling'
-        
-        assert_equal [parked], @model.with_state(:parked)
-      end
-      
-      def test_should_create_plural_with_scope
-        assert @model.respond_to?(:with_states)
-      end
-      
-      def test_should_only_include_records_with_states_in_plural_with_scope
-        parked = @model.create :state => 'parked'
-        idling = @model.create :state => 'idling'
-        
-        assert_equal [parked, idling], @model.with_states(:parked, :idling)
-      end
-      
-      def test_should_create_singular_without_scope
-        assert @model.respond_to?(:without_state)
-      end
-      
-      def test_should_only_include_records_without_state_in_singular_without_scope
-        parked = @model.create :state => 'parked'
-        idling = @model.create :state => 'idling'
-        
-        assert_equal [parked], @model.without_state(:idling)
-      end
-      
-      def test_should_create_plural_without_scope
-        assert @model.respond_to?(:without_states)
-      end
-      
-      def test_should_only_include_records_without_states_in_plural_without_scope
-        parked = @model.create :state => 'parked'
-        idling = @model.create :state => 'idling'
-        first_gear = @model.create :state => 'first_gear'
-        
-        assert_equal [parked, idling], @model.without_states(:first_gear)
-      end
-      
-      def test_should_allow_chaining_scopes
-        parked = @model.create :state => 'parked'
-        idling = @model.create :state => 'idling'
-        
-        assert_equal [idling], @model.without_state(:parked).with_state(:idling)
-      end
-      
-      def test_should_rollback_transaction_if_false
-        @machine.within_transaction(@model.new) do
-          @model.create
-          false
-        end
-        
-        assert_equal 0, @model.count
-      end
-      
-      def test_should_not_rollback_transaction_if_true
-        @machine.within_transaction(@model.new) do
-          @model.create
-          true
-        end
-        
-        assert_equal 1, @model.count
-      end
-      
-      def test_should_invalidate_using_errors
-        I18n.backend = I18n::Backend::Simple.new if Object.const_defined?(:I18n)
-        
-        record = @model.new
-        record.state = 'parked'
-        
-        @machine.invalidate(record, :state, :invalid_transition, [[:event, :park]])
-        
-        assert_equal ['State cannot transition via "park"'], record.errors.full_messages
-      end
-      
-      def test_should_auto_prefix_custom_attributes_on_invalidation
-        record = @model.new
-        @machine.invalidate(record, :event, :invalid)
-        
-        assert_equal ['State event is invalid'], record.errors.full_messages
-      end
-      
-      def test_should_clear_errors_on_reset
-        record = @model.new
-        record.state = 'parked'
-        record.errors.add(:state, 'is invalid')
-        
-        @machine.reset(record)
-        assert_equal [], record.errors.full_messages
-      end
-      
-      def test_should_not_override_the_column_reader
-        record = @model.new
-        record[:state] = 'parked'
-        assert_equal 'parked', record.state
-      end
       
-      def test_should_not_override_the_column_writer
-        record = @model.new
-        record.state = 'parked'
-        assert_equal 'parked', record[:state]
+      def test_should_have_defaults
+        assert_equal e = {:action => :save}, StateMachine::Integrations::ActiveRecord.defaults
       end
     end
     
-    class MachineWithoutDatabaseTest < ActiveRecord::TestCase
+    class MachineWithoutDatabaseTest < BaseTestCase
       def setup
         @model = new_model(false) do
           # Simulate the database not being available entirely
@@ -215,12 +93,12 @@ begin
       end
     end
     
-    class MachineUnmigratedTest < ActiveRecord::TestCase
+    class MachineUnmigratedTest < BaseTestCase
       def setup
         @model = new_model(false)
         
         # Drop the table so that it definitely doesn't exist
-        @model.connection.drop_table(:foo) if @model.connection.table_exists?(:foo)
+        @model.connection.drop_table(:foo) if @model.table_exists?
       end
       
       def test_should_allow_machine_creation
@@ -228,7 +106,30 @@ begin
       end
     end
     
-    class MachineWithStaticInitialStateTest < ActiveRecord::TestCase
+    class MachineByDefaultTest < BaseTestCase
+      def setup
+        @model = new_model
+        @machine = StateMachine::Machine.new(@model)
+      end
+      
+      def test_should_use_save_as_action
+        assert_equal :save, @machine.action
+      end
+      
+      def test_should_use_transactions
+        assert_equal true, @machine.use_transactions
+      end
+      
+      def test_should_create_notifier_before_callback
+        assert_equal 1, @machine.callbacks[:before].size
+      end
+      
+      def test_should_create_notifier_after_callback
+        assert_equal 1, @machine.callbacks[:after].size
+      end
+    end
+    
+    class MachineWithStaticInitialStateTest < BaseTestCase
       def setup
         @model = new_model do
           attr_accessor :value
@@ -241,6 +142,11 @@ begin
         assert_equal 'parked', record.state
       end
       
+      def test_should_set_initial_state_with_nil_attributes
+        record = @model.new(nil)
+        assert_equal 'parked', record.state
+      end
+      
       def test_should_still_set_attributes
         record = @model.new(:value => 1)
         assert_equal 1, record.value
@@ -257,10 +163,9 @@ begin
       
       def test_should_set_attributes_prior_to_after_initialize_hook
         state = nil
-        @model.class_eval do
-          define_method(:after_initialize) do
-            state = self.state
-          end
+        @model.class_eval {define_method(:after_initialize) {}} if ::ActiveRecord::VERSION::MAJOR <= 2
+        @model.after_initialize do |record|
+          state = record.state
         end
         @model.new
         assert_equal 'parked', state
@@ -289,7 +194,7 @@ begin
       end
     end
     
-    class MachineWithDynamicInitialStateTest < ActiveRecord::TestCase
+    class MachineWithDynamicInitialStateTest < BaseTestCase
       def setup
         @model = new_model do
           attr_accessor :value
@@ -319,10 +224,9 @@ begin
       
       def test_should_set_attributes_prior_to_after_initialize_hook
         state = nil
-        @model.class_eval do
-          define_method(:after_initialize) do
-            state = self.state
-          end
+        @model.class_eval {define_method(:after_initialize) {}} if ::ActiveRecord::VERSION::MAJOR <= 2
+        @model.after_initialize do |record|
+          state = record.state
         end
         @model.new
         assert_equal 'parked', state
@@ -351,7 +255,21 @@ begin
       end
     end
     
-    class MachineWithConflictingPredicateTest < ActiveRecord::TestCase
+    class MachineWithColumnDefaultTest < BaseTestCase
+      def setup
+        @model = new_model do
+          connection.add_column :foo, :status, :string, :default => 'idling'
+        end
+        @machine = StateMachine::Machine.new(@model, :status, :initial => :parked)
+        @record = @model.new
+      end
+      
+      def test_should_use_machine_default
+        assert_equal 'parked', @record.status
+      end
+    end
+    
+    class MachineWithConflictingPredicateTest < BaseTestCase
       def setup
         @model = new_model do
           def state?(*args)
@@ -368,7 +286,7 @@ begin
       end
     end
     
-    class MachineWithColumnStateAttributeTest < ActiveRecord::TestCase
+    class MachineWithColumnStateAttributeTest < BaseTestCase
       def setup
         @model = new_model
         @machine = StateMachine::Machine.new(@model, :initial => :parked)
@@ -377,6 +295,16 @@ begin
         @record = @model.new
       end
       
+      def test_should_not_override_the_column_reader
+        @record[:state] = 'parked'
+        assert_equal 'parked', @record.state
+      end
+      
+      def test_should_not_override_the_column_writer
+        @record.state = 'parked'
+        assert_equal 'parked', @record[:state]
+      end
+      
       def test_should_have_an_attribute_predicate
         assert @record.respond_to?(:state?)
       end
@@ -401,11 +329,13 @@ begin
       end
     end
     
-    class MachineWithNonColumnStateAttributeUndefinedTest < ActiveRecord::TestCase
+    class MachineWithNonColumnStateAttributeUndefinedTest < BaseTestCase
       def setup
         @model = new_model do
           def initialize
             # Skip attribute initialization
+            @initialized_state_machines = true
+            super
           end
         end
         
@@ -434,7 +364,7 @@ begin
       end
     end
     
-    class MachineWithNonColumnStateAttributeDefinedTest < ActiveRecord::TestCase
+    class MachineWithNonColumnStateAttributeDefinedTest < BaseTestCase
       def setup
         @model = new_model do
           attr_accessor :status
@@ -462,79 +392,244 @@ begin
       end
     end
     
-    class MachineWithComplexPluralizationTest < ActiveRecord::TestCase
+    class MachineWithAliasedAttributeTest < BaseTestCase
+      def setup
+        @model = new_model do
+          alias_attribute :vehicle_status, :state
+        end
+        
+        @machine = StateMachine::Machine.new(@model, :status, :attribute => :vehicle_status)
+        @machine.state :parked
+        
+        @record = @model.new
+      end
+      
+      def test_should_check_custom_attribute_for_predicate
+        @record.vehicle_status = nil
+        assert !@record.status?(:parked)
+        
+        @record.vehicle_status = 'parked'
+        assert @record.status?(:parked)
+      end
+    end
+    
+    class MachineWithInitializedStateTest < BaseTestCase
       def setup
         @model = new_model
-        @machine = StateMachine::Machine.new(@model, :status)
+        @machine = StateMachine::Machine.new(@model, :initial => :parked)
+        @machine.state nil, :idling
+      end
+      
+      def test_should_allow_nil_initial_state_when_static
+        record = @model.new(:state => nil)
+        assert_nil record.state
+      end
+      
+      def test_should_allow_nil_initial_state_when_dynamic
+        @machine.initial_state = lambda {:parked}
+        record = @model.new(:state => nil)
+        assert_nil record.state
       end
       
-      def test_should_create_singular_with_scope
-        assert @model.respond_to?(:with_status)
+      def test_should_allow_different_initial_state_when_static
+        record = @model.new(:state => 'idling')
+        assert_equal 'idling', record.state
+      end
+      
+      def test_should_allow_different_initial_state_when_dynamic
+        @machine.initial_state = lambda {:parked}
+        record = @model.new(:state => 'idling')
+        assert_equal 'idling', record.state
       end
       
-      def test_should_create_plural_with_scope
-        assert @model.respond_to?(:with_statuses)
+      def test_should_use_default_state_if_protected
+        @model.class_eval do
+          attr_protected :state
+        end
+        
+        record = @model.new(:state => 'idling')
+        assert_equal 'parked', record.state
       end
     end
     
-    class MachineWithOwnerSubclassTest < ActiveRecord::TestCase
+    class MachineWithLoopbackTest < BaseTestCase
       def setup
-        @model = new_model
-        @machine = StateMachine::Machine.new(@model, :state)
+        @model = new_model do
+          connection.add_column :foo, :updated_at, :datetime
+        end
+        
+        @machine = StateMachine::Machine.new(@model, :initial => :parked)
+        @machine.event :park
+        
+        @record = @model.create(:updated_at => Time.now - 1)
+        @transition = StateMachine::Transition.new(@record, @machine, :park, :parked, :parked)
+        
+        @timestamp = @record.updated_at
+        @transition.perform
+      end
+      
+      def test_should_update_record
+        assert_not_equal @timestamp, @record.updated_at
+      end
+    end
+    
+    if ActiveRecord.const_defined?(:Dirty) || ActiveRecord::AttributeMethods.const_defined?(:Dirty)
+      class MachineWithDirtyAttributesTest < BaseTestCase
+        def setup
+          @model = new_model
+          @machine = StateMachine::Machine.new(@model, :initial => :parked)
+          @machine.event :ignite
+          @machine.state :idling
+          
+          @record = @model.create
+          
+          @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
+          @transition.perform(false)
+        end
+        
+        def test_should_include_state_in_changed_attributes
+          assert_equal %w(state), @record.changed
+        end
+        
+        def test_should_track_attribute_change
+          assert_equal %w(parked idling), @record.changes['state']
+        end
+        
+        def test_should_not_reset_changes_on_multiple_transitions
+          transition = StateMachine::Transition.new(@record, @machine, :ignite, :idling, :idling)
+          transition.perform(false)
+          
+          assert_equal %w(parked idling), @record.changes['state']
+        end
+      end
+      
+      class MachineWithDirtyAttributesDuringLoopbackTest < BaseTestCase
+        def setup
+          @model = new_model
+          @machine = StateMachine::Machine.new(@model, :initial => :parked)
+          @machine.event :park
+          
+          @record = @model.create
+          
+          @transition = StateMachine::Transition.new(@record, @machine, :park, :parked, :parked)
+          @transition.perform(false)
+        end
+        
+        def test_should_include_state_in_changed_attributes
+          assert_equal %w(state), @record.changed
+        end
         
-        @subclass = Class.new(@model)
-        @subclass_machine = @subclass.state_machine(:state) {}
-        @subclass_machine.state :parked, :idling, :first_gear
+        def test_should_track_attribute_changes
+          assert_equal %w(parked parked), @record.changes['state']
+        end
       end
       
-      def test_should_only_include_records_with_subclass_states_in_with_scope
-        parked = @subclass.create :state => 'parked'
-        idling = @subclass.create :state => 'idling'
+      class MachineWithDirtyAttributesAndCustomAttributeTest < BaseTestCase
+        def setup
+          @model = new_model do
+            connection.add_column :foo, :status, :string, :default => 'idling'
+          end
+          @machine = StateMachine::Machine.new(@model, :status, :initial => :parked)
+          @machine.event :ignite
+          @machine.state :idling
+          
+          @record = @model.create
+          
+          @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
+          @transition.perform(false)
+        end
+        
+        def test_should_include_state_in_changed_attributes
+          assert_equal %w(status), @record.changed
+        end
+        
+        def test_should_track_attribute_change
+          assert_equal %w(parked idling), @record.changes['status']
+        end
         
-        assert_equal [parked, idling], @subclass.with_states(:parked, :idling)
+        def test_should_not_reset_changes_on_multiple_transitions
+          transition = StateMachine::Transition.new(@record, @machine, :ignite, :idling, :idling)
+          transition.perform(false)
+          
+          assert_equal %w(parked idling), @record.changes['status']
+        end
       end
       
-      def test_should_only_include_records_without_subclass_states_in_without_scope
-        parked = @subclass.create :state => 'parked'
-        idling = @subclass.create :state => 'idling'
-        first_gear = @subclass.create :state => 'first_gear'
+      class MachineWithDirtyAttributeAndCustomAttributesDuringLoopbackTest < BaseTestCase
+        def setup
+          @model = new_model do
+            connection.add_column :foo, :status, :string, :default => 'idling'
+          end
+          @machine = StateMachine::Machine.new(@model, :status, :initial => :parked)
+          @machine.event :park
+          
+          @record = @model.create
+          
+          @transition = StateMachine::Transition.new(@record, @machine, :park, :parked, :parked)
+          @transition.perform(false)
+        end
+        
+        def test_should_include_state_in_changed_attributes
+          assert_equal %w(status), @record.changed
+        end
         
-        assert_equal [parked, idling], @subclass.without_states(:first_gear)
+        def test_should_track_attribute_changes
+          assert_equal %w(parked parked), @record.changes['status']
+        end
       end
     end
     
-    class MachineWithCustomAttributeTest < ActiveRecord::TestCase
+    class MachineWithoutTransactionsTest < BaseTestCase
       def setup
-        @model = new_model do
-          alias_attribute :vehicle_status, :state
+        @model = new_model
+        @machine = StateMachine::Machine.new(@model, :use_transactions => false)
+      end
+      
+      def test_should_not_rollback_transaction_if_false
+        @machine.within_transaction(@model.new) do
+          @model.create
+          false
         end
         
-        @machine = StateMachine::Machine.new(@model, :status, :attribute => :vehicle_status)
-        @machine.state :parked
-        
-        @record = @model.new
+        assert_equal 1, @model.count
       end
       
-      def test_should_add_validation_errors_to_custom_attribute
-        @record.vehicle_status = 'invalid'
+      def test_should_not_rollback_transaction_if_true
+        @machine.within_transaction(@model.new) do
+          @model.create
+          true
+        end
         
-        assert !@record.valid?
-        assert_equal ['Vehicle status is invalid'], @record.errors.full_messages
+        assert_equal 1, @model.count
+      end
+    end
+    
+    class MachineWithTransactionsTest < BaseTestCase
+      def setup
+        @model = new_model
+        @machine = StateMachine::Machine.new(@model, :use_transactions => true)
+      end
+      
+      def test_should_rollback_transaction_if_false
+        @machine.within_transaction(@model.new) do
+          @model.create
+          false
+        end
         
-        @record.vehicle_status = 'parked'
-        assert @record.valid?
+        assert_equal 0, @model.count
       end
       
-      def test_should_check_custom_attribute_for_predicate
-        @record.vehicle_status = nil
-        assert !@record.status?(:parked)
+      def test_should_not_rollback_transaction_if_true
+        @machine.within_transaction(@model.new) do
+          @model.create
+          true
+        end
         
-        @record.vehicle_status = 'parked'
-        assert @record.status?(:parked)
+        assert_equal 1, @model.count
       end
     end
     
-    class MachineWithCallbacksTest < ActiveRecord::TestCase
+    class MachineWithCallbacksTest < BaseTestCase
       def setup
         @model = new_model
         @machine = StateMachine::Machine.new(@model, :initial => :parked)
@@ -641,43 +736,7 @@ begin
       end
     end
     
-    class MachineWithLoopbackTest < ActiveRecord::TestCase
-      def setup
-        changed_attrs = nil
-        
-        @model = new_model do
-          connection.change_table(:foo) {|t| t.datetime(:updated_at)}
-          
-          define_method(:before_update) do
-            changed_attrs = changed_attributes.dup
-          end
-        end
-        
-        @machine = StateMachine::Machine.new(@model, :initial => :parked)
-        @machine.event :park
-        
-        @record = @model.create(:updated_at => Time.now - 1)
-        @timestamp = @record.updated_at
-        
-        @transition = StateMachine::Transition.new(@record, @machine, :park, :parked, :parked)
-        @transition.perform
-        
-        @changed_attrs = changed_attrs
-      end
-      
-      def test_should_include_state_in_changed_attributes
-        @changed_attrs.delete('updated_at')
-        
-        expected = {'state' => 'parked'}
-        assert_equal expected, @changed_attrs
-      end
-      
-      def test_should_update_record
-        assert_not_equal @timestamp, @record.updated_at
-      end
-    end
-    
-    class MachineWithFailedBeforeCallbacksTest < ActiveRecord::TestCase
+    class MachineWithFailedBeforeCallbacksTest < BaseTestCase
       def setup
         @before_count = 0
         @after_count = 0
@@ -716,7 +775,7 @@ begin
       end
     end
     
-    class MachineWithFailedActionTest < ActiveRecord::TestCase
+    class MachineWithFailedActionTest < BaseTestCase
       def setup
         @model = new_model do
           validates_inclusion_of :state, :in => %w(first_gear)
@@ -763,7 +822,40 @@ begin
       end
     end
     
-    class MachineWithValidationsTest < ActiveRecord::TestCase
+    class MachineWithFailedAfterCallbacksTest < BaseTestCase
+       def setup
+        @after_count = 0
+        
+        @model = new_model
+        @machine = StateMachine::Machine.new(@model)
+        @machine.state :parked, :idling
+        @machine.event :ignite
+        @machine.after_transition(lambda {@after_count += 1; false})
+        @machine.after_transition(lambda {@after_count += 1})
+        
+        @record = @model.new(:state => 'parked')
+        @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
+        @result = @transition.perform
+      end
+      
+      def test_should_be_successful
+        assert @result
+      end
+      
+      def test_should_change_current_state
+        assert_equal 'idling', @record.state
+      end
+      
+      def test_should_save_record
+        assert !@record.new_record?
+      end
+      
+      def test_should_not_run_further_after_callbacks
+        assert_equal 1, @after_count
+      end
+    end
+    
+    class MachineWithValidationsTest < BaseTestCase
       def setup
         @model = new_model
         @machine = StateMachine::Machine.new(@model)
@@ -772,6 +864,28 @@ begin
         @record = @model.new
       end
       
+      def test_should_invalidate_using_errors
+        I18n.backend = I18n::Backend::Simple.new if Object.const_defined?(:I18n)
+        @record.state = 'parked'
+        
+        @machine.invalidate(@record, :state, :invalid_transition, [[:event, :park]])
+        assert_equal ['State cannot transition via "park"'], @record.errors.full_messages
+      end
+      
+      def test_should_auto_prefix_custom_attributes_on_invalidation
+        @machine.invalidate(@record, :event, :invalid)
+        
+        assert_equal ['State event is invalid'], @record.errors.full_messages
+      end
+      
+      def test_should_clear_errors_on_reset
+        @record.state = 'parked'
+        @record.errors.add(:state, 'is invalid')
+        
+        @machine.reset(@record)
+        assert_equal [], @record.errors.full_messages
+      end
+      
       def test_should_be_valid_if_state_is_known
         @record.state = 'parked'
         
@@ -786,7 +900,30 @@ begin
       end
     end
     
-    class MachineWithStateDrivenValidationsTest < ActiveRecord::TestCase
+    class MachineWithValidationsAndCustomAttributeTest < BaseTestCase
+      def setup
+        @model = new_model do
+          alias_attribute :status, :state
+        end
+        
+        @machine = StateMachine::Machine.new(@model, :status, :attribute => :state)
+        @machine.state :parked
+        
+        @record = @model.new
+      end
+      
+      def test_should_add_validation_errors_to_custom_attribute
+        @record.state = 'invalid'
+        
+        assert !@record.valid?
+        assert_equal ['State is invalid'], @record.errors.full_messages
+        
+        @record.state = 'parked'
+        assert @record.valid?
+      end
+    end
+      
+    class MachineWithStateDrivenValidationsTest < BaseTestCase
       def setup
         @model = new_model do
           attr_accessor :seatbelt
@@ -815,40 +952,7 @@ begin
       end
     end
     
-    class MachineWithFailedAfterCallbacksTest < ActiveRecord::TestCase
-       def setup
-        @after_count = 0
-        
-        @model = new_model
-        @machine = StateMachine::Machine.new(@model)
-        @machine.state :parked, :idling
-        @machine.event :ignite
-        @machine.after_transition(lambda {@after_count += 1; false})
-        @machine.after_transition(lambda {@after_count += 1})
-        
-        @record = @model.new(:state => 'parked')
-        @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
-        @result = @transition.perform
-      end
-      
-      def test_should_be_successful
-        assert @result
-      end
-      
-      def test_should_change_current_state
-        assert_equal 'idling', @record.state
-      end
-      
-      def test_should_save_record
-        assert !@record.new_record?
-      end
-      
-      def test_should_not_run_further_after_callbacks
-        assert_equal 1, @after_count
-      end
-    end
-    
-    class MachineWithEventAttributesOnValidationTest < ActiveRecord::TestCase
+    class MachineWithEventAttributesOnValidationTest < BaseTestCase
       def setup
         @model = new_model
         @machine = StateMachine::Machine.new(@model)
@@ -925,7 +1029,7 @@ begin
       end
     end
     
-    class MachineWithEventAttributesOnSaveBangTest < ActiveRecord::TestCase
+    class MachineWithEventAttributesOnSaveBangTest < BaseTestCase
       def setup
         @model = new_model
         @machine = StateMachine::Machine.new(@model)
@@ -1002,7 +1106,7 @@ begin
       end
     end
     
-    class MachineWithEventAttributesOnCustomActionTest < ActiveRecord::TestCase
+    class MachineWithEventAttributesOnCustomActionTest < BaseTestCase
       def setup
         @superclass = new_model do
           def persist
@@ -1041,7 +1145,7 @@ begin
       end
     end
     
-    class MachineWithObserversTest < ActiveRecord::TestCase
+    class MachineWithObserversTest < BaseTestCase
       def setup
         @model = new_model
         @machine = StateMachine::Machine.new(@model)
@@ -1114,9 +1218,29 @@ begin
         @transition.perform
         assert_equal [instance], instance.notifications
       end
+      
+      def test_should_use_original_observer_behavior_to_handle_non_state_machine_callbacks
+        observer = new_observer(@model) do
+          def before_save(object)
+          end
+          
+          def before_ignite(*args)
+          end
+          
+          def update_without_multiple_args(observed_method, object)
+            notifications << [observed_method, object] if [:before_save, :before_ignite].include?(observed_method)
+            super
+          end
+        end
+        
+        instance = observer.instance
+        
+        @transition.perform
+        assert_equal [[:before_save, @record]], instance.notifications
+      end
     end
     
-    class MachineWithNamespacedObserversTest < ActiveRecord::TestCase
+    class MachineWithNamespacedObserversTest < BaseTestCase
       def setup
         @model = new_model
         @machine = StateMachine::Machine.new(@model, :state, :namespace => 'alarm')
@@ -1151,7 +1275,7 @@ begin
       end
     end
     
-    class MachineWithMixedCallbacksTest < ActiveRecord::TestCase
+    class MachineWithMixedCallbacksTest < BaseTestCase
       def setup
         @model = new_model
         @machine = StateMachine::Machine.new(@model)
@@ -1204,8 +1328,147 @@ begin
       end
     end
     
+    if ActiveRecord.const_defined?(:NamedScope)
+      class MachineWithScopesTest < BaseTestCase
+        def setup
+          @model = new_model
+          @machine = StateMachine::Machine.new(@model)
+          @machine.state :parked, :first_gear
+          @machine.state :idling, :value => lambda {'idling'}
+        end
+        
+        def test_should_create_singular_with_scope
+          assert @model.respond_to?(:with_state)
+        end
+        
+        def test_should_only_include_records_with_state_in_singular_with_scope
+          parked = @model.create :state => 'parked'
+          idling = @model.create :state => 'idling'
+          
+          assert_equal [parked], @model.with_state(:parked).find(:all)
+        end
+        
+        def test_should_create_plural_with_scope
+          assert @model.respond_to?(:with_states)
+        end
+        
+        def test_should_only_include_records_with_states_in_plural_with_scope
+          parked = @model.create :state => 'parked'
+          idling = @model.create :state => 'idling'
+          
+          assert_equal [parked, idling], @model.with_states(:parked, :idling).find(:all)
+        end
+        
+        def test_should_create_singular_without_scope
+          assert @model.respond_to?(:without_state)
+        end
+        
+        def test_should_only_include_records_without_state_in_singular_without_scope
+          parked = @model.create :state => 'parked'
+          idling = @model.create :state => 'idling'
+          
+          assert_equal [parked], @model.without_state(:idling).find(:all)
+        end
+        
+        def test_should_create_plural_without_scope
+          assert @model.respond_to?(:without_states)
+        end
+        
+        def test_should_only_include_records_without_states_in_plural_without_scope
+          parked = @model.create :state => 'parked'
+          idling = @model.create :state => 'idling'
+          first_gear = @model.create :state => 'first_gear'
+          
+          assert_equal [parked, idling], @model.without_states(:first_gear).find(:all)
+        end
+        
+        def test_should_allow_chaining_scopes
+          parked = @model.create :state => 'parked'
+          idling = @model.create :state => 'idling'
+          
+          assert_equal [idling], @model.without_state(:parked).with_state(:idling).find(:all)
+        end
+      end
+      
+      class MachineWithScopesAndOwnerSubclassTest < BaseTestCase
+        def setup
+          @model = new_model
+          @machine = StateMachine::Machine.new(@model, :state)
+          
+          @subclass = Class.new(@model)
+          @subclass_machine = @subclass.state_machine(:state) {}
+          @subclass_machine.state :parked, :idling, :first_gear
+        end
+        
+        def test_should_only_include_records_with_subclass_states_in_with_scope
+          parked = @subclass.create :state => 'parked'
+          idling = @subclass.create :state => 'idling'
+          
+          assert_equal [parked, idling], @subclass.with_states(:parked, :idling).find(:all)
+        end
+        
+        def test_should_only_include_records_without_subclass_states_in_without_scope
+          parked = @subclass.create :state => 'parked'
+          idling = @subclass.create :state => 'idling'
+          first_gear = @subclass.create :state => 'first_gear'
+          
+          assert_equal [parked, idling], @subclass.without_states(:first_gear).find(:all)
+        end
+      end
+      
+      class MachineWithComplexPluralizationScopesTest < BaseTestCase
+        def setup
+          @model = new_model
+          @machine = StateMachine::Machine.new(@model, :status)
+        end
+        
+        def test_should_create_singular_with_scope
+          assert @model.respond_to?(:with_status)
+        end
+        
+        def test_should_create_plural_with_scope
+          assert @model.respond_to?(:with_statuses)
+        end
+      end
+      
+      class MachineWithScopesAndJoinsTest < BaseTestCase
+        def setup
+          @company = new_model(:company)
+          ActiveRecordTest.const_set('Company', @company)
+          
+          @vehicle = new_model(:vehicle) do
+            connection.add_column :vehicle, :company_id, :integer
+            belongs_to :company, :class_name => 'ActiveRecordTest::Company'
+          end
+          ActiveRecordTest.const_set('Vehicle', @vehicle)
+          
+          @company_machine = StateMachine::Machine.new(@company, :initial => :active)
+          @vehicle_machine = StateMachine::Machine.new(@vehicle, :initial => :parked)
+          @vehicle_machine.state :idling
+          
+          @ford = @company.create
+          @mustang = @vehicle.create(:company => @ford)
+        end
+        
+        def test_should_find_records_in_with_scope
+          assert_equal [@mustang], @vehicle.with_states(:parked).find(:all, :include => :company, :conditions => 'company.state = "active"')
+        end
+        
+        def test_should_find_records_in_without_scope
+          assert_equal [@mustang], @vehicle.without_states(:idling).find(:all, :include => :company, :conditions => 'company.state = "active"')
+        end
+        
+        def teardown
+          ActiveRecordTest.class_eval do
+            remove_const('Vehicle')
+            remove_const('Company')
+          end
+        end
+      end
+    end
+    
     if Object.const_defined?(:I18n)
-      class MachineWithInternationalizationTest < ActiveRecord::TestCase
+      class MachineWithInternationalizationTest < BaseTestCase
         def setup
           I18n.backend = I18n::Backend::Simple.new
           
@@ -1215,20 +1478,14 @@ begin
           @model = new_model
         end
         
-        def test_should_invalidate_using_i18n_default
+        def test_should_use_defaults
           I18n.backend.store_translations(:en, {
-            :activerecord => {
-              :errors => {
-                :messages => {
-                  :invalid_transition => 'cannot {{event}}'
-                }
-              }
-            }
+            :activerecord => {:errors => {:messages => {:invalid_transition => 'cannot {{event}}'}}}
           })
           
           machine = StateMachine::Machine.new(@model)
           machine.state :parked, :idling
-          event = StateMachine::Event.new(machine, :ignite)
+          machine.event :ignite
           
           record = @model.new(:state => 'idling')
           
@@ -1236,15 +1493,9 @@ begin
           assert_equal ['State cannot ignite'], record.errors.full_messages
         end
         
-        def test_should_invalidate_using_customized_i18n_key_if_specified
+        def test_should_allow_customized_error_key
           I18n.backend.store_translations(:en, {
-            :activerecord => {
-              :errors => {
-                :messages => {
-                  :bad_transition => 'cannot {{event}}'
-                }
-              }
-            }
+            :activerecord => {:errors => {:messages => {:bad_transition => 'cannot {{event}}'}}}
           })
           
           machine = StateMachine::Machine.new(@model, :messages => {:invalid_transition => :bad_transition})
@@ -1256,7 +1507,7 @@ begin
           assert_equal ['State cannot ignite'], record.errors.full_messages
         end
         
-        def test_should_invalidate_using_customized_i18n_string_if_specified
+        def test_should_allow_customized_error_string
           machine = StateMachine::Machine.new(@model, :messages => {:invalid_transition => 'cannot {{event}}'})
           machine.state :parked, :idling
           
@@ -1266,6 +1517,81 @@ begin
           assert_equal ['State cannot ignite'], record.errors.full_messages
         end
         
+        def test_should_allow_customized_state_key_scoped_to_class_and_machine
+          I18n.backend.store_translations(:en, {
+            :activerecord => {:state_machines => {:'active_record_test/foo' => {:state => {:states => {:parked => 'shutdown'}}}}}
+          })
+          
+          machine = StateMachine::Machine.new(@model, :initial => :parked)
+          record = @model.new
+          
+          machine.invalidate(record, :event, :invalid_event, [[:state, :parked]])
+          assert_equal ['State event cannot transition when shutdown'], record.errors.full_messages
+        end
+        
+        def test_should_allow_customized_state_key_scoped_to_machine
+          I18n.backend.store_translations(:en, {
+            :activerecord => {:state_machines => {:state => {:states => {:parked => 'shutdown'}}}}
+          })
+          
+          machine = StateMachine::Machine.new(@model, :initial => :parked)
+          record = @model.new
+          
+          machine.invalidate(record, :event, :invalid_event, [[:state, :parked]])
+          assert_equal ['State event cannot transition when shutdown'], record.errors.full_messages
+        end
+        
+        def test_should_allow_customized_state_key_unscoped
+          I18n.backend.store_translations(:en, {
+            :activerecord => {:state_machines => {:states => {:parked => 'shutdown'}}}
+          })
+          
+          machine = StateMachine::Machine.new(@model, :initial => :parked)
+          record = @model.new
+          
+          machine.invalidate(record, :event, :invalid_event, [[:state, :parked]])
+          assert_equal ['State event cannot transition when shutdown'], record.errors.full_messages
+        end
+        
+        def test_should_allow_customized_event_key_scoped_to_class_and_machine
+          I18n.backend.store_translations(:en, {
+            :activerecord => {:state_machines => {:'active_record_test/foo' => {:state => {:events => {:park => 'stop'}}}}}
+          })
+          
+          machine = StateMachine::Machine.new(@model)
+          machine.event :park
+          record = @model.new
+          
+          machine.invalidate(record, :state, :invalid_transition, [[:event, :park]])
+          assert_equal ['State cannot transition via "stop"'], record.errors.full_messages
+        end
+        
+        def test_should_allow_customized_event_key_scoped_to_machine
+          I18n.backend.store_translations(:en, {
+            :activerecord => {:state_machines => {:state => {:events => {:park => 'stop'}}}}
+          })
+          
+          machine = StateMachine::Machine.new(@model)
+          machine.event :park
+          record = @model.new
+          
+          machine.invalidate(record, :state, :invalid_transition, [[:event, :park]])
+          assert_equal ['State cannot transition via "stop"'], record.errors.full_messages
+        end
+        
+        def test_should_allow_customized_event_key_unscoped
+          I18n.backend.store_translations(:en, {
+            :activerecord => {:state_machines => {:events => {:park => 'stop'}}}
+          })
+          
+          machine = StateMachine::Machine.new(@model)
+          machine.event :park
+          record = @model.new
+          
+          machine.invalidate(record, :state, :invalid_transition, [[:event, :park]])
+          assert_equal ['State cannot transition via "stop"'], record.errors.full_messages
+        end
+        
         def test_should_only_add_locale_once_in_load_path
           assert_equal 1, I18n.load_path.select {|path| path =~ %r{state_machine/integrations/active_record/locale\.rb$}}.length