state_machine 1.0.0 → 1.0.1

data/CHANGELOG.rdoc

@@ -1,5 +1,13 @@
 == master
 
+== 1.0.1 / 2011-05-30
+
+* Add the ability to ignore method conflicts for helpers
+* Generate warnings for any helper, not just state helpers, that has a conflicting method defined in the class
+* Fix scopes in Sequel not working if the table name contains double underscores or is not a string/symbol
+* Add full support for chaining state scopes within Sequel integrations
+* Fix Rails 3.1 deprecation warnings for configuring engine locales [Stefan Penner]
+
 == 1.0.0 / 2011-05-12
 
 * Celebrate

data/Rakefile

@@ -6,7 +6,7 @@ require 'rake/gempackagetask'
 
 spec = Gem::Specification.new do |s|
   s.name              = 'state_machine'
-  s.version           = '1.0.0'
+  s.version           = '1.0.1'
   s.platform          = Gem::Platform::RUBY
   s.summary           = 'Adds support for creating state machines for attributes on any Ruby class'
   s.description       = s.summary

data/lib/state_machine/initializers/rails.rb

@@ -13,7 +13,11 @@ if defined?(Rails)
       end
     end
     
-    StateMachine::RailsEngine.paths.config.locales = locale_paths
+    if Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR == 0
+      StateMachine::RailsEngine.paths.config.locales = locale_paths
+    else
+      StateMachine::RailsEngine.paths['config/locales'] = locale_paths
+    end
   elsif defined?(I18n)
     # Rails 2.x
     I18n.load_path.unshift(*locale_paths)

data/lib/state_machine/integrations/active_record.rb

@@ -416,8 +416,8 @@ module StateMachine
         # ActiveModel's use of method_missing / respond_to for attribute methods
         # breaks both ancestor lookups and defined?(super).  Need to special-case
         # the existence of query attribute methods.
-        def owner_class_ancestor_has_method?(method)
-          method == "#{name}?" || super
+        def owner_class_ancestor_has_method?(scope, method)
+          scope == :instance && method == "#{name}?" || super
         end
     end
   end

data/lib/state_machine/integrations/mongo_mapper.rb

@@ -264,8 +264,8 @@ module StateMachine
         # ActiveModel's use of method_missing / respond_to for attribute methods
         # breaks both ancestor lookups and defined?(super).  Need to special-case
         # the existence of query attribute methods.
-        def owner_class_ancestor_has_method?(method)
-          method == "#{name}?" || super
+        def owner_class_ancestor_has_method?(scope, method)
+          scope == :instance && method == "#{name}?" || super
         end
     end
   end

data/lib/state_machine/integrations/mongoid.rb

@@ -349,8 +349,8 @@ module StateMachine
         # ActiveModel's use of method_missing / respond_to for attribute methods
         # breaks both ancestor lookups and defined?(super).  Need to special-case
         # the existence of query attribute methods.
-        def owner_class_ancestor_has_method?(method)
-          method == "#{name}?" || super
+        def owner_class_ancestor_has_method?(scope, method)
+          scope == :instance && method == "#{name}?" || super
         end
     end
   end

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

@@ -26,6 +26,10 @@ module StateMachine
         def action_hook
           action == :save ? :save : super
         end
+        
+        def model_from_dataset(dataset)
+          dataset.model_classes[nil]
+        end
       end
     end
   end

data/lib/state_machine/integrations/sequel.rb

@@ -374,13 +374,39 @@ module StateMachine
         # Creates a scope for finding records *with* a particular state or
         # states for the attribute
         def create_with_scope(name)
-          lambda {|model, values| model.filter(:"#{owner_class.table_name}__#{attribute}" => values)}
+          create_scope(name, lambda {|dataset, values| dataset.filter(attribute_column => values)})
         end
         
         # Creates a scope for finding records *without* a particular state or
         # states for the attribute
         def create_without_scope(name)
-          lambda {|model, values| model.filter(~{:"#{owner_class.table_name}__#{attribute}" => values})}
+          create_scope(name, lambda {|dataset, values| dataset.exclude(attribute_column => values)})
+        end
+
+        # Creates a new named scope with the given name
+        def create_scope(name, scope)
+          machine = self
+          owner_class.def_dataset_method(name) do |*states|
+            machine.send(:run_scope, scope, self, states)
+          end
+          
+          false
+        end
+        
+        # Generates the results for the given scope based on one or more states to
+        # filter by
+        def run_scope(scope, dataset, states)
+          super(scope, model_from_dataset(dataset).state_machine(name), dataset, states)
+        end
+        
+        # Determines the model associated with the given dataset
+        def model_from_dataset(dataset)
+          dataset.model
+        end
+        
+        # Generates the fully-qualifed column name for this machine's attribute
+        def attribute_column
+          ::Sequel::SQL::QualifiedIdentifier.new(owner_class.table_name, attribute)
         end
         
         # Runs a new database transaction, rolling back any changes if the

data/lib/state_machine/machine.rb

@@ -376,6 +376,11 @@ module StateMachine
       :invalid_transition => 'cannot transition via "%s"'
     }
     
+    # Whether to ignore any conflicts that are detected for helper methods that
+    # get generated for a machine's owner class.  Default is false.
+    class << self; attr_accessor :ignore_method_conflicts; end
+    @ignore_method_conflicts = false
+    
     # The class that the machine is defined in
     attr_accessor :owner_class
     
@@ -583,6 +588,11 @@ module StateMachine
     # name.  If the method is already defined in the scope, then this will not
     # override it.
     # 
+    # If passing in a block, there are two side effects to be aware of
+    # 1. The method cannot be chained, meaning that the block cannot call +super+
+    # 2. If the method is already defined in an ancestor, then it will not get
+    #    overridden and a warning will be output.
+    # 
     # Example:
     # 
     #   # Instance helper
@@ -611,15 +621,22 @@ module StateMachine
     #     end
     #   end_eval
     def define_helper(scope, method, *args, &block)
+      helper_module = @helper_modules.fetch(scope)
+      
       if block_given?
-        name = self.name
-        @helper_modules.fetch(scope).class_eval do
-          define_method(method) do |*args|
-            block.call((scope == :instance ? self.class : self).state_machine(name), self, *args)
+        if !self.class.ignore_method_conflicts && conflicting_ancestor = owner_class_ancestor_has_method?(scope, method)
+          ancestor_name = conflicting_ancestor.name && !conflicting_ancestor.name.empty? ? conflicting_ancestor.name : conflicting_ancestor.to_s
+          warn "#{scope == :class ? 'Class' : 'Instance'} method \"#{method}\" is already defined in #{ancestor_name}, use generic helper instead."
+        else
+          name = self.name
+          helper_module.class_eval do
+            define_method(method) do |*args|
+              block.call((scope == :instance ? self.class : self).state_machine(name), self, *args)
+            end
           end
         end
       else
-        @helper_modules.fetch(scope).class_eval(method, *args)
+        helper_module.class_eval(method, *args)
       end
     end
     
@@ -1585,13 +1602,14 @@ module StateMachine
       def define_state_accessor
         attribute = self.attribute
         
-        @helper_modules[:instance].class_eval { attr_accessor attribute }
+        @helper_modules[:instance].class_eval { attr_reader attribute } unless owner_class_ancestor_has_method?(:instance, attribute)
+        @helper_modules[:instance].class_eval { attr_writer attribute } unless owner_class_ancestor_has_method?(:instance, "#{attribute}=")
       end
       
       # Adds predicate method to the owner class for determining the name of the
       # current state
       def define_state_predicate
-        call_super = owner_class_ancestor_has_method?("#{name}?")
+        call_super = !!owner_class_ancestor_has_method?(:instance, "#{name}?")
         define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
           def #{name}?(*args)
             args.empty? && #{call_super} ? super : self.class.state_machine(#{name.inspect}).states.matches?(self, *args)
@@ -1686,14 +1704,35 @@ module StateMachine
       # action must be defined in an ancestor of the owner classs in order for
       # it to be the action hook.
       def action_hook
-        action && owner_class_ancestor_has_method?(action) ? action : nil
+        action && owner_class_ancestor_has_method?(:instance, action) ? action : nil
       end
       
-      # Determines whether any of the ancestors for this machine's owner class
-      # has the given method defined, even if it's private.
-      def owner_class_ancestor_has_method?(method)
-        owner_class.ancestors.any? do |ancestor|
-          ancestor != owner_class && (ancestor.method_defined?(method) || ancestor.private_method_defined?(method))
+      # Determines whether there's already a helper method defined within the
+      # given scope.  This is true only if one of the owner's ancestors defines
+      # the method and is further along in the ancestor chain than this
+      # machine's helper module.
+      def owner_class_ancestor_has_method?(scope, method)
+        superclasses = owner_class.ancestors[1..-1].select {|ancestor| ancestor.is_a?(Class)}
+        
+        if scope == :class
+          # Use singleton classes
+          current = (class << owner_class; self; end)
+          superclass = superclasses.first
+        else
+          current = owner_class
+          superclass = owner_class.superclass
+        end
+        
+        # Generate the list of modules that *only* occur in the owner class, but
+        # were included *prior* to the helper modules, in addition to the
+        # superclasses
+        ancestors = current.ancestors - superclass.ancestors + superclasses
+        ancestors = ancestors[ancestors.index(@helper_modules[scope]) + 1..-1].reverse
+        
+        # Search for for the first ancestor that defined this method
+        ancestors.detect do |ancestor|
+          ancestor = (class << ancestor; self; end) if scope == :class && ancestor.is_a?(Class)
+          ancestor.method_defined?(method) || ancestor.private_method_defined?(method)
         end
       end
       
@@ -1737,14 +1776,20 @@ module StateMachine
               # Converts state names to their corresponding values so that they
               # can be looked up properly
               define_helper(:class, method) do |machine, klass, *states|
-                values = states.flatten.map {|state| machine.states.fetch(state).value}
-                scope.call(klass, values)
+                run_scope(scope, machine, klass, states)
               end
             end
           end
         end
       end
       
+      # Generates the results for the given scope based on one or more states to
+      # filter by
+      def run_scope(scope, machine, klass, states)
+        values = states.flatten.map {|state| machine.states.fetch(state).value}
+        scope.call(klass, values)
+      end
+      
       # Pluralizes the given word using #pluralize (if available) or simply
       # adding an "s" to the end of the word 
       def pluralize(word)

data/lib/state_machine/state.rb

@@ -260,19 +260,11 @@ module StateMachine
       end
       
       # Adds a predicate method to the owner class so long as a name has
-      # actually been configured for the state and the method isn't already
-      # defined in the owner class.
+      # actually been configured for the state
       def add_predicate
-        owner_class = machine.owner_class
-        predicate = "#{qualified_name}?"
-        if !owner_class.method_defined?(predicate) && !owner_class.private_method_defined?(predicate)
-          # Checks whether the current value matches this state
-          machine.define_helper(:instance, predicate) do |machine, object|
-            machine.states.matches?(object, name)
-          end
-        else
-          # Only output a warning since we can't defined the predicate
-          warn "#{owner_class.name}##{predicate} is already defined, use #{owner_class.name}##{machine.name}?(:#{name}) instead."
+        # Checks whether the current value matches this state
+        machine.define_helper(:instance, "#{qualified_name}?") do |machine, object|
+          machine.states.matches?(object, name)
         end
       end
   end

data/test/unit/event_test.rb

@@ -127,8 +127,68 @@ class EventWithDynamicHumanNameTest < Test::Unit::TestCase
   end
 end
 
-class EventWithConflictingHelpersTest < Test::Unit::TestCase
+class EventWithConflictingHelpersBeforeDefinitionTest < Test::Unit::TestCase
   def setup
+    require 'stringio'
+    @original_stderr, $stderr = $stderr, StringIO.new
+    
+    @superclass = Class.new do
+      def can_ignite?
+        0
+      end
+      
+      def ignite_transition
+        0
+      end
+      
+      def ignite
+        0
+      end
+      
+      def ignite!
+        0
+      end
+    end
+    @klass = Class.new(@superclass)
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.events << @event = StateMachine::Event.new(@machine, :ignite)
+    @object = @klass.new
+  end
+  
+  def test_should_not_redefine_predicate
+    assert_equal 0, @object.can_ignite?
+  end
+  
+  def test_should_not_redefine_transition_accessor
+    assert_equal 0, @object.ignite_transition
+  end
+  
+  def test_should_not_redefine_action
+    assert_equal 0, @object.ignite
+  end
+  
+  def test_should_not_redefine_bang_action
+    assert_equal 0, @object.ignite!
+  end
+  
+  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"
+    end.join
+    
+    assert_equal expected, $stderr.string
+  end
+  
+  def teardown
+    $stderr = @original_stderr
+  end
+end
+
+class EventWithConflictingHelpersAfterDefinitionTest < Test::Unit::TestCase
+  def setup
+    require 'stringio'
+    @original_stderr, $stderr = $stderr, StringIO.new
+    
     @klass = Class.new do
       def can_ignite?
         0
@@ -170,31 +230,34 @@ class EventWithConflictingHelpersTest < Test::Unit::TestCase
   def test_should_allow_super_chaining
     @klass.class_eval do
       def can_ignite?
-        super ? 1 : 0
+        super
       end
       
       def ignite_transition
-        super ? 1 : 0
+        super
       end
       
       def ignite
-        super ? 1 : 0
+        super
       end
       
       def ignite!
-        begin
-          super
-          1
-        rescue Exception => ex
-          0
-        end
+        super
       end
     end
     
-    assert_equal 0, @object.can_ignite?
-    assert_equal 0, @object.ignite_transition
-    assert_equal 0, @object.ignite
-    assert_equal 1, @object.ignite!
+    assert_equal false, @object.can_ignite?
+    assert_equal nil, @object.ignite_transition
+    assert_equal false, @object.ignite
+    assert_raise(StateMachine::InvalidTransition) { @object.ignite! }
+  end
+  
+  def test_should_not_output_warning
+    assert_equal '', $stderr.string
+  end
+  
+  def teardown
+    $stderr = @original_stderr
   end
 end
 

data/test/unit/integrations/sequel_test.rb

@@ -20,11 +20,11 @@ module SequelTest
       def new_model(create_table = :foo, &block)
         table_name = create_table || :foo
         
-        DB.create_table!(table_name) do
+        DB.create_table!(::Sequel::SQL::Identifier.new(table_name)) do
           primary_key :id
           column :state, :string
         end if create_table
-        model = Class.new(Sequel::Model(table_name)) do
+        model = Class.new(Sequel::Model(DB[::Sequel::SQL::Identifier.new(table_name)])) do
           self.raise_on_save_failure = false
           (class << self; self; end).class_eval do
             define_method(:name) { "SequelTest::#{table_name.to_s.capitalize}" }
@@ -1426,7 +1426,19 @@ module SequelTest
       parked = @model.create :state => 'parked'
       idling = @model.create :state => 'idling'
       
-      assert_equal [idling], @model.without_state(:parked).filter(:state => 'idling').all
+      assert_equal [idling], @model.without_state(:parked).with_state(:idling).all
+    end
+    
+    def test_should_run_on_tables_with_double_underscores
+      @model = new_model(:foo__bar)
+      @machine = StateMachine::Machine.new(@model)
+      @machine.state :parked, :first_gear
+      @machine.state :idling, :value => lambda {'idling'}
+      
+      parked = @model.create :state => 'parked'
+      idling = @model.create :state => 'idling'
+      
+      assert_equal [parked], @model.with_state(:parked).all
     end
   end
   

data/test/unit/machine_test.rb

@@ -1114,6 +1114,104 @@ class MachineWithInstanceHelpersTest < Test::Unit::TestCase
     assert_equal 'parked', @object.send(:state)
   end
   
+  def test_should_warn_if_defined_in_superclass
+    require 'stringio'
+    @original_stderr, $stderr = $stderr, StringIO.new
+    
+    superclass = Class.new do
+      def park
+      end
+    end
+    klass = Class.new(superclass)
+    machine = StateMachine::Machine.new(klass)
+    
+    machine.define_helper(:instance, :park) {}
+    assert_equal "Instance method \"park\" is already defined in #{superclass.to_s}, use generic helper instead.\n", $stderr.string
+  ensure
+    $stderr = @original_stderr
+  end
+  
+  def test_should_warn_if_defined_in_multiple_superclasses
+    require 'stringio'
+    @original_stderr, $stderr = $stderr, StringIO.new
+    
+    superclass1 = Class.new do
+      def park
+      end
+    end
+    superclass2 = Class.new(superclass1) do
+      def park
+      end
+    end
+    klass = Class.new(superclass2)
+    machine = StateMachine::Machine.new(klass)
+    
+    machine.define_helper(:instance, :park) {}
+    assert_equal "Instance method \"park\" is already defined in #{superclass1.to_s}, use generic helper instead.\n", $stderr.string
+  ensure
+    $stderr = @original_stderr
+  end
+  
+  def test_should_warn_if_defined_in_module_prior_to_helper_module
+    require 'stringio'
+    @original_stderr, $stderr = $stderr, StringIO.new
+    
+    mod = Module.new do
+      def park
+      end
+    end
+    klass = Class.new do
+      include mod
+    end
+    machine = StateMachine::Machine.new(klass)
+    
+    machine.define_helper(:instance, :park) {}
+    assert_equal "Instance method \"park\" is already defined in #{mod.to_s}, use generic helper instead.\n", $stderr.string
+  ensure
+    $stderr = @original_stderr
+  end
+  
+  def test_should_not_warn_if_defined_in_module_after_helper_module
+    require 'stringio'
+    @original_stderr, $stderr = $stderr, StringIO.new
+    
+    klass = Class.new
+    machine = StateMachine::Machine.new(klass)
+    
+    mod = Module.new do
+      def park
+      end
+    end
+    klass.class_eval do
+      include mod
+    end
+    
+    machine.define_helper(:instance, :park) {}
+    assert_equal '', $stderr.string
+  ensure
+    $stderr = @original_stderr
+  end
+  
+  def test_should_define_if_ignoring_method_conflicts_and_defined_in_superclass
+    require 'stringio'
+    @original_stderr, $stderr = $stderr, StringIO.new
+    StateMachine::Machine.ignore_method_conflicts = true
+    
+    superclass = Class.new do
+      def park
+      end
+    end
+    klass = Class.new(superclass)
+    machine = StateMachine::Machine.new(klass)
+    
+    machine.define_helper(:instance, :park) {true}
+    assert_equal '', $stderr.string
+    assert_equal true, klass.new.park
+  ensure
+    StateMachine::Machine.ignore_method_conflicts = false
+    $stderr = @original_stderr
+  end
+  
   def test_should_define_nonexistent_methods
     @machine.define_helper(:instance, :state) {'parked'}
     assert_equal 'parked', @object.state
@@ -1186,6 +1284,104 @@ class MachineWithClassHelpersTest < Test::Unit::TestCase
     assert_equal [], @klass.send(:states)
   end
   
+  def test_should_warn_if_defined_in_superclass
+    require 'stringio'
+    @original_stderr, $stderr = $stderr, StringIO.new
+    
+    superclass = Class.new do
+      def self.park
+      end
+    end
+    klass = Class.new(superclass)
+    machine = StateMachine::Machine.new(klass)
+    
+    machine.define_helper(:class, :park) {}
+    assert_equal "Class method \"park\" is already defined in #{superclass.to_s}, use generic helper instead.\n", $stderr.string
+  ensure
+    $stderr = @original_stderr
+  end
+  
+  def test_should_warn_if_defined_in_multiple_superclasses
+    require 'stringio'
+    @original_stderr, $stderr = $stderr, StringIO.new
+    
+    superclass1 = Class.new do
+      def self.park
+      end
+    end
+    superclass2 = Class.new(superclass1) do
+      def self.park
+      end
+    end
+    klass = Class.new(superclass2)
+    machine = StateMachine::Machine.new(klass)
+    
+    machine.define_helper(:class, :park) {}
+    assert_equal "Class method \"park\" is already defined in #{superclass1.to_s}, use generic helper instead.\n", $stderr.string
+  ensure
+    $stderr = @original_stderr
+  end
+  
+  def test_should_warn_if_defined_in_module_prior_to_helper_module
+    require 'stringio'
+    @original_stderr, $stderr = $stderr, StringIO.new
+    
+    mod = Module.new do
+      def park
+      end
+    end
+    klass = Class.new do
+      extend mod
+    end
+    machine = StateMachine::Machine.new(klass)
+    
+    machine.define_helper(:class, :park) {}
+    assert_equal "Class method \"park\" is already defined in #{mod.to_s}, use generic helper instead.\n", $stderr.string
+  ensure
+    $stderr = @original_stderr
+  end
+  
+  def test_should_not_warn_if_defined_in_module_after_helper_module
+    require 'stringio'
+    @original_stderr, $stderr = $stderr, StringIO.new
+    
+    klass = Class.new
+    machine = StateMachine::Machine.new(klass)
+    
+    mod = Module.new do
+      def park
+      end
+    end
+    klass.class_eval do
+      extend mod
+    end
+    
+    machine.define_helper(:class, :park) {}
+    assert_equal '', $stderr.string
+  ensure
+    $stderr = @original_stderr
+  end
+  
+  def test_should_define_if_ignoring_method_conflicts_and_defined_in_superclass
+    require 'stringio'
+    @original_stderr, $stderr = $stderr, StringIO.new
+    StateMachine::Machine.ignore_method_conflicts = true
+    
+    superclass = Class.new do
+      def self.park
+      end
+    end
+    klass = Class.new(superclass)
+    machine = StateMachine::Machine.new(klass)
+    
+    machine.define_helper(:class, :park) {true}
+    assert_equal '', $stderr.string
+    assert_equal true, klass.park
+  ensure
+    StateMachine::Machine.ignore_method_conflicts = false
+    $stderr = @original_stderr
+  end
+  
   def test_should_define_nonexistent_methods
     @machine.define_helper(:class, :states) {[]}
     assert_equal [], @klass.states
@@ -1217,8 +1413,176 @@ class MachineWithClassHelpersTest < Test::Unit::TestCase
   end
 end
 
-class MachineWithConflictingHelpersTest < Test::Unit::TestCase
+class MachineWithConflictingHelpersBeforeDefinitionTest < Test::Unit::TestCase
+  def setup
+    require 'stringio'
+    @original_stderr, $stderr = $stderr, StringIO.new
+    
+    @superclass = Class.new do
+      def self.with_state
+        :with_state
+      end
+      
+      def self.with_states
+        :with_states
+      end
+      
+      def self.without_state
+        :without_state
+      end
+      
+      def self.without_states
+        :without_states
+      end
+      
+      def self.human_state_name
+        :human_state_name
+      end
+      
+      def self.human_state_event_name
+        :human_state_event_name
+      end
+      
+      attr_accessor :status
+      
+      def state
+        'parked'
+      end
+      
+      def state=(value)
+        self.status = value
+      end
+      
+      def state?
+        true
+      end
+      
+      def state_name
+        :parked
+      end
+      
+      def human_state_name
+        'parked'
+      end
+      
+      def state_events
+        [:ignite]
+      end
+      
+      def state_transitions
+        [{:parked => :idling}]
+      end
+      
+      def state_paths
+        [[{:parked => :idling}]]
+      end
+    end
+    @klass = Class.new(@superclass)
+    
+    StateMachine::Integrations.const_set('Custom', Module.new do
+      include StateMachine::Integrations::Base
+      
+      def create_with_scope(name)
+        lambda {|klass, values| []}
+      end
+      
+      def create_without_scope(name)
+        lambda {|klass, values| []}
+      end
+    end)
+    
+    @machine = StateMachine::Machine.new(@klass, :integration => :custom)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+    @object = @klass.new
+  end
+  
+  def test_should_not_redefine_singular_with_scope
+    assert_equal :with_state, @klass.with_state
+  end
+  
+  def test_should_not_redefine_plural_with_scope
+    assert_equal :with_states, @klass.with_states
+  end
+  
+  def test_should_not_redefine_singular_without_scope
+    assert_equal :without_state, @klass.without_state
+  end
+  
+  def test_should_not_redefine_plural_without_scope
+    assert_equal :without_states, @klass.without_states
+  end
+  
+  def test_should_not_redefine_human_attribute_name_reader
+    assert_equal :human_state_name, @klass.human_state_name
+  end
+  
+  def test_should_not_redefine_human_event_name_reader
+    assert_equal :human_state_event_name, @klass.human_state_event_name
+  end
+  
+  def test_should_not_redefine_attribute_writer
+    assert_equal 'parked', @object.state
+  end
+  
+  def test_should_not_redefine_attribute_writer
+    @object.state = 'parked'
+    assert_equal 'parked', @object.status
+  end
+  
+  def test_should_not_define_attribute_predicate
+    assert @object.state?
+  end
+  
+  def test_should_not_redefine_attribute_name_reader
+    assert_equal :parked, @object.state_name
+  end
+  
+  def test_should_not_redefine_attribute_human_name_reader
+    assert_equal 'parked', @object.human_state_name
+  end
+  
+  def test_should_not_redefine_attribute_events_reader
+    assert_equal [:ignite], @object.state_events
+  end
+  
+  def test_should_not_redefine_attribute_transitions_reader
+    assert_equal [{:parked => :idling}], @object.state_transitions
+  end
+  
+  def test_should_not_redefine_attribute_paths_reader
+    assert_equal [[{:parked => :idling}]], @object.state_paths
+  end
+  
+  def test_should_output_warning
+    expected = [
+      'Instance method "state_events"',
+      'Instance method "state_transitions"',
+      'Instance method "state_paths"',
+      'Class method "human_state_name"',
+      'Class method "human_state_event_name"',
+      'Instance method "state_name"',
+      'Instance method "human_state_name"',
+      'Class method "with_state"',
+      'Class method "without_state"',
+      'Class method "with_states"',
+      'Class method "without_states"'
+    ].map {|method| "#{method} is already defined in #{@superclass.to_s}, use generic helper instead.\n"}.join
+    
+    assert_equal expected, $stderr.string
+  end
+  
+  def teardown
+    $stderr = @original_stderr
+    StateMachine::Integrations.send(:remove_const, 'Custom')
+  end
+end
+
+class MachineWithConflictingHelpersAfterDefinitionTest < Test::Unit::TestCase
   def setup
+    require 'stringio'
+    @original_stderr, $stderr = $stderr, StringIO.new
+    
     @klass = Class.new do
       def self.with_state
         :with_state
@@ -1357,84 +1721,89 @@ class MachineWithConflictingHelpersTest < Test::Unit::TestCase
   def test_should_allow_super_chaining
     @klass.class_eval do
       def self.with_state(*states)
-        super == []
+        super
       end
       
       def self.with_states(*states)
-        super == []
+        super
       end
       
       def self.without_state(*states)
-        super == []
+        super
       end
       
       def self.without_states(*states)
-        super == []
+        super
       end
       
       def self.human_state_name(state)
-        super == 'parked'
+        super
       end
       
       def self.human_state_event_name(event)
-        super == 'ignite'
+        super
       end
       
       attr_accessor :status
       
       def state
-        super || 'parked'
+        super
       end
       
       def state=(value)
         super
-        self.status = value
       end
       
       def state?(state)
-        super ? 1 : 0
+        super
       end
       
       def state_name
-        super == :parked ? 1 : 0
+        super
       end
       
       def human_state_name
-        super == 'parked' ? 1 : 0
+        super
       end
       
       def state_events
-        super == []
+        super
       end
       
       def state_transitions
-        super == []
+        super
       end
       
       def state_paths
-        super == []
+        super
       end
     end
     
-    assert_equal true, @klass.with_state
-    assert_equal true, @klass.with_states
-    assert_equal true, @klass.without_state
-    assert_equal true, @klass.without_states
-    assert_equal true, @klass.human_state_name(:parked)
-    assert_equal true, @klass.human_state_event_name(:ignite)
+    assert_equal [], @klass.with_state
+    assert_equal [], @klass.with_states
+    assert_equal [], @klass.without_state
+    assert_equal [], @klass.without_states
+    assert_equal 'parked', @klass.human_state_name(:parked)
+    assert_equal 'ignite', @klass.human_state_event_name(:ignite)
     
-    assert_equal 'parked', @object.state
+    assert_equal nil, @object.state
     @object.state = 'idling'
-    assert_equal 'idling', @object.status
-    assert_equal 0, @object.state?(:parked)
-    assert_equal 0, @object.state_name
-    assert_equal 0, @object.human_state_name
-    assert_equal true, @object.state_events
-    assert_equal true, @object.state_transitions
-    assert_equal true, @object.state_paths
+    assert_equal 'idling', @object.state
+    assert_equal nil, @object.status
+    assert_equal false, @object.state?(:parked)
+    assert_equal :idling, @object.state_name
+    assert_equal 'idling', @object.human_state_name
+    assert_equal [], @object.state_events
+    assert_equal [], @object.state_transitions
+    assert_equal [], @object.state_paths
+  end
+  
+  def test_should_not_output_warning
+    assert_equal '', $stderr.string
   end
   
   def teardown
+    $stderr = @original_stderr
     StateMachine::Integrations.send(:remove_const, 'Custom')
   end
 end

data/test/unit/state_test.rb

@@ -458,7 +458,36 @@ class StateNotFinalTest < Test::Unit::TestCase
   end
 end
 
-class StateWithConflictingHelpersTest < Test::Unit::TestCase
+class StateWithConflictingHelpersBeforeDefinitionTest < Test::Unit::TestCase
+  def setup
+    require 'stringio'
+    @original_stderr, $stderr = $stderr, StringIO.new
+    
+    @superclass = Class.new do
+      def parked?
+        0
+      end
+    end
+    @klass = Class.new(@superclass)
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.state :parked
+    @object = @klass.new
+  end
+  
+  def test_should_not_override_state_predicate
+    assert_equal 0, @object.parked?
+  end
+  
+  def test_should_output_warning
+    assert_equal "Instance method \"parked?\" is already defined in #{@superclass.to_s}, use generic helper instead.\n", $stderr.string
+  end
+  
+  def teardown
+    $stderr = @original_stderr
+  end
+end
+
+class StateWithConflictingHelpersAfterDefinitionTest < Test::Unit::TestCase
   def setup
     require 'stringio'
     @original_stderr, $stderr = $stderr, StringIO.new
@@ -477,18 +506,18 @@ class StateWithConflictingHelpersTest < Test::Unit::TestCase
     assert_equal 0, @object.parked?
   end
   
-  def test_should_not_allow_super_chaining
+  def test_should_still_allow_super_chaining
     @klass.class_eval do
       def parked?
-        super ? 1 : 0
+        super
       end
     end
     
-    assert_raise(NoMethodError) { @object.parked? }
+    assert_equal false, @object.parked?
   end
   
-  def test_should_output_warning
-    assert_equal "#parked? is already defined, use #state?(:parked) instead.\n", $stderr.string
+  def test_should_not_output_warning
+    assert_equal '', $stderr.string
   end
   
   def teardown
@@ -496,7 +525,7 @@ class StateWithConflictingHelpersTest < Test::Unit::TestCase
   end
 end
 
-class EventWithConflictingMachineTest < Test::Unit::TestCase
+class StateWithConflictingMachineTest < Test::Unit::TestCase
   def setup
     require 'stringio'
     @original_stderr, $stderr = $stderr, StringIO.new

data/test/unit/transition_test.rb

@@ -1508,7 +1508,7 @@ class TransitionEqualityTest < Test::Unit::TestCase
   end
   
   def test_should_not_be_equal_with_different_machines
-    machine = StateMachine::Machine.new(@klass, :namespace => :other)
+    machine = StateMachine::Machine.new(@klass, :status, :namespace => :other)
     machine.state :parked, :idling
     machine.event :ignite
     transition = StateMachine::Transition.new(@object, machine, :ignite, :parked, :idling)

metadata

@@ -1,33 +1,23 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: state_machine
-version: !ruby/object:Gem::Version 
-  hash: 23
-  prerelease: false
-  segments: 
-  - 1
-  - 0
-  - 0
-  version: 1.0.0
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Aaron Pfeifer
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-05-12 00:00:00 -04:00
+date: 2011-05-30 00:00:00.000000000 -04:00
 default_executable: 
 dependencies: []
-
 description: Adds support for creating state machines for attributes on any Ruby class
 email: aaron@pluginaweek.org
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - examples/car.rb
 - examples/TrafficLight_state.png
 - examples/vehicle.rb
@@ -138,38 +128,29 @@ files:
 has_rdoc: true
 homepage: http://www.pluginaweek.org
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: pluginaweek
-rubygems_version: 1.3.7
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Adds support for creating state machines for attributes on any Ruby class
-test_files: 
+test_files:
 - test/unit/path_test.rb
 - test/unit/condition_proxy_test.rb
 - test/unit/state_machine_test.rb