state_machine 1.1.2 → 1.2.0

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

@@ -1,5 +1,5 @@
 filename = "#{File.dirname(__FILE__)}/../active_model/locale.rb"
-translations = eval(IO.read(filename), binding, filename)
+translations = eval(IO.read(File.expand_path(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

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

@@ -10,7 +10,7 @@ module StateMachine
           define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
             def attributes_from_column_definition(*)
               result = super
-              self.class.state_machines.initialize_states(self, :dynamic => false, :to => result)
+              self.class.state_machines.initialize_states(self, :static => :force, :dynamic => false, :to => result)
               result
             end
           end_eval
@@ -81,10 +81,6 @@ module StateMachine
           :activerecord
         end
         
-        def action_hook
-          action == :save ? :create_or_update : super
-        end
-        
         def load_observer_extensions
           super
           ::ActiveRecord::Observer.class_eval do
@@ -122,18 +118,6 @@ module StateMachine
           klass.self_and_descendants_from_active_record
         end
       end
-      
-      version '3.0.x' do
-        def self.active?
-          ::ActiveRecord::VERSION::MAJOR == 3 && ::ActiveRecord::VERSION::MINOR == 0
-        end
-        
-        def define_action_hook
-          # +around+ callbacks don't have direct access to results until AS 3.1
-          owner_class.set_callback(:save, :after, 'value', :prepend => true) if action_hook == :save
-          super
-        end
-      end
     end
   end
 end

data/lib/state_machine/integrations/base.rb

@@ -18,16 +18,25 @@ module StateMachine
         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.
+        # is only true if the ORM that the integration is for is currently
+        # defined.
         def available?
-          false
+          matching_ancestors.any? && Object.const_defined?(matching_ancestors[0].split('::')[0])
         end
         
-        # Whether the integration should be used for the given class.  Default
-        # is false.
+        # The list of ancestor names that cause this integration to matched.
+        def matching_ancestors
+          []
+        end
+        
+        # Whether the integration should be used for the given class.
         def matches?(klass)
-          false
+          matches_ancestors?(klass.ancestors.map {|ancestor| ancestor.name})
+        end
+        
+        # Whether the integration should be used for the given list of ancestors.
+        def matches_ancestors?(ancestors)
+          (ancestors & matching_ancestors).any?
         end
         
         # Tracks the various version overrides for an integration

data/lib/state_machine/integrations/data_mapper.rb

@@ -108,6 +108,42 @@ module StateMachine
     #     end
     #   end
     # 
+    # === Within DataMapper Hooks
+    # 
+    # DataMapper protects against the potential for system stack errors resulting
+    # from infinite loops by preventing records from being saved multiple times
+    # within save hooks.  You need to be acutely aware of this when interacting
+    # with state_machine within save hooks.  There are two things to keep in mind:
+    # 
+    # 1. You cannot run a state_machine event during an `after :save/:create` hook.
+    # 2. If you need to run a state_machine event during a `before :save/:create/etc.`
+    #    hook, then you have to force the machine's action to be skipped by passing
+    #    `false` in as an argument to the event.
+    # 
+    # For example:
+    # 
+    #   class Vehicle
+    #     include DataMapper::Resource
+    #     ...
+    #     
+    #     state_machine :initial => :parked do
+    #       event :ignite do
+    #         transition :parked => :idling
+    #       end
+    #     end
+    #     
+    #     # This will allow the event to transition without attempting to save a second time
+    #     before :create { ignite(false) }
+    #     
+    #     # This will never work because DataMapper will refuse to save the
+    #     # changes since we're still inside of a transaction
+    #     # after :create { ignite }
+    #   end
+    # 
+    # While the above will work, in reality you should typically just set the
+    # `state_event` attribute in `#initialize` to automatically transition an
+    # object on creation.
+    # 
     # == Transactions
     # 
     # By default, the use of transactions during an event transition is
@@ -146,21 +182,6 @@ module StateMachine
     #     end
     #   end
     # 
-    # 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.  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
     # 
     # If an event fails to successfully fire because there are no matching
@@ -302,26 +323,38 @@ module StateMachine
     # The failure callback creates +TransitionLog+ records using a second
     # connection to the database, allowing them to be saved without being
     # affected by rollbacks in the +Vehicle+ resource's transaction.
+    # 
+    # === Callback Order
+    # 
+    # Callbacks occur in the following order.  Callbacks specific to state_machine
+    # are bolded.  The remaining callbacks are part of ActiveRecord.
+    # 
+    # * (-) save
+    # * (-) begin transaction (if enabled)
+    # * (1) *before_transition*
+    # * (2) before :valid?
+    # * (-) valid?
+    # * (3) after :valid?
+    # * (4) before :save
+    # * (-) save
+    # * (5) before :create
+    # * (-) create
+    # * (6) after :create
+    # * (7) after :save
+    # * (8) *after_transition*
+    # * (-) end transaction (if enabled)
     module DataMapper
       include Base
       
       require 'state_machine/integrations/data_mapper/versions'
       
       # 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)
-        klass <= ::DataMapper::Resource
+      def self.matching_ancestors
+        %w(DataMapper::Resource)
       end
       
       # Loads additional files specific to DataMapper
@@ -371,6 +404,16 @@ module StateMachine
           @supports_validations ||= ::DataMapper.const_defined?('Validate')
         end
         
+        # Gets the db default for the machine's attribute
+        def owner_class_attribute_default
+          attribute_property && attribute_property.default
+        end
+        
+        # Gets the property for this machine's attribute (if it exists)
+        def attribute_property
+          owner_class.properties.detect {|property| property.name == attribute}
+        end
+        
         # Pluralizes the name using the built-in inflector
         def pluralize(word)
           ::DataMapper::Inflector.pluralize(word.to_s)
@@ -382,14 +425,14 @@ module StateMachine
         def define_state_initializer
           define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
             def initialize(*args)
-              self.class.state_machines.initialize_states(self) { super }
+              self.class.state_machines.initialize_states(self, :static => :force) { super }
             end
           end_eval
         end
         
         # Skips defining reader/writer methods since this is done automatically
         def define_state_accessor
-          owner_class.property(attribute, String) unless owner_class.properties.detect {|property| property.name == attribute}
+          owner_class.property(attribute, String) unless attribute_property
           
           if supports_validations?
             name = self.name
@@ -402,20 +445,40 @@ module StateMachine
         
         # Adds hooks into validation for automatically firing events
         def define_action_helpers
-          super
-          
-          if action == :save && supports_validations?
+          if action_hook == :save
             define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
-              def valid?(*)
-                self.class.state_machines.transitions(self, :save, :after => false).perform { super }
+              def save(*)
+                result = self.class.state_machines.transitions(self, :save).perform { super }
+                assert_save_successful(:save, result)
+                result
+              end
+              
+              def save!(*)
+                result = self.class.state_machines.transitions(self, :save).perform { super }
+                assert_save_successful(:save!, result)
+                result
+              end
+              
+              def save_self(*)
+                self.class.state_machines.transitions(self, :save).perform { super }
               end
             end_eval
+            
+            define_validation_hook
+          else
+            super
           end
         end
         
-        # Uses internal save hooks if using the :save action
-        def action_hook
-          action == :save ? :save_self : super
+        # Adds hooks into validation for automatically firing events
+        def define_validation_hook
+          if supports_validations?
+            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
         
         # Creates a scope for finding records *with* a particular state or

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

@@ -1,23 +1,33 @@
 module StateMachine
   module Integrations #:nodoc:
     module DataMapper
-      version '0.9.x' do
+      version '0.9.x - 0.10.x' do
         def self.active?
-          ::DataMapper::VERSION =~ /^0\.9\./
+          ::DataMapper::VERSION =~ /^0\.\d\./ || ::DataMapper::VERSION =~ /^0\.10\./
         end
         
-        def action_hook
-          action
+        def pluralize(word)
+          ::Extlib::Inflection.pluralize(word.to_s)
         end
       end
       
-      version '0.9.x - 0.10.x' do
+      version '0.9.x' do
         def self.active?
-          ::DataMapper::VERSION =~ /^0\.\d\./ || ::DataMapper::VERSION =~ /^0\.10\./
+          ::DataMapper::VERSION =~ /^0\.9\./
         end
         
-        def pluralize(word)
-          ::Extlib::Inflection.pluralize(word.to_s)
+        def define_action_helpers
+          if action_hook == :save
+            define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
+              def save(*)
+                self.class.state_machines.transitions(self, :save).perform { super }
+              end
+            end_eval
+            
+            define_validation_hook
+          else
+            super
+          end
         end
       end
       
@@ -33,6 +43,34 @@ module StateMachine
         end
       end
       
+      version '0.10.x' do
+        def self.active?
+          ::DataMapper::VERSION =~ /^0\.10\./
+        end
+        
+        def define_action_helpers
+          if action_hook == :save
+            define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
+              def save(*)
+                self.class.state_machines.transitions(self, :save).perform { super }
+              end
+              
+              def save!(*)
+                self.class.state_machines.transitions(self, :save).perform { super }
+              end
+              
+              def save_self(*)
+                self.class.state_machines.transitions(self, :save).perform { super }
+              end
+            end_eval
+            
+            define_validation_hook
+          else
+            super
+          end
+        end
+      end
+      
       version '1.0.0' do
         def self.active?
           ::DataMapper::VERSION == '1.0.0'

data/lib/state_machine/integrations/mongo_mapper.rb

@@ -233,6 +233,22 @@ module StateMachine
     # Note, also, that the transition can be accessed by simply defining
     # additional arguments in the callback block.
     # 
+    # === Callback Order
+    # 
+    # Callbacks occur in the following order.  Callbacks specific to state_machine
+    # are bolded.  The remaining callbacks are part of MongoMapper.
+    # 
+    # * (-) save
+    # * (1) *before_transition*
+    # * (-) valid
+    # * (2) before_validation
+    # * (3) after_validation
+    # * (4) before_save
+    # * (5) before_create
+    # * (6) after_create
+    # * (7) after_save
+    # * (8) *after_transition*
+    # 
     # == Internationalization
     # 
     # Any error message that is generated from performing invalid transitions
@@ -291,17 +307,10 @@ 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)
-        klass <= ::MongoMapper::Document
+      def self.matching_ancestors
+        %w(MongoMapper::Document)
       end
       
       protected
@@ -310,27 +319,45 @@ module StateMachine
           action == :save
         end
         
+        # Gets the db default for the machine's attribute
+        def owner_class_attribute_default
+          attribute_key && attribute_key.default_value
+        end
+        
+        # Gets the Mongoid key for this machine's attribute (if it exists)
+        def attribute_key
+          owner_class.keys[attribute.to_s]
+        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, <<-end_eval, __FILE__, __LINE__ + 1
             def initialize(*args)
-              self.class.state_machines.initialize_states(self) { super }
+              self.class.state_machines.initialize_states(self, :static => :force) { super }
             end
           end_eval
         end
         
         # Skips defining reader/writer methods since this is done automatically
         def define_state_accessor
-          owner_class.key(attribute, String) unless owner_class.keys.include?(attribute.to_s)
+          owner_class.key(attribute, String) unless attribute_key
           super
         end
         
         # Uses around callbacks to run state events if using the :save hook
         def define_action_hook
           if action_hook == :save
-            owner_class.set_callback(:save, :around, self, :prepend => true)
+            define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
+              def save(*)
+                self.class.state_machine(#{name.inspect}).send(:around_save, self) { super }
+              end
+              
+              def save!(*)
+                self.class.state_machine(#{name.inspect}).send(:around_save, self) { super } || raise(::MongoMapper::DocumentNotValid.new(self))
+              end
+            end_eval
           else
             super
           end

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

@@ -1,4 +1,4 @@
 filename = "#{File.dirname(__FILE__)}/../active_model/locale.rb"
-translations = eval(IO.read(filename), binding, filename)
+translations = eval(IO.read(File.expand_path(filename)), binding, filename)
 translations[:en][:mongo_mapper] = translations[:en].delete(:activemodel)
 translations

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

@@ -14,7 +14,7 @@ module StateMachine
           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 }
+              attrs && attrs.stringify_keys.key?('_id') ? super : self.class.state_machines.initialize_states(self, :static => :force) { super }
             end
           end_eval
         end
@@ -49,10 +49,6 @@ module StateMachine
           })
         end
         
-        def action_hook
-          action == :save ? :create_or_update : super
-        end
-        
         def load_locale
         end
         
@@ -82,25 +78,12 @@ module StateMachine
         def define_state_initializer
           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 }
+              from_db = args[1]
+              from_db ? super : self.class.state_machines.initialize_states(self, :static => :force) { 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\./
-        end
-        
-        def define_action_hook
-          # +around+ callbacks don't have direct access to results until AS 3.1
-          owner_class.set_callback(:save, :after, 'value', :prepend => true) if action_hook == :save
-          super
-        end
-      end
     end
   end
 end