aasm 4.12.0 → 4.12.1

data/lib/aasm/persistence/base.rb

@@ -34,13 +34,17 @@ module AASM
       # This allows for nil aasm states - be sure to add validation to your model
       def aasm_read_state(name=:default)
         state = send(self.class.aasm(name).attribute_name)
-        if new_record?
-          state.blank? ? aasm(name).determine_state_name(self.class.aasm(name).initial_state) : state.to_sym
+        if state.blank?
+          aasm_new_record? ? aasm(name).determine_state_name(self.class.aasm(name).initial_state) : nil
         else
-          state.blank? ? nil : state.to_sym
+          state.to_sym
         end
       end
 
+      def aasm_new_record?
+        new_record?
+      end
+
       module ClassMethods
         def aasm_column(attribute_name=nil)
           warn "[DEPRECATION] aasm_column is deprecated. Use aasm.attribute_name instead"

data/lib/aasm/persistence/mongoid_persistence.rb

@@ -1,3 +1,4 @@
+require 'aasm/persistence/orm'
 module AASM
   module Persistence
     module MongoidPersistence
@@ -30,6 +31,7 @@ module AASM
       #
       def self.included(base)
         base.send(:include, AASM::Persistence::Base)
+        base.send(:include, AASM::Persistence::ORM)
         base.send(:include, AASM::Persistence::MongoidPersistence::InstanceMethods)
         base.extend AASM::Persistence::MongoidPersistence::ClassMethods
 
@@ -50,55 +52,21 @@ module AASM
 
       module InstanceMethods
 
-        # Writes <tt>state</tt> to the state field and persists it to the database
-        #
-        #   foo = Foo.find(1)
-        #   foo.aasm.current_state # => :opened
-        #   foo.close!
-        #   foo.aasm.current_state # => :closed
-        #   Foo.find(1).aasm.current_state # => :closed
-        #
-        # NOTE: intended to be called from an event
-        def aasm_write_state(state, name=:default)
-          old_value = read_attribute(self.class.aasm(name).attribute_name)
-          aasm_write_attribute(state, name)
-
-          success = if aasm_skipping_validations(name)
-                      value = aasm_raw_attribute_value(state, name)
-                      aasm_update_column(name, value)
-                    else
-                      self.save
-                    end
-
-          unless success
-            aasm_rollback(name, old_value)
-            raise Mongoid::Errors::Validations.new(self) if aasm_whiny_persistence(name)
-          end
+        private
 
-          success
+        def aasm_save
+          self.save
         end
 
-        # Writes <tt>state</tt> to the state field, but does not persist it to the database
-        #
-        #   foo = Foo.find(1)
-        #   foo.aasm.current_state # => :opened
-        #   foo.close
-        #   foo.aasm.current_state # => :closed
-        #   Foo.find(1).aasm.current_state # => :opened
-        #   foo.save
-        #   foo.aasm.current_state # => :closed
-        #   Foo.find(1).aasm.current_state # => :closed
-        #
-        # NOTE: intended to be called from an event
-        def aasm_write_state_without_persistence(state, name=:default)
-          aasm_write_attribute(state, name)
+        def aasm_raise_invalid_record
+          raise Mongoid::Errors::Validations.new(self)
         end
 
-      private
-
-        def aasm_update_column(name, value)
-          attribute_name = self.class.aasm(name).attribute_name
+        def aasm_supports_transactions?
+          false
+        end
 
+        def aasm_update_column(attribute_name, value)
           if Mongoid::VERSION.to_f >= 4
             set(Hash[attribute_name, value])
           else
@@ -108,25 +76,12 @@ module AASM
           true
         end
 
-        def aasm_rollback(name, old_value)
-          write_attribute(self.class.aasm(name).attribute_name, old_value)
-          false
-        end
-
-        def aasm_skipping_validations(state_machine_name)
-          AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.skip_validation_on_save
-        end
-
-        def aasm_whiny_persistence(state_machine_name)
-          AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.whiny_persistence
-        end
-
-        def aasm_write_attribute(state, name=:default)
-          write_attribute(self.class.aasm(name).attribute_name, aasm_raw_attribute_value(state, name))
+        def aasm_read_attribute(name)
+          read_attribute(name)
         end
 
-        def aasm_raw_attribute_value(state, _name=:default)
-          state.to_s
+        def aasm_write_attribute(name, value)
+          write_attribute(name, value)
         end
 
         # Ensures that if the aasm_state column is nil and the record is new

data/lib/aasm/persistence/orm.rb

@@ -0,0 +1,142 @@
+module AASM
+  module Persistence
+    # This module adds transactional support for any database that supports it.
+    # This includes rollback capability and rollback/commit callbacks.
+    module ORM
+
+      # Writes <tt>state</tt> to the state column and persists it to the database
+      #
+      #   foo = Foo.find(1)
+      #   foo.aasm.current_state # => :opened
+      #   foo.close!
+      #   foo.aasm.current_state # => :closed
+      #   Foo.find(1).aasm.current_state # => :closed
+      #
+      # NOTE: intended to be called from an event
+      def aasm_write_state(state, name=:default)
+        attribute_name = self.class.aasm(name).attribute_name
+        old_value = aasm_read_attribute(attribute_name)
+        aasm_write_state_attribute state, name
+
+        success = if aasm_skipping_validations(name)
+          aasm_update_column(attribute_name, aasm_raw_attribute_value(state, name))
+        else
+          aasm_save
+        end
+
+        unless success
+          aasm_rollback(name, old_value)
+          aasm_raise_invalid_record if aasm_whiny_persistence(name)
+        end
+
+        success
+      end
+
+      # Writes <tt>state</tt> to the state field, but does not persist it to the database
+      #
+      #   foo = Foo.find(1)
+      #   foo.aasm.current_state # => :opened
+      #   foo.close
+      #   foo.aasm.current_state # => :closed
+      #   Foo.find(1).aasm.current_state # => :opened
+      #   foo.save
+      #   foo.aasm.current_state # => :closed
+      #   Foo.find(1).aasm.current_state # => :closed
+      #
+      # NOTE: intended to be called from an event
+      def aasm_write_state_without_persistence(state, name=:default)
+        aasm_write_state_attribute(state, name)
+      end
+
+      private
+
+      # Save the record and return true if it succeeded/false otherwise.
+      def aasm_save
+        raise("Define #aasm_save_without_error in the AASM Persistence class.")
+      end
+
+      def aasm_raise_invalid_record
+        raise("Define #aasm_raise_invalid_record in the AASM Persistence class.")
+      end
+
+      # Update only the column without running validations.
+      def aasm_update_column(attribute_name, value)
+        raise("Define #aasm_update_column in the AASM Persistence class.")
+      end
+
+      def aasm_read_attribute(name)
+        raise("Define #aasm_read_attribute the AASM Persistence class.")
+      end
+
+      def aasm_write_attribute(name, value)
+        raise("Define #aasm_write_attribute in the AASM Persistence class.")
+      end
+
+      # Returns true or false if transaction completed successfully.
+      def aasm_transaction(requires_new, requires_lock)
+        raise("Define #aasm_transaction the AASM Persistence class.")
+      end
+
+      def aasm_supports_transactions?
+        true
+      end
+
+      def aasm_write_state_attribute(state, name=:default)
+        aasm_write_attribute(self.class.aasm(name).attribute_name, aasm_raw_attribute_value(state, name))
+      end
+
+      def aasm_raw_attribute_value(state, _name=:default)
+        state.to_s
+      end
+
+      def aasm_rollback(name, old_value)
+        aasm_write_attribute(self.class.aasm(name).attribute_name, old_value)
+        false
+      end
+
+      def aasm_whiny_persistence(state_machine_name)
+        AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.whiny_persistence
+      end
+
+      def aasm_skipping_validations(state_machine_name)
+        AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.skip_validation_on_save
+      end
+
+      def requires_new?(state_machine_name)
+        AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.requires_new_transaction
+      end
+
+      def requires_lock?(state_machine_name)
+        AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.requires_lock
+      end
+
+      # Returns true if event was fired successfully and transaction completed.
+      def aasm_fire_event(state_machine_name, name, options, *args, &block)
+        if aasm_supports_transactions? && options[:persist]
+          event = self.class.aasm(state_machine_name).state_machine.events[name]
+          event.fire_callbacks(:before_transaction, self, *args)
+          event.fire_global_callbacks(:before_all_transactions, self, *args)
+
+          begin
+            success = aasm_transaction(requires_new?(state_machine_name), requires_lock?(state_machine_name)) do
+              super
+            end
+
+            if success
+              event.fire_callbacks(:after_commit, self, *args)
+              event.fire_global_callbacks(:after_all_commits, self, *args)
+            end
+
+            success
+          ensure
+            event.fire_callbacks(:after_transaction, self, *args)
+            event.fire_global_callbacks(:after_all_transactions, self, *args)
+          end
+        else
+          super
+        end
+      end
+
+    end # Transactional
+  end # Persistence
+end # AASM

data/lib/aasm/persistence/redis_persistence.rb

@@ -8,13 +8,12 @@ module AASM
       end
 
       module InstanceMethods
-        # Add the inital value to intiializer
+        # Initialize with default values
         #
-        # redis-objects removed the key from redis when set to nil
+        # Redis::Objects removes the key from Redis when set to `nil`
         def initialize(*args)
           super
-          state = send(self.class.aasm.attribute_name)
-          state.value = aasm.determine_state_name(self.class.aasm.initial_state)
+          aasm_ensure_initial_state
         end
         # Returns the value of the aasm.attribute_name - called from <tt>aasm.current_state</tt>
         #
@@ -68,8 +67,10 @@ module AASM
         #   foo.aasm_state # => nil
         #
         def aasm_ensure_initial_state
-          aasm.enter_initial_state if
-          send(self.class.aasm.attribute_name).to_s.strip.empty?
+          AASM::StateMachineStore.fetch(self.class, true).machine_names.each do |name|
+            aasm_column = self.class.aasm(name).attribute_name
+            aasm(name).enter_initial_state if send(aasm_column).value.blank?
+          end
         end
 
         # Writes <tt>state</tt> to the state column and persists it to the database
@@ -81,12 +82,16 @@ module AASM
         #   Foo[1].aasm.current_state # => :closed
         #
         # NOTE: intended to be called from an event
-        def aasm_write_state(state)
-          aasm_column = self.class.aasm.attribute_name
-          self.send("#{aasm_column}=", state)
+        def aasm_write_state(state, name=:default)
+          aasm_column = self.class.aasm(name).attribute_name
+          send("#{aasm_column}").value = state
         end
 
         # Writes <tt>state</tt> to the state column, but does not persist it to the database
+        # (but actually it still does)
+        #
+        # With Redis::Objects it's not possible to skip persisting - it's not an ORM,
+        # it does not operate like an AR model and does not know how to postpone changes.
         #
         #   foo = Foo[1]
         #   foo.aasm.current_state # => :opened
@@ -98,8 +103,8 @@ module AASM
         #   Foo[1].aasm.current_state # => :closed
         #
         # NOTE: intended to be called from an event
-        def aasm_write_state_without_persistence(state)
-          send("#{self.class.aasm.attribute_name}=", state)
+        def aasm_write_state_without_persistence(state, name=:default)
+          aasm_write_state(state, name)
         end
       end
     end

data/lib/aasm/persistence/sequel_persistence.rb

@@ -1,8 +1,10 @@
+require 'aasm/persistence/orm'
 module AASM
   module Persistence
     module SequelPersistence
       def self.included(base)
         base.send(:include, AASM::Persistence::Base)
+        base.send(:include, AASM::Persistence::ORM)
         base.send(:include, AASM::Persistence::SequelPersistence::InstanceMethods)
       end
 
@@ -17,42 +19,42 @@ module AASM
           super
         end
 
-        # Returns the value of the aasm.attribute_name - called from <tt>aasm.current_state</tt>
-        #
-        # If it's a new record, and the aasm state column is blank it returns the initial state
-        #
-        #   class Foo < Sequel::Model
-        #     include AASM
-        #     aasm :column => :status do
-        #       state :opened
-        #       state :closed
-        #     end
-        #   end
-        #
-        #   foo = Foo.new
-        #   foo.current_state # => :opened
-        #   foo.close
-        #   foo.current_state # => :closed
-        #
-        #   foo = Foo[1]
-        #   foo.current_state # => :opened
-        #   foo.aasm_state = nil
-        #   foo.current_state # => nil
-        #
-        # NOTE: intended to be called from an event
-        #
-        # This allows for nil aasm states - be sure to add validation to your model
-        def aasm_read_state(name=:default)
-          state = send(self.class.aasm(name).attribute_name)
-          if new? && state.to_s.strip.empty?
-            aasm(name).determine_state_name(self.class.aasm(name).initial_state)
-          elsif state.nil?
-            nil
-          else
-            state.to_sym
+        def aasm_raise_invalid_record
+          raise Sequel::ValidationFailed.new(self)
+        end
+
+        def aasm_new_record?
+          new?
+        end
+
+        # Returns nil if fails silently
+        # http://sequel.jeremyevans.net/rdoc/classes/Sequel/Model/InstanceMethods.html#method-i-save
+        def aasm_save
+          !save(raise_on_failure: false).nil?
+        end
+
+        def aasm_read_attribute(name)
+          send(name)
+        end
+
+        def aasm_write_attribute(name, value)
+          send("#{name}=", value)
+        end
+
+        def aasm_transaction(requires_new, requires_lock)
+          self.class.db.transaction(savepoint: requires_new) do
+            if requires_lock
+              # http://sequel.jeremyevans.net/rdoc/classes/Sequel/Model/InstanceMethods.html#method-i-lock-21
+              requires_lock.is_a?(String) ? lock!(requires_lock) : lock!
+            end
+            yield
           end
         end
 
+        def aasm_update_column(attribute_name, value)
+          this.update(attribute_name => value)
+        end
+
         # Ensures that if the aasm_state column is nil and the record is new
         # that the initial state gets populated before validation on create
         #
@@ -72,39 +74,10 @@ module AASM
           AASM::StateMachineStore.fetch(self.class, true).machine_names.each do |state_machine_name|
             aasm(state_machine_name).enter_initial_state if
               (new? || values.key?(self.class.aasm(state_machine_name).attribute_name)) &&
-              send(self.class.aasm(state_machine_name).attribute_name).to_s.strip.empty?
+                send(self.class.aasm(state_machine_name).attribute_name).to_s.strip.empty?
           end
         end
 
-        # Writes <tt>state</tt> to the state column and persists it to the database
-        #
-        #   foo = Foo[1]
-        #   foo.aasm.current_state # => :opened
-        #   foo.close!
-        #   foo.aasm.current_state # => :closed
-        #   Foo[1].aasm.current_state # => :closed
-        #
-        # NOTE: intended to be called from an event
-        def aasm_write_state state, name=:default
-          aasm_column = self.class.aasm(name).attribute_name
-          update_only({aasm_column => state.to_s}, aasm_column)
-        end
-
-        # Writes <tt>state</tt> to the state column, but does not persist it to the database
-        #
-        #   foo = Foo[1]
-        #   foo.aasm.current_state # => :opened
-        #   foo.close
-        #   foo.aasm.current_state # => :closed
-        #   Foo[1].aasm.current_state # => :opened
-        #   foo.save
-        #   foo.aasm.current_state # => :closed
-        #   Foo[1].aasm.current_state # => :closed
-        #
-        # NOTE: intended to be called from an event
-        def aasm_write_state_without_persistence state, name=:default
-          send("#{self.class.aasm(name).attribute_name}=", state.to_s)
-        end
       end
     end
   end