state_machine 1.0.1 → 1.0.2

data/lib/state_machine/integrations/active_record.rb

@@ -137,7 +137,46 @@ module StateMachine
     #   end
     # 
     # If using the +save+ action for the machine, this option will be ignored as
-    # the transaction will be created by ActiveRecord within +save+.
+    # the transaction will be created by ActiveRecord within +save+.  To avoid
+    # this, use a different action like so:
+    # 
+    #   class Vehicle < ActiveRecord::Base
+    #     state_machine :initial => :parked, :use_transactions => false, :action => :save_state do
+    #       ...
+    #     end
+    #     
+    #     alias_method :save_state, :save
+    #   end
+    # 
+    # == Validations
+    # 
+    # As mentioned in StateMachine::Machine#state, you can define behaviors,
+    # like validations, that only execute for certain states. One *important*
+    # caveat here is that, due to a constraint in ActiveRecord's validation
+    # framework, custom validators will not work as expected when defined to run
+    # in multiple states.  For example:
+    # 
+    #   class Vehicle < ActiveRecord::Base
+    #     state_machine do
+    #       ...
+    #       state :first_gear, :second_gear do
+    #         validate :speed_is_legal
+    #       end
+    #     end
+    #   end
+    # 
+    # In this case, the <tt>:speed_is_legal</tt> validation will only get run
+    # for the <tt>:second_gear</tt> state.  To avoid this, you can define your
+    # custom validation like so:
+    # 
+    #   class Vehicle < ActiveRecord::Base
+    #     state_machine do
+    #       ...
+    #       state :first_gear, :second_gear do
+    #         validate {|vehicle| vehicle.speed_is_legal}
+    #       end
+    #     end
+    #   end
     # 
     # == Validation errors
     # 
@@ -417,7 +456,7 @@ module StateMachine
         # breaks both ancestor lookups and defined?(super).  Need to special-case
         # the existence of query attribute methods.
         def owner_class_ancestor_has_method?(scope, method)
-          scope == :instance && method == "#{name}?" || super
+          scope == :instance && method == "#{attribute}?" ? owner_class : super
         end
     end
   end

data/lib/state_machine/integrations/data_mapper.rb

@@ -137,7 +137,10 @@ module StateMachine
     # 
     # To turn on transactions:
     # 
-    #   class Vehicle < ActiveRecord::Base
+    #   class Vehicle
+    #     include DataMapper::Resource
+    #     ...
+    #     
     #     state_machine :initial => :parked, :use_transactions => true do
     #       ...
     #     end
@@ -145,7 +148,18 @@ module StateMachine
     # 
     # If using the +save+ action for the machine, this option will be ignored as
     # the transaction behavior will depend on the +save+ implementation within
-    # DataMapper.
+    # DataMapper.  To avoid this, use a different action like so:
+    # 
+    #   class Vehicle
+    #     include DataMapper::Resource
+    #     ...
+    #     
+    #     state_machine :initial => :parked, :use_transactions => false, :action => :save_state do
+    #       ...
+    #     end
+    #     
+    #     alias_method :save_state, :save
+    #   end
     # 
     # == Validation errors
     # 
@@ -294,6 +308,7 @@ module StateMachine
       protected
         # Initializes class-level extensions and defaults for this machine
         def after_initialize
+          super
           load_observer_extensions
         end
         

data/lib/state_machine/integrations/mongo_mapper.rb

@@ -107,6 +107,40 @@ module StateMachine
     #     end
     #   end
     # 
+    # == Validations
+    # 
+    # As mentioned in StateMachine::Machine#state, you can define behaviors,
+    # like validations, that only execute for certain states. One *important*
+    # caveat here is that, due to a constraint in MongoMapper's validation
+    # framework, custom validators will not work as expected when defined to run
+    # in multiple states.  For example:
+    # 
+    #   class Vehicle
+    #     include MongoMapper::Document
+    #     
+    #     state_machine do
+    #       ...
+    #       state :first_gear, :second_gear do
+    #         validate :speed_is_legal
+    #       end
+    #     end
+    #   end
+    # 
+    # In this case, the <tt>:speed_is_legal</tt> validation will only get run
+    # for the <tt>:second_gear</tt> state.  To avoid this, you can define your
+    # custom validation like so:
+    # 
+    #   class Vehicle
+    #     include MongoMapper::Document
+    #     
+    #     state_machine do
+    #       ...
+    #       state :first_gear, :second_gear do
+    #         validate {|vehicle| vehicle.speed_is_legal}
+    #       end
+    #     end
+    #   end
+    # 
     # == Validation errors
     # 
     # If an event fails to successfully fire because there are no matching
@@ -260,13 +294,6 @@ module StateMachine
         def define_scope(name, scope)
           lambda {|model, values| model.query.merge(model.query(scope.call(values)))}
         end
-        
-        # 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?(scope, method)
-          scope == :instance && method == "#{name}?" || super
-        end
     end
   end
 end

data/lib/state_machine/integrations/mongoid.rb

@@ -105,6 +105,40 @@ module StateMachine
     #     end
     #   end
     # 
+    # == Validations
+    # 
+    # As mentioned in StateMachine::Machine#state, you can define behaviors,
+    # like validations, that only execute for certain states. One *important*
+    # caveat here is that, due to a constraint in Mongoid's validation
+    # framework, custom validators will not work as expected when defined to run
+    # in multiple states.  For example:
+    # 
+    #   class Vehicle
+    #     include Mongoid::Document
+    #     
+    #     state_machine do
+    #       ...
+    #       state :first_gear, :second_gear do
+    #         validate :speed_is_legal
+    #       end
+    #     end
+    #   end
+    # 
+    # In this case, the <tt>:speed_is_legal</tt> validation will only get run
+    # for the <tt>:second_gear</tt> state.  To avoid this, you can define your
+    # custom validation like so:
+    # 
+    #   class Vehicle
+    #     include Mongoid::Document
+    #     
+    #     state_machine do
+    #       ...
+    #       state :first_gear, :second_gear do
+    #         validate {|vehicle| vehicle.speed_is_legal}
+    #       end
+    #     end
+    #   end
+    # 
     # == Validation errors
     # 
     # If an event fails to successfully fire because there are no matching
@@ -262,26 +296,7 @@ module StateMachine
         super
       end
       
-      # Forces the change in state to be recognized regardless of whether the
-      # state value actually changed
-      def write(object, attribute, value, *args)
-        result = super
-        
-        if (attribute == :state || attribute == :event && value) && !object.send("#{self.attribute}_changed?")
-          current = read(object, :state)
-          object.changes[self.attribute.to_s] = [attribute == :event ? current : value, current]
-        end
-        
-        result
-      end
-      
       protected
-        # 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)
-          false
-        end
-        
         # Only runs validations on the action if using <tt>:save</tt>
         def runs_validations_on_action?
           action == :save
@@ -345,13 +360,6 @@ module StateMachine
         def define_scope(name, scope)
           lambda {|model, values| model.criteria.where(scope.call(values))}
         end
-        
-        # 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?(scope, method)
-          scope == :instance && method == "#{name}?" || super
-        end
     end
   end
 end

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

@@ -1,10 +1,10 @@
 module StateMachine
   module Integrations #:nodoc:
     module Mongoid
-      # Assumes Mongoid 2.1+ uses ActiveModel 3.1+
-      version '2.0.x' do
+      # Assumes Mongoid 2.2+ uses ActiveModel 3.1+
+      version '2.0.x - 2.1.x' do
         def self.active?
-          ::Mongoid::VERSION >= '2.0.0' && ::Mongoid::VERSION < '2.1.0'
+          ::Mongoid::VERSION >= '2.0.0' && ::Mongoid::VERSION < '2.2.0'
         end
         
         def define_action_hook
@@ -13,6 +13,32 @@ module StateMachine
           super
         end
       end
+      
+      version '2.0.x' do
+        def self.active?
+          ::Mongoid::VERSION >= '2.0.0' && ::Mongoid::VERSION < '2.1.0'
+        end
+        
+        # Forces the change in state to be recognized regardless of whether the
+        # state value actually changed
+        def write(object, attribute, value, *args)
+          result = super
+          
+          if (attribute == :state || attribute == :event && value) && !object.send("#{self.attribute}_changed?")
+            current = read(object, :state)
+            object.changes[self.attribute.to_s] = [attribute == :event ? current : value, current]
+          end
+          
+          result
+        end
+        
+        protected
+          # 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)
+            false
+          end
+      end
     end
   end
 end

data/lib/state_machine/integrations/sequel.rb

@@ -135,7 +135,16 @@ module StateMachine
     #   end
     # 
     # If using the +save+ action for the machine, this option will be ignored as
-    # the transaction will be created by Sequel within +save+.
+    # the transaction will be created by Sequel within +save+.  To avoid
+    # this, use a different action like so:
+    # 
+    #   class Vehicle < Sequel::Model
+    #     state_machine :initial => :parked, :use_transactions => false, :action => :save_state do
+    #       ...
+    #     end
+    #     
+    #     alias_method :save_state, :save
+    #   end
     # 
     # == Validation errors
     # 
@@ -276,22 +285,9 @@ module StateMachine
         # initial state of the machine *before* any attributes are set on the
         # object
         def define_state_initializer
-          # Hooks in to attribute initialization to set the states *prior* to
-          # the attributes being set
           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)
-                changed_columns.clear
-                yield(*args) if block_given?
-              end
-            end
-            
-            # Initializes static states
-            def set(*)
-              self.class.state_machines.initialize_states(self, :dynamic => false) if values.empty?
-              super
+            def initialize_set(*)
+              self.class.state_machines.initialize_states(self) { super }
             end
           end_eval
         end
@@ -305,70 +301,24 @@ module StateMachine
           end
         end
         
-        # Adds hooks into validation for automatically firing events.  This is
-        # a bit more complicated than other integrations since Sequel doesn't
-        # provide an easy way to hook around validation calls
+        # Defines validation hooks if the machine's action is to save the model
         def define_action_helpers
           super
-          
-          if action == :save
-            define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
-              def valid?(*args)
-                yielded = false
-                result = self.class.state_machines.transitions(self, :save, :after => false).perform do
-                  yielded = true
-                  super
-                end
-                
-                if yielded || result
-                  result
-                else
-                  #{handle_validation_failure}
-                end
-              end
-            end_eval
-          end
+          define_validation_hook if action == :save
         end
         
-        # Uses custom hooks for :save actions in order to preserve failure
-        # behavior within Sequel.  This is a bit more complicated than other
-        # integrations since Sequel doesn't provide an easy way to hook around
-        # save calls.
-        def define_action_hook
-          if action == :save
-            define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
-              def #{action_hook}(*)
-                yielded = false
-                result = self.class.state_machines.transitions(self, :save).perform do
-                  yielded = true
-                  super
-                end
-                
-                if yielded || result
-                  result
-                else
-                  #{handle_save_failure}
-                end
-              end
-            end_eval
-          else
-            super
-          end
+        # Adds hooks into validation for automatically firing events
+        def define_validation_hook
+          define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
+            def around_validation(*)
+              self.class.state_machines.transitions(self, :save, :after => false).perform { super }
+            end
+          end_eval
         end
         
         # Uses internal save hooks if using the :save action
         def action_hook
-          action == :save ? :_save : super
-        end
-        
-        # Handles whether validation errors should be raised
-        def handle_validation_failure
-          'raise_on_failure?(args.first || {}) ? raise_hook_failure(:validation) : result'
-        end
-        
-        # Handles how save failures are raised
-        def handle_save_failure
-          'raise_hook_failure(:save)'
+          action == :save ? :around_save : super
         end
         
         # Creates a scope for finding records *with* a particular state or

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

@@ -1,17 +1,70 @@
 module StateMachine
   module Integrations #:nodoc:
     module Sequel
-      version '2.8.x - 3.13.x' do
+      version '2.8.x - 3.23.x' do
         def self.active?
-          !defined?(::Sequel::MAJOR) || ::Sequel::MAJOR == 2 || ::Sequel::MAJOR == 3 && ::Sequel::MINOR <= 13
+          !defined?(::Sequel::MAJOR) || ::Sequel::MAJOR == 2 || ::Sequel::MAJOR == 3 && ::Sequel::MINOR <= 23
         end
         
-        def handle_validation_failure
-          'raise_on_save_failure ? save_failure(:validation) : result'
+        def define_state_initializer
+          define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
+            def initialize(*)
+              super do |*args|
+                self.class.state_machines.initialize_states(self, :static => false)
+                changed_columns.clear
+                yield(*args) if block_given?
+              end
+            end
+            
+            def set(*)
+              self.class.state_machines.initialize_states(self, :dynamic => false) if values.empty?
+              super
+            end
+          end_eval
         end
         
-        def handle_save_failure
-          'save_failure(:save)'
+        def define_validation_hook
+          define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
+            def valid?(*args)
+              yielded = false
+              result = self.class.state_machines.transitions(self, :save, :after => false).perform do
+                yielded = true
+                super
+              end
+              
+              if yielded || result
+                result
+              else
+                #{handle_validation_failure}
+              end
+            end
+          end_eval
+        end
+        
+        def define_action_hook
+          if action == :save
+            define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
+              def #{action_hook}(*)
+                yielded = false
+                result = self.class.state_machines.transitions(self, :save).perform do
+                  yielded = true
+                  super
+                end
+                
+                if yielded || result
+                  result
+                else
+                  #{handle_save_failure}
+                end
+              end
+            end_eval
+          else
+            super
+          end
+        end
+        
+        def action_hook
+          action == :save ? :_save : super
         end
       end
       
@@ -31,6 +84,34 @@ module StateMachine
           dataset.model_classes[nil]
         end
       end
+      
+      version '2.8.x - 3.13.x' do
+        def self.active?
+          !defined?(::Sequel::MAJOR) || ::Sequel::MAJOR == 2 || ::Sequel::MAJOR == 3 && ::Sequel::MINOR <= 13
+        end
+        
+        def handle_validation_failure
+          'raise_on_save_failure ? save_failure(:validation) : result'
+        end
+        
+        def handle_save_failure
+          'save_failure(:save)'
+        end
+      end
+      
+      version '3.14.x - 3.23.x' do
+        def self.active?
+          defined?(::Sequel::MAJOR) && ::Sequel::MAJOR == 3 && ::Sequel::MINOR >= 14 && ::Sequel::MINOR <= 23
+        end
+        
+        def handle_validation_failure
+          'raise_on_failure?(args.first || {}) ? raise_hook_failure(:validation) : result'
+        end
+        
+        def handle_save_failure
+          'raise_hook_failure(:save)'
+        end
+      end
     end
   end
 end