aasm 4.0.8 → 4.5.2

data/lib/aasm/aasm.rb

@@ -8,36 +8,63 @@ module AASM
 
     # do not overwrite existing state machines, which could have been created by
     # inheritance, see class method inherited
-    AASM::StateMachine[base] ||= AASM::StateMachine.new
+    AASM::StateMachine[base] ||= {}
 
     AASM::Persistence.load_persistence(base)
     super
   end
 
   module ClassMethods
-
     # make sure inheritance (aka subclassing) works with AASM
     def inherited(base)
-      AASM::StateMachine[base] = AASM::StateMachine[self].clone
+      AASM::StateMachine[base] = {}
+      AASM::StateMachine[self].keys.each do |state_machine_name|
+        AASM::StateMachine[base][state_machine_name] = AASM::StateMachine[self][state_machine_name].clone
+      end
       super
     end
 
     # this is the entry point for all state and event definitions
-    def aasm(options={}, &block)
-      @aasm ||= AASM::Base.new(self, options)
-      @aasm.instance_eval(&block) if block # new DSL
-      @aasm
-    end
+    def aasm(*args, &block)
+      if args[0].is_a?(Symbol) || args[0].is_a?(String)
+        # using custom name
+        state_machine_name = args[0].to_sym
+        options = args[1] || {}
+      else
+        # using the default state_machine_name
+        state_machine_name = :default
+        options = args[0] || {}
+      end
 
-    # deprecated, remove in version 4.1
-    def aasm_human_event_name(event) # event_name?
-      warn '[DEPRECATION] AASM: aasm_human_event_name is deprecated, use aasm.human_event_name instead'
-      aasm.human_event_name(event)
+      AASM::StateMachine[self][state_machine_name] ||= AASM::StateMachine.new(state_machine_name)
+
+      @aasm ||= {}
+      if @aasm[state_machine_name]
+        # make sure to use provided options
+        options.each do |key, value|
+          @aasm[state_machine_name].state_machine.config.send("#{key}=", value)
+        end
+      else
+        # create a new base
+        @aasm[state_machine_name] = AASM::Base.new(
+          self,
+          state_machine_name,
+          AASM::StateMachine[self][state_machine_name],
+          options
+        )
+      end
+      @aasm[state_machine_name].instance_eval(&block) if block # new DSL
+      @aasm[state_machine_name]
     end
   end # ClassMethods
 
-  def aasm
-    @aasm ||= AASM::InstanceBase.new(self)
+  # this is the entry point for all instance-level access to AASM
+  def aasm(name=:default)
+    unless AASM::StateMachine[self.class][name.to_sym]
+      raise AASM::UnknownStateMachineError.new("There is no state machine with the name '#{name}' defined in #{self.class.name}!")
+    end
+    @aasm ||= {}
+    @aasm[name.to_sym] ||= AASM::InstanceBase.new(self, name.to_sym)
   end
 
 private
@@ -56,66 +83,72 @@ private
     return args
   end
 
-  def aasm_fire_event(event_name, options, *args, &block)
-    event = self.class.aasm.state_machine.events[event_name]
+  def aasm_fire_event(state_machine_name, event_name, options, *args, &block)
+    event = self.class.aasm(state_machine_name).state_machine.events[event_name]
     begin
-      old_state = aasm.state_object_for_name(aasm.current_state)
+      old_state = aasm(state_machine_name).state_object_for_name(aasm(state_machine_name).current_state)
 
       # new event before callback
       event.fire_callbacks(
         :before,
         self,
-        *process_args(event, aasm.current_state, *args)
+        *process_args(event, aasm(state_machine_name).current_state, *args)
       )
 
       if may_fire_to = event.may_fire?(self, *args)
-        old_state.fire_callbacks(:before_exit, self)
-        old_state.fire_callbacks(:exit, self) # TODO: remove for AASM 4?
+        old_state.fire_callbacks(:before_exit, self,
+          *process_args(event, aasm(state_machine_name).current_state, *args))
+        old_state.fire_callbacks(:exit, self,
+          *process_args(event, aasm(state_machine_name).current_state, *args))
 
         if new_state_name = event.fire(self, {:may_fire => may_fire_to}, *args)
-          aasm_fired(event, old_state, new_state_name, options, *args, &block)
+          aasm_fired(state_machine_name, event, old_state, new_state_name, options, *args, &block)
         else
-          aasm_failed(event_name, old_state)
+          aasm_failed(state_machine_name, event_name, old_state)
         end
       else
-        aasm_failed(event_name, old_state)
+        aasm_failed(state_machine_name, event_name, old_state)
       end
     rescue StandardError => e
-      event.fire_callbacks(:error, self, e, *process_args(event, aasm.current_state, *args)) || raise(e)
+      event.fire_callbacks(:error, self, e, *process_args(event, aasm(state_machine_name).current_state, *args)) || raise(e)
     end
   end
 
-  def aasm_fired(event, old_state, new_state_name, options, *args)
+  def aasm_fired(state_machine_name, event, old_state, new_state_name, options, *args)
     persist = options[:persist]
 
-    new_state = aasm.state_object_for_name(new_state_name)
+    new_state = aasm(state_machine_name).state_object_for_name(new_state_name)
 
-    new_state.fire_callbacks(:before_enter, self)
+    new_state.fire_callbacks(:before_enter, self,
+      *process_args(event, aasm(state_machine_name).current_state, *args))
 
-    new_state.fire_callbacks(:enter, self) # TODO: remove for AASM 4?
+    new_state.fire_callbacks(:enter, self,
+      *process_args(event, aasm(state_machine_name).current_state, *args)) # TODO: remove for AASM 4?
 
     persist_successful = true
     if persist
-      persist_successful = aasm.set_current_state_with_persistence(new_state_name)
+      persist_successful = aasm(state_machine_name).set_current_state_with_persistence(new_state_name)
       if persist_successful
         yield if block_given?
         event.fire_callbacks(:success, self)
       end
     else
-      aasm.current_state = new_state_name
+      aasm(state_machine_name).current_state = new_state_name
       yield if block_given?
     end
 
     if persist_successful
-      old_state.fire_callbacks(:after_exit, self)
-      new_state.fire_callbacks(:after_enter, self)
+      old_state.fire_callbacks(:after_exit, self,
+        *process_args(event, aasm(state_machine_name).current_state, *args))
+      new_state.fire_callbacks(:after_enter, self,
+        *process_args(event, aasm(state_machine_name).current_state, *args))
       event.fire_callbacks(
         :after,
         self,
         *process_args(event, old_state.name, *args)
       )
 
-      self.aasm_event_fired(event.name, old_state.name, aasm.current_state) if self.respond_to?(:aasm_event_fired)
+      self.aasm_event_fired(event.name, old_state.name, aasm(state_machine_name).current_state) if self.respond_to?(:aasm_event_fired)
     else
       self.aasm_event_failed(event.name, old_state.name) if self.respond_to?(:aasm_event_failed)
     end
@@ -123,13 +156,13 @@ private
     persist_successful
   end
 
-  def aasm_failed(event_name, old_state)
+  def aasm_failed(state_machine_name, event_name, old_state)
     if self.respond_to?(:aasm_event_failed)
       self.aasm_event_failed(event_name, old_state.name)
     end
 
-    if AASM::StateMachine[self.class].config.whiny_transitions
-      raise AASM::InvalidTransition, "Event '#{event_name}' cannot transition from '#{aasm.current_state}'"
+    if AASM::StateMachine[self.class][state_machine_name].config.whiny_transitions
+      raise AASM::InvalidTransition.new(self, event_name, state_machine_name)
     else
       false
     end

data/lib/aasm/base.rb

@@ -3,10 +3,12 @@ module AASM
 
     attr_reader :state_machine
 
-    def initialize(klass, options={}, &block)
+    def initialize(klass, name, state_machine, options={}, &block)
       @klass = klass
-      @state_machine = AASM::StateMachine[@klass]
-      @state_machine.config.column ||= (options[:column] || :aasm_state).to_sym # aasm4
+      @name = name
+      # @state_machine = @klass.aasm(@name).state_machine
+      @state_machine = state_machine
+      @state_machine.config.column ||= (options[:column] || default_column).to_sym
       # @state_machine.config.column = options[:column].to_sym if options[:column] # master
       @options = options
 
@@ -27,11 +29,19 @@ module AASM
 
       configure :enum, nil
 
-      if @state_machine.config.no_direct_assignment
-        @klass.send(:define_method, "#{@state_machine.config.column}=") do |state_name|
-          raise AASM::NoDirectAssignmentError.new('direct assignment of AASM column has been disabled (see AASM configuration for this class)')
+      # make sure to raise an error if no_direct_assignment is enabled
+      # and attribute is directly assigned though
+      @klass.class_eval %Q(
+        def #{@state_machine.config.column}=(state_name)
+          if self.class.aasm(:#{@name}).state_machine.config.no_direct_assignment
+            raise AASM::NoDirectAssignmentError.new(
+              'direct assignment of AASM column has been disabled (see AASM configuration for this class)'
+            )
+          else
+            super
+          end
         end
-      end
+      )
     end
 
     # This method is both a getter and a setter
@@ -56,10 +66,16 @@ module AASM
     def state(name, options={})
       @state_machine.add_state(name, @klass, options)
 
-      @klass.send(:define_method, "#{name}?") do
-        aasm.current_state == name
+      if @klass.instance_methods.include?("#{name}?")
+        warn "#{@klass.name}: The aasm state name #{name} is already used!"
       end
 
+      @klass.class_eval <<-EORUBY, __FILE__, __LINE__ + 1
+        def #{name}?
+          aasm(:#{@name}).current_state == :#{name}
+        end
+      EORUBY
+
       unless @klass.const_defined?("STATE_#{name.upcase}")
         @klass.const_set("STATE_#{name.upcase}", name)
       end
@@ -67,24 +83,34 @@ module AASM
 
     # define an event
     def event(name, options={}, &block)
-      @state_machine.events[name] = AASM::Core::Event.new(name, options, &block)
+      @state_machine.add_event(name, options, &block)
+
+      if @klass.instance_methods.include?("may_#{name}?".to_sym)
+        warn "#{@klass.name}: The aasm event name #{name} is already used!"
+      end
 
       # an addition over standard aasm so that, before firing an event, you can ask
       # may_event? and get back a boolean that tells you whether the guard method
       # on the transition will let this happen.
-      @klass.send(:define_method, "may_#{name}?") do |*args|
-        aasm.may_fire_event?(name, *args)
-      end
+      @klass.class_eval <<-EORUBY, __FILE__, __LINE__ + 1
+        def may_#{name}?(*args)
+          aasm(:#{@name}).may_fire_event?(:#{name}, *args)
+        end
 
-      @klass.send(:define_method, "#{name}!") do |*args, &block|
-        aasm.current_event = "#{name}!".to_sym
-        aasm_fire_event(name, {:persist => true}, *args, &block)
-      end
+        def #{name}!(*args, &block)
+          aasm(:#{@name}).current_event = :#{name}!
+          aasm_fire_event(:#{@name}, :#{name}, {:persist => true}, *args, &block)
+        end
 
-      @klass.send(:define_method, "#{name}") do |*args, &block|
-        aasm.current_event = name.to_sym
-        aasm_fire_event(name, {:persist => false}, *args, &block)
-      end
+        def #{name}(*args, &block)
+          aasm(:#{@name}).current_event = :#{name}
+          aasm_fire_event(:#{@name}, :#{name}, {:persist => false}, *args, &block)
+        end
+      EORUBY
+    end
+
+    def after_all_transitions(*callbacks, &block)
+      @state_machine.add_global_callbacks(:after_all_transitions, *callbacks, &block)
     end
 
     def states
@@ -114,6 +140,10 @@ module AASM
 
     private
 
+    def default_column
+      @name.to_sym == :default ? :aasm_state : @name.to_sym
+    end
+
     def configure(key, default_value)
       if @options.key?(key)
         @state_machine.config.send("#{key}=", @options[key])

data/lib/aasm/core/event.rb

@@ -2,17 +2,18 @@ module AASM::Core
   class Event
     include DslHelper
 
-    attr_reader :name, :options
+    attr_reader :name, :state_machine, :options
 
-    def initialize(name, options = {}, &block)
+    def initialize(name, state_machine, options = {}, &block)
       @name = name
+      @state_machine = state_machine
       @transitions = []
       @guards = Array(options[:guard] || options[:guards] || options[:if])
       @unless = Array(options[:unless]) #TODO: This could use a better name
 
       # from aasm4
       @options = options # QUESTION: .dup ?
-      add_options_from_dsl(@options, [:after, :before, :error, :success], &block) if block
+      add_options_from_dsl(@options, [:after, :before, :error, :success, :after_commit], &block) if block
     end
 
     # a neutered version of fire - it doesn't actually fire the event, it just
@@ -61,11 +62,11 @@ module AASM::Core
       if definitions # define new transitions
         # Create a separate transition for each from-state to the given state
         Array(definitions[:from]).each do |s|
-          @transitions << AASM::Core::Transition.new(attach_event_guards(definitions.merge(:from => s.to_sym)), &block)
+          @transitions << AASM::Core::Transition.new(self, attach_event_guards(definitions.merge(:from => s.to_sym)), &block)
         end
         # Create a transition if :to is specified without :from (transitions from ANY state)
         if @transitions.empty? && definitions[:to]
-          @transitions << AASM::Core::Transition.new(attach_event_guards(definitions), &block)
+          @transitions << AASM::Core::Transition.new(self, attach_event_guards(definitions), &block)
         end
       end
       @transitions
@@ -89,7 +90,7 @@ module AASM::Core
     def _fire(obj, options={}, to_state=nil, *args)
       result = options[:test_only] ? false : nil
       if @transitions.map(&:from).any?
-        transitions = @transitions.select { |t| t.from == obj.aasm.current_state }
+        transitions = @transitions.select { |t| t.from == obj.aasm(state_machine.name).current_state }
         return result if transitions.size == 0
       else
         transitions = @transitions

data/lib/aasm/core/state.rb

@@ -1,10 +1,11 @@
 module AASM::Core
   class State
-    attr_reader :name, :options
+    attr_reader :name, :state_machine, :options
 
-    def initialize(name, klass, options={})
+    def initialize(name, klass, state_machine, options={})
       @name = name
       @klass = klass
+      @state_machine = state_machine
       update(options)
     end
 
@@ -28,12 +29,12 @@ module AASM::Core
       name.to_s
     end
 
-    def fire_callbacks(action, record)
+    def fire_callbacks(action, record, *args)
       action = @options[action]
       catch :halt_aasm_chain do
         action.is_a?(Array) ?
-                action.each {|a| _fire_callbacks(a, record)} :
-                _fire_callbacks(action, record)
+                action.each {|a| _fire_callbacks(a, record, args)} :
+                _fire_callbacks(action, record, args)
       end
     end
 
@@ -66,12 +67,14 @@ module AASM::Core
       self
     end
 
-    def _fire_callbacks(action, record)
+    def _fire_callbacks(action, record, args)
       case action
         when Symbol, String
-          record.send(action)
+          arity = record.send(:method, action.to_sym).arity
+          record.send(action, *(arity < 0 ? args : args[0...arity]))
         when Proc
-          action.call(record)
+          arity = action.arity
+          action.call(record, *(arity < 0 ? args : args[0...arity]))
       end
     end
 

data/lib/aasm/core/transition.rb

@@ -2,12 +2,13 @@ module AASM::Core
   class Transition
     include DslHelper
 
-    attr_reader :from, :to, :opts
+    attr_reader :from, :to, :event, :opts
     alias_method :options, :opts
 
-    def initialize(opts, &block)
+    def initialize(event, opts, &block)
       add_options_from_dsl(opts, [:on_transition, :guard, :after], &block) if block
 
+      @event = event
       @from = opts[:from]
       @to = opts[:to]
       @guards = Array(opts[:guards]) + Array(opts[:guard]) + Array(opts[:if])
@@ -29,6 +30,7 @@ module AASM::Core
     end
 
     def execute(obj, *args)
+      invoke_callbacks_compatible_with_guard(event.state_machine.global_callbacks[:after_all_transitions], obj, args)
       invoke_callbacks_compatible_with_guard(@after, obj, args)
     end
 
@@ -44,8 +46,8 @@ module AASM::Core
 
     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=)
+        record.aasm(event.state_machine.name).from_state = @from if record.aasm(event.state_machine.name).respond_to?(:from_state=)
+        record.aasm(event.state_machine.name).to_state = @to if record.aasm(event.state_machine.name).respond_to?(:to_state=)
       end
 
       case code
@@ -53,7 +55,7 @@ module AASM::Core
         arity = record.send(:method, code.to_sym).arity
         arity == 0 ? record.send(code) : record.send(code, *args)
       when Proc
-        code.arity == 0 ? record.instance_exec(&code) : record.instance_exec(*args, &code)
+        code.parameters.size == 0 ? record.instance_exec(&code) : record.instance_exec(*args, &code)
       when Array
         if options[:guard]
           # invoke guard callbacks

data/lib/aasm/errors.rb

@@ -1,5 +1,19 @@
 module AASM
-  class InvalidTransition < RuntimeError; end
+
+  class UnknownStateMachineError < RuntimeError; end
+
+  class InvalidTransition < RuntimeError
+    attr_reader :object, :event_name, :state_machine_name
+
+    def initialize(object, event_name, state_machine_name)
+      @object, @event_name, @state_machine_name = object, event_name, state_machine_name
+    end
+
+    def message
+      "Event '#{event_name}' cannot transition from '#{object.aasm(state_machine_name).current_state}'"
+    end
+  end
+
   class UndefinedState < RuntimeError; end
   class NoDirectAssignmentError < RuntimeError; end
 end

data/lib/aasm/instance_base.rb

@@ -3,21 +3,22 @@ module AASM
 
     attr_accessor :from_state, :to_state, :current_event
 
-    def initialize(instance)
+    def initialize(instance, name=:default) # instance of the class including AASM, name of the state machine
       @instance = instance
+      @name = name
     end
 
     def current_state
-      @instance.aasm_read_state
+      @instance.aasm_read_state(@name)
     end
 
     def current_state=(state)
-      @instance.aasm_write_state_without_persistence(state)
-      @current_state = state
+      @instance.aasm_write_state_without_persistence(state, @name)
+      # @current_state = state
     end
 
     def enter_initial_state
-      state_name = determine_state_name(@instance.class.aasm.initial_state)
+      state_name = determine_state_name(@instance.class.aasm(@name).initial_state)
       state_object = state_object_for_name(state_name)
 
       state_object.fire_callbacks(:before_enter, @instance)
@@ -29,24 +30,27 @@ module AASM
     end
 
     def human_state
-      AASM::Localizer.new.human_state_name(@instance.class, current_state)
+      AASM::Localizer.new.human_state_name(@instance.class, state_object_for_name(current_state))
     end
 
     def states(options={})
       if options[:permitted]
         # ugliness level 1000
         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) }
+        transitions = @instance.class.aasm(@name).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)}
+        @instance.class.aasm(@name).states.select {|s| tos.include?(s.name.to_sym)}
       else
-        @instance.class.aasm.states
+        @instance.class.aasm(@name).states
       end
     end
 
     def events(options={})
       state = options[:state] || current_state
-      events = @instance.class.aasm.events.select {|e| e.transitions_from_state?(state) }
+      events = @instance.class.aasm(@name).events.select {|e| e.transitions_from_state?(state) }
+
+      options[:reject] = Array(options[:reject])
+      events.reject! { |e| options[:reject].include?(e.name) }
 
       if options[:permitted]
         # filters the results of events_for_current_state so that only those that
@@ -58,7 +62,7 @@ module AASM
     end
 
     def state_object_for_name(name)
-      obj = @instance.class.aasm.states.find {|s| s == name}
+      obj = @instance.class.aasm(@name).states.find {|s| s.name == name}
       raise AASM::UndefinedState, "State :#{name} doesn't exist" if obj.nil?
       obj
     end
@@ -75,7 +79,7 @@ module AASM
     end
 
     def may_fire_event?(name, *args)
-      if event = @instance.class.aasm.state_machine.events[name]
+      if event = @instance.class.aasm(@name).state_machine.events[name]
         !!event.may_fire?(@instance, *args)
       else
         false # unknown event
@@ -83,7 +87,7 @@ module AASM
     end
 
     def set_current_state_with_persistence(state)
-      save_success = @instance.aasm_write_state(state)
+      save_success = @instance.aasm_write_state(state, @name)
       self.current_state = state if save_success
       save_success
     end

data/lib/aasm/localizer.rb

@@ -21,7 +21,7 @@ module AASM
 
     def item_for(klass, state, ancestor, options={})
       separator = options[:old_style] ? '.' : '/'
-      :"#{i18n_scope(klass)}.attributes.#{i18n_klass(ancestor)}.#{klass.aasm.attribute_name}#{separator}#{state}"
+      :"#{i18n_scope(klass)}.attributes.#{i18n_klass(ancestor)}.#{klass.aasm(state.state_machine.name).attribute_name}#{separator}#{state}"
     end
 
     def translate_queue(checklist)