state_machine 0.10.1 → 0.10.2

data/CHANGELOG.rdoc

@@ -1,5 +1,14 @@
 == master
 
+== 0.10.2 / 2011-03-31
+
+* Use more integrated state initialization hooks for ActiveRecord, Mongoid, and Sequel
+* Remove mass-assignment filtering usage in all ORM integrations
+* Only support official Mongoid 2.0.0 release and up (no more RC support)
+* Fix attributes getting initialized more than once if different state machines use the same attribute
+* Only initialize states if state is blank and blank is not a valid state
+* Fix instance / class helpers failing when used with certain libraries (such as Thin)
+
 == 0.10.1 / 2011-03-22
 
 * Fix classes with multiple state machines failing to initialize in ActiveRecord / Mongoid / Sequel integrations

data/Rakefile

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

@@ -280,23 +280,23 @@ module StateMachine
       # the current event
       def add_actions
         # Checks whether the event can be fired on the current object
-        machine.define_helper(:instance, "can_#{qualified_name}?") do |machine, object, _super, *args|
+        machine.define_helper(:instance, "can_#{qualified_name}?") do |machine, object, *args|
           machine.event(name).can_fire?(object, *args)
         end
         
         # Gets the next transition that would be performed if the event were
         # fired now
-        machine.define_helper(:instance, "#{qualified_name}_transition") do |machine, object, _super, *args|
+        machine.define_helper(:instance, "#{qualified_name}_transition") do |machine, object, *args|
           machine.event(name).transition_for(object, *args)
         end
         
         # Fires the event
-        machine.define_helper(:instance, qualified_name) do |machine, object, _super, *args|
+        machine.define_helper(:instance, qualified_name) do |machine, object, *args|
           machine.event(name).fire(object, *args)
         end
         
         # Fires the event, raising an exception if it fails
-        machine.define_helper(:instance, "#{qualified_name}!") do |machine, object, _super, *args|
+        machine.define_helper(:instance, "#{qualified_name}!") do |machine, object, *args|
           object.send(qualified_name, *args) || raise(StateMachine::InvalidTransition.new(object, machine, name))
         end
       end

data/lib/state_machine/integrations/active_model.rb

@@ -8,7 +8,6 @@ module StateMachine
     # following features need to be included in order for the integration to be
     # detected:
     # * ActiveModel::Dirty
-    # * ActiveModel::MassAssignmentSecurity
     # * ActiveModel::Observing
     # * ActiveModel::Validations
     # 
@@ -17,7 +16,6 @@ module StateMachine
     # 
     #   class Vehicle
     #     include ActiveModel::Dirty
-    #     include ActiveModel::MassAssignmentSecurity
     #     include ActiveModel::Observing
     #     include ActiveModel::Validations
     #     
@@ -270,11 +268,11 @@ module StateMachine
       @defaults = {}
       
       # Should this integration be used for state machines in the given class?
-      # Classes that include ActiveModel::Dirty, ActiveModel::MassAssignmentSecurity,
-      # ActiveModel::Observing, or ActiveModel::Validations will automatically
-      # use the ActiveModel integration.
+      # Classes that include ActiveModel::Dirty,  ActiveModel::Observing, or
+      # ActiveModel::Validations will automatically use the ActiveModel
+      # integration.
       def self.matches?(klass)
-        features = %w(Dirty MassAssignmentSecurity Observing Validations)
+        features = %w(Dirty Observing Validations)
         defined?(::ActiveModel) && features.any? {|feature| ::ActiveModel.const_defined?(feature) && klass <= ::ActiveModel.const_get(feature)}
       end
       
@@ -340,13 +338,6 @@ module StateMachine
           defined?(::ActiveModel::Dirty) && owner_class <= ::ActiveModel::Dirty && object.respond_to?("#{self.attribute}_changed?")
         end
         
-        # Whether the protection of attributes via mass-assignment is supported
-        # in this integration.  Only true if the ActiveModel feature is enabled
-        # on the owner class.
-        def supports_mass_assignment_security?
-          defined?(::ActiveModel::MassAssignmentSecurity) && owner_class <= ::ActiveModel::MassAssignmentSecurity
-        end
-        
         # Gets the terminator to use for callbacks
         def callback_terminator
           @terminator ||= lambda {|result| result == false}
@@ -357,25 +348,6 @@ module StateMachine
           klass.i18n_scope
         end
         
-        # Only allows state initialization on new records that aren't being
-        # created with a set of attributes that includes this machine's
-        # attribute.
-        def initialize_state?(object, options)
-          if supports_mass_assignment_security?
-            attributes = (options[:attributes] || {}).dup.stringify_keys!
-            ignore = filter_attributes(object, attributes).keys
-            !ignore.map {|attribute| attribute.to_sym}.include?(attribute) 
-          else
-            super
-          end
-        end
-        
-        # Filters attributes that cannot be assigned through the initialization
-        # of the object
-        def filter_attributes(object, attributes)
-          object.send(:sanitize_for_mass_assignment, attributes)
-        end
-        
         # The default options to use when generating messages for validation
         # errors
         def default_error_message_options(object, attribute, message)

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

@@ -7,10 +7,11 @@ module StateMachine
         end
         
         def define_validation_hook
-          action = self.action
-          define_helper(:instance, :valid?) do |machine, object, _super, *|
-            object.class.state_machines.transitions(object, action, :after => false).perform { _super.call }
-          end
+          define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
+            def valid?(*)
+              self.class.state_machines.transitions(self, #{action.inspect}, :after => false).perform { super }
+            end
+          end_eval
         end
       end
       

data/lib/state_machine/integrations/active_record.rb

@@ -356,46 +356,31 @@ module StateMachine
           end
         end
         
-        # Loads extensions to ActiveRecord's Observers
-        def load_observer_extensions
-          super
-          ::ActiveRecord::Observer.class_eval do
-            include StateMachine::Integrations::ActiveModel::Observer
-          end unless ::ActiveRecord::Observer < StateMachine::Integrations::ActiveModel::Observer
-        end
-        
         # Only runs validations on the action if using <tt>:save</tt>
         def runs_validations_on_action?
           action == :save
         end
         
-        # Only allows state initialization on new records that aren't being
-        # created with a set of attributes that includes this machine's
-        # attribute.
-        def initialize_state?(object, options)
-          super if object.new_record?
-        end
-        
         # Defines an initialization hook into the owner class for setting the
         # initial state of the machine *before* any attributes are set on the
         # object
         def define_state_initializer
-          # Ensure that the attributes setter gets used to force initialization
-          # of the state machines
-          define_helper(:instance, :initialize) do |machine, object, _super, *args|
-            _super.call(args.shift || {}, *args)
-          end
-          
-          # Hooks in to attribute initialization to set the states *prior*
-          # to the attributes being set
-          define_helper(:instance, :attributes=) do |machine, object, _super, new_attributes, *|
-            if !object.instance_variable_defined?('@initialized_state_machines')
-              object.class.state_machines.initialize_states(object, :attributes => new_attributes) { _super.call }
-              object.instance_variable_set('@initialized_state_machines', true)
-            else
-              _super.call
+          define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
+            # Initializes dynamic states
+            def initialize(*)
+              super do |*args|
+                self.class.state_machines.initialize_states(self, :static => false)
+                yield(*args) if block_given?
+              end
             end
-          end
+            
+            # Initializes static states
+            def attributes_from_column_definition(*)
+              result = super
+              self.class.state_machines.initialize_states(self, :dynamic => false, :to => result)
+              result
+            end
+          end_eval
         end
         
         # Uses around callbacks to run state events if using the :save hook

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

@@ -69,8 +69,11 @@ module StateMachine
           action == :save ? :create_or_update : super
         end
         
-        def filter_attributes(object, attributes)
-          object.send(:remove_attributes_protected_from_mass_assignment, attributes)
+        def load_observer_extensions
+          super
+          ::ActiveRecord::Observer.class_eval do
+            include StateMachine::Integrations::ActiveModel::Observer
+          end unless ::ActiveRecord::Observer < StateMachine::Integrations::ActiveModel::Observer
         end
       end
       

data/lib/state_machine/integrations/data_mapper.rb

@@ -306,21 +306,15 @@ module StateMachine
           ::DataMapper::Inflector.pluralize(word.to_s)
         end
         
-        # Only allows state initialization on new records that aren't being
-        # created with a set of attributes that includes this machine's
-        # attribute.
-        def initialize_state?(object, options)
-          ignore = (options[:attributes] || {}).keys
-          !ignore.map {|attribute| attribute.to_sym}.include?(attribute) 
-        end
-        
         # Defines an initialization hook into the owner class for setting the
         # initial state of the machine *before* any attributes are set on the
         # object
         def define_state_initializer
-          define_helper(:instance, :initialize) do |machine, object, _super, *args|
-            object.class.state_machines.initialize_states(object, :attributes => args.first) { _super.call }
-          end
+          define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
+            def initialize(*args)
+              self.class.state_machines.initialize_states(self) { super }
+            end
+          end_eval
         end
         
         # Skips defining reader/writer methods since this is done automatically
@@ -341,9 +335,11 @@ module StateMachine
           super
           
           if action == :save && supports_validations?
-            define_helper(:instance, :valid?) do |machine, object, _super, *|
-              object.class.state_machines.transitions(object, :save, :after => false).perform { _super.call }
-            end
+            define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
+              def valid?(*)
+                self.class.state_machines.transitions(self, :save, :after => false).perform { super }
+              end
+            end_eval
           end
         end
         

data/lib/state_machine/integrations/mongo_mapper.rb

@@ -212,26 +212,15 @@ module StateMachine
           action == :save
         end
         
-        # MongoMapper uses its own implementation of mass-assignment security
-        # instead of ActiveModel's, but still has a similar enough API that it
-        # can get enabled
-        def supports_mass_assignment_security?
-          true
-        end
-        
-        # Filters attributes that cannot be assigned through the initialization
-        # of the object
-        def filter_attributes(object, attributes)
-          object.send(:filter_protected_attrs, attributes)
-        end
-        
         # Defines an initialization hook into the owner class for setting the
         # initial state of the machine *before* any attributes are set on the
         # object
         def define_state_initializer
-          define_helper(:instance, :initialize) do |machine, object, _super, *args|
-            object.class.state_machines.initialize_states(object, :attributes => args.first) { _super.call }
-          end
+          define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
+            def initialize(*args)
+              self.class.state_machines.initialize_states(self) { super }
+            end
+          end_eval
         end
         
         # Skips defining reader/writer methods since this is done automatically

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

@@ -6,14 +6,18 @@ module StateMachine
           !defined?(::MongoMapper::Plugins)
         end
         
-        def initialize_state?(object, options)
-          attributes = options[:attributes] || {}
-          super unless attributes.stringify_keys.key?('_id')
-        end
-        
         def filter_attributes(object, attributes)
           attributes
         end
+        
+        def define_state_initializer
+          define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
+            def initialize(*args)
+              attrs, * = args
+              attrs && attrs.stringify_keys.key?('_id') ? super : self.class.state_machines.initialize_states(self) { super }
+            end
+          end_eval
+        end
       end
       
       version '0.5.x - 0.7.x' do
@@ -72,23 +76,27 @@ module StateMachine
         end
       end
       
-      version '0.5.x - 0.8.3' do
+      version '0.7.x - 0.8.3' do
         def self.active?
-          !defined?(::MongoMapper::Version) || ::MongoMapper::Version <= '0.8.3'
+          # Only 0.8.x and up has a Version string available, so Plugins is used
+          # to detect when 0.7.x is active
+          defined?(::MongoMapper::Plugins) && (!defined?(::MongoMapper::Version) || ::MongoMapper::Version <= '0.8.3')
         end
         
         def define_state_initializer
-          define_helper(:instance, :initialize) do |machine, object, _super, *args|
-            attrs, from_db = args
-            from_db ? _super.call : object.class.state_machines.initialize_states(object, :attributes => attrs) { _super.call }
-          end
+          define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
+            def initialize(*args)
+              attrs, from_db = args
+              from_db ? super : self.class.state_machines.initialize_states(self) { super }
+            end
+          end_eval
         end
       end
       
       # Assumes MongoMapper 0.10+ uses ActiveModel 3.1+
       version '0.9.x' do
         def self.active?
-          !defined?(::MongoMapper::Version) || ::MongoMapper::Version =~ /^0\.9\./
+          defined?(::MongoMapper::Version) && ::MongoMapper::Version =~ /^0\.9\./
         end
         
         def define_action_hook

data/lib/state_machine/integrations/mongoid.rb

@@ -179,6 +179,62 @@ module StateMachine
     # 
     # Note, also, that the transition can be accessed by simply defining
     # additional arguments in the callback block.
+    # 
+    # == Observers
+    # 
+    # In addition to support for Mongoid-like hooks, there is additional support
+    # for Mongoid observers.  Because of the way Mongoid observers are designed,
+    # there is less flexibility around the specific transitions that can be
+    # hooked in.  However, a large number of hooks *are* supported.  For
+    # example, if a transition for a record's +state+ attribute changes the
+    # state from +parked+ to +idling+ via the +ignite+ event, the following
+    # observer methods are supported:
+    # * before/after/after_failure_to-_ignite_from_parked_to_idling
+    # * before/after/after_failure_to-_ignite_from_parked
+    # * before/after/after_failure_to-_ignite_to_idling
+    # * before/after/after_failure_to-_ignite
+    # * before/after/after_failure_to-_transition_state_from_parked_to_idling
+    # * before/after/after_failure_to-_transition_state_from_parked
+    # * before/after/after_failure_to-_transition_state_to_idling
+    # * before/after/after_failure_to-_transition_state
+    # * before/after/after_failure_to-_transition
+    # 
+    # The following class shows an example of some of these hooks:
+    # 
+    #   class VehicleObserver < Mongoid::Observer
+    #     def before_save(vehicle)
+    #       # log message
+    #     end
+    #     
+    #     # Callback for :ignite event *before* the transition is performed
+    #     def before_ignite(vehicle, transition)
+    #       # log message
+    #     end
+    #     
+    #     # Callback for :ignite event *after* the transition has been performed
+    #     def after_ignite(vehicle, transition)
+    #       # put on seatbelt
+    #     end
+    #     
+    #     # Generic transition callback *before* the transition is performed
+    #     def after_transition(vehicle, transition)
+    #       Audit.log(vehicle, transition)
+    #     end
+    #   end
+    # 
+    # More flexible transition callbacks can be defined directly within the
+    # model as described in StateMachine::Machine#before_transition
+    # and StateMachine::Machine#after_transition.
+    # 
+    # To define a single observer for multiple state machines:
+    # 
+    #   class StateMachineObserver < Mongoid::Observer
+    #     observe Vehicle, Switch, Project
+    #     
+    #     def after_transition(record, transition)
+    #       Audit.log(record, transition)
+    #     end
+    #   end
     module Mongoid
       include Base
       include ActiveModel
@@ -230,25 +286,26 @@ module StateMachine
           action == :save
         end
         
-        # Only allows state initialization on new records that aren't being
-        # created with a set of attributes that includes this machine's
-        # attribute.
-        def initialize_state?(object, options)
-          super if object.new_record?
-        end
-        
         # Defines an initialization hook into the owner class for setting the
         # initial state of the machine *before* any attributes are set on the
         # object
         def define_state_initializer
-          define_helper(:instance, :process) do |machine, object, _super, *args|
-            if !object.instance_variable_defined?('@initialized_state_machines')
-              object.class.state_machines.initialize_states(object, :attributes => args.first) { _super.call }
-              object.instance_variable_set('@initialized_state_machines', true)
-            else
-              _super.call
+          define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
+            # Initializes dynamic states
+            def initialize(*)
+              super do |*args|
+                self.class.state_machines.initialize_states(self, :static => false)
+                yield(*args) if block_given?
+              end
             end
-          end
+            
+            # Initializes static states
+            def apply_default_attributes(*)
+              result = super
+              self.class.state_machines.initialize_states(self, :dynamic => false, :to => result) if new_record?
+              result
+            end
+          end_eval
         end
         
         # Skips defining reader/writer methods since this is done automatically