state_machine 1.0.2 → 1.0.3

data/lib/state_machine/node_collection.rb

@@ -24,6 +24,7 @@ module StateMachine
       @nodes = []
       @indices = Array(options[:index]).inject({}) {|indices, attribute| indices[attribute] = {}; indices}
       @default_index = Array(options[:index]).first
+      @contexts = []
     end
     
     # Creates a copy of this collection such that modifications don't affect
@@ -32,9 +33,15 @@ module StateMachine
       super
       
       nodes = @nodes
+      contexts = @contexts
       @nodes = []
+      @contexts = []
       @indices = @indices.inject({}) {|indices, (name, index)| indices[name] = {}; indices}
+      
+      # Add nodes *prior* to copying over the contexts so that they don't get
+      # evaluated multiple times
       concat(nodes.map {|n| n.dup})
+      @contexts = contexts.dup
     end
     
     # Changes the current machine associated with the collection.  In turn, this
@@ -54,11 +61,26 @@ module StateMachine
       index(index_name).keys
     end
     
+    # Tracks a context that should be evaluated for any nodes that get added
+    # which match the given set of nodes.  Matchers can be used so that the
+    # context can get added once and evaluated after multiple adds.
+    def context(nodes, &block)
+      nodes = nodes.first.is_a?(Matcher) ? nodes.first : WhitelistMatcher.new(nodes)
+      @contexts << context = {:nodes => nodes, :block => block}
+      
+      # Evaluate the new context for existing nodes
+      each {|node| eval_context(context, node)}
+      
+      context
+    end
+    
     # Adds a new node to the collection.  By doing so, this will also add it to
-    # the configured indices.
+    # the configured indices.  This will also evaluate any existings contexts
+    # that match the new node.
     def <<(node)
       @nodes << node
       @indices.each {|attribute, index| index[value(node, attribute)] = node}
+      @contexts.each {|context| eval_context(context, node)}
       self
     end
     
@@ -122,7 +144,12 @@ module StateMachine
     # 
     # If the key cannot be found, then nil will be returned.
     def [](key, index_name = @default_index)
-      index(index_name)[key]
+      index = self.index(index_name)
+      if index.include?(key)
+        index[key]
+      elsif @indices.include?(:"#{index_name}_to_s")
+        self[key.to_s, :"#{index_name}_to_s"]
+      end
     end
     
     # Gets the node indexed by the given key.  By default, this will look up the
@@ -141,7 +168,7 @@ module StateMachine
       self[key, index_name] || raise(IndexError, "#{key.inspect} is an invalid #{index_name}")
     end
     
-    private
+    protected
       # Gets the given index.  If the index does not exist, then an ArgumentError
       # is raised.
       def index(name)
@@ -153,5 +180,11 @@ module StateMachine
       def value(node, attribute)
         node.send(attribute)
       end
+      
+      # Evaluates the given context for a particular node.  This will only
+      # evaluate the context if the node matches.
+      def eval_context(context, node)
+        node.context(&context[:block]) if context[:nodes].matches?(node.name)
+      end
   end
 end

data/lib/state_machine/state.rb

@@ -96,6 +96,11 @@ module StateMachine
       @methods = methods.dup
     end
     
+    # Converts the name of this state to a string
+    def name_to_s
+      name.to_s
+    end
+    
     # Determines whether there are any states that can be transitioned to from
     # this state.  If there are none, then this state is considered *final*.
     # Any objects in a final state will remain so forever given the current
@@ -179,9 +184,7 @@ module StateMachine
     # This can be called multiple times.  Each time a new context is created,
     # a new module will be included in the owner class.
     def context(&block)
-      owner_class = machine.owner_class
       machine_name = machine.name
-      name = self.name
       
       # Evaluate the method definitions
       context = StateContext.new(self)
@@ -199,7 +202,7 @@ module StateMachine
       
       # Include the context so that it can be bound to the owner class (the
       # context is considered an ancestor, so it's allowed to be bound)
-      owner_class.class_eval { include context }
+      machine.owner_class.class_eval { include context }
       
       context
     end

data/lib/state_machine/state_collection.rb

@@ -4,7 +4,7 @@ module StateMachine
   # Represents a collection of states in a state machine
   class StateCollection < NodeCollection
     def initialize(machine) #:nodoc:
-      super(machine, :index => [:name, :qualified_name, :value])
+      super(machine, :index => [:name, :name_to_s, :qualified_name, :value])
     end
     
     # Determines whether the given object is in a specific state.  If the

data/lib/state_machine/version.rb

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

data/lib/tasks/state_machine.rb

@@ -1,9 +1,19 @@
 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'
+  desc 'Draws state machines using GraphViz (options: CLASS=User,Vehicle; FILE=user.rb,vehicle.rb [not required in Rails / Merb]; FONT=Arial; FORMAT=png; ORIENTATION=portrait'
   task :draw do
+    # Build drawing options
+    options = {}
+    options[:file] = ENV['FILE'] if ENV['FILE']
+    options[:path] = ENV['TARGET'] if ENV['TARGET']
+    options[:format] = ENV['FORMAT'] if ENV['FORMAT']
+    options[:font] = ENV['FONT'] if ENV['FONT']
+    options[:orientation] = ENV['ORIENTATION'] if ENV['ORIENTATION']
+    
     if defined?(Rails)
+      puts "Files are automatically loaded in Rails; ignoring FILE option" if options.delete(:file)
       Rake::Task['environment'].invoke
     elsif defined?(Merb)
+      puts "Files are automatically loaded in Merb; ignoring FILE option" if options.delete(:file)
       Rake::Task['merb_env'].invoke
       
       # Fix ruby-graphviz being incompatible with Merb's process title
@@ -14,14 +24,6 @@ namespace :state_machine do
       require 'state_machine'
     end
     
-    # Build drawing options
-    options = {}
-    options[:file] = ENV['FILE'] if ENV['FILE']
-    options[:path] = ENV['TARGET'] if ENV['TARGET']
-    options[:format] = ENV['FORMAT'] if ENV['FORMAT']
-    options[:font] = ENV['FONT'] if ENV['FONT']
-    options[:orientation] = ENV['ORIENTATION'] if ENV['ORIENTATION']
-    
     StateMachine::Machine.draw(ENV['CLASS'], options)
   end
 end

data/state_machine.gemspec

@@ -12,11 +12,10 @@ Gem::Specification.new do |s|
   s.require_paths     = ["lib"]
   s.files             = `git ls-files`.split("\n")
   s.test_files        = `git ls-files -- test/*`.split("\n")
-  s.rdoc_options      = %w(--line-numbers --inline-source --title state_machine --main README.rdoc)
-  s.extra_rdoc_files  = %w(README.rdoc CHANGELOG.rdoc LICENSE)
+  s.rdoc_options      = %w(--line-numbers --inline-source --title state_machine --main README.md)
+  s.extra_rdoc_files  = %w(README.md CHANGELOG.md LICENSE)
   
   s.add_development_dependency("rake")
   s.add_development_dependency("rcov")
   s.add_development_dependency("appraisal", "~> 0.3.8")
-  s.add_development_dependency("ruby-graphviz", "~> 1.0")
 end

data/test/functional/state_machine_test.rb

@@ -74,6 +74,10 @@ class Vehicle < ModelBase
       vehicle.time_elapsed = Time.now - time
     end
     
+    event all do
+      transition :locked => :parked
+    end
+    
     event :park do
       transition [:idling, :first_gear] => :parked
     end
@@ -191,7 +195,7 @@ end
 class TrafficLight
   state_machine :initial => :stop do
     event :cycle do
-      transition :stop => :proceed, :proceed=> :caution, :caution => :stop
+      transition :stop => :proceed, :proceed => :caution, :caution => :stop
     end
     
     state :stop do
@@ -208,10 +212,20 @@ class TrafficLight
       end
     end
     
+    state all - :proceed do
+      def capture_violations?
+        true
+      end
+    end
+    
     state :proceed do
       def color(transform)
         'green'
       end
+
+      def capture_violations?
+        false
+      end
     end
     
     state :caution do
@@ -713,6 +727,33 @@ class VehicleRepairedTest < Test::Unit::TestCase
   end
 end
 
+class VehicleLockedTest < Test::Unit::TestCase
+  def setup
+    @vehicle = Vehicle.new
+    @vehicle.state = 'locked'
+  end
+  
+  def test_should_be_parked_after_park
+    @vehicle.park
+    assert @vehicle.parked?
+  end
+  
+  def test_should_be_parked_after_ignite
+    @vehicle.ignite
+    assert @vehicle.parked?
+  end
+  
+  def test_should_be_parked_after_shift_up
+    @vehicle.shift_up
+    assert @vehicle.parked?
+  end
+  
+  def test_should_be_parked_after_shift_down
+    @vehicle.shift_down
+    assert @vehicle.parked?
+  end
+end
+
 class VehicleWithParallelEventsTest < Test::Unit::TestCase
   def setup
     @vehicle = Vehicle.new
@@ -968,6 +1009,10 @@ class TrafficLightStopTest < Test::Unit::TestCase
     color = @light.color {|value| value.upcase!}
     assert_equal 'RED', color
   end
+  
+  def test_should_use_stop_capture_violations
+    assert_equal true, @light.capture_violations?
+  end
 end
 
 class TrafficLightProceedTest < Test::Unit::TestCase
@@ -979,6 +1024,10 @@ class TrafficLightProceedTest < Test::Unit::TestCase
   def test_should_use_proceed_color
     assert_equal 'green', @light.color
   end
+  
+  def test_should_use_proceed_capture_violations
+    assert_equal false, @light.capture_violations?
+  end
 end
 
 class TrafficLightCautionTest < Test::Unit::TestCase
@@ -990,4 +1039,8 @@ class TrafficLightCautionTest < Test::Unit::TestCase
   def test_should_use_caution_color
     assert_equal 'yellow', @light.color
   end
+  
+  def test_should_use_caution_capture_violations
+    assert_equal true, @light.capture_violations?
+  end
 end

data/test/unit/event_collection_test.rb

@@ -40,6 +40,10 @@ class EventCollectionTest < Test::Unit::TestCase
     assert_equal @open, @events[:enable]
   end
   
+  def test_should_index_by_string_name
+    assert_equal @open, @events['enable']
+  end
+  
   def test_should_index_by_qualified_name
     assert_equal @open, @events[:enable_alarm, :qualified_name]
   end

data/test/unit/event_test.rb

@@ -173,7 +173,7 @@ class EventWithConflictingHelpersBeforeDefinitionTest < Test::Unit::TestCase
   
   def test_should_output_warning
     expected = %w(can_ignite? ignite_transition ignite ignite!).map do |method|
-      "Instance method \"#{method}\" is already defined in #{@superclass.to_s}, use generic helper instead.\n"
+      "Instance method \"#{method}\" is already defined in #{@superclass.to_s}, use generic helper instead or set StateMachine::Machine.ignore_method_conflicts = true.\n"
     end.join
     
     assert_equal expected, $stderr.string
@@ -341,6 +341,20 @@ class EventWithNamespaceTest < Test::Unit::TestCase
   end
 end
 
+class EventContextTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.events << @event = StateMachine::Event.new(@machine, :ignite, :human_name => 'start')
+  end
+  
+  def test_should_evaluate_within_the_event
+    scope = nil
+    @event.context { scope = self }
+    assert_equal @event, scope
+  end
+end
+
 class EventTransitionsTest < Test::Unit::TestCase
   def setup
     @machine = StateMachine::Machine.new(Class.new)
@@ -568,6 +582,25 @@ class EventWithMatchingDisabledTransitionsTest < Test::Unit::TestCase
     assert_equal ['cannot transition via "start"'], @object.errors
   end
   
+  def test_should_invalid_with_human_state_name_if_specified
+    klass = Class.new do
+      attr_accessor :errors
+    end
+    
+    machine = StateMachine::Machine.new(klass, :integration => :custom, :messages => {:invalid_transition => 'cannot transition via "%s" from "%s"'})
+    parked, idling = machine.state :parked, :idling
+    parked.human_name = 'stopped'
+    
+    machine.events << event = StateMachine::Event.new(machine, :ignite)
+    event.transition(:parked => :idling, :if => lambda {false})
+    
+    object = @klass.new
+    object.state = 'parked'
+    
+    event.fire(object)
+    assert_equal ['cannot transition via "ignite" from "stopped"'], object.errors
+  end
+  
   def test_should_reset_existing_error
     @object.errors = ['invalid']
     

data/test/unit/integrations/active_model_test.rb

@@ -798,6 +798,54 @@ module ActiveModelTest
       @transition.perform
       assert_equal [instance], instance.notifications
     end
+    
+    def test_should_support_nil_from_states
+      callbacks = [
+        :before_ignite_from_nil_to_idling,
+        :before_ignite_from_nil,
+        :before_transition_state_from_nil_to_idling,
+        :before_transition_state_from_nil
+      ]
+      
+      notified = false
+      observer = new_observer(@model) do
+        callbacks.each do |callback|
+          define_method(callback) do |*args|
+            notifications << callback
+          end
+        end
+      end
+      
+      instance = observer.instance
+      
+      transition = StateMachine::Transition.new(@record, @machine, :ignite, nil, :idling)
+      transition.perform
+      assert_equal callbacks, instance.notifications
+    end
+    
+    def test_should_support_nil_to_states
+      callbacks = [
+        :before_ignite_from_parked_to_nil,
+        :before_ignite_to_nil,
+        :before_transition_state_from_parked_to_nil,
+        :before_transition_state_to_nil
+      ]
+      
+      notified = false
+      observer = new_observer(@model) do
+        callbacks.each do |callback|
+          define_method(callback) do |*args|
+            notifications << callback
+          end
+        end
+      end
+      
+      instance = observer.instance
+      
+      transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, nil)
+      transition.perform
+      assert_equal callbacks, instance.notifications
+    end
   end
   
   class MachineWithNamespacedObserversTest < BaseTestCase
@@ -994,6 +1042,17 @@ module ActiveModelTest
       assert_equal 'shutdown', machine.state(:parked).human_name
     end
     
+    def test_should_allow_customized_state_key_scoped_to_class
+      I18n.backend.store_translations(:en, {
+        :activemodel => {:state_machines => {:'active_model_test/foo' => {:states => {:parked => 'shutdown'}}}}
+      })
+      
+      machine = StateMachine::Machine.new(@model)
+      machine.state :parked
+      
+      assert_equal 'shutdown', machine.state(:parked).human_name
+    end
+    
     def test_should_allow_customized_state_key_scoped_to_machine
       I18n.backend.store_translations(:en, {
         :activemodel => {:state_machines => {:state => {:states => {:parked => 'shutdown'}}}}
@@ -1016,6 +1075,16 @@ module ActiveModelTest
       assert_equal 'shutdown', machine.state(:parked).human_name
     end
     
+    def test_should_support_nil_state_key
+      I18n.backend.store_translations(:en, {
+        :activemodel => {:state_machines => {:states => {:nil => 'empty'}}}
+      })
+      
+      machine = StateMachine::Machine.new(@model)
+      
+      assert_equal 'empty', machine.state(nil).human_name
+    end
+    
     def test_should_allow_customized_event_key_scoped_to_class_and_machine
       I18n.backend.store_translations(:en, {
         :activemodel => {:state_machines => {:'active_model_test/foo' => {:state => {:events => {:park => 'stop'}}}}}
@@ -1027,6 +1096,17 @@ module ActiveModelTest
       assert_equal 'stop', machine.event(:park).human_name
     end
     
+    def test_should_allow_customized_event_key_scoped_to_class
+      I18n.backend.store_translations(:en, {
+        :activemodel => {:state_machines => {:'active_model_test/foo' => {:events => {:park => 'stop'}}}}
+      })
+      
+      machine = StateMachine::Machine.new(@model)
+      machine.event :park
+      
+      assert_equal 'stop', machine.event(:park).human_name
+    end
+    
     def test_should_allow_customized_event_key_scoped_to_machine
       I18n.backend.store_translations(:en, {
         :activemodel => {:state_machines => {:state => {:events => {:park => 'stop'}}}}