state_machine 1.0.3 → 1.1.0

data/lib/state_machine/integrations/data_mapper/versions.rb

@@ -9,10 +9,6 @@ module StateMachine
         def action_hook
           action
         end
-        
-        def mark_dirty(object, value)
-          object.original_values[self.attribute] = "#{value}-ignored" if object.original_values[self.attribute] == value
-        end
       end
       
       version '0.9.x - 0.10.x' do
@@ -37,29 +33,6 @@ module StateMachine
         end
       end
       
-      version '0.10.x' do
-        def self.active?
-          ::DataMapper::VERSION =~ /^0\.10\./
-        end
-        
-        def mark_dirty(object, value)
-          property = owner_class.properties[self.attribute]
-          object.original_attributes[property] = "#{value}-ignored" unless object.original_attributes.include?(property)
-        end
-      end
-      
-      version '1.0.x - 1.1.x' do
-        def self.active?
-          ::DataMapper::VERSION =~ /^1\.[01]\./
-        end
-        
-        def mark_dirty(object, value)
-          object.persisted_state = ::DataMapper::Resource::State::Dirty.new(object) if object.persisted_state.is_a?(::DataMapper::Resource::State::Clean)
-          property = owner_class.properties[self.attribute]
-          object.persisted_state.original_attributes[property] = value unless object.persisted_state.original_attributes.include?(property)
-        end
-      end
-      
       version '1.0.0' do
         def self.active?
           ::DataMapper::VERSION == '1.0.0'

data/lib/state_machine/integrations/mongo_mapper.rb

@@ -158,6 +158,14 @@ module StateMachine
     # *not* because a matching transition was not available, no error messages
     # will be added to the state attribute.
     # 
+    # In addition, if you're using the <tt>ignite!</tt> version of the event,
+    # then the failure reason (such as the current validation errors) will be
+    # included in the exception that gets raised when the event fails.  For
+    # example, assuming there's a validation on a field called +name+ on the class:
+    # 
+    #   vehicle = Vehicle.new
+    #   vehicle.ignite!       # => StateMachine::InvalidTransition: Cannot transition state via :ignite from :parked (Reason(s): Name cannot be blank)
+    # 
     # == Scopes
     # 
     # To assist in filtering models with specific states, a series of basic

data/lib/state_machine/integrations/mongo_mapper/versions.rb

@@ -64,10 +64,6 @@ module StateMachine
           true
         end
         
-        def supports_dirty_tracking?(object)
-          true
-        end
-        
         def callback_terminator
         end
         

data/lib/state_machine/integrations/mongoid.rb

@@ -156,6 +156,14 @@ module StateMachine
     # *not* because a matching transition was not available, no error messages
     # will be added to the state attribute.
     # 
+    # In addition, if you're using the <tt>ignite!</tt> version of the event,
+    # then the failure reason (such as the current validation errors) will be
+    # included in the exception that gets raised when the event fails.  For
+    # example, assuming there's a validation on a field called +name+ on the class:
+    # 
+    #   vehicle = Vehicle.new
+    #   vehicle.ignite!       # => StateMachine::InvalidTransition: Cannot transition state via :ignite from :parked (Reason(s): Name cannot be blank)
+    # 
     # == Scopes
     # 
     # To assist in filtering models with specific states, a series of basic
@@ -363,8 +371,13 @@ module StateMachine
         def define_state_initializer
           define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
             def initialize(*)
-              @attributes = {}
-              self.class.state_machines.initialize_states(self) { super }
+              @attributes ||= {}
+              self.class.state_machines.initialize_states(self, :dynamic => false)
+              
+              super do |*args|
+                self.class.state_machines.initialize_states(self, :static => false)
+                yield(*args) if block_given?
+              end
             end
           end_eval
         end

data/lib/state_machine/integrations/mongoid/versions.rb

@@ -49,13 +49,6 @@ module StateMachine
           
           result
         end
-        
-        protected
-          # Mongoid uses its own implementation of dirty tracking instead of
-          # ActiveModel's and doesn't support the #{attribute}_will_change! APIs
-          def supports_dirty_tracking?(object)
-            false
-          end
       end
     end
   end

data/lib/state_machine/integrations/sequel.rb

@@ -163,6 +163,14 @@ module StateMachine
     # *not* because a matching transition was not available, no error messages
     # will be added to the state attribute.
     # 
+    # In addition, if you're using the <tt>ignite!</tt> version of the event,
+    # then the failure reason (such as the current validation errors) will be
+    # included in the exception that gets raised when the event fails.  For
+    # example, assuming there's a validation on a field called +name+ on the class:
+    # 
+    #   vehicle = Vehicle.new
+    #   vehicle.ignite!       # => StateMachine::InvalidTransition: Cannot transition state via :ignite from :parked (Reason(s): Name cannot be blank)
+    # 
     # == Scopes
     # 
     # To assist in filtering models with specific states, a series of class
@@ -297,6 +305,12 @@ module StateMachine
         object.errors.add(self.attribute(attribute), generate_message(message, values))
       end
       
+      # Describes the current validation errors on the given object.  If none
+      # are specific, then the default error is interpeted as a "halt".
+      def errors_for(object)
+        object.errors.empty? ? 'Transition halted' : object.errors.full_messages * ', '
+      end
+      
       # Resets any errors previously added when invalidating the given object
       def reset(object)
         object.errors.clear

data/lib/state_machine/machine.rb

@@ -1814,6 +1814,13 @@ module StateMachine
     def invalidate(object, attribute, message, values = [])
     end
     
+    # Gets a description of the errors for the given object.  This is used to
+    # provide more detailed information when an InvalidTransition exception is
+    # raised.
+    def errors_for(object)
+      ''
+    end
+    
     # Resets any errors previously added when invalidating the given object.
     # 
     # By default, this is a no-op.
@@ -1993,6 +2000,11 @@ module StateMachine
           machine.events.transitions_for(object, *args)
         end
         
+        # Fire an arbitrary event for this machine
+        define_helper(:instance, "fire_#{attribute(:event)}") do |machine, object, event, *args|
+          machine.events.fetch(event).fire(object, *args)
+        end
+        
         # Add helpers for tracking the event / transition to invoke when the
         # action is called
         if action

data/lib/state_machine/state.rb

@@ -195,7 +195,7 @@ module StateMachine
         # Calls the method defined by the current state of the machine
         context.class_eval <<-end_eval, __FILE__, __LINE__ + 1
           def #{method}(*args, &block)
-            self.class.state_machine(#{machine_name.inspect}).states.match!(self).call(self, #{method.inspect}, lambda {super}, *args, &block)
+            self.class.state_machine(#{machine_name.inspect}).states.fetch(#{name.inspect}).call(self, #{method.inspect}, lambda {super(*args, &block)}, *args, &block)
           end
         end_eval
       end
@@ -213,11 +213,12 @@ module StateMachine
     # If the method has never been defined for this state, then a NoMethodError
     # will be raised.
     def call(object, method, method_missing = nil, *args, &block)
-      if context_method = methods[method.to_sym]
+      if machine.states.matches?(object, name) && context_method = methods[method.to_sym]
         # Method is defined by the state: proxy it through
         context_method.bind(object).call(*args, &block)
       else
-        # Dispatch to the superclass since this state doesn't handle the method
+        # Dispatch to the superclass since the object either isn't in this state
+        # or this state doesn't handle the method
         method_missing.call if method_missing
       end
     end

data/lib/state_machine/state_context.rb

@@ -79,20 +79,21 @@ module StateMachine
     # *not* need to specify the <tt>:from</tt> option for the transition.  For
     # example:
     # 
-    #  state_machine do
-    #    state :parked do
-    #      transition :to => same, :on => :park, :unless => :seatbelt_on? # Transitions to :parked if seatbelt is off
-    #      transition :to => :idling, :on => [:ignite, :shift_up]         # Transitions to :idling
-    #    end
-    #  end
+    #   state_machine do
+    #     state :parked do
+    #       transition :to => :idling, :on => [:ignite, :shift_up]                          # Transitions to :idling
+    #       transition :from => [:idling, :parked], :on => :park, :unless => :seatbelt_on?  # Transitions to :parked if seatbelt is off
+    #     end
+    #   end
     # 
     # See StateMachine::Machine#transition for a description of the possible
     # configurations for defining transitions.
     def transition(options)
-      assert_valid_keys(options, :to, :on, :if, :unless)
-      raise ArgumentError, 'Must specify :to state and :on event' unless options[:to] && options[:on]
+      assert_valid_keys(options, :from, :to, :on, :if, :unless)
+      raise ArgumentError, 'Must specify :on event' unless options[:on]
+      raise ArgumentError, 'Must specify either :to or :from state' unless !options[:to] ^ !options[:from]
       
-      machine.transition(options.merge(:from => state.name))
+      machine.transition(options.merge(options[:to] ? {:from => state.name} : {:to => state.name}))
     end
     
     # Hooks in condition-merging to methods that don't exist in this module

data/lib/state_machine/transition.rb

@@ -15,8 +15,11 @@ module StateMachine
       @from_state = machine.states.match!(object)
       @from = machine.read(object, :state)
       @event = machine.events.fetch(event)
+      errors = machine.errors_for(object)
       
-      super(object, "Cannot transition #{machine.name} via :#{self.event} from #{from_name.inspect}")
+      message = "Cannot transition #{machine.name} via :#{self.event} from #{from_name.inspect}"
+      message << " (Reason(s): #{errors})" unless errors.empty?
+      super(object, message)
     end
     
     # The event that triggered the failed transition
@@ -351,6 +354,8 @@ module StateMachine
       # around callbacks when the remainder of the callback will be executed at
       # a later point in time.
       def pause
+        raise ArgumentError, 'around_transition callbacks cannot be called in multiple execution contexts in java implementations of Ruby. Use before/after_transitions instead.' if RUBY_PLATFORM == 'java'
+        
         unless @resume_block
           require 'continuation' unless defined?(callcc)
           callcc do |block|

data/lib/state_machine/version.rb

@@ -1,3 +1,3 @@
 module StateMachine
-  VERSION = '1.0.3'
+  VERSION = '1.1.0'
 end

data/state_machine.gemspec

@@ -17,5 +17,5 @@ Gem::Specification.new do |s|
   
   s.add_development_dependency("rake")
   s.add_development_dependency("rcov")
-  s.add_development_dependency("appraisal", "~> 0.3.8")
+  s.add_development_dependency("appraisal", "~> 0.4.0")
 end

data/test/functional/state_machine_test.rb

@@ -40,7 +40,7 @@ class ModelBase
 end
 
 class Vehicle < ModelBase
-  attr_accessor :auto_shop, :seatbelt_on, :insurance_premium, :force_idle, :callbacks, :saved, :time_elapsed
+  attr_accessor :auto_shop, :seatbelt_on, :insurance_premium, :force_idle, :callbacks, :saved, :time_elapsed, :last_transition_args
   
   def initialize(attributes = {})
     attributes = {
@@ -58,6 +58,7 @@ class Vehicle < ModelBase
   
   # Defines the state machine for the state of the vehicled
   state_machine :initial => lambda {|vehicle| vehicle.force_idle ? :idling : :parked}, :action => :save do
+    before_transition {|vehicle, transition| vehicle.last_transition_args = transition.args}
     before_transition :parked => any, :do => :put_on_seatbelt
     before_transition any => :stalled, :do => :increase_insurance_premium
     after_transition any => :parked, :do => lambda {|vehicle| vehicle.seatbelt_on = false}
@@ -340,6 +341,25 @@ class VehicleUnsavedTest < Test::Unit::TestCase
     ]], @vehicle.state_paths(:to => :first_gear)
   end
   
+  def test_should_allow_generic_event_to_fire
+    assert @vehicle.fire_state_event(:ignite)
+    assert_equal 'idling', @vehicle.state
+  end
+  
+  def test_should_pass_arguments_through_to_generic_event_runner
+    @vehicle.fire_state_event(:ignite, 1, 2, 3)
+    assert_equal [1, 2, 3], @vehicle.last_transition_args
+  end
+  
+  def test_should_allow_skipping_action_through_generic_event_runner
+    @vehicle.fire_state_event(:ignite, false)
+    assert_equal false, @vehicle.saved
+  end
+  
+  def test_should_raise_error_with_invalid_event_through_generic_event_runer
+    assert_raise(IndexError) { @vehicle.fire_state_event(:invalid) }
+  end
+  
   def test_should_allow_ignite
     assert @vehicle.ignite
     assert_equal 'idling', @vehicle.state

data/test/unit/event_test.rb

@@ -474,6 +474,11 @@ class EventWithTransitionsTest < Test::Unit::TestCase
     assert_equal [:parked, :idling, :first_gear, :stalled], @event.known_states
   end
   
+  def test_should_clear_known_states_on_reset
+    @event.reset
+    assert_equal [], @event.known_states
+  end
+  
   def test_should_use_pretty_inspect
     assert_match "#<StateMachine::Event name=:ignite transitions=[:parked => :idling, :first_gear => :idling]>", @event.inspect
   end
@@ -690,6 +695,11 @@ class EventWithMatchingEnabledTransitionsTest < Test::Unit::TestCase
     assert_equal [], @object.errors
   end
   
+  def test_should_not_be_able_to_fire_on_reset
+    @event.reset
+    assert !@event.can_fire?(@object)
+  end
+  
   def teardown
     StateMachine::Integrations.send(:remove_const, 'Custom')
   end

data/test/unit/integrations/active_model_test.rb

@@ -17,7 +17,7 @@ module ActiveModelTest
           def self.model_attribute(name)
             define_method(name) { instance_variable_get("@#{name}") }
             define_method("#{name}=") do |value|
-              send("#{name}_will_change!") if self.class <= ActiveModel::Dirty && !send("#{name}_changed?")
+              send("#{name}_will_change!") if self.class <= ActiveModel::Dirty && value != instance_variable_get("@#{name}")
               instance_variable_set("@#{name}", value)
             end
           end
@@ -79,10 +79,6 @@ module ActiveModelTest
       assert StateMachine::Integrations::ActiveModel.available?
     end
     
-    def test_should_match_if_class_includes_dirty_feature
-      assert StateMachine::Integrations::ActiveModel.matches?(new_model { include ActiveModel::Dirty })
-    end
-    
     def test_should_match_if_class_includes_observing_feature
       assert StateMachine::Integrations::ActiveModel.matches?(new_model { include ActiveModel::Observing })
     end
@@ -350,12 +346,12 @@ module ActiveModelTest
       @transition.perform
     end
     
-    def test_should_include_state_in_changed_attributes
-      assert_equal %w(state), @record.changed
+    def test_should_not_include_state_in_changed_attributes
+      assert_equal [], @record.changed
     end
     
-    def test_should_track_attribute_changes
-      assert_equal %w(parked parked), @record.changes['state']
+    def test_should_not_track_attribute_changes
+      assert_equal nil, @record.changes['state']
     end
   end
   
@@ -408,12 +404,12 @@ module ActiveModelTest
       @transition.perform
     end
     
-    def test_should_include_state_in_changed_attributes
-      assert_equal %w(status), @record.changed
+    def test_should_not_include_state_in_changed_attributes
+      assert_equal [], @record.changed
     end
     
-    def test_should_track_attribute_changes
-      assert_equal %w(parked parked), @record.changes['status']
+    def test_should_not_track_attribute_changes
+      assert_equal nil, @record.changes['status']
     end
   end
   
@@ -430,24 +426,12 @@ module ActiveModelTest
       @record.state_event = 'ignite'
     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 parked), @record.changes['state']
-    end
-    
-    def test_should_not_reset_changes_on_multiple_changes
-      @record.state_event = 'ignite'
-      assert_equal %w(parked parked), @record.changes['state']
+    def test_should_not_include_state_in_changed_attributes
+      assert_equal [], @record.changed
     end
     
-    def test_should_not_include_state_in_changed_attributes_if_nil
-      @record = @model.create
-      @record.state_event = nil
-      
-      assert_equal [], @record.changed
+    def test_should_not_track_attribute_change
+      assert_equal nil, @record.changes['state']
     end
   end
   
@@ -694,6 +678,24 @@ module ActiveModelTest
       assert @record.valid?
     end
   end
+  
+  class MachineErrorsTest < BaseTestCase
+    def setup
+      @model = new_model { include ActiveModel::Validations }
+      @machine = StateMachine::Machine.new(@model)
+      @record = @model.new
+    end
+    
+    def test_should_be_able_to_describe_current_errors
+      @record.errors.add(:id, 'cannot be blank')
+      @record.errors.add(:state, 'is invalid')
+      assert_equal ['Id cannot be blank', 'State is invalid'], @machine.errors_for(@record).split(', ').sort
+    end
+    
+    def test_should_describe_as_halted_with_no_errors
+      assert_equal 'Transition halted', @machine.errors_for(@record)
+    end
+  end
     
   class MachineWithStateDrivenValidationsTest < BaseTestCase
     def setup

data/test/unit/integrations/active_record_test.rb

@@ -189,6 +189,15 @@ module ActiveRecordTest
       assert_equal [record], block_args
     end
     
+    def test_should_set_attributes_prior_to_initialize_block
+      state = nil
+      record = @model.new do |record|
+        state = record.state
+      end
+      
+      assert_equal 'parked', state
+    end
+    
     def test_should_set_attributes_prior_to_after_initialize_hook
       state = nil
       @model.class_eval {define_method(:after_initialize) {}} if ::ActiveRecord::VERSION::MAJOR <= 2
@@ -264,6 +273,15 @@ module ActiveRecordTest
       assert_equal [record], block_args
     end
     
+    def test_should_set_attributes_prior_to_initialize_block
+      state = nil
+      record = @model.new do |record|
+        state = record.state
+      end
+      
+      assert_equal 'parked', state
+    end
+    
     def test_should_set_attributes_prior_to_after_initialize_hook
       state = nil
       @model.class_eval {define_method(:after_initialize) {}} if ::ActiveRecord::VERSION::MAJOR <= 2
@@ -605,8 +623,14 @@ module ActiveRecordTest
       @transition.perform
     end
     
-    def test_should_update_record
-      assert_not_equal @timestamp, @record.updated_at
+    if ActiveRecord.const_defined?(:Dirty) || ActiveRecord::AttributeMethods.const_defined?(:Dirty)
+      def test_should_not_update_record
+        assert_equal @timestamp, @record.updated_at
+      end
+    else
+      def test_should_update_record
+        assert_not_equal @timestamp, @record.updated_at
+      end
     end
   end
   
@@ -657,12 +681,12 @@ module ActiveRecordTest
         @transition.perform(false)
       end
       
-      def test_should_include_state_in_changed_attributes
-        assert_equal %w(state), @record.changed
+      def test_should_not_include_state_in_changed_attributes
+        assert_equal [], @record.changed
       end
       
-      def test_should_track_attribute_changes
-        assert_equal %w(parked parked), @record.changes['state']
+      def test_should_not_track_attribute_changes
+        assert_equal nil, @record.changes['state']
       end
     end
     
@@ -711,12 +735,12 @@ module ActiveRecordTest
         @transition.perform(false)
       end
       
-      def test_should_include_state_in_changed_attributes
-        assert_equal %w(status), @record.changed
+      def test_should_not_include_state_in_changed_attributes
+        assert_equal [], @record.changed
       end
       
-      def test_should_track_attribute_changes
-        assert_equal %w(parked parked), @record.changes['status']
+      def test_should_not_track_attribute_changes
+        assert_equal nil, @record.changes['status']
       end
     end
     
@@ -730,24 +754,12 @@ module ActiveRecordTest
         @record.state_event = 'ignite'
       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 parked), @record.changes['state']
-      end
-      
-      def test_should_not_reset_changes_on_multiple_changes
-        @record.state_event = 'ignite'
-        assert_equal %w(parked parked), @record.changes['state']
+      def test_should_not_include_state_in_changed_attributes
+        assert_equal [], @record.changed
       end
       
-      def test_should_not_include_state_in_changed_attributes_if_nil
-        @record = @model.create
-        @record.state_event = nil
-        
-        assert_equal [], @record.changed
+      def test_should_not_track_attribute_change
+        assert_equal nil, @record.changes['state']
       end
     end
   else
@@ -1111,6 +1123,24 @@ module ActiveRecordTest
       assert @record.valid?
     end
   end
+  
+  class MachineErrorsTest < BaseTestCase
+    def setup
+      @model = new_model
+      @machine = StateMachine::Machine.new(@model)
+      @record = @model.new
+    end
+    
+    def test_should_be_able_to_describe_current_errors
+      @record.errors.add(:id, 'cannot be blank')
+      @record.errors.add(:state, 'is invalid')
+      assert_equal ['Id cannot be blank', 'State is invalid'], @machine.errors_for(@record).split(', ').sort
+    end
+    
+    def test_should_describe_as_halted_with_no_errors
+      assert_equal 'Transition halted', @machine.errors_for(@record)
+    end
+  end
     
   class MachineWithStateDrivenValidationsTest < BaseTestCase
     def setup