aasm 4.6.0 → 4.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5b8d8a7ce2210a49761c9f1c622393a1bc453452
-  data.tar.gz: 1239b8468c521eb11bdbfef04d58540a6d1e5b72
+  metadata.gz: f758ead4b090ac11ffd00fd7b5a85b5a24dfa626
+  data.tar.gz: 7e2192786e067726f08fdae1f70341922edf63bb
 SHA512:
-  metadata.gz: 7b8f2affa363cce45636f684c24e2f72d71cb0a5af4fce0303894a77eb9db7fb37f08442c4b4b1955d7aaae042225ec4b3e52b27ffafe5cbb0c765c15498cf65
-  data.tar.gz: d9769d7cfd98b28e98f8a79c9b0b823cabec8b721bf5bdfaaae3dac37ca2b6127c38b42d427ed2fd451a67987c2371e36f4b46df09e0b4042fb1abb2c44320cd
+  metadata.gz: f3df7b62a3328455e73356824ceca28663ea789963518730e731078f8d419dbcda1fc20dafe7697563e5e8da5a97fe1409ddda0366b48258c14c14e671b4b855
+  data.tar.gz: 2a001ca4ce4e3b8452396546201e2506fc467eb5b12ad24dfbd21ed420f20112df5b854e45e2c02211a463f3476ec4e0ce9a587936c082c0200ed4e5bebf6127

data/CHANGELOG.md

@@ -1,9 +1,14 @@
 # CHANGELOG
 
+## 4.7.0
+
+ * fix: allow :send as event name (see [issue #257](https://github.com/aasm/aasm/issues/257) for details)
+ * add new callbacks: transactions, all events, ensure (see [issue #282](https://github.com/aasm/aasm/issues/282) for details, thanks to [@HoyaBoya](https://github.com/HoyaBoya))
+
 ## 4.6.0
 
  * fix: make sure the column is actually present for _ActiveRecord_ enums (see [issue #265](https://github.com/aasm/aasm/issues/265) and [issue #152](https://github.com/aasm/aasm/issues/152) for details, thanks to [@anilmaurya](https://github.com/anilmaurya))
-* add generators to configure active_record and mongoid after install (see [issue #261](https://github.com/aasm/aasm/issues/261) for details, thanks to [@anilmaurya](https://github.com/anilmaurya))
+ * add generators to configure active_record and mongoid after install (see [issue #261](https://github.com/aasm/aasm/issues/261) for details, thanks to [@anilmaurya](https://github.com/anilmaurya))
 
 ## 4.5.2
 

data/README.md

@@ -146,6 +146,7 @@ Here you can see a list of all possible callbacks, together with their order of
 
 ```ruby
 begin
+  event           before_all_events
   event           before
   event           guards
   transition      guards
@@ -160,8 +161,13 @@ begin
   old_state       after_exit
   new_state       after_enter
   event           after
+  event           after_all_events
 rescue
   event           error
+  event           error_on_all_events
+ensure
+  event           ensure
+  event           ensure_on_all_events
 end
 ```
 
@@ -614,6 +620,17 @@ Since version *3.0.13* AASM supports ActiveRecord transactions. So whenever a tr
 callback or the state update fails, all changes to any database record are rolled back.
 Mongodb does not support transactions.
 
+There are currently 3 transactional callbacks that can be handled on the event, and 2 transactional callbacks for all events.
+
+```ruby
+  event           before_all_transactions
+  event           before_transaction
+  event           aasm_fire_event (within transaction)
+  event           after_commit (if event successful)
+  event           after_transaction
+  event           after_all_transactions
+```
+
 If you want to make sure a depending action happens only after the transaction is committed,
 use the `after_commit` callback along with the auto-save (bang) methods, like this:
 

data/lib/aasm/aasm.rb

@@ -88,6 +88,12 @@ private
     begin
       old_state = aasm(state_machine_name).state_object_for_name(aasm(state_machine_name).current_state)
 
+      event.fire_global_callbacks(
+        :before_all_events,
+        self,
+        *process_args(event, aasm(state_machine_name).current_state, *args)
+      )
+
       # new event before callback
       event.fire_callbacks(
         :before,
@@ -110,7 +116,12 @@ private
         aasm_failed(state_machine_name, event_name, old_state)
       end
     rescue StandardError => e
-      event.fire_callbacks(:error, self, e, *process_args(event, aasm(state_machine_name).current_state, *args)) || raise(e)
+      event.fire_callbacks(:error, self, e, *process_args(event, aasm(state_machine_name).current_state, *args)) ||
+      event.fire_global_callbacks(:error_on_all_events, self, e, *process_args(event, aasm(state_machine_name).current_state, *args)) ||
+      raise(e)
+    ensure
+      event.fire_callbacks(:ensure, self, *process_args(event, aasm(state_machine_name).current_state, *args))
+      event.fire_global_callbacks(:ensure_on_all_events, self, *process_args(event, aasm(state_machine_name).current_state, *args))
     end
   end
 
@@ -147,6 +158,11 @@ private
         self,
         *process_args(event, old_state.name, *args)
       )
+      event.fire_global_callbacks(
+        :after_all_events,
+        self,
+        *process_args(event, old_state.name, *args)
+      )
 
       self.aasm_event_fired(event.name, old_state.name, aasm(state_machine_name).current_state) if self.respond_to?(:aasm_event_fired)
     else

data/lib/aasm/base.rb

@@ -113,6 +113,30 @@ module AASM
       @state_machine.add_global_callbacks(:after_all_transitions, *callbacks, &block)
     end
 
+    def after_all_transactions(*callbacks, &block)
+      @state_machine.add_global_callbacks(:after_all_transactions, *callbacks, &block)
+    end
+
+    def before_all_transactions(*callbacks, &block)
+      @state_machine.add_global_callbacks(:before_all_transactions, *callbacks, &block)
+    end
+
+    def before_all_events(*callbacks, &block)
+      @state_machine.add_global_callbacks(:before_all_events, *callbacks, &block)
+    end
+
+    def after_all_events(*callbacks, &block)
+      @state_machine.add_global_callbacks(:after_all_events, *callbacks, &block)
+    end
+
+    def error_on_all_events(*callbacks, &block)
+      @state_machine.add_global_callbacks(:error_on_all_events, *callbacks, &block)
+    end
+
+    def ensure_on_all_events(*callbacks, &block)
+      @state_machine.add_global_callbacks(:ensure_on_all_events, *callbacks, &block)
+    end
+
     def states
       @state_machine.states
     end

data/lib/aasm/core/event.rb

@@ -13,7 +13,16 @@ module AASM::Core
 
       # from aasm4
       @options = options # QUESTION: .dup ?
-      add_options_from_dsl(@options, [:after, :before, :error, :success, :after_commit], &block) if block
+      add_options_from_dsl(@options, [
+        :after,
+        :after_commit,
+        :after_transaction,
+        :before,
+        :before_transaction,
+        :ensure,
+        :error,
+        :success,
+      ], &block) if block
     end
 
     # a neutered version of fire - it doesn't actually fire the event, it just
@@ -43,6 +52,10 @@ module AASM::Core
       @transitions.select { |t| t.to == state }
     end
 
+    def fire_global_callbacks(callback_name, record, *args)
+      invoke_callbacks(state_machine.global_callbacks[callback_name], record, args)
+    end
+
     def fire_callbacks(callback_name, record, *args)
       # strip out the first element in args if it's a valid to_state
       # #given where we're coming from, this condition implies args not empty
@@ -128,8 +141,8 @@ module AASM::Core
           unless record.respond_to?(code, true)
             raise NoMethodError.new("NoMethodError: undefined method `#{code}' for #{record.inspect}:#{record.class}")
           end
-          arity = record.send(:method, code.to_sym).arity
-          record.send(code, *(arity < 0 ? args : args[0...arity]))
+          arity = record.__send__(:method, code.to_sym).arity
+          record.__send__(code, *(arity < 0 ? args : args[0...arity]))
           true
 
         when Proc
@@ -145,6 +158,5 @@ module AASM::Core
           false
       end
     end
-
   end
 end # AASM

data/lib/aasm/core/state.rb

@@ -70,8 +70,8 @@ module AASM::Core
     def _fire_callbacks(action, record, args)
       case action
         when Symbol, String
-          arity = record.send(:method, action.to_sym).arity
-          record.send(action, *(arity < 0 ? args : args[0...arity]))
+          arity = record.__send__(:method, action.to_sym).arity
+          record.__send__(action, *(arity < 0 ? args : args[0...arity]))
         when Proc
           arity = action.arity
           action.call(record, *(arity < 0 ? args : args[0...arity]))

data/lib/aasm/core/transition.rb

@@ -52,8 +52,8 @@ module AASM::Core
 
       case code
       when Symbol, String
-        arity = record.send(:method, code.to_sym).arity
-        arity == 0 ? record.send(code) : record.send(code, *args)
+        arity = record.__send__(:method, code.to_sym).arity
+        arity == 0 ? record.__send__(code) : record.__send__(code, *args)
       when Proc
         code.parameters.size == 0 ? record.instance_exec(&code) : record.instance_exec(*args, &code)
       when Array

data/lib/aasm/persistence/active_record_persistence.rb

@@ -129,11 +129,9 @@ module AASM
         end
 
         # Ensures that if the aasm_state column is nil and the record is new
-        # then the initial state gets populated before validation on create
+        # then the initial state gets populated after initialization
         #
         #   foo = Foo.new
-        #   foo.aasm_state # => nil
-        #   foo.valid?
         #   foo.aasm_state # => "open" (where :open is the initial state)
         #
         #
@@ -159,11 +157,24 @@ module AASM
         end
 
         def aasm_fire_event(state_machine_name, name, options, *args, &block)
-          success = options[:persist] ? self.class.transaction(:requires_new => requires_new?(state_machine_name)) { super } : super
+          event = self.class.aasm(state_machine_name).state_machine.events[name]
+
+          if options[:persist]
+            event.fire_callbacks(:before_transaction, self, *args)
+            event.fire_global_callbacks(:before_all_transactions, self, *args)
+          end
 
-          if success && options[:persist]
-            event = self.class.aasm(state_machine_name).state_machine.events[name]
-            event.fire_callbacks(:after_commit, self, *args)
+          begin
+            success = options[:persist] ? self.class.transaction(:requires_new => requires_new?(state_machine_name)) { super } : super
+            if options[:persist] && success
+              event.fire_callbacks(:after_commit, self, *args)
+              event.fire_global_callbacks(:after_all_commits, self, *args)
+            end
+          ensure
+            if options[:persist]
+              event.fire_callbacks(:after_transaction, self, *args)
+              event.fire_global_callbacks(:after_all_transactions, self, *args)
+            end
           end
 
           success

data/lib/aasm/version.rb

@@ -1,3 +1,3 @@
 module AASM
-  VERSION = "4.6.0"
+  VERSION = "4.7.0"
 end

data/spec/models/callbacks/basic.rb

@@ -18,7 +18,10 @@ module Callbacks
     end
 
     aasm do
-      after_all_transitions :after_all_transitions
+      before_all_events       :before_all_events
+      after_all_events        :after_all_events
+      ensure_on_all_events    :ensure_on_all_events
+      after_all_transitions   :after_all_transitions
 
       state :open, :initial => true,
         :before_enter => :before_enter_open,
@@ -36,11 +39,11 @@ module Callbacks
         :exit         => :exit_closed,
         :after_exit   => :after_exit_closed
 
-      event :close, :before => :before_event, :after => :after_event, :guard => :event_guard do
+      event :close, :before => :before_event, :after => :after_event, :guard => :event_guard, :ensure => :ensure_event do
         transitions :to => :closed, :from => [:open], :guard => :transition_guard, :after => :after_transition
       end
 
-      event :open, :before => :before_event, :after => :after_event do
+      event :open, :before => :before_event, :after => :after_event  do
         transitions :to => :open, :from => :closed
       end
     end
@@ -50,29 +53,33 @@ module Callbacks
       puts text if @log
     end
 
-    def aasm_write_state(*args); log('aasm_write_state'); true; end
+    def aasm_write_state(*args);  log('aasm_write_state'); true;  end
+    def before_enter_open;        log('before_enter_open');       end
+    def enter_open;               log('enter_open');              end
+    def before_exit_open;         log('before_exit_open');        end
+    def after_enter_open;         log('after_enter_open');        end
+    def exit_open;                log('exit_open');               end
+    def after_exit_open;          log('after_exit_open');         end
 
-    def before_enter_open;    log('before_enter_open');   end
-    def enter_open;           log('enter_open');          end
-    def before_exit_open;     log('before_exit_open');    end
-    def after_enter_open;     log('after_enter_open');    end
-    def exit_open;            log('exit_open');           end
-    def after_exit_open;      log('after_exit_open');     end
+    def before_enter_closed;      log('before_enter_closed'); end
+    def enter_closed;             log('enter_closed');        end
+    def before_exit_closed;       log('before_exit_closed');  end
+    def exit_closed;              log('exit_closed');         end
+    def after_enter_closed;       log('after_enter_closed');  end
+    def after_exit_closed;        log('after_exit_closed');   end
 
-    def before_enter_closed;  log('before_enter_closed'); end
-    def enter_closed;         log('enter_closed');        end
-    def before_exit_closed;   log('before_exit_closed');  end
-    def exit_closed;          log('exit_closed');         end
-    def after_enter_closed;   log('after_enter_closed');  end
-    def after_exit_closed;    log('after_exit_closed');   end
+    def event_guard;              log('event_guard');         !@fail_event_guard;      end
+    def transition_guard;         log('transition_guard');    !@fail_transition_guard; end
 
-    def event_guard;          log('event_guard');         !@fail_event_guard;      end
-    def transition_guard;     log('transition_guard');    !@fail_transition_guard; end
+    def after_transition;         log('after_transition');        end
+    def after_all_transitions;    log('after_all_transitions');   end
 
-    def after_transition;     log('after_transition');    end
-    def after_all_transitions;log('after_all_transitions');end
+    def before_all_events;        log('before_all_events')    end
+    def before_event;             log('before_event');        end
+    def after_event;              log('after_event');         end
+    def after_all_events;         log('after_all_events');    end
 
-    def before_event;         log('before_event');        end
-    def after_event;          log('after_event');         end
+    def ensure_event;             log('ensure');              end
+    def ensure_on_all_events;     log('ensure');              end
   end
 end

data/spec/models/foo.rb

@@ -1,16 +1,19 @@
-class Foo
-  include AASM
-  aasm do
-    state :open, :initial => true, :before_exit => :before_exit
-    state :closed, :before_enter => :before_enter
-    state :final
-
-    event :close, :success => :success_callback do
-      transitions :from => [:open], :to => [:closed]
-    end
-
-    event :null do
-      transitions :from => [:open], :to => [:closed, :final], :guard => :always_false
+module Fooable
+  def self.included(base)
+    base.class_eval do
+      aasm do
+        state :open, :initial => true, :before_exit => :before_exit
+        state :closed, :before_enter => :before_enter
+        state :final
+
+        event :close, :success => :success_callback do
+          transitions :from => [:open], :to => [:closed]
+        end
+
+        event :null do
+          transitions :from => [:open], :to => [:closed, :final], :guard => :always_false
+        end
+      end
     end
   end
 
@@ -23,10 +26,21 @@ class Foo
 
   def before_enter
   end
+
   def before_exit
   end
 end
 
+class Foo
+  include AASM
+  include Fooable
+end
+
+class FooGlobal
+  include AASM
+  include Fooable
+end
+
 class FooTwo < Foo
   include AASM
   aasm do

data/spec/models/state_machine_with_failed_event.rb

@@ -4,9 +4,17 @@ class StateMachineWithFailedEvent
   aasm do
     state :init, :initial => true
     state :failed
+    state :sent
 
     event :failed do
       transitions :from => :init, :to => :failed
     end
+    event :send, :before => :callback do
+      transitions :from => :init, :to => :sent
+    end
+  end
+
+  def callback
+    true
   end
 end

data/spec/models/validator.rb

@@ -1,23 +1,51 @@
 require 'active_record'
 
 class Validator < ActiveRecord::Base
+  attr_accessor :after_all_transactions_performed,
+    :after_transaction_performed_on_fail,
+    :after_transaction_performed_on_run,
+    :before_all_transactions_performed,
+    :before_transaction_performed_on_fail,
+    :before_transaction_performed_on_run
 
   include AASM
+
   aasm :column => :status do
+    before_all_transactions :before_all_transactions
+    after_all_transactions  :after_all_transactions
+
     state :sleeping, :initial => true
     state :running
     state :failed, :after_enter => :fail
 
     event :run, :after_commit => :change_name! do
+      after_transaction do
+        @after_transaction_performed_on_run = true
+      end
+
+      before_transaction do
+        @before_transaction_performed_on_run = true
+      end
+
       transitions :to => :running, :from => :sleeping
     end
+
     event :sleep do
       after_commit do |name|
         change_name_on_sleep name
       end
       transitions :to => :sleeping, :from => :running
     end
+
     event :fail do
+      after_transaction do
+        @after_transaction_performed_on_fail = true
+      end
+
+      before_transaction do
+        @before_transaction_performed_on_fail = true
+      end
+
       transitions :to => :failed, :from => [:sleeping, :running]
     end
   end
@@ -37,6 +65,14 @@ class Validator < ActiveRecord::Base
   def fail
     raise StandardError.new('failed on purpose')
   end
+
+  def after_all_transactions
+    @after_all_transactions_performed = true
+  end
+
+  def before_all_transactions
+    @before_all_transactions_performed = true
+  end
 end
 
 class MultipleValidator < ActiveRecord::Base

data/spec/unit/callbacks_spec.rb

@@ -1,6 +1,65 @@
 require 'spec_helper'
 Dir[File.dirname(__FILE__) + "/../models/callbacks/*.rb"].sort.each { |f| require File.expand_path(f) }
 
+shared_examples 'an implemented callback that accepts error' do
+  context 'with callback defined' do
+    it "should run error_callback if an exception is raised" do
+      aasm_model.class.send(:define_method, callback_name) do |e|
+        @data = [e]
+      end
+
+      allow(aasm_model).to receive(:before_enter).and_raise(e = StandardError.new)
+
+      aasm_model.safe_close!
+      expect(aasm_model.data).to eql [e]
+    end
+
+    it "should run error_callback without parameters if callback does not support any" do
+      aasm_model.class.send(:define_method, callback_name) do |e|
+        @data = []
+      end
+
+      allow(aasm_model).to receive(:before_enter).and_raise(e = StandardError.new)
+
+      aasm_model.safe_close!('arg1', 'arg2')
+      expect(aasm_model.data).to eql []
+    end
+
+    it "should run error_callback with parameters if callback supports them" do
+      aasm_model.class.send(:define_method, callback_name) do |e, arg1, arg2|
+        @data = [arg1, arg2]
+      end
+
+      allow(aasm_model).to receive(:before_enter).and_raise(e = StandardError.new)
+
+      aasm_model.safe_close!('arg1', 'arg2')
+      expect(aasm_model.data).to eql ['arg1', 'arg2']
+    end
+  end
+end
+
+shared_examples 'an implemented callback' do
+  context 'with callback defined' do
+    it 'should run callback without parameters if callback does not support any' do
+      aasm_model.class.send(:define_method, callback_name) do
+        @data = ['callback-was-called']
+      end
+
+      aasm_model.safe_close!
+      expect(aasm_model.data).to eql ['callback-was-called']
+    end
+
+    it 'should run callback with parameters if callback supports them' do
+      aasm_model.class.send(:define_method, callback_name) do |arg1, arg2|
+        @data = [arg1, arg2]
+      end
+
+      aasm_model.safe_close!('arg1', 'arg2')
+      expect(aasm_model.data).to eql ['arg1', 'arg2']
+    end
+  end
+end
+
 describe 'callbacks for the new DSL' do
 
   it "be called in order" do
@@ -10,6 +69,7 @@ describe 'callbacks for the new DSL' do
     callback.aasm.current_state
 
     unless show_debug_log
+      expect(callback).to receive(:before_all_events).once.ordered
       expect(callback).to receive(:before_event).once.ordered
       expect(callback).to receive(:event_guard).once.ordered.and_return(true)
       expect(callback).to receive(:transition_guard).once.ordered.and_return(true)
@@ -25,6 +85,9 @@ describe 'callbacks for the new DSL' do
       expect(callback).to receive(:after_exit_open).once.ordered                    # these should be after the state changes
       expect(callback).to receive(:after_enter_closed).once.ordered
       expect(callback).to receive(:after_event).once.ordered
+      expect(callback).to receive(:after_all_events).once.ordered
+      expect(callback).to receive(:ensure_event).once.ordered
+      expect(callback).to receive(:ensure_on_all_events).once.ordered
     end
 
     # puts "------- close!"
@@ -35,11 +98,13 @@ describe 'callbacks for the new DSL' do
     callback = Callbacks::Basic.new(:log => false)
     callback.aasm.current_state
 
+    expect(callback).to receive(:before_all_events).once.ordered
     expect(callback).to receive(:before_event).once.ordered
     expect(callback).to receive(:event_guard).once.ordered.and_return(false)
     expect(callback).to_not receive(:transition_guard)
     expect(callback).to_not receive(:before_exit_open)
     expect(callback).to_not receive(:exit_open)
+    expect(callback).to_not receive(:after_all_transitions)
     expect(callback).to_not receive(:after_transition)
     expect(callback).to_not receive(:before_enter_closed)
     expect(callback).to_not receive(:enter_closed)
@@ -47,6 +112,9 @@ describe 'callbacks for the new DSL' do
     expect(callback).to_not receive(:after_exit_open)
     expect(callback).to_not receive(:after_enter_closed)
     expect(callback).to_not receive(:after_event)
+    expect(callback).to_not receive(:after_all_events)
+    expect(callback).to receive(:ensure_event).once.ordered
+    expect(callback).to receive(:ensure_on_all_events).once.ordered
 
     expect {
       callback.close!
@@ -72,11 +140,13 @@ describe 'callbacks for the new DSL' do
       callback.aasm.current_state
 
       unless show_debug_log
+        expect(callback).to receive(:before_all_events).once.ordered
         expect(callback).to receive(:before_event).once.ordered
         expect(callback).to receive(:event_guard).once.ordered.and_return(true)
         expect(callback).to receive(:transition_guard).once.ordered.and_return(false)
         expect(callback).to_not receive(:before_exit_open)
         expect(callback).to_not receive(:exit_open)
+        expect(callback).to_not receive(:after_all_transitions)
         expect(callback).to_not receive(:after_transition)
         expect(callback).to_not receive(:before_enter_closed)
         expect(callback).to_not receive(:enter_closed)
@@ -84,6 +154,9 @@ describe 'callbacks for the new DSL' do
         expect(callback).to_not receive(:after_exit_open)
         expect(callback).to_not receive(:after_enter_closed)
         expect(callback).to_not receive(:after_event)
+        expect(callback).to_not receive(:after_all_events)
+        expect(callback).to receive(:ensure_event).once.ordered
+        expect(callback).to receive(:ensure_on_all_events).once.ordered
       end
 
       expect {
@@ -201,49 +274,50 @@ describe 'event callbacks' do
       @foo = Foo.new
     end
 
-    context "error_callback defined" do
-      it "should run error_callback if an exception is raised" do
-        def @foo.error_callback(e)
-          @data = [e]
-        end
-
-        allow(@foo).to receive(:before_enter).and_raise(e = StandardError.new)
-
-        @foo.safe_close!
-        expect(@foo.data).to eql [e]
-      end
+    it_behaves_like 'an implemented callback that accepts error' do
+      let(:aasm_model) { @foo }
+      let(:callback_name) { :error_callback }
+    end
 
-      it "should run error_callback without parameters if callback does not support any" do
-        def @foo.error_callback(e)
-          @data = []
-        end
+    it "should raise NoMethodError if exception is raised and error_callback is declared but not defined" do
+      allow(@foo).to receive(:before_enter).and_raise(StandardError)
+      expect{@foo.safe_close!}.to raise_error(NoMethodError)
+    end
 
-        allow(@foo).to receive(:before_enter).and_raise(e = StandardError.new)
+    it "should propagate an error if no error callback is declared" do
+      allow(@foo).to receive(:before_enter).and_raise("Cannot enter safe")
+      expect{@foo.close!}.to raise_error(StandardError, "Cannot enter safe")
+    end
+  end
 
-        @foo.safe_close!('arg1', 'arg2')
-        expect(@foo.data).to eql []
-      end
+  describe 'with an ensure callback defined' do
+    before do
+      class Foo
+        # this hack is needed to allow testing of parameters, since RSpec
+        # destroys a method's arity when mocked
+        attr_accessor :data
 
-      it "should run error_callback with parameters if callback supports them" do
-        def @foo.error_callback(e, arg1, arg2)
-          @data = [arg1, arg2]
+        aasm do
+          event :safe_close, :success => :success_callback, :ensure => :ensure_callback do
+            transitions :to => :closed, :from => [:open]
+          end
         end
+      end
 
-        allow(@foo).to receive(:before_enter).and_raise(e = StandardError.new)
+      @foo = Foo.new
+    end
 
-        @foo.safe_close!('arg1', 'arg2')
-        expect(@foo.data).to eql ['arg1', 'arg2']
-      end
+    it_behaves_like 'an implemented callback' do
+      let(:aasm_model) { @foo }
+      let(:callback_name) { :ensure_callback }
     end
 
-    it "should raise NoMethodError if exception is raised and error_callback is declared but not defined" do
-      allow(@foo).to receive(:before_enter).and_raise(StandardError)
+    it "should raise NoMethodError if ensure_callback is declared but not defined" do
       expect{@foo.safe_close!}.to raise_error(NoMethodError)
     end
 
-    it "should propagate an error if no error callback is declared" do
-        allow(@foo).to receive(:before_enter).and_raise("Cannot enter safe")
-        expect{@foo.close!}.to raise_error(StandardError, "Cannot enter safe")
+    it "should not raise any error if no ensure_callback is declared" do
+      expect{@foo.close!}.to_not raise_error
     end
   end
 
@@ -292,5 +366,76 @@ describe 'event callbacks' do
       @foo.close!
     end
   end
+end
+
+describe 'global error_on_all_events_callback callbacks' do
+  describe "with an error_on_all_events" do
+    before do
+      class FooGlobal
+        # this hack is needed to allow testing of parameters, since RSpec
+        # destroys a method's arity when mocked
+        attr_accessor :data
+
+        aasm do
+          error_on_all_events  :error_on_all_events_callback
+
+          event :safe_close do
+            transitions :to => :closed, :from => [:open]
+          end
+        end
+      end
+
+      @foo = FooGlobal.new
+    end
+
+    it_behaves_like 'an implemented callback that accepts error' do
+      let(:aasm_model) { @foo }
+      let(:callback_name) { :error_on_all_events_callback }
+    end
+
+    it "should raise NoMethodError if exception is raised and error_callback is declared but not defined" do
+      allow(@foo).to receive(:before_enter).and_raise(StandardError)
+      expect{@foo.safe_close!}.to raise_error(NoMethodError)
+    end
 
+    it "should raise NoMethodError if no error callback is declared" do
+      allow(@foo).to receive(:before_enter).and_raise("Cannot enter safe")
+      expect{@foo.close!}.to raise_error(NoMethodError)
+    end
+  end
+end
+
+describe 'global ensure_on_all_events_callback callbacks' do
+  describe "with an ensure_on_all_events" do
+    before do
+      class FooGlobal
+        # this hack is needed to allow testing of parameters, since RSpec
+        # destroys a method's arity when mocked
+        attr_accessor :data
+
+        aasm do
+          ensure_on_all_events  :ensure_on_all_events_callback
+
+          event :safe_close do
+            transitions :to => :closed, :from => [:open]
+          end
+        end
+      end
+
+      @foo = FooGlobal.new
+    end
+
+    it_behaves_like 'an implemented callback' do
+      let(:aasm_model) { @foo }
+      let(:callback_name) { :ensure_on_all_events_callback }
+    end
+
+    it "should raise NoMethodError if ensure_on_all_events callback is declared but not defined" do
+      expect{@foo.safe_close!}.to raise_error(NoMethodError)
+    end
+
+    it "should raise NoMethodError if no ensure_on_all_events callback is declared" do
+      expect{@foo.close!}.to raise_error(NoMethodError)
+    end
+  end
 end

data/spec/unit/event_naming_spec.rb

@@ -5,7 +5,12 @@ describe "event naming" do
 
   it "allows an event of failed without blowing the stack aka stack level too deep" do
     state_machine.failed
-
     expect { state_machine.failed }.to raise_error(AASM::InvalidTransition)
   end
+
+  it "allows send as event name" do
+    expect(state_machine.aasm.current_state).to eq :init
+    state_machine.send
+    expect(state_machine.aasm.current_state).to eq :sent
+  end
 end

data/spec/unit/persistence/active_record_persistence_spec.rb

@@ -494,7 +494,72 @@ describe 'transitions with persistence' do
         expect(validator).to be_running
         expect(validator.name).to eq("name")
       end
+    end
 
+    describe 'before and after transaction callbacks' do
+      [:after, :before].each do |event_type|
+        describe "#{event_type}_transaction callback" do
+          it "should fire :#{event_type}_transaction if transaction was successful" do
+            validator = Validator.create(:name => 'name')
+            expect(validator).to be_sleeping
+
+            expect { validator.run! }.to change { validator.send("#{event_type}_transaction_performed_on_run") }.from(nil).to(true)
+            expect(validator).to be_running
+          end
+
+          it "should fire :#{event_type}_transaction if transaction failed" do
+            validator = Validator.create(:name => 'name')
+            expect do
+              begin
+                validator.fail!
+              rescue => ignored
+              end
+            end.to change { validator.send("#{event_type}_transaction_performed_on_fail") }.from(nil).to(true)
+            expect(validator).to_not be_running
+          end
+
+          it "should not fire :#{event_type}_transaction if not saving" do
+            validator = Validator.create(:name => 'name')
+            expect(validator).to be_sleeping
+            expect { validator.run }.to_not change { validator.send("#{event_type}_transaction_performed_on_run") }
+            expect(validator).to be_running
+            expect(validator.name).to eq("name")
+          end
+        end
+      end
+    end
+
+    describe 'before and after all transactions callbacks' do
+      [:after, :before].each do |event_type|
+        describe "#{event_type}_all_transactions callback" do
+          it "should fire :#{event_type}_all_transactions if transaction was successful" do
+            validator = Validator.create(:name => 'name')
+            expect(validator).to be_sleeping
+
+            expect { validator.run! }.to change { validator.send("#{event_type}_all_transactions_performed") }.from(nil).to(true)
+            expect(validator).to be_running
+          end
+
+          it "should fire :#{event_type}_all_transactions if transaction failed" do
+            validator = Validator.create(:name => 'name')
+            expect do
+              begin
+                validator.fail!
+              rescue => ignored
+              end
+            end.to change { validator.send("#{event_type}_all_transactions_performed") }.from(nil).to(true)
+            expect(validator).to_not be_running
+          end
+
+          it "should not fire :#{event_type}_all_transactions if not saving" do
+            validator = Validator.create(:name => 'name')
+            expect(validator).to be_sleeping
+            expect { validator.run }.to_not change { validator.send("#{event_type}_all_transactions_performed") }
+            expect(validator).to be_running
+            expect(validator.name).to eq("name")
+          end
+        end
+      end
     end
 
     context "when not persisting" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aasm
 version: !ruby/object:Gem::Version
-  version: 4.6.0
+  version: 4.7.0
 platform: ruby
 authors:
 - Scott Barron