aasm 4.5.1 → 5.5.0

data/lib/aasm/aasm.rb

@@ -1,4 +1,6 @@
 module AASM
+  # this is used internally as an argument default value to represent no value
+  NO_VALUE = :_aasm_no_value
 
   # provide a state machine for the including class
   # make sure to load class methods as well
@@ -8,7 +10,7 @@ module AASM
 
     # do not overwrite existing state machines, which could have been created by
     # inheritance, see class method inherited
-    AASM::StateMachine[base] ||= {}
+    AASM::StateMachineStore.register(base)
 
     AASM::Persistence.load_persistence(base)
     super
@@ -17,10 +19,8 @@ module AASM
   module ClassMethods
     # make sure inheritance (aka subclassing) works with AASM
     def inherited(base)
-      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
+      AASM::StateMachineStore.register(base, self)
+
       super
     end
 
@@ -36,9 +36,15 @@ module AASM
         options = args[0] || {}
       end
 
-      AASM::StateMachine[self][state_machine_name] ||= AASM::StateMachine.new(state_machine_name)
+      AASM::StateMachineStore.fetch(self, true).register(state_machine_name, AASM::StateMachine.new(state_machine_name))
+
+      # use a default despite the DSL configuration default.
+      # this is because configuration hasn't been setup for the AASM class but we are accessing a DSL option already for the class.
+      aasm_klass = options[:with_klass] || AASM::Base
 
-      @aasm ||= {}
+      raise ArgumentError, "The class #{aasm_klass} must inherit from AASM::Base!" unless aasm_klass.ancestors.include?(AASM::Base)
+
+      @aasm ||= Concurrent::Map.new
       if @aasm[state_machine_name]
         # make sure to use provided options
         options.each do |key, value|
@@ -46,10 +52,10 @@ module AASM
         end
       else
         # create a new base
-        @aasm[state_machine_name] = AASM::Base.new(
+        @aasm[state_machine_name] = aasm_klass.new(
           self,
           state_machine_name,
-          AASM::StateMachine[self][state_machine_name],
+          AASM::StateMachineStore.fetch(self, true).machine(state_machine_name),
           options
         )
       end
@@ -60,13 +66,18 @@ module AASM
 
   # this is the entry point for all instance-level access to AASM
   def aasm(name=:default)
-    unless AASM::StateMachine[self.class][name.to_sym]
+    unless AASM::StateMachineStore.fetch(self.class, true).machine(name)
       raise AASM::UnknownStateMachineError.new("There is no state machine with the name '#{name}' defined in #{self.class.name}!")
     end
-    @aasm ||= {}
+    @aasm ||= Concurrent::Map.new
     @aasm[name.to_sym] ||= AASM::InstanceBase.new(self, name.to_sym)
   end
 
+  def initialize_dup(other)
+    @aasm = Concurrent::Map.new
+    super
+  end
+
 private
 
   # Takes args and a from state and removes the first
@@ -88,65 +99,91 @@ private
     begin
       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(state_machine_name).current_state, *args)
-      )
+      fire_default_callbacks(event, *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,
-          *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))
-
+        fire_exit_callbacks(old_state, *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(state_machine_name, event, old_state, new_state_name, options, *args, &block)
         else
-          aasm_failed(state_machine_name, event_name, old_state)
+          aasm_failed(state_machine_name, event_name, old_state, event.failed_callbacks)
         end
       else
-        aasm_failed(state_machine_name, event_name, old_state)
+        aasm_failed(state_machine_name, event_name, old_state, event.failed_callbacks)
       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)
+      false
+    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
 
+  def fire_default_callbacks(event, *processed_args)
+    event.fire_global_callbacks(
+      :before_all_events,
+      self,
+      *processed_args
+    )
+
+    # new event before callback
+    event.fire_callbacks(
+      :before,
+      self,
+      *processed_args
+    )
+  end
+
+  def fire_exit_callbacks(old_state, *processed_args)
+    old_state.fire_callbacks(:before_exit, self, *processed_args)
+    old_state.fire_callbacks(:exit, self, *processed_args)
+  end
+
   def aasm_fired(state_machine_name, event, old_state, new_state_name, options, *args)
     persist = options[:persist]
 
     new_state = aasm(state_machine_name).state_object_for_name(new_state_name)
+    callback_args = process_args(event, aasm(state_machine_name).current_state, *args)
 
-    new_state.fire_callbacks(:before_enter, self,
-      *process_args(event, aasm(state_machine_name).current_state, *args))
+    new_state.fire_callbacks(:before_enter, self, *callback_args)
 
-    new_state.fire_callbacks(:enter, self,
-      *process_args(event, aasm(state_machine_name).current_state, *args)) # TODO: remove for AASM 4?
+    new_state.fire_callbacks(:enter, self, *callback_args) # TODO: remove for AASM 4?
 
     persist_successful = true
     if persist
       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)
+        event.fire_callbacks(:before_success, self, *callback_args)
+        event.fire_transition_callbacks(self, *process_args(event, old_state.name, *args))
+        event.fire_callbacks(:success, self, *callback_args)
       end
     else
       aasm(state_machine_name).current_state = new_state_name
       yield if block_given?
     end
 
+    binding_event = event.options[:binding_event]
+    if binding_event
+      __send__("#{binding_event}#{'!' if persist}")
+    end
+
     if persist_successful
-      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))
+      old_state.fire_callbacks(:after_exit, self, *callback_args)
+      new_state.fire_callbacks(:after_enter, self, *callback_args)
       event.fire_callbacks(
         :after,
         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
@@ -156,13 +193,13 @@ private
     persist_successful
   end
 
-  def aasm_failed(state_machine_name, event_name, old_state)
+  def aasm_failed(state_machine_name, event_name, old_state, failures = [])
     if self.respond_to?(:aasm_event_failed)
       self.aasm_event_failed(event_name, old_state.name)
     end
 
-    if AASM::StateMachine[self.class][state_machine_name].config.whiny_transitions
-      raise AASM::InvalidTransition.new(self, event_name, state_machine_name)
+    if AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.whiny_transitions
+      raise AASM::InvalidTransition.new(self, event_name, state_machine_name, failures)
     else
       false
     end

data/lib/aasm/base.rb

@@ -1,12 +1,14 @@
+require 'logger'
+
 module AASM
   class Base
 
-    attr_reader :state_machine
+    attr_reader :klass, :state_machine
 
     def initialize(klass, name, state_machine, options={}, &block)
       @klass = klass
       @name = name
-      # @state_machine = @klass.aasm(@name).state_machine
+      # @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
@@ -21,27 +23,43 @@ module AASM
       # don't store any new state if the model is invalid (in ActiveRecord)
       configure :skip_validation_on_save, false
 
+      # raise if the model is invalid (in ActiveRecord)
+      configure :whiny_persistence, false
+
+      # Use transactions (in ActiveRecord)
+      configure :use_transactions, true
+
       # use requires_new for nested transactions (in ActiveRecord)
       configure :requires_new_transaction, true
 
+      # use pessimistic locking (in ActiveRecord)
+      # true for FOR UPDATE lock
+      # string for a specific lock type i.e. FOR UPDATE NOWAIT
+      configure :requires_lock, false
+
+      # automatically set `"#{state_name}_at" = ::Time.now` on state changes
+      configure :timestamps, false
+
       # set to true to forbid direct assignment of aasm_state column (in ActiveRecord)
       configure :no_direct_assignment, false
 
+      # allow a AASM::Base sub-class to be used for state machine
+      configure :with_klass, AASM::Base
+
       configure :enum, nil
 
+      # Set to true to namespace reader methods and constants
+      configure :namespace, false
+
+      # Configure a logger, with default being a Logger to STDERR
+      configure :logger, Logger.new(STDERR)
+
+      # setup timestamp-setting callback if enabled
+      setup_timestamps(@name)
+
       # 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
-      )
+      setup_no_direct_assignment(@name)
     end
 
     # This method is both a getter and a setter
@@ -63,21 +81,29 @@ module AASM
     end
 
     # define a state
-    def state(name, options={})
-      @state_machine.add_state(name, @klass, options)
+    # args
+    # [0] state
+    # [1] options (or nil)
+    # or
+    # [0] state
+    # [1..] state
+    def state(*args)
+      names, options = interpret_state_args(args)
+      names.each do |name|
+        @state_machine.add_state(name, klass, options)
 
-      if @klass.instance_methods.include?("#{name}?")
-        warn "#{@klass.name}: The aasm state name #{name} is already used!"
-      end
+        aasm_name = @name.to_sym
+        state = name.to_sym
 
-      @klass.class_eval <<-EORUBY, __FILE__, __LINE__ + 1
-        def #{name}?
-          aasm(:#{@name}).current_state == :#{name}
+        method_name = namespace? ? "#{namespace}_#{name}" : name
+        safely_define_method klass, "#{method_name}?", -> do
+          aasm(aasm_name).current_state == state
         end
-      EORUBY
 
-      unless @klass.const_defined?("STATE_#{name.upcase}")
-        @klass.const_set("STATE_#{name.upcase}", name)
+        const_name = namespace? ? "STATE_#{namespace.upcase}_#{name.upcase}" : "STATE_#{name.upcase}"
+        unless klass.const_defined?(const_name)
+          klass.const_set(const_name, name)
+        end
       end
     end
 
@@ -85,34 +111,65 @@ module AASM
     def event(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
+      aasm_name = @name.to_sym
+      event = name.to_sym
 
       # 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.class_eval <<-EORUBY, __FILE__, __LINE__ + 1
-        def may_#{name}?(*args)
-          aasm(:#{@name}).may_fire_event?(:#{name}, *args)
-        end
+      safely_define_method klass, "may_#{name}?", ->(*args) do
+        aasm(aasm_name).may_fire_event?(event, *args)
+      end
 
-        def #{name}!(*args, &block)
-          aasm(:#{@name}).current_event = :#{name}!
-          aasm_fire_event(:#{@name}, :#{name}, {:persist => true}, *args, &block)
-        end
+      safely_define_method klass, "#{name}!", ->(*args, &block) do
+        aasm(aasm_name).current_event = :"#{name}!"
+        aasm_fire_event(aasm_name, event, {:persist => true}, *args, &block)
+      end
+
+      safely_define_method klass, name, ->(*args, &block) do
+        aasm(aasm_name).current_event = event
+        aasm_fire_event(aasm_name, event, {:persist => false}, *args, &block)
+      end
+
+      skip_instance_level_validation(event, name, aasm_name, klass)
+
+      # Create aliases for the event methods. Keep the old names to maintain backwards compatibility.
+      if namespace?
+        klass.send(:alias_method, "may_#{name}_#{namespace}?", "may_#{name}?")
+        klass.send(:alias_method, "#{name}_#{namespace}!", "#{name}!")
+        klass.send(:alias_method, "#{name}_#{namespace}", name)
+      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 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
@@ -123,7 +180,7 @@ module AASM
 
     # aasm.event(:event_name).human?
     def human_event_name(event) # event_name?
-      AASM::Localizer.new.human_event_name(@klass, event)
+      AASM::Localizer.new.human_event_name(klass, event)
     end
 
     def states_for_select
@@ -134,6 +191,7 @@ module AASM
       if options[:transition]
         @state_machine.events[options[:transition]].transitions_to_state(state).flatten.map(&:from).flatten
       else
+
         events.map {|e| e.transitions_to_state(state)}.flatten.map(&:from).flatten
       end
     end
@@ -152,5 +210,94 @@ module AASM
       end
     end
 
+    def safely_define_method(klass, method_name, method_definition)
+      # Warn if method exists and it did not originate from an enum
+      if klass.method_defined?(method_name) &&
+         ! ( @state_machine.config.enum &&
+             klass.respond_to?(:defined_enums) &&
+             klass.defined_enums.values.any?{ |methods|
+                 methods.keys{| enum | enum + '?' == method_name }
+             })
+        unless AASM::Configuration.hide_warnings
+          @state_machine.config.logger.warn "#{klass.name}: overriding method '#{method_name}'!"
+        end
+      end
+
+      klass.send(:define_method, method_name, method_definition).tap do |sym|
+        apply_ruby2_keyword(klass, sym)
+      end
+    end
+
+    def apply_ruby2_keyword(klass, sym)
+      if RUBY_VERSION >= '2.7.1'
+        if klass.instance_method(sym).parameters.find { |type, _| type.to_s.start_with?('rest') }
+          # If there is a place where you are receiving in *args, do ruby2_keywords.
+          klass.module_eval do
+            ruby2_keywords sym
+          end
+        end
+      end
+    end
+
+    def namespace?
+      !!@state_machine.config.namespace
+    end
+
+    def namespace
+      if @state_machine.config.namespace == true
+        @name
+      else
+        @state_machine.config.namespace
+      end
+    end
+
+    def interpret_state_args(args)
+      if args.last.is_a?(Hash) && args.size == 2
+        [[args.first], args.last]
+      elsif args.size > 0
+        [args, {}]
+      else
+        raise "count not parse states: #{args}"
+      end
+    end
+
+    def skip_instance_level_validation(event, name, aasm_name, klass)
+      # Overrides the skip_validation config for an instance (If skip validation is set to false in original config) and
+      # restores it back to the original value after the event is fired.
+      safely_define_method klass, "#{name}_without_validation!", ->(*args, &block) do
+        original_config = AASM::StateMachineStore.fetch(self.class, true).machine(aasm_name).config.skip_validation_on_save
+        begin
+          AASM::StateMachineStore.fetch(self.class, true).machine(aasm_name).config.skip_validation_on_save = true unless original_config
+          aasm(aasm_name).current_event = :"#{name}!"
+          aasm_fire_event(aasm_name, event, {:persist => true}, *args, &block)
+        ensure
+          AASM::StateMachineStore.fetch(self.class, true).machine(aasm_name).config.skip_validation_on_save = original_config
+        end
+      end
+    end
+
+    def setup_timestamps(aasm_name)
+      return unless @state_machine.config.timestamps
+
+      after_all_transitions do
+        if self.class.aasm(:"#{aasm_name}").state_machine.config.timestamps
+          ts_setter = "#{aasm(aasm_name).to_state}_at="
+          respond_to?(ts_setter) && send(ts_setter, ::Time.now)
+        end
+      end
+    end
+
+    def setup_no_direct_assignment(aasm_name)
+      return unless @state_machine.config.no_direct_assignment
+
+      @klass.send(:define_method, "#{@state_machine.config.column}=") do |state_name|
+        if self.class.aasm(:"#{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(state_name)
+        end
+      end
+    end
+
   end
 end

data/lib/aasm/configuration.rb

@@ -9,15 +9,40 @@ module AASM
     # for all persistence layers: create named scopes for each state
     attr_accessor :create_scopes
 
-    # for ActiveRecord: don't store any new state if the model is invalid
+    # for ActiveRecord: when the model is invalid, true -> raise, false -> return false
+    attr_accessor :whiny_persistence
+
+    # for ActiveRecord: store the new state even if the model is invalid and return true
     attr_accessor :skip_validation_on_save
 
+    # for ActiveRecord: use transactions
+    attr_accessor :use_transactions
+
     # for ActiveRecord: use requires_new for nested transactions?
     attr_accessor :requires_new_transaction
 
+    # for ActiveRecord: use pessimistic locking
+    attr_accessor :requires_lock
+
+    # automatically set `"#{state_name}_at" = ::Time.now` on state changes
+    attr_accessor :timestamps
+
     # forbid direct assignment in aasm_state column (in ActiveRecord)
     attr_accessor :no_direct_assignment
 
+    # allow a AASM::Base sub-class to be used for state machine
+    attr_accessor :with_klass
+
     attr_accessor :enum
+
+    # namespace reader methods and constants
+    attr_accessor :namespace
+
+    # Configure a logger, with default being a Logger to STDERR
+    attr_accessor :logger
+
+    class << self
+      attr_accessor :hide_warnings
+    end
   end
-end
+end