aasm 5.0.8

data/lib/aasm/persistence/dynamoid_persistence.rb

@@ -0,0 +1,92 @@
+module AASM
+  module Persistence
+    module DynamoidPersistence
+      def self.included(base)
+        base.send(:include, AASM::Persistence::Base)
+        base.send(:include, AASM::Persistence::DynamoidPersistence::InstanceMethods)
+
+        base.after_initialize :aasm_ensure_initial_state
+
+        # Because Dynamoid only use define_method to add attribute assignment method in Class.
+        #
+        # In AASM::Base.initialize, it redefines and calls super in this method without superclass method.
+        # We override method_missing to solve this problem.
+        #
+        base.class_eval %Q(
+          def method_missing(method_name, *arguments, &block)
+            if (AASM::StateMachineStore.fetch(self.class, true).machine_names.map { |state_machine_name| self.class.aasm(state_machine_name).attribute_name.to_s + "=" }).include? method_name.to_s
+              attribute_name = method_name.to_s.gsub("=", '')
+              write_attribute(attribute_name.to_sym, *arguments)
+            else
+              super
+            end
+          end
+        )
+      end
+
+      module InstanceMethods
+
+        # Writes <tt>state</tt> to the state column and persists it to the database
+        # using update_attribute (which bypasses validation)
+        #
+        #   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)
+          write_attribute(self.class.aasm(name).attribute_name, state.to_s)
+
+          unless self.save(:validate => false)
+            write_attribute(self.class.aasm(name).attribute_name, old_value)
+            return false
+          end
+
+          true
+        end
+
+        # Writes <tt>state</tt> to the state column, 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)
+          write_attribute(self.class.aasm(name).attribute_name, state.to_s)
+        end
+
+      private
+
+        # Ensures that if the aasm_state column is nil and the record is new
+        # that the initial state gets populated before validation on create
+        #
+        #   foo = Foo.new
+        #   foo.aasm_state # => nil
+        #   foo.valid?
+        #   foo.aasm_state # => "open" (where :open is the initial state)
+        #
+        #
+        #   foo = Foo.find(:first)
+        #   foo.aasm_state # => 1
+        #   foo.aasm_state = nil
+        #   foo.valid?
+        #   foo.aasm_state # => nil
+        #
+        def aasm_ensure_initial_state
+          AASM::StateMachineStore.fetch(self.class, true).machine_names.each do |state_machine_name|
+            aasm(state_machine_name).enter_initial_state if !send(self.class.aasm(state_machine_name).attribute_name) || send(self.class.aasm(state_machine_name).attribute_name).empty?
+          end
+        end
+      end # InstanceMethods
+    end
+  end # Persistence
+end # AASM

data/lib/aasm/persistence/mongoid_persistence.rb

@@ -0,0 +1,126 @@
+require 'aasm/persistence/orm'
+module AASM
+  module Persistence
+    module MongoidPersistence
+      # This method:
+      #
+      # * extends the model with ClassMethods
+      # * includes InstanceMethods
+      #
+      # Adds
+      #
+      #   before_validation :aasm_ensure_initial_state
+      #
+      # As a result, it doesn't matter when you define your methods - the following 2 are equivalent
+      #
+      #   class Foo
+      #     include Mongoid::Document
+      #     def aasm_write_state(state)
+      #       "bar"
+      #     end
+      #     include AASM
+      #   end
+      #
+      #   class Foo
+      #     include Mongoid::Document
+      #     include AASM
+      #     def aasm_write_state(state)
+      #       "bar"
+      #     end
+      #   end
+      #
+      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
+
+        base.after_initialize :aasm_ensure_initial_state
+      end
+
+      module ClassMethods
+        def aasm_create_scope(state_machine_name, scope_name)
+          scope_options = lambda {
+            send(
+              :where,
+              { aasm(state_machine_name).attribute_name.to_sym => scope_name.to_s }
+            )
+          }
+          send(:scope, scope_name, scope_options)
+        end
+      end
+
+      module InstanceMethods
+
+        private
+
+        def aasm_save
+          self.save
+        end
+
+        def aasm_raise_invalid_record
+          raise Mongoid::Errors::Validations.new(self)
+        end
+
+        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
+            set(attribute_name, value)
+          end
+
+          true
+        end
+
+        def aasm_read_attribute(name)
+          read_attribute(name)
+        end
+
+        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
+        # that the initial state gets populated before validation on create
+        #
+        #   foo = Foo.new
+        #   foo.aasm_state # => nil
+        #   foo.valid?
+        #   foo.aasm_state # => "open" (where :open is the initial state)
+        #
+        #
+        #   foo = Foo.find(:first)
+        #   foo.aasm_state # => 1
+        #   foo.aasm_state = nil
+        #   foo.valid?
+        #   foo.aasm_state # => nil
+        #
+        def aasm_ensure_initial_state
+          AASM::StateMachineStore.fetch(self.class, true).machine_names.each do |state_machine_name|
+            attribute_name = self.class.aasm(state_machine_name).attribute_name.to_s
+            # Do not load initial state when object attributes are not loaded,
+            # mongoid has_many relationship does not load child object attributes when
+            # only ids are loaded, for example parent.child_ids will not load child object attributes.
+            # This feature is introduced in mongoid > 4.
+            if attribute_names.include?(attribute_name) && !attributes[attribute_name] || attributes[attribute_name].empty?
+              # attribute_missing? is defined in mongoid > 4
+              return if Mongoid::VERSION.to_f >= 4 && attribute_missing?(attribute_name)
+              send("#{self.class.aasm(state_machine_name).attribute_name}=", aasm(state_machine_name).enter_initial_state.to_s)
+            end
+          end
+        end
+      end # InstanceMethods
+
+      # module NamedScopeMethods
+      #   def aasm_state_with_named_scope name, options = {}
+      #     aasm_state_without_named_scope name, options
+      #     self.named_scope name, :conditions => { "#{table_name}.#{self.aasm.attribute_name}" => name.to_s} unless self.respond_to?(name)
+      #   end
+      # end
+    end
+  end # Persistence
+end # AASM

data/lib/aasm/persistence/no_brainer_persistence.rb

@@ -0,0 +1,105 @@
+require 'aasm/persistence/orm'
+module AASM
+  module Persistence
+    module NoBrainerPersistence
+      # This method:
+      #
+      # * extends the model with ClassMethods
+      # * includes InstanceMethods
+      #
+      # Adds
+      #
+      #   before_validation :aasm_ensure_initial_state
+      #
+      # As a result, it doesn't matter when you define your methods - the following 2 are equivalent
+      #
+      #   class Foo
+      #     include NoBrainer::Document
+      #     def aasm_write_state(state)
+      #       "bar"
+      #     end
+      #     include AASM
+      #   end
+      #
+      #   class Foo
+      #     include NoBrainer::Document
+      #     include AASM
+      #     def aasm_write_state(state)
+      #       "bar"
+      #     end
+      #   end
+      #
+      def self.included(base)
+        base.send(:include, AASM::Persistence::Base)
+        base.send(:include, AASM::Persistence::ORM)
+        base.send(:include, AASM::Persistence::NoBrainerPersistence::InstanceMethods)
+        base.extend AASM::Persistence::NoBrainerPersistence::ClassMethods
+
+        base.after_initialize :aasm_ensure_initial_state
+      end
+
+      module ClassMethods
+        def aasm_create_scope(state_machine_name, scope_name)
+          scope_options = lambda {
+            where(aasm(state_machine_name).attribute_name.to_sym => scope_name.to_s)
+          }
+          send(:scope, scope_name, scope_options)
+        end
+      end
+
+      module InstanceMethods
+
+        private
+
+        def aasm_save
+          self.save
+        end
+
+        def aasm_raise_invalid_record
+          raise NoBrainer::Error::DocumentInvalid.new(self)
+        end
+
+        def aasm_supports_transactions?
+          false
+        end
+
+        def aasm_update_column(attribute_name, value)
+          write_attribute(attribute_name, value)
+          save(validate: false)
+
+          true
+        end
+
+        def aasm_read_attribute(name)
+          read_attribute(name)
+        end
+
+        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
+        # that the initial state gets populated before validation on create
+        #
+        #   foo = Foo.new
+        #   foo.aasm_state # => nil
+        #   foo.valid?
+        #   foo.aasm_state # => "open" (where :open is the initial state)
+        #
+        #
+        #   foo = Foo.find(:first)
+        #   foo.aasm_state # => 1
+        #   foo.aasm_state = nil
+        #   foo.valid?
+        #   foo.aasm_state # => nil
+        #
+        def aasm_ensure_initial_state
+          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 !read_attribute(aasm_column) || read_attribute(aasm_column).empty?
+          end
+        end
+      end # InstanceMethods
+    end
+  end # Persistence
+end # AASM

data/lib/aasm/persistence/orm.rb

@@ -0,0 +1,150 @@
+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 use_transactions?(state_machine_name)
+        AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.use_transactions
+      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 = if options[:persist] && use_transactions?(state_machine_name)
+              aasm_transaction(requires_new?(state_machine_name), requires_lock?(state_machine_name)) do
+                super
+              end
+            else
+              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