state_machine 0.7.5 → 0.7.6

data/lib/state_machine/matcher_helpers.rb

@@ -24,6 +24,7 @@ module StateMachine
     # are known:
     # * +parked+
     # * +stalled+
+    # * +idling+
     def all
       AllMatcher.instance
     end

data/lib/state_machine/state.rb

@@ -119,7 +119,9 @@ module StateMachine
     def value(eval = true)
       if @value.is_a?(Proc) && eval
         if cache_value?
-          instance_variable_defined?('@cached_value') ? @cached_value : @cached_value = @value.call
+          @value = @value.call
+          machine.states.update(self)
+          @value
         else
           @value.call
         end
@@ -154,11 +156,11 @@ module StateMachine
     # a new module will be included in the owner class.
     def context(&block)
       owner_class = machine.owner_class
-      attribute = machine.attribute
+      machine_name = machine.name
       name = self.name
       
       # Evaluate the method definitions
-      context = ConditionProxy.new(owner_class, lambda {|object| object.send("#{attribute}_name") == name})
+      context = ConditionProxy.new(owner_class, lambda {|object| object.class.state_machine(machine_name).states.matches?(object, name)})
       context.class_eval(&block)
       context.instance_methods.each do |method|
         methods[method.to_sym] = context.instance_method(method)
@@ -166,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(#{attribute.inspect}).states.match!(self).call(self, #{method.inspect}, *args, &block)
+            self.class.state_machine(#{machine_name.inspect}).states.match!(self).call(self, #{method.inspect}, *args, &block)
           end
         end_eval
       end

data/lib/state_machine/state_collection.rb

@@ -27,7 +27,7 @@ module StateMachine
     #   states.matches?(vehicle, :idling)   # => false
     #   states.matches?(vehicle, :invalid)  # => IndexError: :invalid is an invalid key for :name index
     def matches?(object, name)
-      fetch(name).matches?(machine.read(object))
+      fetch(name).matches?(machine.read(object, :state))
     end
     
     # Determines the current state of the given object as configured by this
@@ -53,7 +53,7 @@ module StateMachine
     #   vehicle.state = 'invalid'
     #   states.match(vehicle)         # => nil
     def match(object)
-      value = machine.read(object)
+      value = machine.read(object, :state)
       self[value, :value] || detect {|state| state.matches?(value)}
     end
     
@@ -77,7 +77,7 @@ module StateMachine
     #   vehicle.state = 'invalid'
     #   states.match!(vehicle)        # => ArgumentError: "invalid" is not a known state value
     def match!(object)
-      match(object) || raise(ArgumentError, "#{machine.read(object).inspect} is not a known #{machine.attribute} value")
+      match(object) || raise(ArgumentError, "#{machine.read(object, :state).inspect} is not a known #{machine.name} value")
     end
     
     # Gets the order in which states should be displayed based on where they

data/lib/state_machine/transition.rb

@@ -136,7 +136,7 @@ module StateMachine
       
       # From state information
       from_state = machine.states.fetch(from_name)
-      @from = machine.read(object)
+      @from = machine.read(object, :state)
       @from_name = from_state.name
       @qualified_from_name = from_state.qualified_name
       
@@ -259,7 +259,7 @@ module StateMachine
     #   
     #   vehicle.state   # => 'idling'
     def persist
-      machine.write(object, to)
+      machine.write(object, :state, to)
     end
     
     # Runs the machine's +after+ callbacks for this transition.  Only
@@ -326,7 +326,7 @@ module StateMachine
     #   transition.rollback
     #   vehicle.state             # => "parked"
     def rollback
-      machine.write(object, from)
+      machine.write(object, :state, from)
     end
     
     # Generates a nicely formatted description of this transitions's contents.

data/test/unit/eval_helpers_test.rb

@@ -45,6 +45,24 @@ class EvalHelpersSymbolWithArgumentsTest < Test::Unit::TestCase
   end
 end
 
+class EvalHelpersSymbolTaintedMethodTest < Test::Unit::TestCase
+  include StateMachine::EvalHelpers
+  
+  def setup
+    class << (@object = Object.new)
+      def callback
+        true
+      end
+      
+      taint
+    end
+  end
+  
+  def test_should_not_raise_security_error
+    assert_nothing_raised { evaluate_method(@object, :callback, 1, 2, 3) }
+  end
+end
+
 class EvalHelpersStringTest < Test::Unit::TestCase
   include StateMachine::EvalHelpers
   

data/test/unit/event_collection_test.rb

@@ -261,3 +261,33 @@ class EventCollectionWithValidationsTest < Test::Unit::TestCase
     StateMachine::Integrations.send(:remove_const, 'Custom')
   end
 end
+
+class EventCollectionWithCustomMachineAttributeTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new do
+      def save
+      end
+    end
+    
+    @machine = StateMachine::Machine.new(@klass, :state, :attribute => :state_id, :initial => :parked, :action => :save)
+    @events = StateMachine::EventCollection.new(@machine)
+    
+    @machine.event :ignite
+    @machine.state :parked, :idling
+    @events << @ignite = StateMachine::Event.new(@machine, :ignite)
+    
+    @object = @klass.new
+  end
+  
+  def test_should_not_have_transition_if_nil
+    @object.state_event = nil
+    assert_nil @events.attribute_transition_for(@object)
+  end
+  
+  def test_should_have_valid_transition_if_event_can_be_fired
+    @ignite.transition :parked => :idling
+    @object.state_event = 'ignite'
+    
+    assert_instance_of StateMachine::Transition, @events.attribute_transition_for(@object)
+  end
+end

data/test/unit/integrations/active_record_test.rb

@@ -172,6 +172,13 @@ begin
         assert_equal 'cannot transition via "park"', record.errors.on(:state)
       end
       
+      def test_should_auto_prefix_custom_attributes_on_invalidation
+        record = @model.new
+        @machine.invalidate(record, :event, :invalid)
+        
+        assert_equal 'is invalid', record.errors.on(:state_event)
+      end
+      
       def test_should_clear_errors_on_reset
         record = @model.new
         record.state = 'parked'
@@ -360,6 +367,60 @@ begin
       end
     end
     
+    class MachineWithOwnerSubclassTest < ActiveRecord::TestCase
+      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)
+      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)
+      end
+    end
+    
+    class MachineWithCustomAttributeTest < ActiveRecord::TestCase
+      def setup
+        @model = new_model
+        @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
+      
+      def test_should_check_custom_attribute_for_predicate
+        @record.state = nil
+        assert !@record.status?(:parked)
+        
+        @record.state = 'parked'
+        assert @record.status?(:parked)
+      end
+    end
+    
     class MachineWithCallbacksTest < ActiveRecord::TestCase
       def setup
         @model = new_model
@@ -965,16 +1026,25 @@ begin
           machine.invalidate(record, :state, :invalid_transition, [[:event, :ignite]])
           assert_equal 'cannot ignite', record.errors.on(:state)
         end
-      end
-      
-      def test_should_invalidate_using_customized_i18n_string_if_specified
-        machine = StateMachine::Machine.new(@model, :messages => {:invalid_transition => 'cannot {{event}}'})
-        machine.state :parked, :idling
         
-        record = @model.new(:state => 'idling')
+        def test_should_invalidate_using_customized_i18n_string_if_specified
+          machine = StateMachine::Machine.new(@model, :messages => {:invalid_transition => 'cannot {{event}}'})
+          machine.state :parked, :idling
+          
+          record = @model.new(:state => 'idling')
+          
+          machine.invalidate(record, :state, :invalid_transition, [[:event, :ignite]])
+          assert_equal 'cannot ignite', record.errors.on(:state)
+        end
         
-        machine.invalidate(record, :state, :invalid_transition, [[:event, :ignite]])
-        assert_equal 'cannot ignite', record.errors.on(:state)
+        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
+          
+          # Create another ActiveRecord model that will triger the i18n feature
+          new_model
+          
+          assert_equal 1, I18n.load_path.select {|path| path =~ %r{state_machine/integrations/active_record/locale\.rb$}}.length
+        end
       end
     else
       $stderr.puts 'Skipping ActiveRecord I18n tests. `gem install active_record` >= v2.2.0 and try again.'

data/test/unit/integrations/data_mapper_test.rb

@@ -232,6 +232,57 @@ begin
       end
     end
     
+    class MachineWithOwnerSubclassTest < BaseTestCase
+      def setup
+        @resource = new_resource
+        @machine = StateMachine::Machine.new(@resource, :state)
+        
+        @subclass = Class.new(@resource)
+        @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)
+      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)
+      end
+    end
+    
+    class MachineWithTransactionsTest < BaseTestCase
+      def setup
+        @resource = new_resource
+        @machine = StateMachine::Machine.new(@resource, :use_transactions => true)
+      end
+      
+      def test_should_rollback_transaction_if_false
+        @machine.within_transaction(@resource.new) do
+          @resource.create
+          false
+        end
+        
+        assert_equal 0, @resource.all.size
+      end
+      
+      def test_should_not_rollback_transaction_if_true
+        @machine.within_transaction(@resource.new) do
+          @resource.create
+          true
+        end
+        
+        assert_equal 1, @resource.all.size
+      end
+    end
+    
     class MachineWithCallbacksTest < BaseTestCase
       def setup
         @resource = new_resource
@@ -544,6 +595,12 @@ begin
           assert_equal ['cannot transition via "park"'], @record.errors.on(:state)
         end
         
+        def test_should_auto_prefix_custom_attributes_on_invalidation
+          @machine.invalidate(@record, :event, :invalid)
+          
+          assert_equal ['is invalid'], @record.errors.on(:state_event)
+        end
+        
         def test_should_clear_errors_on_reset
           @record.state = 'parked'
           @record.errors.add(:state, 'is invalid')
@@ -566,6 +623,26 @@ begin
         end
       end
       
+      class MachineWithValidationsAndCustomAttributeTest < BaseTestCase
+        def setup
+          @resource = new_resource
+          @machine = StateMachine::Machine.new(@resource, :status, :attribute => :state)
+          @machine.state :parked
+          
+          @record = @resource.new
+        end
+        
+        def test_should_add_validation_errors_to_custom_attribute
+          @record.state = 'invalid'
+          
+          assert !@record.valid?
+          assert_equal ['is invalid'], @record.errors.on(:state)
+          
+          @record.state = 'parked'
+          assert @record.valid?
+        end
+      end
+      
       class MachineWithStateDrivenValidationsTest < BaseTestCase
         def setup
           @resource = new_resource do

data/test/unit/integrations/sequel_test.rb

@@ -25,10 +25,9 @@ begin
           end if auto_migrate
           model = Class.new(Sequel::Model(:foo)) do
             self.raise_on_save_failure = false
-            plugin :validation_class_methods if respond_to?(:plugin)
-            
             def self.name; 'SequelTest::Foo'; end
           end
+          model.plugin(:validation_class_methods) if model.respond_to?(:plugin)
           model.class_eval(&block) if block_given?
           model
         end
@@ -146,6 +145,13 @@ begin
         assert_equal ['cannot transition via "park"'], record.errors.on(:state)
       end
       
+      def test_should_auto_prefix_custom_attributes_on_invalidation
+        record = @model.new
+        @machine.invalidate(record, :event, :invalid)
+        
+        assert_equal ['is invalid'], record.errors.on(:state_event)
+      end
+      
       def test_should_clear_errors_on_reset
         record = @model.new
         record.state = 'parked'
@@ -245,6 +251,52 @@ begin
       end
     end
     
+    class MachineWithOwnerSubclassTest < 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).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).all
+      end
+    end
+    
+    class MachineWithCustomAttributeTest < BaseTestCase
+      def setup
+        @model = new_model
+        @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 ['is invalid'], @record.errors.on(:state)
+        
+        @record.state = 'parked'
+        assert @record.valid?
+      end
+    end
+    
     class MachineWithCallbacksTest < BaseTestCase
       def setup
         @model = new_model

data/test/unit/machine_collection_test.rb

@@ -688,3 +688,23 @@ class MachineCollectionFireImplicitWithValidationsTest < Test::Unit::TestCase
     StateMachine::Integrations.send(:remove_const, 'Custom')
   end
 end
+
+class MachineCollectionFireImplicitWithCustomMachineNameTest < MachineCollectionFireImplicitTest
+  def setup
+    super
+    
+    @object.state_event = 'ignite'
+  end
+  
+  def test_should_be_successful_on_complete_file
+    assert @machines.fire_event_attributes(@object, :save) { true }
+    assert_equal 'idling', @object.state
+    assert_nil @object.state_event
+  end
+  
+  def test_should_be_successful_on_partial_fire
+    @machines.fire_event_attributes(@object, :save, false) { true }
+    assert_equal 'idling', @object.state
+    assert_equal :ignite, @object.state_event
+  end
+end