state_machine 0.10.3 → 0.10.4

data/CHANGELOG.rdoc

@@ -1,5 +1,9 @@
 == master
 
+== 0.10.4 / 2011-04-14
+
+* Fix translations not being available under certain environments in Rails applications
+
 == 0.10.3 / 2011-04-07
 
 * Fix state initialization failing in ActiveRecord 3.0.2+ when using with_state scopes for the default scope

data/Rakefile

@@ -6,7 +6,7 @@ require 'rake/gempackagetask'
 
 spec = Gem::Specification.new do |s|
   s.name              = 'state_machine'
-  s.version           = '0.10.3'
+  s.version           = '0.10.4'
   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

@@ -1,5 +1,21 @@
-class StateMachine::Railtie < Rails::Railtie
-  rake_tasks do
-    load 'tasks/state_machine.rb'
+if defined?(Rails)
+  # Track all of the applicable locales to load
+  locale_paths = []
+  StateMachine::Integrations.all.each do |integration|
+    locale_paths << integration.locale_path if integration.available? && integration.locale_path
   end
-end if defined?(Rails::Railtie)
+  
+  if defined?(Rails::Engine)
+    # Rails 3.x
+    class StateMachine::RailsEngine < Rails::Engine
+      rake_tasks do
+        load 'tasks/state_machine.rb'
+      end
+    end
+    
+    StateMachine::RailsEngine.paths.config.locales = locale_paths
+  elsif defined?(I18n)
+    # Rails 2.x
+    I18n.load_path.unshift(*locale_paths)
+  end
+end

data/lib/state_machine/integrations/active_model.rb

@@ -267,13 +267,18 @@ module StateMachine
       
       @defaults = {}
       
+      # Whether this integration is available.  Only true if ActiveModel is
+      # defined.
+      def self.available?
+        defined?(::ActiveModel)
+      end
+      
       # Should this integration be used for state machines in the given class?
       # Classes that include ActiveModel::Dirty,  ActiveModel::Observing, or
       # ActiveModel::Validations will automatically use the ActiveModel
       # integration.
       def self.matches?(klass)
-        features = %w(Dirty Observing Validations)
-        defined?(::ActiveModel) && features.any? {|feature| ::ActiveModel.const_defined?(feature) && klass <= ::ActiveModel.const_get(feature)}
+        %w(Dirty Observing Validations).any? {|feature| ::ActiveModel.const_defined?(feature) && klass <= ::ActiveModel.const_get(feature)}
       end
       
       # Forces the change in state to be recognized regardless of whether the
@@ -308,11 +313,6 @@ module StateMachine
       end
       
       protected
-        # The name of this integration
-        def integration
-          :active_model
-        end
-        
         # Whether observers are supported in the integration.  Only true if
         # ActiveModel::Observer is available.
         def supports_observers?
@@ -387,12 +387,7 @@ module StateMachine
         
         # Loads any locale files needed for translating validation errors
         def load_locale
-          I18n.load_path.unshift(locale_path) unless I18n.load_path.include?(locale_path)
-        end
-        
-        # The path to the locale file containing state_machine translations
-        def locale_path
-          "#{File.dirname(__FILE__)}/#{integration}/locale.rb"
+          I18n.load_path.unshift(@integration.locale_path) unless I18n.load_path.include?(@integration.locale_path)
         end
         
         # Loads extensions to ActiveModel's Observers

data/lib/state_machine/integrations/active_record/locale.rb

@@ -2,6 +2,13 @@ filename = "#{File.dirname(__FILE__)}/../active_model/locale.rb"
 translations = eval(IO.read(filename), binding, filename)
 translations[:en][:activerecord] = translations[:en].delete(:activemodel)
 
+# Only ActiveRecord 2.3.5+ can pull i18n >= 0.1.3 from system-wide gems (and
+# therefore possibly have I18n::VERSION available)
+begin
+  require 'i18n/version'
+rescue Exception => ex
+end unless ::ActiveRecord::VERSION::MAJOR == 2 && (::ActiveRecord::VERSION::MINOR < 3 || ::ActiveRecord::VERSION::TINY < 5)
+
 # Only i18n 0.4.0+ has the new %{key} syntax
 if !defined?(I18n::VERSION) || I18n::VERSION < '0.4.0'
   translations[:en][:activerecord][:errors][:messages].each do |key, message|

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

@@ -97,15 +97,6 @@ module StateMachine
         end
       end
       
-      version '2.0 - 2.3.4' do
-        def self.active?
-          ::ActiveRecord::VERSION::MAJOR == 2 && (::ActiveRecord::VERSION::MINOR < 3 || ::ActiveRecord::VERSION::TINY < 5)
-        end
-        
-        def load_i18n_version
-        end
-      end
-      
       version '2.0.x' do
         def self.active?
           ::ActiveRecord::VERSION::MAJOR == 2 && ::ActiveRecord::VERSION::MINOR == 0

data/lib/state_machine/integrations/active_record.rb

@@ -323,11 +323,17 @@ module StateMachine
       # The default options to use for state machines using this integration
       @defaults = {:action => :save}
       
+      # Whether this integration is available.  Only true if ActiveRecord::Base
+      # is defined.
+      def self.available?
+        defined?(::ActiveRecord::Base)
+      end
+      
       # Should this integration be used for state machines in the given class?
       # Classes that inherit from ActiveRecord::Base will automatically use
       # the ActiveRecord integration.
       def self.matches?(klass)
-        defined?(::ActiveRecord::Base) && klass <= ::ActiveRecord::Base
+        klass <= ::ActiveRecord::Base
       end
       
       def self.extended(base) #:nodoc:
@@ -336,26 +342,6 @@ module StateMachine
       end
       
       protected
-        # The name of this integration
-        def integration
-          :active_record
-        end
-        
-        # Loads locale files needed for translations
-        def load_locale
-          load_i18n_version
-          super
-        end
-        
-        # Loads the version of the i18n library so that that proper
-        # interpolation syntax can be used
-        def load_i18n_version
-          begin
-            require 'i18n/version'
-          rescue Exception => ex
-          end
-        end
-        
         # Only runs validations on the action if using <tt>:save</tt>
         def runs_validations_on_action?
           action == :save

data/lib/state_machine/integrations/base.rb

@@ -2,21 +2,34 @@ module StateMachine
   module Integrations
     # Provides a set of base helpers for managing individual integrations
     module Base
-      # Never matches
-      def self.matches?(klass)
-        false
-      end
-      
-      def self.included(base) #:nodoc:
-        base.class_eval do
-          extend ClassMethods
-        end
-      end
-      
       module ClassMethods
         # The default options to use for state machines using this integration
         attr_reader :defaults
         
+        # The name of the integration
+        def integration_name
+          @integration_name ||= begin
+            name = self.name.split('::').last
+            name.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+            name.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+            name.downcase!
+            name.to_sym
+          end
+        end
+        
+        # Whether this integration is available for the current library.  This
+        # is usually only true if the ORM that the integration is for is
+        # currently defined.  Default is false.
+        def available?
+          false
+        end
+        
+        # Whether the integration should be used for the given class.  Default
+        # is false.
+        def matches?(klass)
+          false
+        end
+        
         # Tracks the various version overrides for an integration
         def versions
           @versions ||= []
@@ -51,6 +64,14 @@ module StateMachine
           mod
         end
         
+        # The path to the locale file containing translations for this
+        # integration.  This file will only exist for integrations that actually
+        # support i18n.
+        def locale_path
+          path = "#{File.dirname(__FILE__)}/#{integration_name}/locale.rb"
+          path if File.exists?(path)
+        end
+        
         # Extends the given object with any version overrides that are currently
         # active
         def extended(base)
@@ -59,6 +80,12 @@ module StateMachine
           end
         end
       end
+      
+      extend ClassMethods
+      
+      def self.included(base) #:nodoc:
+        base.class_eval { extend ClassMethods }
+      end
     end
   end
 end

data/lib/state_machine/integrations/data_mapper.rb

@@ -248,12 +248,18 @@ module StateMachine
       # The default options to use for state machines using this integration
       class << self; attr_reader :defaults; end
       @defaults = {:action => :save, :use_transactions => false}
-        
+      
+      # Whether this integration is available.  Only true if DataMapper::Resource
+      # is defined.
+      def self.available?
+        defined?(::DataMapper::Resource)
+      end
+      
       # Should this integration be used for state machines in the given class?
       # Classes that include DataMapper::Resource will automatically use the
       # DataMapper integration.
       def self.matches?(klass)
-        defined?(::DataMapper::Resource) && klass <= ::DataMapper::Resource
+        klass <= ::DataMapper::Resource
       end
       
       # Loads additional files specific to DataMapper

data/lib/state_machine/integrations/mongo_mapper.rb

@@ -194,19 +194,20 @@ module StateMachine
       # The default options to use for state machines using this integration
       @defaults = {:action => :save}
       
+      # Whether this integration is available.  Only true if MongoMapper::Document
+      # is defined.
+      def self.available?
+        defined?(::MongoMapper::Document)
+      end
+      
       # Should this integration be used for state machines in the given class?
       # Classes that include MongoMapper::Document will automatically use the
       # MongoMapper integration.
       def self.matches?(klass)
-        defined?(::MongoMapper::Document) && klass <= ::MongoMapper::Document
+        klass <= ::MongoMapper::Document
       end
       
       protected
-        # The name of this integration
-        def integration
-          :mongo_mapper
-        end
-        
         # Only runs validations on the action if using <tt>:save</tt>
         def runs_validations_on_action?
           action == :save

data/lib/state_machine/integrations/mongoid.rb

@@ -244,11 +244,17 @@ module StateMachine
       # The default options to use for state machines using this integration
       @defaults = {:action => :save}
       
+      # Whether this integration is available.  Only true if Mongoid::Document
+      # is defined.
+      def self.available?
+        defined?(::Mongoid::Document)
+      end
+      
       # Should this integration be used for state machines in the given class?
       # Classes that include Mongoid::Document will automatically use the
       # Mongoid integration.
       def self.matches?(klass)
-        defined?(::Mongoid::Document) && klass <= ::Mongoid::Document
+        klass <= ::Mongoid::Document
       end
       
       def self.extended(base) #:nodoc:
@@ -270,11 +276,6 @@ module StateMachine
       end
       
       protected
-        # The name of this integration
-        def integration
-          :mongoid
-        end
-        
         # 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)

data/lib/state_machine/integrations/sequel.rb

@@ -224,11 +224,17 @@ module StateMachine
       class << self; attr_reader :defaults; end
       @defaults = {:action => :save}
       
+      # Whether this integration is available.  Only true if Sequel::Model is
+      # defined.
+      def self.available?
+        defined?(::Sequel::Model)
+      end
+      
       # Should this integration be used for state machines in the given class?
       # Classes that include Sequel::Model will automatically use the Sequel
       # integration.
       def self.matches?(klass)
-        defined?(::Sequel::Model) && klass <= ::Sequel::Model
+        klass <= ::Sequel::Model
       end
       
       # Forces the change in state to be recognized regardless of whether the

data/lib/state_machine/integrations.rb

@@ -4,7 +4,16 @@ Dir["#{File.dirname(__FILE__)}/integrations/*.rb"].sort.each do |path|
   require "state_machine/integrations/#{File.basename(path)}"
 end
 
+require 'state_machine/error'
+
 module StateMachine
+  # An invalid integration was specified
+  class IntegrationNotFound < Error
+    def initialize(name)
+      super(nil, "#{name.inspect} is an invalid integration")
+    end
+  end
+  
   # Integrations allow state machines to take advantage of features within the
   # context of a particular library.  This is currently most useful with
   # database libraries.  For example, the various database integrations allow
@@ -65,10 +74,7 @@ module StateMachine
     #   StateMachine::Integrations.match(MongoMapperVehicle)  # => StateMachine::Integrations::MongoMapper
     #   StateMachine::Integrations.match(SequelVehicle)       # => StateMachine::Integrations::Sequel
     def self.match(klass)
-      constants = self.constants.map {|c| c.to_s}.select {|c| c != 'ActiveModel'}.sort << 'ActiveModel'
-      if integration = constants.find {|name| const_get(name).matches?(klass)}
-        find(integration)
-      end
+      all.detect {|integration| integration.available? && integration.matches?(klass)}
     end
     
     # Finds an integration with the given name.  If the integration cannot be
@@ -76,15 +82,29 @@ module StateMachine
     # 
     # == Examples
     # 
-    #   StateMachine::Integrations.find(:active_record)   # => StateMachine::Integrations::ActiveRecord
-    #   StateMachine::Integrations.find(:active_model)    # => StateMachine::Integrations::ActiveModel
-    #   StateMachine::Integrations.find(:data_mapper)     # => StateMachine::Integrations::DataMapper
-    #   StateMachine::Integrations.find(:mongoid)         # => StateMachine::Integrations::Mongoid
-    #   StateMachine::Integrations.find(:mongo_mapper)    # => StateMachine::Integrations::MongoMapper
-    #   StateMachine::Integrations.find(:sequel)          # => StateMachine::Integrations::Sequel
-    #   StateMachine::Integrations.find(:invalid)         # => NameError: wrong constant name Invalid
-    def self.find(name)
-      const_get(name.to_s.gsub(/(?:^|_)(.)/) {$1.upcase})
+    #   StateMachine::Integrations.find_by_name(:active_record) # => StateMachine::Integrations::ActiveRecord
+    #   StateMachine::Integrations.find_by_name(:active_model)  # => StateMachine::Integrations::ActiveModel
+    #   StateMachine::Integrations.find_by_name(:data_mapper)   # => StateMachine::Integrations::DataMapper
+    #   StateMachine::Integrations.find_by_name(:mongoid)       # => StateMachine::Integrations::Mongoid
+    #   StateMachine::Integrations.find_by_name(:mongo_mapper)  # => StateMachine::Integrations::MongoMapper
+    #   StateMachine::Integrations.find_by_name(:sequel)        # => StateMachine::Integrations::Sequel
+    #   StateMachine::Integrations.find_by_name(:invalid)       # => StateMachine::IntegrationNotFound: :invalid is an invalid integration
+    def self.find_by_name(name)
+      all.detect {|integration| integration.integration_name == name} || raise(IntegrationNotFound.new(name))
+    end
+    
+    # Gets a list of all of the available integrations for use.  This will
+    # always list the ActiveModel integration last.
+    # 
+    # == Example
+    # 
+    #   StateMachine::Integrations.all
+    #   # => [StateMachine::Integrations::ActiveRecord, StateMachine::Integrations::DataMapper
+    #   #     StateMachine::Integrations::Mongoid, StateMachine::Integrations::MongoMapper,
+    #   #     StateMachine::Integrations::Sequel, StateMachine::Integrations::ActiveModel]
+    def self.all
+      constants = self.constants.map {|c| c.to_s}.select {|c| c != 'ActiveModel'}.sort << 'ActiveModel'
+      constants.map {|c| const_get(c)}
     end
   end
 end

data/lib/state_machine/machine.rb

@@ -421,14 +421,14 @@ module StateMachine
       
       # Find an integration that matches this machine's owner class
       if options.include?(:integration)
-        integration = StateMachine::Integrations.find(options[:integration]) if options[:integration]
+        @integration = StateMachine::Integrations.find_by_name(options[:integration]) if options[:integration]
       else
-        integration = StateMachine::Integrations.match(owner_class)
+        @integration = StateMachine::Integrations.match(owner_class)
       end
-
-      if integration
-        extend integration
-        options = (integration.defaults || {}).merge(options)
+      
+      if @integration
+        extend @integration
+        options = (@integration.defaults || {}).merge(options)
       end
       
       # Add machine-wide defaults

data/test/unit/integrations/active_model_test.rb

@@ -75,6 +75,14 @@ module ActiveModelTest
   end
   
   class IntegrationTest < BaseTestCase
+    def test_should_have_an_integration_name
+      assert_equal :active_model, StateMachine::Integrations::ActiveModel.integration_name
+    end
+    
+    def test_should_be_available
+      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
@@ -94,6 +102,10 @@ module ActiveModelTest
     def test_should_have_no_defaults
       assert_equal e = {}, StateMachine::Integrations::ActiveModel.defaults
     end
+    
+    def test_should_have_a_locale_path
+      assert_not_nil StateMachine::Integrations::ActiveModel.locale_path
+    end
   end
   
   class MachineByDefaultTest < BaseTestCase

data/test/unit/integrations/active_record_test.rb

@@ -74,6 +74,14 @@ module ActiveRecordTest
   end
   
   class IntegrationTest < BaseTestCase
+    def test_should_have_an_integration_name
+      assert_equal :active_record, StateMachine::Integrations::ActiveRecord.integration_name
+    end
+    
+    def test_should_be_available
+      assert StateMachine::Integrations::ActiveRecord.available?
+    end
+    
     def test_should_match_if_class_inherits_from_active_record
       assert StateMachine::Integrations::ActiveRecord.matches?(new_model)
     end
@@ -85,6 +93,10 @@ module ActiveRecordTest
     def test_should_have_defaults
       assert_equal e = {:action => :save}, StateMachine::Integrations::ActiveRecord.defaults
     end
+    
+    def test_should_have_a_locale_path
+      assert_not_nil StateMachine::Integrations::ActiveRecord.locale_path
+    end
   end
   
   class MachineWithoutDatabaseTest < BaseTestCase

data/test/unit/integrations/base_test.rb

@@ -5,9 +5,21 @@ require 'rubygems'
 
 module BaseTest  
   class IntegrationTest < Test::Unit::TestCase
+    def test_should_have_an_integration_name
+      assert_equal :base, StateMachine::Integrations::Base.integration_name
+    end
+    
+    def test_should_not_be_available
+      assert !StateMachine::Integrations::Base.available?
+    end
+    
     def test_should_not_match_any_classes
       assert !StateMachine::Integrations::Base.matches?(Class.new)
     end
+    
+    def test_should_not_have_a_locale_path
+      assert_nil StateMachine::Integrations::Base.locale_path
+    end
   end
   
   class IncludedTest < Test::Unit::TestCase

data/test/unit/integrations/data_mapper_test.rb

@@ -58,6 +58,14 @@ module DataMapperTest
   end
   
   class IntegrationTest < BaseTestCase
+    def test_should_have_an_integration_name
+      assert_equal :data_mapper, StateMachine::Integrations::DataMapper.integration_name
+    end
+    
+    def test_should_be_available
+      assert StateMachine::Integrations::DataMapper.available?
+    end
+    
     def test_should_match_if_class_includes_data_mapper
       assert StateMachine::Integrations::DataMapper.matches?(new_resource)
     end
@@ -69,6 +77,10 @@ module DataMapperTest
     def test_should_have_defaults
       assert_equal e = {:action => :save, :use_transactions => false}, StateMachine::Integrations::DataMapper.defaults
     end
+    
+    def test_should_not_have_a_locale_path
+      assert_nil StateMachine::Integrations::DataMapper.locale_path
+    end
   end
   
   class MachineWithoutDatabaseTest < BaseTestCase

data/test/unit/integrations/mongo_mapper_test.rb

@@ -49,6 +49,14 @@ module MongoMapperTest
   end
   
   class IntegrationTest < BaseTestCase
+    def test_should_have_an_integration_name
+      assert_equal :mongo_mapper, StateMachine::Integrations::MongoMapper.integration_name
+    end
+    
+    def test_should_be_available
+      assert StateMachine::Integrations::MongoMapper.available?
+    end
+    
     def test_should_match_if_class_includes_mongo_mapper
       assert StateMachine::Integrations::MongoMapper.matches?(new_model)
     end
@@ -60,6 +68,10 @@ module MongoMapperTest
     def test_should_have_defaults
       assert_equal e = {:action => :save}, StateMachine::Integrations::MongoMapper.defaults
     end
+    
+    def test_should_have_a_locale_path
+      assert_not_nil StateMachine::Integrations::MongoMapper.locale_path
+    end
   end
   
   class MachineWithoutDatabaseTest < BaseTestCase

data/test/unit/integrations/mongoid_test.rb

@@ -40,6 +40,14 @@ module MongoidTest
   end
   
   class IntegrationTest < BaseTestCase
+    def test_should_have_an_integration_name
+      assert_equal :mongoid, StateMachine::Integrations::Mongoid.integration_name
+    end
+    
+    def test_should_be_available
+      assert StateMachine::Integrations::Mongoid.available?
+    end
+    
     def test_should_match_if_class_includes_mongoid
       assert StateMachine::Integrations::Mongoid.matches?(new_model)
     end
@@ -51,6 +59,10 @@ module MongoidTest
     def test_should_have_defaults
       assert_equal e = {:action => :save}, StateMachine::Integrations::Mongoid.defaults
     end
+    
+    def test_should_have_a_locale_path
+      assert_not_nil StateMachine::Integrations::Mongoid.locale_path
+    end
   end
   
   class MachineByDefaultTest < BaseTestCase

data/test/unit/integrations/sequel_test.rb

@@ -38,6 +38,14 @@ module SequelTest
   end
   
   class IntegrationTest < BaseTestCase
+    def test_should_have_an_integration_name
+      assert_equal :sequel, StateMachine::Integrations::Sequel.integration_name
+    end
+    
+    def test_should_be_available
+      assert StateMachine::Integrations::Sequel.available?
+    end
+    
     def test_should_match_if_class_inherits_from_sequel
       assert StateMachine::Integrations::Sequel.matches?(new_model)
     end
@@ -49,6 +57,10 @@ module SequelTest
     def test_should_have_defaults
       assert_equal e = {:action => :save}, StateMachine::Integrations::Sequel.defaults
     end
+    
+    def test_should_not_have_a_locale_path
+      assert_nil StateMachine::Integrations::Sequel.locale_path
+    end
   end
   
   class MachineWithoutDatabaseTest < BaseTestCase

data/test/unit/integrations_test.rb

@@ -11,6 +11,12 @@ class IntegrationMatcherTest < Test::Unit::TestCase
   
   def test_should_return_integration_class_if_match_found
     integration = Module.new do
+      include StateMachine::Integrations::Base
+      
+      def self.available?
+        true
+      end
+      
       def self.matches?(klass)
         true
       end
@@ -25,30 +31,31 @@ end
 
 class IntegrationFinderTest < Test::Unit::TestCase
   def test_should_find_base
-    assert_equal StateMachine::Integrations::Base, StateMachine::Integrations.find(:base)
+    assert_equal StateMachine::Integrations::Base, StateMachine::Integrations.find_by_name(:base)
   end
   
   def test_should_find_active_model
-    assert_equal StateMachine::Integrations::ActiveModel, StateMachine::Integrations.find(:active_model)
+    assert_equal StateMachine::Integrations::ActiveModel, StateMachine::Integrations.find_by_name(:active_model)
   end
   
   def test_should_find_active_record
-    assert_equal StateMachine::Integrations::ActiveRecord, StateMachine::Integrations.find(:active_record)
+    assert_equal StateMachine::Integrations::ActiveRecord, StateMachine::Integrations.find_by_name(:active_record)
   end
   
   def test_should_find_data_mapper
-    assert_equal StateMachine::Integrations::DataMapper, StateMachine::Integrations.find(:data_mapper)
+    assert_equal StateMachine::Integrations::DataMapper, StateMachine::Integrations.find_by_name(:data_mapper)
   end
   
   def test_should_find_mongo_mapper
-    assert_equal StateMachine::Integrations::MongoMapper, StateMachine::Integrations.find(:mongo_mapper)
+    assert_equal StateMachine::Integrations::MongoMapper, StateMachine::Integrations.find_by_name(:mongo_mapper)
   end
   
   def test_should_find_sequel
-    assert_equal StateMachine::Integrations::Sequel, StateMachine::Integrations.find(:sequel)
+    assert_equal StateMachine::Integrations::Sequel, StateMachine::Integrations.find_by_name(:sequel)
   end
   
   def test_should_raise_an_exception_if_invalid
-    assert_raise(NameError) { StateMachine::Integrations.find(:invalid) }
+    exception = assert_raise(StateMachine::IntegrationNotFound) { StateMachine::Integrations.find_by_name(:invalid) }
+    assert_equal ':invalid is an invalid integration', exception.message
   end
 end

data/test/unit/machine_test.rb

@@ -499,6 +499,10 @@ class MachineWithCustomIntegrationTest < Test::Unit::TestCase
     integration = Module.new do
       include StateMachine::Integrations::Base
       
+      def self.available?
+        true
+      end
+      
       def self.matches?(klass)
         true
       end
@@ -511,8 +515,30 @@ class MachineWithCustomIntegrationTest < Test::Unit::TestCase
     machine = StateMachine::Machine.new(Class.new, :integration => :custom)
     assert (class << machine; ancestors; end).include?(StateMachine::Integrations::Custom)
   end
+  
+  def test_should_not_be_extended_by_the_integration_if_implicit_but_not_available
+    StateMachine::Integrations::Custom.class_eval do
+      def self.available?
+        false
+      end
+    end
+    
+    machine = StateMachine::Machine.new(Class.new)
+    assert !(class << machine; ancestors; end).include?(StateMachine::Integrations::Custom)
+  end
+
+  def test_should_not_be_extended_by_the_integration_if_implicit_but_not_matched
+    StateMachine::Integrations::Custom.class_eval do
+      def self.matches?(klass)
+        false
+      end
+    end
+    
+    machine = StateMachine::Machine.new(Class.new)
+    assert !(class << machine; ancestors; end).include?(StateMachine::Integrations::Custom)
+  end
 
-  def test_should_be_extended_by_the_integration_if_implicit
+  def test_should_be_extended_by_the_integration_if_implicit_and_available_and_matches
     machine = StateMachine::Machine.new(Class.new)
     assert (class << machine; ancestors; end).include?(StateMachine::Integrations::Custom)
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: state_machine
 version: !ruby/object:Gem::Version 
-  hash: 49
-  prerelease: 
+  hash: 63
+  prerelease: false
   segments: 
   - 0
   - 10
-  - 3
-  version: 0.10.3
+  - 4
+  version: 0.10.4
 platform: ruby
 authors: 
 - Aaron Pfeifer
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-07 00:00:00 -04:00
+date: 2011-04-14 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -165,7 +165,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: pluginaweek
-rubygems_version: 1.6.2
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Adds support for creating state machines for attributes on any Ruby class