state_machine 1.1.0 → 1.1.1

data/lib/state_machine/node_collection.rb

@@ -2,6 +2,8 @@ require 'state_machine/assertions'
 
 module StateMachine
   # Represents a collection of nodes in a state machine, be it events or states.
+  # Nodes will not differentiate between the String and Symbol versions of the
+  # values being indexed.
   class NodeCollection
     include Enumerable
     include Assertions
@@ -22,7 +24,13 @@ module StateMachine
       
       @machine = machine
       @nodes = []
-      @indices = Array(options[:index]).inject({}) {|indices, attribute| indices[attribute] = {}; indices}
+      @index_names = Array(options[:index])
+      @indices = @index_names.inject({}) do |indices, name|
+        indices[name] = {}
+        indices[:"#{name}_to_s"] = {}
+        indices[:"#{name}_to_sym"] = {}
+        indices
+      end
       @default_index = Array(options[:index]).first
       @contexts = []
     end
@@ -79,7 +87,7 @@ module StateMachine
     # that match the new node.
     def <<(node)
       @nodes << node
-      @indices.each {|attribute, index| index[value(node, attribute)] = node}
+      @index_names.each {|name| add_to_index(name, value(node, name), node)}
       @contexts.each {|context| eval_context(context, node)}
       self
     end
@@ -93,16 +101,7 @@ module StateMachine
     # has changed since it was added to the collection, the old indexed keys
     # will be replaced with the updated ones.
     def update(node)
-      @indices.each do |attribute, index|
-        old_key = RUBY_VERSION < '1.9' ? index.index(node) : index.key(node)
-        new_key = value(node, attribute)
-        
-        # Only replace the key if it's changed
-        if old_key != new_key
-          index.delete(old_key)
-          index[new_key] = node
-        end
-      end
+      @index_names.each {|name| update_index(name, node)}
     end
     
     # Calls the block once for each element in self, passing that element as a
@@ -144,12 +143,10 @@ module StateMachine
     # 
     # If the key cannot be found, then nil will be returned.
     def [](key, index_name = @default_index)
-      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
+      self.index(index_name)[key] ||
+      self.index(:"#{index_name}_to_s")[key.to_s] ||
+      to_sym?(key) && self.index(:"#{index_name}_to_sym")[:"#{key}"] ||
+      nil
     end
     
     # Gets the node indexed by the given key.  By default, this will look up the
@@ -181,6 +178,41 @@ module StateMachine
         node.send(attribute)
       end
       
+      # Adds the given key / node combination to an index, including the string
+      # and symbol versions of the index
+      def add_to_index(name, key, node)
+        index(name)[key] = node
+        index(:"#{name}_to_s")[key.to_s] = node
+        index(:"#{name}_to_sym")[:"#{key}"] = node if to_sym?(key)
+      end
+      
+      # Removes the given key from an index, including the string and symbol
+      # versions of the index
+      def remove_from_index(name, key)
+        index(name).delete(key)
+        index(:"#{name}_to_s").delete(key.to_s)
+        index(:"#{name}_to_sym").delete(:"#{key}") if to_sym?(key)
+      end
+      
+      # Updates the node for the given index, including the string and symbol
+      # versions of the index
+      def update_index(name, node)
+        index = self.index(name)
+        old_key = RUBY_VERSION < '1.9' ? index.index(node) : index.key(node)
+        new_key = value(node, name)
+        
+        # Only replace the key if it's changed
+        if old_key != new_key
+          remove_from_index(name, old_key)
+          add_to_index(name, new_key, node)
+        end
+      end
+      
+      # Determines whether the given value can be converted to a symbol
+      def to_sym?(value)
+        "#{value}" != ''
+      end
+      
       # Evaluates the given context for a particular node.  This will only
       # evaluate the context if the node matches.
       def eval_context(context, node)

data/lib/state_machine/state.rb

@@ -96,11 +96,6 @@ 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

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, :name_to_s, :qualified_name, :value])
+      super(machine, :index => [:name, :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.1.0'
+  VERSION = '1.1.1'
 end

data/test/unit/event_collection_test.rb

@@ -47,6 +47,40 @@ class EventCollectionTest < Test::Unit::TestCase
   def test_should_index_by_qualified_name
     assert_equal @open, @events[:enable_alarm, :qualified_name]
   end
+  
+  def test_should_index_by_string_qualified_name
+    assert_equal @open, @events['enable_alarm', :qualified_name]
+  end
+end
+
+class EventStringCollectionTest < Test::Unit::TestCase
+  def setup
+    machine = StateMachine::Machine.new(Class.new, :namespace => 'alarm')
+    @events = StateMachine::EventCollection.new(machine)
+    
+    @events << @open = StateMachine::Event.new(machine, 'enable')
+    machine.events.concat(@events)
+  end
+  
+  def test_should_index_by_name
+    assert_equal @open, @events['enable', :name]
+  end
+  
+  def test_should_index_by_name_by_default
+    assert_equal @open, @events['enable']
+  end
+  
+  def test_should_index_by_symbol_name
+    assert_equal @open, @events[:enable]
+  end
+  
+  def test_should_index_by_qualified_name
+    assert_equal @open, @events['enable_alarm', :qualified_name]
+  end
+  
+  def test_should_index_by_symbol_qualified_name
+    assert_equal @open, @events[:enable_alarm, :qualified_name]
+  end
 end
 
 class EventCollectionWithEventsWithTransitionsTest < Test::Unit::TestCase

data/test/unit/integrations/data_mapper_test.rb

@@ -107,6 +107,44 @@ module DataMapperTest
     end
   end
   
+  class MachineWithoutPropertyTest < BaseTestCase
+    def setup
+      @resource = new_resource
+      StateMachine::Machine.new(@resource, :status)
+    end
+    
+    def test_should_define_field_with_string_type
+      property = @resource.properties.detect {|property| property.name == :status}
+      assert_not_nil property
+      
+      if Gem::Version.new(::DataMapper::VERSION) >= Gem::Version.new('1.0.0')
+        assert_instance_of DataMapper::Property::String, property
+      else
+        assert_equal String, property.type
+      end
+    end
+  end
+  
+  class MachineWithPropertyTest < BaseTestCase
+    def setup
+      @resource = new_resource do
+        property :status, Integer
+      end
+      StateMachine::Machine.new(@resource, :status)
+    end
+    
+    def test_should_not_redefine_field
+      property = @resource.properties.detect {|property| property.name == :status}
+      assert_not_nil property
+      
+      if Gem::Version.new(::DataMapper::VERSION) >= Gem::Version.new('1.0.0')
+        assert_instance_of DataMapper::Property::Integer, property
+      else
+        assert_equal Integer, property.type
+      end
+    end
+  end
+  
   class MachineByDefaultTest < BaseTestCase
     def setup
       @resource = new_resource

data/test/unit/integrations/mongo_mapper_test.rb

@@ -75,6 +75,34 @@ module MongoMapperTest
     end
   end
   
+  class MachineWithoutKeyTest < BaseTestCase
+    def setup
+      @model = new_model
+      StateMachine::Machine.new(@model, :status)
+    end
+    
+    def test_should_define_field_with_string_type
+      key = @model.keys['status']
+      assert_not_nil key
+      assert_equal String, key.type
+    end
+  end
+  
+  class MachineWithKeyTest < BaseTestCase
+    def setup
+      @model = new_model do
+        key :status, Integer
+      end
+      StateMachine::Machine.new(@model, :status)
+    end
+    
+    def test_should_not_redefine_field
+      key = @model.keys['status']
+      assert_not_nil key
+      assert_equal Integer, key.type
+    end
+  end
+  
   class MachineByDefaultTest < BaseTestCase
     def setup
       @model = new_model

data/test/unit/integrations/mongoid_test.rb

@@ -62,6 +62,34 @@ module MongoidTest
     end
   end
   
+  class MachineWithoutFieldTest < BaseTestCase
+    def setup
+      @model = new_model
+      StateMachine::Machine.new(@model, :status)
+    end
+    
+    def test_should_define_field_with_string_type
+      field = @model.fields['status']
+      assert_not_nil field
+      assert_equal String, field.type
+    end
+  end
+  
+  class MachineWithFieldTest < BaseTestCase
+    def setup
+      @model = new_model do
+        field :status, :type => Integer
+      end
+      StateMachine::Machine.new(@model, :status)
+    end
+    
+    def test_should_not_redefine_field
+      field = @model.fields['status']
+      assert_not_nil field
+      assert_equal Integer, field.type
+    end
+  end
+  
   class MachineByDefaultTest < BaseTestCase
     def setup
       @model = new_model

data/test/unit/machine_test.rb

@@ -2082,6 +2082,15 @@ class MachineWithStatesTest < Test::Unit::TestCase
     exception = assert_raise(ArgumentError) {@machine.state(:first_gear, :invalid => true)}
     assert_equal 'Invalid key(s): invalid', exception.message
   end
+  
+  def test_should_raise_exception_if_conflicting_type_used_for_name
+    exception = assert_raise(ArgumentError) { @machine.state 'first_gear' }
+    assert_equal '"first_gear" state defined as String, :parked defined as Symbol; all states must be consistent', exception.message
+  end
+  
+  def test_should_not_raise_exception_if_conflicting_type_is_nil_for_name
+    assert_nothing_raised { @machine.state nil }
+  end
 end
 
 class MachineWithStatesWithCustomValuesTest < Test::Unit::TestCase
@@ -2320,6 +2329,12 @@ class MachineWithEventsTest < Test::Unit::TestCase
     exception = assert_raise(IndexError) {@klass.human_state_event_name(:invalid)}
     assert_equal ':invalid is an invalid name', exception.message
   end
+  
+  def test_should_raise_exception_if_conflicting_type_used_for_name
+    @machine.event :park
+    exception = assert_raise(ArgumentError) {  @machine.event 'ignite' }
+    assert_equal '"ignite" event defined as String, :park defined as Symbol; all events must be consistent', exception.message
+  end
 end
 
 class MachineWithExistingEventTest < Test::Unit::TestCase

data/test/unit/node_collection_test.rb

@@ -1,10 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 class Node < Struct.new(:name, :value, :machine)
-  def name_to_s
-    name.to_s
-  end
-  
   def context
     yield
   end
@@ -246,7 +242,7 @@ end
 class NodeCollectionWithStringIndexTest < Test::Unit::TestCase
   def setup
     machine = StateMachine::Machine.new(Class.new)
-    @collection = StateMachine::NodeCollection.new(machine, :index => [:name, :name_to_s, :value])
+    @collection = StateMachine::NodeCollection.new(machine, :index => [:name, :value])
     
     @parked = Node.new(:parked, 1)
     @collection << @parked
@@ -257,15 +253,47 @@ class NodeCollectionWithStringIndexTest < Test::Unit::TestCase
   end
   
   def test_should_index_by_string_name
-    assert_equal @parked, @collection['parked', :name_to_s]
+    assert_equal @parked, @collection['parked']
+  end
+end
+
+class NodeCollectionWithSymbolIndexTest < Test::Unit::TestCase
+  def setup
+    machine = StateMachine::Machine.new(Class.new)
+    @collection = StateMachine::NodeCollection.new(machine, :index => [:name, :value])
+    
+    @parked = Node.new('parked', 1)
+    @collection << @parked
   end
   
-  def test_should_fallback_to_string_index
+  def test_should_index_by_name
     assert_equal @parked, @collection['parked']
   end
   
-  def test_should_not_fallback_to_string_index_if_not_available
-    assert_nil @collection['1', :value]
+  def test_should_index_by_symbol_name
+    assert_equal @parked, @collection[:parked]
+  end
+end
+
+class NodeCollectionWithNumericIndexTest < Test::Unit::TestCase
+  def setup
+    machine = StateMachine::Machine.new(Class.new)
+    @collection = StateMachine::NodeCollection.new(machine, :index => [:name, :value])
+    
+    @parked = Node.new(10, 1)
+    @collection << @parked
+  end
+  
+  def test_should_index_by_name
+    assert_equal @parked, @collection[10]
+  end
+  
+  def test_should_index_by_string_name
+    assert_equal @parked, @collection['10']
+  end
+  
+  def test_should_index_by_symbol_name
+    assert_equal @parked, @collection[:'10']
   end
 end
 

data/test/unit/state_collection_test.rb

@@ -49,6 +49,10 @@ class StateCollectionTest < Test::Unit::TestCase
     assert_equal @parked, @states[:parked, :qualified_name]
   end
   
+  def test_should_index_by_string_qualified_name
+    assert_equal @parked, @states['parked', :qualified_name]
+  end
+  
   def test_should_index_by_value
     assert_equal @parked, @states['parked', :value]
   end
@@ -88,6 +92,40 @@ class StateCollectionTest < Test::Unit::TestCase
   end
 end
 
+class StateCollectionStringTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @states = StateMachine::StateCollection.new(@machine)
+    
+    @states << @nil = StateMachine::State.new(@machine, nil)
+    @states << @parked = StateMachine::State.new(@machine, 'parked')
+    @machine.states.concat(@states)
+    
+    @object = @klass.new
+  end
+  
+  def test_should_index_by_name
+    assert_equal @parked, @states['parked', :name]
+  end
+  
+  def test_should_index_by_name_by_default
+    assert_equal @parked, @states['parked']
+  end
+  
+  def test_should_index_by_symbol_name
+    assert_equal @parked, @states[:parked]
+  end
+  
+  def test_should_index_by_qualified_name
+    assert_equal @parked, @states['parked', :qualified_name]
+  end
+  
+  def test_should_index_by_symbol_qualified_name
+    assert_equal @parked, @states[:parked, :qualified_name]
+  end
+end
+
 class StateCollectionWithNamespaceTest < Test::Unit::TestCase
   def setup
     @klass = Class.new

data/test/unit/state_test.rb

@@ -15,7 +15,7 @@ class StateByDefaultTest < Test::Unit::TestCase
   end
   
   def test_should_have_a_qualified_name
-    assert_equal :parked, @state.name
+    assert_equal :parked, @state.qualified_name
   end
   
   def test_should_have_a_human_name