aasm 5.0.8

data/lib/aasm/core/invokers/literal_invoker.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module AASM
+  module Core
+    module Invokers
+      ##
+      # Literal invoker which allows to use strings or symbols to call
+      # record methods as state/event/transition callbacks.
+      class LiteralInvoker < BaseInvoker
+        def may_invoke?
+          subject.is_a?(String) || subject.is_a?(Symbol)
+        end
+
+        def log_failure
+          failures << subject
+        end
+
+        def invoke_subject
+          @result = exec_subject
+        end
+
+        private
+
+        def subject_arity
+          @arity ||= record.__send__(:method, subject.to_sym).arity
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def exec_subject
+          raise(*record_error) unless record.respond_to?(subject, true)
+          return record.__send__(subject) if subject_arity.zero?
+          return record.__send__(subject, *args) if subject_arity < 0
+          record.__send__(subject, *args[0..(subject_arity - 1)])
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def record_error
+          [
+            NoMethodError,
+            'NoMethodError: undefined method ' \
+            "`#{subject}' for #{record.inspect}:#{record.class}"
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/aasm/core/invokers/proc_invoker.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module AASM
+  module Core
+    module Invokers
+      ##
+      # Proc invoker which allows to use Procs as
+      # state/event/transition callbacks.
+      class ProcInvoker < BaseInvoker
+        def may_invoke?
+          subject.is_a?(Proc)
+        end
+
+        def log_failure
+          return log_source_location if Method.method_defined?(:source_location)
+          log_proc_info
+        end
+
+        def invoke_subject
+          @result = if support_parameters?
+                      exec_proc(parameters_to_arity)
+                    else
+                      exec_proc(subject.arity)
+                    end
+        end
+
+        private
+
+        def support_parameters?
+          subject.respond_to?(:parameters)
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def exec_proc(parameters_size)
+          return record.instance_exec(&subject) if parameters_size.zero?
+          return record.instance_exec(*args, &subject) if parameters_size < 0
+          record.instance_exec(*args[0..(parameters_size - 1)], &subject)
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def log_source_location
+          failures << subject.source_location.join('#')
+        end
+
+        def log_proc_info
+          failures << subject
+        end
+
+        def parameters_to_arity
+          subject.parameters.inject(0) do |memo, parameter|
+            memo += 1
+            memo *= -1 if parameter[0] == :rest && memo > 0
+            memo
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aasm/core/state.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module AASM::Core
+  class State
+    attr_reader :name, :state_machine, :options
+
+    def initialize(name, klass, state_machine, options={})
+      @name = name
+      @klass = klass
+      @state_machine = state_machine
+      update(options)
+    end
+
+    # called internally by Ruby 1.9 after clone()
+    def initialize_copy(orig)
+      super
+      @options = {}
+      orig.options.each_pair do |name, setting|
+        @options[name] = if setting.is_a?(Hash) || setting.is_a?(Array)
+                           setting.dup
+                         else
+                           setting
+                         end
+      end
+    end
+
+    def ==(state)
+      if state.is_a? Symbol
+        name == state
+      else
+        name == state.name
+      end
+    end
+
+    def <=>(state)
+      if state.is_a? Symbol
+        name <=> state
+      else
+        name <=> state.name
+      end
+    end
+
+    def to_s
+      name.to_s
+    end
+
+    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, args)} :
+                _fire_callbacks(action, record, args)
+      end
+    end
+
+    def display_name
+      @display_name ||= begin
+        if Module.const_defined?(:I18n)
+          localized_name
+        else
+          name.to_s.gsub(/_/, ' ').capitalize
+        end
+      end
+    end
+
+    def localized_name
+      AASM::Localizer.new.human_state_name(@klass, self)
+    end
+    alias human_name localized_name
+
+    def for_select
+      [display_name, name.to_s]
+    end
+
+  private
+
+    def update(options = {})
+      if options.key?(:display) then
+        @display_name = options.delete(:display)
+      end
+      @options = options
+      self
+    end
+
+    def _fire_callbacks(action, record, args)
+      Invoker.new(action, record, args).invoke
+    end
+
+  end
+end # AASM

data/lib/aasm/core/transition.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module AASM::Core
+  class Transition
+    include DslHelper
+
+    attr_reader :from, :to, :event, :opts, :failures
+    alias_method :options, :opts
+
+    def initialize(event, opts, &block)
+      add_options_from_dsl(opts, [:on_transition, :guard, :after, :success], &block) if block
+
+      @event = event
+      @from = opts[:from]
+      @to = opts[:to]
+      @guards = Array(opts[:guards]) + Array(opts[:guard]) + Array(opts[:if])
+      @unless = Array(opts[:unless]) #TODO: This could use a better name
+      @failures = []
+
+      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
+
+      @success = Array(opts[:success])
+      @success = @success[0] if @success.size == 1
+
+      @opts = opts
+    end
+
+    # called internally by Ruby 1.9 after clone()
+    def initialize_copy(orig)
+      super
+      @guards = @guards.dup
+      @unless = @unless.dup
+      @opts   = {}
+      orig.opts.each_pair { |name, setting| @opts[name] = setting.is_a?(Hash) || setting.is_a?(Array) ? setting.dup : setting }
+    end
+
+    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)
+      invoke_callbacks_compatible_with_guard(event.state_machine.global_callbacks[:after_all_transitions], obj, args)
+      invoke_callbacks_compatible_with_guard(@after, obj, args)
+    end
+
+    def ==(obj)
+      @from == obj.from && @to == obj.to
+    end
+
+    def from?(value)
+      @from == value
+    end
+
+    def invoke_success_callbacks(obj, *args)
+      _fire_callbacks(@success, obj, args)
+    end
+
+    private
+
+    def invoke_callbacks_compatible_with_guard(code, record, args, options={})
+      if record.respond_to?(:aasm)
+        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
+
+      Invoker.new(code, record, args)
+             .with_options(options)
+             .with_failures(failures)
+             .invoke
+    end
+
+    def _fire_callbacks(code, record, args)
+      Invoker.new(code, record, args).invoke
+    end
+
+  end
+end # AASM

data/lib/aasm/dsl_helper.rb

@@ -0,0 +1,30 @@
+module DslHelper
+
+  class Proxy
+    attr_accessor :options
+
+    def initialize(options, valid_keys, source)
+      @valid_keys = valid_keys
+      @source = source
+
+      @options = options
+    end
+
+    def method_missing(name, *args, &block)
+      if @valid_keys.include?(name)
+        options[name] = Array(options[name])
+        options[name] << block if block
+        options[name] += Array(args)
+      else
+        @source.send name, *args, &block
+      end
+    end
+  end
+
+  def add_options_from_dsl(options, valid_keys, &block)
+    proxy = Proxy.new(options, valid_keys, self)
+    proxy.instance_eval(&block)
+    proxy.options
+  end
+
+end

data/lib/aasm/errors.rb

@@ -0,0 +1,21 @@
+module AASM
+
+  class UnknownStateMachineError < RuntimeError; end
+
+  class InvalidTransition < RuntimeError
+    attr_reader :object, :event_name, :originating_state, :failures, :state_machine_name
+
+    def initialize(object, event_name, state_machine_name, failures = [])
+      @object, @event_name, @originating_state, @failures = object, event_name, object.aasm(state_machine_name).current_state, failures
+      @state_machine_name = state_machine_name
+      super("Event '#{event_name}' cannot transition from '#{originating_state}'.#{reasoning}")
+    end
+
+    def reasoning
+      " Failed callback(s): #{failures}." unless failures.empty?
+    end
+  end
+
+  class UndefinedState < RuntimeError; end
+  class NoDirectAssignmentError < RuntimeError; end
+end

data/lib/aasm/instance_base.rb

@@ -0,0 +1,133 @@
+module AASM
+  class InstanceBase
+
+    attr_accessor :from_state, :to_state, :current_event
+
+    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(@name)
+    end
+
+    def current_state=(state)
+      @instance.aasm_write_state_without_persistence(state, @name)
+    end
+
+    def enter_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)
+      self.current_state = state_name
+      state_object.fire_callbacks(:after_enter, @instance)
+
+      state_name
+    end
+
+    def human_state
+      AASM::Localizer.new.human_state_name(@instance.class, state_object_for_name(current_state))
+    end
+
+    def states(options={}, *args)
+      if options.has_key?(:permitted)
+        selected_events = events({:permitted => options[:permitted]}, *args)
+        # An array of arrays. Each inner array represents the transitions that
+        # transition from the current state for an event
+        event_transitions = selected_events.map {|e| e.transitions_from_state(current_state) }
+
+        # An array of :to transition states
+        to_state_names = event_transitions.map do |transitions|
+          return nil if transitions.empty?
+
+          # Return the :to state of the first transition that is allowed (or not) or nil
+          if options[:permitted]
+            transition = transitions.find { |t| t.allowed?(@instance, *args) }
+          else
+            transition = transitions.find { |t| !t.allowed?(@instance, *args) }
+          end
+          transition ? transition.to : nil
+        end.flatten.compact.uniq
+
+        # Select states that are in to_state_names
+        @instance.class.aasm(@name).states.select {|s| to_state_names.include?(s.name)}
+      else
+        @instance.class.aasm(@name).states
+      end
+    end
+
+    def events(options={}, *args)
+      state = options[:state] || current_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.has_key?(:permitted)
+        # filters the results of events_for_current_state so that only those that
+        # are really currently possible (given transition guards) are shown.
+        if options[:permitted]
+          events.select! { |e| @instance.send("may_#{e.name}?", *args) }
+        else
+          events.select! { |e| !@instance.send("may_#{e.name}?", *args) }
+        end
+      end
+
+      events
+    end
+
+    def permitted_transitions
+      events(permitted: true).flat_map do |event|
+        available_transitions = event.transitions_from_state(current_state)
+        allowed_transitions = available_transitions.select { |t| t.allowed?(@instance) }
+
+        allowed_transitions.map do |transition|
+          { event: event.name, state: transition.to }
+        end
+      end
+    end
+
+    def state_object_for_name(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
+
+    def determine_state_name(state)
+      case state
+        when Symbol, String
+          state
+        when Proc
+          state.call(@instance)
+        else
+          raise NotImplementedError, "Unrecognized state-type given. Expected Symbol, String, or Proc."
+      end
+    end
+
+    def may_fire_event?(name, *args)
+      if event = @instance.class.aasm(@name).state_machine.events[name]
+        !!event.may_fire?(@instance, *args)
+      else
+        false # unknown event
+      end
+    end
+
+    def fire(event_name, *args, &block)
+      @instance.send(event_name, *args, &block)
+    end
+
+    def fire!(event_name, *args, &block)
+      event_name = event_name.to_s.+("!").to_sym
+      @instance.send(event_name, *args, &block)
+    end
+
+    def set_current_state_with_persistence(state)
+      save_success = @instance.aasm_write_state(state, @name)
+      self.current_state = state if save_success
+      save_success
+    end
+
+  end
+end