state_machine 1.1.2 → 1.2.0

data/lib/state_machine/integrations/mongoid.rb

@@ -283,6 +283,22 @@ module StateMachine
     #     end
     #   end
     # 
+    # === Callback Order
+    # 
+    # Callbacks occur in the following order.  Callbacks specific to state_machine
+    # are bolded.  The remaining callbacks are part of Mongoid.
+    # 
+    # * (-) 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
@@ -341,17 +357,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 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)
-        klass <= ::Mongoid::Document
+      def self.matching_ancestors
+        %w(Mongoid::Document)
       end
       
       def self.extended(base) #:nodoc:
@@ -365,33 +374,62 @@ module StateMachine
           action == :save
         end
         
+        # Gets the db default for the machine's attribute
+        def owner_class_attribute_default
+          attribute_field && attribute_field.default_val
+        end
+        
+        # Gets the field for this machine's attribute (if it exists)
+        def attribute_field
+          owner_class.fields[attribute.to_s] || owner_class.fields[owner_class.aliased_fields[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(*)
-              @attributes ||= {}
-              self.class.state_machines.initialize_states(self, :dynamic => false)
-              
               super do |*args|
                 self.class.state_machines.initialize_states(self, :static => false)
                 yield(*args) if block_given?
               end
             end
+            
+            def apply_pre_processed_defaults
+              defaults = {}
+              self.class.state_machines.initialize_states(self, :static => :force, :dynamic => false, :to => defaults)
+              defaults.each do |attr, value|
+                send(:"\#{attr}=", value) unless attributes.include?(attr)
+              end
+              super
+            end
           end_eval
         end
         
         # Skips defining reader/writer methods since this is done automatically
         def define_state_accessor
-          owner_class.field(attribute, :type => String) unless owner_class.fields.include?(attribute.to_s)
+          owner_class.field(attribute, :type => String) unless attribute_field
           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 insert(*)
+                self.class.state_machine(#{name.inspect}).send(:around_save, self) { super.persisted? }
+                self
+              end
+              
+              def update(*)
+                self.class.state_machine(#{name.inspect}).send(:around_save, self) { super }
+              end
+              
+              def upsert(*)
+                self.class.state_machine(#{name.inspect}).send(:around_save, self) { super }
+              end
+            end_eval
           else
             super
           end

data/lib/state_machine/integrations/mongoid/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][:mongoid] = translations[:en].delete(:activemodel)
 translations

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

@@ -1,53 +1,79 @@
 module StateMachine
   module Integrations #:nodoc:
     module Mongoid
-      version '2.0.x - 2.2.x' do
+      version '2.x' do
         def self.active?
-          ::Mongoid::VERSION =~ /^2\.[0-2]\./
+          ::Mongoid::VERSION =~ /^2\./
         end
         
         def define_state_initializer
           define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
-            # Initializes dynamic states
             def initialize(*)
+              @attributes ||= {}
+              self.class.state_machines.initialize_states(self, :static => :force, :dynamic => false)
+              
               super do |*args|
                 self.class.state_machines.initialize_states(self, :static => false)
                 yield(*args) if block_given?
               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
         
+        def owner_class_attribute_default
+          attribute_field && attribute_field.default
+        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
+          if action_hook == :save
+            define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
+              def insert(*)
+                self.class.state_machine(#{name.inspect}).send(:around_save, self) { super.persisted? }
+                self
+              end
+              
+              def update(*)
+                self.class.state_machine(#{name.inspect}).send(:around_save, self) { super }
+              end
+            end_eval
+          else
+            super
+          end
         end
       end
       
-      version '2.0.x' do
+      version '2.0.x - 2.3.x' do
         def self.active?
-          ::Mongoid::VERSION =~ /^2\.0\./
+          ::Mongoid::VERSION =~ /^2\.[0-3]\./
         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
+        def attribute_field
+          owner_class.fields[attribute.to_s]
+        end
+      end
+      
+      version '2.0.x - 2.2.x' do
+        def self.active?
+          ::Mongoid::VERSION =~ /^2\.[0-2]\./
+        end
+        
+        def define_state_initializer
+          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
+            
+            # Initializes static states
+            def apply_default_attributes(*)
+              result = super
+              self.class.state_machines.initialize_states(self, :static => :force, :dynamic => false, :to => result) if new_record?
+              result
+            end
+          end_eval
         end
       end
     end

data/lib/state_machine/integrations/sequel.rb

@@ -134,18 +134,6 @@ module StateMachine
     #     end
     #   end
     # 
-    # If using the +save+ action for the machine, this option will be ignored as
-    # 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
     # 
     # If an event fails to successfully fire because there are no matching
@@ -265,26 +253,38 @@ module StateMachine
     # The +TransitionLog+ model uses a second connection to the database that
     # allows new records to be saved without being affected by rollbacks in the
     # +Vehicle+ model's transaction.
+    # 
+    # === Callback Order
+    # 
+    # Callbacks occur in the following order.  Callbacks specific to state_machine
+    # are bolded.  The remaining callbacks are part of Sequel.
+    # 
+    # * (-) save
+    # * (-) begin transaction (if enabled)
+    # * (1) *before_transition*
+    # * (2) before_validation
+    # * (-) validate
+    # * (3) after_validation
+    # * (4) before_save
+    # * (5) before_create
+    # * (-) create
+    # * (6) after_create
+    # * (7) after_save
+    # * (8) *after_transition*
+    # * (-) end transaction (if enabled)
+    # * (9) after_commit
     module Sequel
       include Base
       
       require 'state_machine/integrations/sequel/versions'
       
       # The default options to use for state machines using this integration
-      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)
-        klass <= ::Sequel::Model
+      def self.matching_ancestors
+        %w(Sequel::Model)
       end
       
       # Forces the change in state to be recognized regardless of whether the
@@ -331,7 +331,6 @@ module StateMachine
         
         # Loads all of the Sequel plugins necessary to run
         def load_plugins
-          owner_class.plugin(:validation_class_methods)
           owner_class.plugin(:hook_class_methods)
         end
         
@@ -346,18 +345,20 @@ module StateMachine
         def define_state_initializer
           define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
             def initialize_set(*)
-              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
-          name = self.name
-          owner_class.validates_each(attribute) do |record, attr, value|
-            machine = record.class.state_machine(name)
-            machine.invalidate(record, :state, :invalid) unless machine.states.match(record)
-          end
+          define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
+            def validate(*)
+              super
+              machine = self.class.state_machine(#{name.inspect})
+              machine.invalidate(self, :state, :invalid) unless machine.states.match(self)
+            end
+          end_eval
         end
         
         # Defines validation hooks if the machine's action is to save the model
@@ -366,6 +367,43 @@ module StateMachine
           define_validation_hook if action == :save
         end
         
+        # Uses around callbacks to run state events if using the :save hook
+        def define_action_hook
+          if action == :save
+            define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
+              def #{action_hook}(*args)
+                opts = args.last.is_a?(Hash) ? args.last : {}
+                yielded = false
+                result = self.class.state_machine(#{name.inspect}).send(:around_save, self) do
+                  yielded = true
+                  super
+                end
+                
+                if yielded || result
+                  result
+                else
+                  #{handle_save_failure}
+                end
+              end
+            end_eval
+          else
+            super
+          end
+        end
+        
+        # Handles how save failures (due to invalid transitions) are raised
+        def handle_save_failure
+          'raise_hook_failure(:before_transition) if raise_on_failure?(opts)'
+        end
+        
+        # Runs state events around the machine's :save action
+        def around_save(object)
+          result = transaction(object) do
+            object.class.state_machines.transitions(object, action).perform { yield }
+          end
+          result
+        end
+        
         # Adds hooks into validation for automatically firing events
         def define_validation_hook
           define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
@@ -375,9 +413,16 @@ module StateMachine
           end_eval
         end
         
-        # Uses internal save hooks if using the :save action
-        def action_hook
-          action == :save ? :around_save : super
+        # Gets the db default for the machine's attribute
+        def owner_class_attribute_default
+          if owner_class.db.table_exists?(owner_class.table_name) && column = owner_class.db_schema[attribute.to_sym]
+            column[:default]
+          end
+        end
+        
+        # Uses the DB literal to match the default against the specified state
+        def owner_class_attribute_default_matches?(state)
+          owner_class.db.literal(state.value) == owner_class_attribute_default
         end
         
         # Creates a scope for finding records *with* a particular state or
@@ -421,7 +466,11 @@ module StateMachine
         # Runs a new database transaction, rolling back any changes if the
         # yielded block fails (i.e. returns false).
         def transaction(object)
-          object.db.transaction {raise ::Sequel::Error::Rollback unless yield}
+          result = nil
+          object.db.transaction do
+            raise ::Sequel::Error::Rollback unless result = yield
+          end
+          result
         end
         
         # Creates a new callback in the callback chain, always ensuring that

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

@@ -17,7 +17,7 @@ module StateMachine
             end
             
             def set(*)
-              self.class.state_machines.initialize_states(self, :dynamic => false) if values.empty?
+              self.class.state_machines.initialize_states(self, :static => :force, :dynamic => false) if values.empty?
               super
             end
           end_eval
@@ -26,6 +26,7 @@ module StateMachine
         def define_validation_hook
           define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
             def valid?(*args)
+              opts = args.first.is_a?(Hash) ? args.first : {}
               yielded = false
               result = self.class.state_machines.transitions(self, :save, :after => false).perform do
                 yielded = true
@@ -40,31 +41,19 @@ module StateMachine
             end
           end_eval
         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 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
+        def handle_validation_failure
+          'raise_on_save_failure ? save_failure(:validation) : result'
         end
         
-        def action_hook
-          action == :save ? :_save : super
+        def handle_save_failure
+          'save_failure(:save) if raise_on_save_failure'
         end
       end
       
@@ -79,26 +68,16 @@ module StateMachine
         def load_inflector
         end
         
-        def action_hook
-          action == :save ? :save : super
-        end
-        
         def model_from_dataset(dataset)
           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)'
+        def define_state_accessor
+          name = self.name
+          owner_class.validates_each(attribute) do |record, attr, value|
+            machine = record.class.state_machine(name)
+            machine.invalidate(record, :state, :invalid) unless machine.states.match(record)
+          end
         end
       end
       
@@ -108,11 +87,7 @@ module StateMachine
         end
         
         def handle_validation_failure
-          'raise_on_failure?(args.first || {}) ? raise_hook_failure(:validation) : result'
-        end
-        
-        def handle_save_failure
-          'raise_hook_failure(:save)'
+          'raise_on_failure?(opts) ? raise_hook_failure(:validation) : result'
         end
       end
     end