aasm 3.4.0 → 4.0.0

data/lib/aasm/instance_base.rb

@@ -21,7 +21,7 @@ module AASM
       state_object = state_object_for_name(state_name)
 
       state_object.fire_callbacks(:before_enter, @instance)
-      state_object.fire_callbacks(:enter, @instance)
+      # state_object.fire_callbacks(:enter, @instance)
       self.current_state = state_name
       state_object.fire_callbacks(:after_enter, @instance)
 
@@ -33,9 +33,10 @@ module AASM
     end
 
     def states(options={})
-      if options[:permissible]
+      if options[:permitted]
         # ugliness level 1000
-        transitions = @instance.class.aasm.events.values_at(*permissible_events).compact.map {|e| e.transitions_from_state(current_state) }
+        permitted_event_names = events(:permitted => true).map(&:name)
+        transitions = @instance.class.aasm.state_machine.events.values_at(*permitted_event_names).compact.map {|e| e.transitions_from_state(current_state) }
         tos = transitions.map {|t| t[0] ? t[0].to : nil}.flatten.compact.map(&:to_sym).uniq
         @instance.class.aasm.states.select {|s| tos.include?(s.name.to_sym)}
       else
@@ -43,18 +44,17 @@ module AASM
       end
     end
 
-    # QUESTION: shouldn't events and permissible_events be the same thing?
-    # QUESTION: shouldn't events return objects instead of strings?
-    def events(state=current_state)
-      events = @instance.class.aasm.events.values.select {|e| e.transitions_from_state?(state) }
-      events.map {|e| e.name}
-    end
+    def events(options={})
+      state = options[:state] || current_state
+      events = @instance.class.aasm.events.select {|e| e.transitions_from_state?(state) }
+
+      if options[:permitted]
+        # filters the results of events_for_current_state so that only those that
+        # are really currently possible (given transition guards) are shown.
+        events.select! { |e| @instance.send("may_#{e.name}?") }
+      end
 
-    # filters the results of events_for_current_state so that only those that
-    # are really currently possible (given transition guards) are shown.
-    # QUESTION: what about events.permissible ?
-    def permissible_events
-      events.select{ |e| @instance.send(("may_" + e.to_s + "?").to_sym) }
+      events
     end
 
     def state_object_for_name(name)
@@ -75,7 +75,7 @@ module AASM
     end
 
     def may_fire_event?(name, *args)
-      if event = @instance.class.aasm.events[name]
+      if event = @instance.class.aasm.state_machine.events[name]
         event.may_fire?(@instance, *args)
       else
         false # unknown event

data/lib/aasm/persistence/active_record_persistence.rb

@@ -174,8 +174,8 @@ module AASM
           success = options[:persist] ? self.class.transaction(:requires_new => requires_new?) { super } : super
 
           if success && options[:persist]
-            new_state = aasm.state_object_for_name(aasm.current_state)
-            new_state.fire_callbacks(:after_commit, self)
+            event = self.class.aasm.state_machine.events[name]
+            event.fire_callbacks(:after_commit, self)
           end
 
           success

data/lib/aasm/state_machine.rb

@@ -16,7 +16,7 @@ module AASM
       @initial_state = nil
       @states = []
       @events = {}
-      @config = OpenStruct.new
+      @config = AASM::Configuration.new
     end
 
     # called internally by Ruby 1.9 after clone()

data/lib/aasm/transition.rb

@@ -1,33 +1,35 @@
 module AASM
   class Transition
+    include DslHelper
+
     attr_reader :from, :to, :opts
     alias_method :options, :opts
 
-    def initialize(opts)
+    def initialize(opts, &block)
+      add_options_from_dsl(opts, [:on_transition, :guard, :after], &block) if block
+
       @from = opts[:from]
       @to = opts[:to]
-      @guards = Array(opts[:guard] || opts[:guards])
-      @on_transition = opts[:on_transition]
+      @guards = Array(opts[:guard] || opts[:guards] || opts[:if])
+      @unless = Array(opts[:unless]) #TODO: This could use a better name
+
+      if opts[:on_transition]
+        warn '[DEPRECATION] :on_transition is deprecated, use :after instead'
+        opts[:after] = Array(opts[:after]) + Array(opts[:on_transition])
+      end
+      @after = Array(opts[:after])
+      @after = @after[0] if @after.size == 1
+
       @opts = opts
     end
 
-    # TODO: should be named allowed? or similar
-    def perform(obj, *args)
-      @guards.each do |guard|
-        case guard
-        when Symbol, String
-          return false unless obj.send(guard, *args)
-        when Proc
-          return false unless guard.call(obj, *args)
-        end
-      end
-      true
+    def allowed?(obj, *args)
+      invoke_callbacks_compatible_with_guard(@guards, obj, args, :guard => true) &&
+      invoke_callbacks_compatible_with_guard(@unless, obj, args, :unless => true)
     end
 
     def execute(obj, *args)
-      @on_transition.is_a?(Array) ?
-              @on_transition.each {|ot| _execute(obj, ot, *args)} :
-              _execute(obj, @on_transition, *args)
+      invoke_callbacks_compatible_with_guard(@after, obj, args)
     end
 
     def ==(obj)
@@ -40,15 +42,33 @@ module AASM
 
     private
 
-    def _execute(obj, on_transition, *args)
-      obj.aasm.from_state = @from if obj.aasm.respond_to?(:from_state=)
-      obj.aasm.to_state = @to if obj.aasm.respond_to?(:to_state=)
+    def invoke_callbacks_compatible_with_guard(code, record, args, options={})
+      if record.respond_to?(:aasm)
+        record.aasm.from_state = @from if record.aasm.respond_to?(:from_state=)
+        record.aasm.to_state = @to if record.aasm.respond_to?(:to_state=)
+      end
 
-      case on_transition
-      when Proc
-        on_transition.arity == 0 ? on_transition.call : on_transition.call(obj, *args)
+      case code
       when Symbol, String
-        obj.send(:method, on_transition.to_sym).arity == 0 ? obj.send(on_transition) : obj.send(on_transition, *args)
+        # QUESTION : record.send(code, *args) ?
+        arity = record.send(:method, code.to_sym).arity
+        arity == 0 ? record.send(code) : record.send(code, *args)
+      when Proc
+        # QUESTION : record.instance_exec(*args, &code) ?
+        code.arity == 0 ? record.instance_exec(&code) : record.instance_exec(*args, &code)
+      when Array
+        if options[:guard]
+          # invoke guard callbacks
+          code.all? {|a| invoke_callbacks_compatible_with_guard(a, record, args)}
+        elsif options[:unless]
+          # invoke unless callbacks
+          code.all? {|a| !invoke_callbacks_compatible_with_guard(a, record, args)}
+        else
+          # invoke after callbacks
+          code.map {|a| invoke_callbacks_compatible_with_guard(a, record, args)}
+        end
+      else
+        true
       end
     end
 

data/lib/aasm/version.rb

@@ -1,3 +1,3 @@
 module AASM
-  VERSION = "3.4.0"
+  VERSION = "4.0.0"
 end

data/spec/database.rb

@@ -1,5 +1,5 @@
 ActiveRecord::Migration.suppress_messages do
-  %w{gates readers writers transients simples simple_new_dsls no_scopes thieves localizer_test_models persisted_states provided_and_persisted_states}.each do |table_name|
+  %w{gates readers writers transients simples simple_new_dsls no_scopes no_direct_assignments thieves localizer_test_models persisted_states provided_and_persisted_states}.each do |table_name|
     ActiveRecord::Migration.create_table table_name, :force => true do |t|
       t.string "aasm_state"
     end

data/spec/models/auth_machine.rb

@@ -5,14 +5,18 @@ class AuthMachine
 
   aasm do
     state :passive
-    state :pending, :initial => true, :enter => :make_activation_code
-    state :active,  :enter => :do_activate
+    state :pending, :initial => true, :before_enter => :make_activation_code
+    state :active,  :before_enter => :do_activate
     state :suspended
-    state :deleted, :enter => :do_delete, :exit => :do_undelete
+    state :deleted, :before_enter => :do_delete#, :exit => :do_undelete
     state :waiting
 
     event :register do
-      transitions :from => :passive, :to => :pending, :guard => Proc.new {|u| u.can_register? }
+      transitions :from => :passive, :to => :pending do
+        guard do
+          can_register?
+        end
+      end
     end
 
     event :activate do
@@ -33,8 +37,8 @@ class AuthMachine
     end
 
     event :unsuspend do
-      transitions :from => :suspended, :to => :active,  :guard => Proc.new {|u| u.has_activated? }
-      transitions :from => :suspended, :to => :pending, :guard => Proc.new {|u| u.has_activation_code? }
+      transitions :from => :suspended, :to => :active,  :guard => Proc.new { has_activated? }
+      transitions :from => :suspended, :to => :pending, :guard => :has_activation_code?
       transitions :from => :suspended, :to => :passive
     end
 

data/spec/models/callback_new_dsl.rb

@@ -1,9 +1,16 @@
 class CallbackNewDsl
   include AASM
 
+  def initialize(options={})
+    @fail_event_guard = options[:fail_event_guard]
+    @fail_transition_guard = options[:fail_transition_guard]
+    @log = options[:log]
+  end
+
   aasm do
     state :open, :initial => true,
       :before_enter => :before_enter_open,
+      :enter        => :enter_open,
       :after_enter  => :after_enter_open,
       :before_exit  => :before_exit_open,
       :exit         => :exit_open,
@@ -14,10 +21,62 @@ class CallbackNewDsl
       :enter        => :enter_closed,
       :after_enter  => :after_enter_closed,
       :before_exit  => :before_exit_closed,
+      :exit         => :exit_closed,
+      :after_exit   => :after_exit_closed
+
+    event :close, :before => :before, :after => :after, :guard => :event_guard do
+      transitions :to => :closed, :from => [:open], :guard => :transition_guard, :after => :transitioning
+    end
+
+    event :open, :before => :before, :after => :after do
+      transitions :to => :open, :from => :closed
+    end
+  end
+
+  def log(text)
+    puts text if @log
+  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 event_guard; log('event_guard'); !@fail_event_guard; end
+  def transition_guard; log('transition_guard'); !@fail_transition_guard; end
+  def transitioning; log('transitioning'); end
+
+  def before; log('before'); end
+  def after; log('after'); end
+end
+
+class CallbackNewDslArgs
+  include AASM
+
+  aasm do
+    state :open, :initial => true,
+      :before_enter => :before_enter_open,
+      :after_enter  => :after_enter_open,
+      :before_exit  => :before_exit_open,
+      :after_exit   => :after_exit_open
+
+    state :closed,
+      :before_enter => :before_enter_closed,
+      :after_enter  => :after_enter_closed,
+      :before_exit  => :before_exit_closed,
       :after_exit   => :after_exit_closed
 
     event :close, :before => :before, :after => :after do
-      transitions :to => :closed, :from => [:open]
+      transitions :to => :closed, :from => [:open], :after => :transition_proc
     end
 
     event :open, :before => :before, :after => :after do
@@ -25,19 +84,46 @@ class CallbackNewDsl
     end
   end
 
-  def before_enter_open; end
-  def before_exit_open; end
-  def after_enter_open; end
-  def after_exit_open; end
+  def log(text)
+    # puts text
+  end
+
+  def before_enter_open; log('before_enter_open'); end
+  def before_exit_open; log('before_exit_open'); end
+  def after_enter_open; log('after_enter_open'); end
+  def after_exit_open; log('after_exit_open'); end
+
+  def before_enter_closed; log('before_enter_closed'); end
+  def before_exit_closed; log('before_enter_closed'); end
+  def after_enter_closed; log('after_enter_closed'); end
+  def after_exit_closed; log('after_exit_closed'); end
+
+  def before(*args); log('before'); end
+  def transition_proc(arg1, arg2); log('transition_proc'); end
+  def after(*args); log('after'); end
+end
+
+class CallbackWithStateArg
+
+  include AASM
+
+  aasm do
+    state :open, :inital => true
+    state :closed
+    state :out_to_lunch
+
+    event :close, :before => :before_method, :after => :after_method do
+      transitions :to => :closed, :from => [:open], :after => :transition_method
+      transitions :to => :out_to_lunch, :from => [:open], :after => :transition_method2
+    end
+  end
+
+  def before_method(arg); end
+
+  def after_method(arg); end
 
-  def before_enter_closed; end
-  def before_exit_closed; end
-  def after_enter_closed; end
-  def after_exit_closed; end
+  def transition_method(arg); end
 
-  def before; end
-  def after; end
+  def transition_method2(arg); end
 
-  def enter_closed; end
-  def exit_open; end
 end

data/spec/models/double_definer.rb

@@ -10,9 +10,9 @@ class DoubleDefiner
     end
 
     # simulating a reload
-    state :finished, :enter => :do_enter
+    state :finished, :before_enter => :do_enter
     event :finish do
-      transitions :from => :started, :to => :finished, :on_transition => :do_on_transition
+      transitions :from => :started, :to => :finished, :after => :do_on_transition
     end
   end
 

data/spec/models/foo.rb

@@ -1,8 +1,8 @@
 class Foo
   include AASM
   aasm do
-    state :open, :initial => true, :exit => :exit
-    state :closed, :enter => :enter
+    state :open, :initial => true, :before_exit => :before_exit
+    state :closed, :before_enter => :before_enter
     state :final
 
     event :close, :success => :success_callback do
@@ -21,9 +21,9 @@ class Foo
   def success_callback
   end
 
-  def enter
+  def before_enter
   end
-  def exit
+  def before_exit
   end
 end
 

data/spec/models/parametrised_event.rb

@@ -12,9 +12,9 @@ class ParametrisedEvent
     end
 
     event :dress do
-      transitions :from => :sleeping, :to => :working, :on_transition => :wear_clothes
-      transitions :from => :showering, :to => [:working, :dating], :on_transition => Proc.new { |obj, *args| obj.wear_clothes(*args) }
-      transitions :from => :showering, :to => :prettying_up, :on_transition => [:condition_hair, :fix_hair]
+      transitions :from => :sleeping, :to => :working, :after => :wear_clothes
+      transitions :from => :showering, :to => [:working, :dating], :after => Proc.new { |*args| wear_clothes(*args) }
+      transitions :from => :showering, :to => :prettying_up, :after => [:condition_hair, :fix_hair]
     end
   end
 

data/spec/models/persistence.rb

@@ -48,7 +48,22 @@ end
 class NoScope < ActiveRecord::Base
   include AASM
   aasm :create_scopes => false do
-    state :ignored_scope
+    state :pending, :initial => true
+    state :running
+    event :run do
+      transitions :from => :pending, :to => :running
+    end
+  end
+end
+
+class NoDirectAssignment < ActiveRecord::Base
+  include AASM
+  aasm :no_direct_assignment => true do
+    state :pending, :initial => true
+    state :running
+    event :run do
+      transitions :from => :pending, :to => :running
+    end
   end
 end
 

data/spec/models/validator.rb

@@ -1,12 +1,14 @@
 require 'active_record'
 
 class Validator < ActiveRecord::Base
+
   include AASM
   aasm :column => :status do
     state :sleeping, :initial => true
-    state :running, :after_commit => :change_name!
-    state :failed, :after_enter => :fail, :after_commit => :change_name!
-    event :run do
+    state :running
+    state :failed, :after_enter => :fail
+
+    event :run, :after_commit => :change_name! do
       transitions :to => :running, :from => :sleeping
     end
     event :sleep do
@@ -16,6 +18,7 @@ class Validator < ActiveRecord::Base
       transitions :to => :failed, :from => [:sleeping, :running]
     end
   end
+
   validates_presence_of :name
 
   def change_name!