aasm 4.12.3 → 5.1.1

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module AASM
+  module Core
+    module Invokers
+      ##
+      # Base concrete invoker class which contain basic
+      # invoking and logging definitions
+      class BaseInvoker
+        attr_reader :failures, :subject, :record, :args, :result
+
+        ##
+        # Initialize a new concrete invoker instance.
+        # NOTE that concrete invoker must be used per-subject/record
+        #      (one instance per subject/record)
+        #
+        # ==Options:
+        #
+        # +subject+ - invoking subject comparable with this invoker
+        # +record+  - invoking record
+        # +args+    - arguments which will be passed to the callback
+
+        def initialize(subject, record, args)
+          @subject = subject
+          @record = record
+          @args = args
+          @result = false
+          @failures = []
+        end
+
+        ##
+        # Collect failures to a specified buffer
+        #
+        # ==Options:
+        #
+        # +failures+ - failures buffer to collect failures
+
+        def with_failures(failures_buffer)
+          @failures = failures_buffer
+          self
+        end
+
+        ##
+        # Execute concrete invoker, log the error and return result
+
+        def invoke
+          return unless may_invoke?
+          log_failure unless invoke_subject
+          result
+        end
+
+        ##
+        # Check if concrete invoker may be invoked for a specified subject
+
+        def may_invoke?
+          raise NoMethodError, '"#may_invoke?" is not implemented'
+        end
+
+        ##
+        # Log failed invoking
+
+        def log_failure
+          raise NoMethodError, '"#log_failure" is not implemented'
+        end
+
+        ##
+        # Execute concrete invoker
+
+        def invoke_subject
+          raise NoMethodError, '"#invoke_subject" is not implemented'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module AASM
+  module Core
+    module Invokers
+      ##
+      # Class invoker which allows to use classes which respond to #call
+      # to be used as state/event/transition callbacks.
+      class ClassInvoker < BaseInvoker
+        def may_invoke?
+          subject.is_a?(Class) && subject.instance_methods.include?(:call)
+        end
+
+        def log_failure
+          return log_source_location if Method.method_defined?(:source_location)
+          log_method_info
+        end
+
+        def invoke_subject
+          @result = retrieve_instance.call
+        end
+
+        private
+
+        def log_source_location
+          failures << instance.method(:call).source_location.join('#')
+        end
+
+        def log_method_info
+          failures << instance.method(:call)
+        end
+
+        def instance
+          @instance ||= retrieve_instance
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def retrieve_instance
+          return subject.new if subject_arity.zero?
+          return subject.new(record) if subject_arity == 1
+          return subject.new(record, *args) if subject_arity < 0
+          subject.new(record, *args[0..(subject_arity - 2)])
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def subject_arity
+          @arity ||= subject.instance_method(:initialize).arity
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AASM::Core
   class State
     attr_reader :name, :state_machine, :options
@@ -13,7 +15,13 @@ module AASM::Core
     def initialize_copy(orig)
       super
       @options = {}
-      orig.options.each_pair { |name, setting| @options[name] = setting.is_a?(Hash) || setting.is_a?(Array) ? setting.dup : setting }
+      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)
@@ -75,14 +83,7 @@ module AASM::Core
     end
 
     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]))
-        when Proc
-          arity = action.arity
-          action.call(record, *(arity < 0 ? args : args[0...arity]))
-      end
+      Invoker.new(action, record, args).invoke
     end
 
   end

data/lib/aasm/core/transition.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AASM::Core
   class Transition
     include DslHelper
@@ -67,77 +69,14 @@ module AASM::Core
         record.aasm(event.state_machine.name).to_state = @to if record.aasm(event.state_machine.name).respond_to?(:to_state=)
       end
 
-      case code
-      when Symbol, String
-        result = (record.__send__(:method, code.to_sym).arity == 0 ? record.__send__(code) : record.__send__(code, *args))
-        failures << code unless result
-        result
-      when Proc
-        if code.respond_to?(:parameters)
-          # In Ruby's Proc, the 'arity' method is not a good condidate to know if
-          # we should pass the arguments or not, since it does return 0 even in
-          # presence of optional parameters.
-          result = (code.parameters.size == 0 ? record.instance_exec(&code) : record.instance_exec(*args, &code))
-
-          failures << code.source_location.join('#') unless result
-        else
-          # In RubyMotion's Proc, the 'parameter' method does not exists, however its
-          # 'arity' method works just like the one from Method, only returning 0 when
-          # there is no parameters whatsoever, optional or not.
-          result = (code.arity == 0 ? record.instance_exec(&code) : record.instance_exec(*args, &code))
-
-          # Sadly, RubyMotion's Proc does not define the method 'source_location' either.
-          failures << code unless result
-        end
-
-        result
-      when Class
-        arity = code.instance_method(:initialize).arity
-        if arity == 0
-          instance = code.new
-        elsif arity == 1
-          instance = code.new(record)
-        else
-          instance = code.new(record, *args)
-        end
-        result = instance.call
-
-        if Method.method_defined?(:source_location)
-          failures << instance.method(:call).source_location.join('#') unless result
-        else
-          # RubyMotion support ('source_location' not defined for Method)
-          failures << instance.method(:call) unless result
-        end
-
-        result
-      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
+      Invoker.new(code, record, args)
+             .with_options(options)
+             .with_failures(failures)
+             .invoke
     end
 
     def _fire_callbacks(code, record, args)
-      case code
-        when Symbol, String
-          arity = record.send(:method, code.to_sym).arity
-          record.send(code, *(arity < 0 ? args : args[0...arity]))
-        when Proc
-          code.arity == 0 ? record.instance_exec(&code) : record.instance_exec(*args, &code)
-        when Array
-          code.map {|a| _fire_callbacks(a, record, args)}
-        else
-          true
-      end
+      Invoker.new(code, record, args).invoke
     end
 
   end

data/lib/aasm/errors.rb

@@ -3,15 +3,16 @@ module AASM
   class UnknownStateMachineError < RuntimeError; end
 
   class InvalidTransition < RuntimeError
-    attr_reader :object, :event_name, :originating_state, :failures
+    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
-      super("Event '#{event_name}' cannot transition from '#{originating_state}'. #{reasoning}")
+      @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?
+      " Failed callback(s): #{failures}." unless failures.empty?
     end
   end
 

data/lib/aasm/instance_base.rb

@@ -28,7 +28,7 @@ module AASM
     end
 
     def human_state
-      AASM::Localizer.new.human_state_name(@instance.class, state_object_for_name(current_state))
+      state_object_for_name(current_state).display_name
     end
 
     def states(options={}, *args)
@@ -78,6 +78,17 @@ module AASM
       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?
@@ -91,7 +102,7 @@ module AASM
         when Proc
           state.call(@instance)
         else
-          raise NotImplementedError, "Unrecognized state-type given.  Expected Symbol, String, or Proc."
+          raise NotImplementedError, "Unrecognized state-type given. Expected Symbol, String, or Proc."
       end
     end
 
@@ -104,11 +115,12 @@ module AASM
     end
 
     def fire(event_name, *args, &block)
-      @instance.send(:aasm_fire_event, @name, event_name, {persist: false}, *args, &block)
+      @instance.send(event_name, *args, &block)
     end
 
     def fire!(event_name, *args, &block)
-      @instance.send(:aasm_fire_event, @name, event_name, {persist: true}, *args, &block)
+      event_name = event_name.to_s.+("!").to_sym
+      @instance.send(event_name, *args, &block)
     end
 
     def set_current_state_with_persistence(state)

data/lib/aasm/persistence.rb

@@ -12,6 +12,9 @@ module AASM
         elsif hierarchy.include?("Mongoid::Document")
           require_persistence :mongoid
           include_persistence base, :mongoid
+        elsif hierarchy.include?("NoBrainer::Document")
+          require_persistence :no_brainer
+          include_persistence base, :no_brainer
         elsif hierarchy.include?("Sequel::Model")
           require_persistence :sequel
           include_persistence base, :sequel

data/lib/aasm/persistence/active_record_persistence.rb

@@ -41,14 +41,15 @@ module AASM
 
       module ClassMethods
         def aasm_create_scope(state_machine_name, scope_name)
-          conditions = {
-            table_name => { aasm(state_machine_name).attribute_name => scope_name.to_s }
-          }
           if ActiveRecord::VERSION::MAJOR >= 3
+            conditions = { aasm(state_machine_name).attribute_name => scope_name.to_s }
             class_eval do
-              scope scope_name, lambda { where(conditions) }
+              scope scope_name, lambda { where(table_name => conditions) }
             end
           else
+            conditions = {
+              table_name => { aasm(state_machine_name).attribute_name => scope_name.to_s }
+            }
             class_eval do
               named_scope scope_name, :conditions => conditions
             end
@@ -60,6 +61,24 @@ module AASM
 
         private
 
+        def aasm_execute_after_commit
+          begin
+            require 'after_commit_everywhere'
+            raise LoadError unless Gem::Version.new(::AfterCommitEverywhere::VERSION) >= Gem::Version.new('0.1.5')
+
+            self.extend ::AfterCommitEverywhere
+            after_commit do
+              yield
+            end
+          rescue LoadError
+            warn <<-MSG
+  [DEPRECATION] :after_commit AASM callback is not safe in terms of race conditions and redundant calls.
+                Please add `gem 'after_commit_everywhere', '~> 0.1', '>= 0.1.5'` to your Gemfile in order to fix that.
+            MSG
+            yield
+          end
+        end
+
         def aasm_raise_invalid_record
           raise ActiveRecord::RecordInvalid.new(self)
         end
@@ -140,7 +159,8 @@ module AASM
 
         def aasm_column_is_blank?(state_machine_name)
           attribute_name = self.class.aasm(state_machine_name).attribute_name
-          attribute_names.include?(attribute_name.to_s) && send(attribute_name).blank?
+          attribute_names.include?(attribute_name.to_s) &&
+            (send(attribute_name).respond_to?(:empty?) ? !!send(attribute_name).empty? : !send(attribute_name))
         end
 
         def aasm_validate_states