aasm 4.11.1 → 4.12.1

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

data/lib/aasm/persistence.rb

@@ -12,9 +12,6 @@ module AASM
         elsif hierarchy.include?("Mongoid::Document")
           require_persistence :mongoid
           include_persistence base, :mongoid
-        elsif hierarchy.include?("MongoMapper::Document")
-          require_persistence :mongo_mapper
-          include_persistence base, :mongo_mapper
         elsif hierarchy.include?("Sequel::Model")
           require_persistence :sequel
           include_persistence base, :sequel

data/lib/aasm/state_machine.rb

@@ -16,8 +16,10 @@ module AASM
     # called internally by Ruby 1.9 after clone()
     def initialize_copy(orig)
       super
-      @states = @states.dup
-      @events = @events.dup
+      @states = orig.states.collect { |state| state.clone }
+      @events = {}
+      orig.events.each_pair { |name, event| @events[name] = event.clone }
+      @global_callbacks = @global_callbacks.dup
     end
 
     def add_state(state_name, klass, options)

data/lib/aasm/state_machine_store.rb

@@ -1,8 +1,11 @@
+require 'concurrent'
 module AASM
   class StateMachineStore
+    @stores = Concurrent::Map.new
+
     class << self
       def stores
-        @stores ||= {}
+        @stores
       end
 
       # do not overwrite existing state machines, which could have been created by
@@ -38,7 +41,7 @@ module AASM
     end
 
     def initialize
-      @machines = {}
+      @machines = Concurrent::Map.new
     end
 
     def clone

data/lib/aasm/version.rb

@@ -1,3 +1,3 @@
 module AASM
-  VERSION = "4.11.1"
+  VERSION = "4.12.1"
 end

data/lib/generators/active_record/templates/migration.rb

@@ -1,4 +1,4 @@
-class AASMCreate<%= table_name.camelize %> < ActiveRecord::Migration
+class AASMCreate<%= table_name.camelize %> < ActiveRecord::Migration[<%=  ActiveRecord::VERSION::STRING.to_f %>]
   def change
     create_table(:<%= table_name %>) do |t|
       t.string :<%= column_name %>

data/lib/generators/active_record/templates/migration_existing.rb

@@ -1,4 +1,4 @@
-class Add<%= column_name.camelize %>To<%= table_name.camelize %> < ActiveRecord::Migration
+class Add<%= column_name.camelize %>To<%= table_name.camelize %> < ActiveRecord::Migration[<%=  ActiveRecord::VERSION::STRING.to_f %>]
   def change
     add_column :<%= table_name %>, :<%= column_name %>, :string
   end

data/lib/motion-aasm.rb

@@ -11,9 +11,10 @@ file_dependencies = {
 
 exclude_files = [
   'aasm/rspec.*',
+  'aasm/minitest.*',
+  'aasm/minitest_spec.*',
   'aasm/persistence/active_record_persistence.rb',
   'aasm/persistence/dynamoid_persistence.rb',
-  'aasm/persistence/mongo_mapper_persistence.rb',
   'aasm/persistence/mongoid_persistence.rb',
   'aasm/persistence/sequel_persistence.rb',
   'aasm/persistence/redis_persistence.rb'

data/spec/generators/active_record_generator_spec.rb

@@ -1,44 +1,47 @@
 require 'spec_helper'
-require 'generator_spec'
-require 'generators/active_record/aasm_generator'
 
-describe ActiveRecord::Generators::AASMGenerator, type: :generator do
-  destination File.expand_path("../../../tmp", __FILE__)
+if defined?(ActiveRecord)
+  require 'generator_spec'
+  require 'generators/active_record/aasm_generator'
+
+  describe ActiveRecord::Generators::AASMGenerator, type: :generator do
+    destination File.expand_path("../../../tmp", __FILE__)
+
+    before(:all) do
+      prepare_destination
+    end
+
+    it "creates model with aasm block for default column_name" do
+      run_generator %w(user)
+      assert_file "app/models/user.rb", /include AASM\n\n  aasm do\n  end\n/
+    end
+
+    it "creates model with aasm block for custom column_name" do
+      run_generator %w(user state)
+      assert_file "app/models/user.rb", /aasm :column => 'state' do\n  end\n/
+    end
+
+    it "creates model with aasm block for namespaced model" do
+      run_generator %w(Admin::User state)
+      assert_file "app/models/admin/user.rb", /aasm :column => 'state' do\n  end\n/
+    end
+
+    it "creates migration for model with aasm_column" do
+      run_generator %w(post)
+      assert_migration "db/migrate/aasm_create_posts.rb", /create_table(:posts) do |t|\n  t.string :aasm_state\n/
+    end
+
+    it "add aasm_column in existing model" do
+      run_generator %w(job)
+      assert_file "app/models/job.rb"
+      run_generator %w(job)
+      assert_migration "db/migrate/add_aasm_state_to_jobs.rb"
+    end
+
+    it "add custom aasm_column in existing model" do
+      run_generator %w(job state)
+      assert_migration "db/migrate/add_state_to_jobs.rb"
+    end
 
-  before(:all) do
-    prepare_destination
   end
-
-  it "creates model with aasm block for default column_name" do
-    run_generator %w(user)
-    assert_file "app/models/user.rb", /include AASM\n\n  aasm do\n  end\n/
-  end
-
-  it "creates model with aasm block for custom column_name" do
-    run_generator %w(user state)
-    assert_file "app/models/user.rb", /aasm :column => 'state' do\n  end\n/
-  end
-
-  it "creates model with aasm block for namespaced model" do
-    run_generator %w(Admin::User state)
-    assert_file "app/models/admin/user.rb", /aasm :column => 'state' do\n  end\n/
-  end
-
-  it "creates migration for model with aasm_column" do
-    run_generator %w(post)
-    assert_migration "db/migrate/aasm_create_posts.rb", /create_table(:posts) do |t|\n  t.string :aasm_state\n/
-  end
-
-  it "add aasm_column in existing model" do
-    run_generator %w(job)
-    assert_file "app/models/job.rb"
-    run_generator %w(job)
-    assert_migration "db/migrate/add_aasm_state_to_jobs.rb"
-  end
-
-  it "add custom aasm_column in existing model" do
-    run_generator %w(job state)
-    assert_migration "db/migrate/add_state_to_jobs.rb"
-  end
-
 end

data/spec/generators/mongoid_generator_spec.rb

@@ -1,9 +1,8 @@
 require 'spec_helper'
-require 'generator_spec'
-require 'generators/mongoid/aasm_generator'
 
-begin
-  require "mongoid"
+if defined?(Mongoid::Document)
+  require 'generator_spec'
+  require 'generators/mongoid/aasm_generator'
 
   describe Mongoid::Generators::AASMGenerator, type: :generator do
     destination File.expand_path("../../../tmp", __FILE__)
@@ -28,6 +27,5 @@ begin
     end
 
   end
-rescue LoadError
-  puts "Not running Mongoid specs because mongoid gem is not installed!!!"
+
 end

data/spec/models/active_record/complex_active_record_example.rb

@@ -7,7 +7,7 @@ class ComplexActiveRecordExample < ActiveRecord::Base
     state :three
 
     event :increment do
-      transitions :from => :one, :to => :two
+      transitions :from => :one, :to => :two, guard: :allowed?
       transitions :from => :two, :to => :three
     end
     event :reset do
@@ -15,6 +15,10 @@ class ComplexActiveRecordExample < ActiveRecord::Base
     end
   end
 
+  def allowed?
+    true
+  end
+
   aasm :right, :column => 'right' do
     state :alpha, :initial => true
     state :beta

data/spec/models/{invalid_persistor.rb → active_record/invalid_persistor.rb}

@@ -1,5 +1,3 @@
-require 'active_record'
-
 class InvalidPersistor < ActiveRecord::Base
   include AASM
   aasm :column => :status, :skip_validation_on_save => true do

data/spec/models/{silent_persistor.rb → active_record/silent_persistor.rb}

@@ -1,5 +1,3 @@
-require 'active_record'
-
 class SilentPersistor < ActiveRecord::Base
   include AASM
   aasm :column => :status, :whiny_persistence => false do

data/spec/models/{transactor.rb → active_record/transactor.rb}

@@ -1,5 +1,3 @@
-require 'active_record'
-
 class Transactor < ActiveRecord::Base
 
   belongs_to :worker

data/spec/models/{validator.rb → active_record/validator.rb}

@@ -1,5 +1,3 @@
-require 'active_record'
-
 class Validator < ActiveRecord::Base
   attr_accessor :after_all_transactions_performed,
     :after_transaction_performed_on_fail,

data/spec/models/callbacks/basic.rb

@@ -43,6 +43,7 @@ module Callbacks
             :before => :before_event,
             :after => :after_event,
             :guard => :event_guard,
+            :before_success => :event_before_success,
             :ensure => :ensure_event do
         transitions :to => :closed, :from => [:open],
                     :guard => :transition_guard,
@@ -78,6 +79,8 @@ module Callbacks
     def event_guard;              log('event_guard');         !@fail_event_guard;      end
     def transition_guard;         log('transition_guard');    !@fail_transition_guard; end
 
+    def event_before_success;     log('event_before_success'); end
+
     def after_transition;         log('after_transition');        end
     def after_all_transitions;    log('after_all_transitions');   end
 
@@ -86,8 +89,8 @@ module Callbacks
     def after_event;              log('after_event');         end
     def after_all_events;         log('after_all_events');    end
 
-    def after_transition;     log('after_transition');    end
-    def success_transition;   log('transition_success');  end
+    def after_transition;         log('after_transition');    end
+    def success_transition;       log('transition_success');  end
 
     def ensure_event;             log('ensure');              end
     def ensure_on_all_events;     log('ensure');              end

data/spec/models/guard_with_params.rb

@@ -10,7 +10,7 @@ class GuardWithParams
 
   def user_is_manager?(user)
     ok = false
-    if user.has_role? :manager
+    if user && user.has_role?(:manager)
       ok = true
     end
     return ok

data/spec/models/guardian_without_from_specified.rb

@@ -0,0 +1,18 @@
+class GuardianWithoutFromSpecified
+  include AASM
+
+  aasm do
+    state :alpha, :initial => true
+    state :beta
+    state :gamma
+
+    event :use_guards_where_the_first_fails do
+      transitions :to => :beta,  :guard => :fail
+      transitions :to => :gamma, :guard => :succeed
+    end
+  end
+
+
+  def fail; false; end
+  def succeed; true; end
+end

data/spec/models/mongoid/invalid_persistor_mongoid.rb

@@ -0,0 +1,39 @@
+class InvalidPersistorMongoid
+  include Mongoid::Document
+  include AASM
+
+  field :name
+  field :status
+
+  aasm :left, column: :status, skip_validation_on_save: true do
+    state :sleeping, :initial => true
+    state :running
+    event :run do
+      transitions :to => :running, :from => :sleeping
+    end
+    event :sleep do
+      transitions :to => :sleeping, :from => :running
+    end
+  end
+  validates_presence_of :name
+end
+
+class MultipleInvalidPersistorMongoid
+  include Mongoid::Document
+  include AASM
+
+  field :name
+  field :status
+
+  aasm :left, column: :status, skip_validation_on_save: true do
+    state :sleeping, :initial => true
+    state :running
+    event :run do
+      transitions :to => :running, :from => :sleeping
+    end
+    event :sleep do
+      transitions :to => :sleeping, :from => :running
+    end
+  end
+  validates_presence_of :name
+end