aasm 4.12.2 → 5.5.0

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,11 +1,14 @@
+# frozen_string_literal: true
+
 module AASM::Core
   class State
-    attr_reader :name, :state_machine, :options
+    attr_reader :name, :state_machine, :options, :default_display_name
 
     def initialize(name, klass, state_machine, options={})
       @name = name
       @klass = klass
       @state_machine = state_machine
+      @default_display_name = name.to_s.gsub(/_/, ' ').capitalize
       update(options)
     end
 
@@ -13,7 +16,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)
@@ -46,11 +55,11 @@ module AASM::Core
     end
 
     def display_name
-      @display_name ||= begin
+      @display_name = begin
         if Module.const_defined?(:I18n)
           localized_name
         else
-          name.to_s.gsub(/_/, ' ').capitalize
+          @default_display_name
         end
       end
     end
@@ -67,22 +76,15 @@ module AASM::Core
   private
 
     def update(options = {})
-      if options.key?(:display) then
-        @display_name = options.delete(:display)
+      if options.key?(:display)
+        @default_display_name = options.delete(:display)
       end
       @options = options
       self
     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,6 +1,8 @@
+# frozen_string_literal: true
+
 module AASM::Core
   class Transition
-    include DslHelper
+    include AASM::DslHelper
 
     attr_reader :from, :to, :event, :opts, :failures
     alias_method :options, :opts
@@ -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/dsl_helper.rb

@@ -1,30 +1,32 @@
-module DslHelper
+module AASM
+  module DslHelper
 
-  class Proxy
-    attr_accessor :options
+    class Proxy
+      attr_accessor :options
 
-    def initialize(options, valid_keys, source)
-      @valid_keys = valid_keys
-      @source = source
+      def initialize(options, valid_keys, source)
+        @valid_keys = valid_keys
+        @source = source
 
-      @options = options
-    end
+        @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
+      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
-  end
 
-  def add_options_from_dsl(options, valid_keys, &block)
-    proxy = Proxy.new(options, valid_keys, self)
-    proxy.instance_eval(&block)
-    proxy.options
-  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
+  end
+end

data/lib/aasm/errors.rb

@@ -3,18 +3,20 @@ 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
 
   class UndefinedState < RuntimeError; end
+  class UndefinedEvent < UndefinedState; end
   class NoDirectAssignmentError < RuntimeError; end
 end

data/lib/aasm/instance_base.rb

@@ -1,6 +1,5 @@
 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
@@ -28,7 +27,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 +77,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 +101,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
 
@@ -103,11 +113,32 @@ module AASM
       end
     end
 
+    def fire(event_name, *args, &block)
+      event_exists?(event_name)
+
+      @instance.send(event_name, *args, &block)
+    end
+
+    def fire!(event_name, *args, &block)
+      event_exists?(event_name, true)
+      bang_event_name = "#{event_name}!".to_sym
+      @instance.send(bang_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
 
+    private
+
+    def event_exists?(event_name, bang = false)
+      event = @instance.class.aasm(@name).state_machine.events[event_name.to_sym]
+      return true if event
+
+      event_error = bang ? "#{event_name}!" : event_name
+      raise AASM::UndefinedEvent, "Event :#{event_error} doesn't exist" if event.nil?
+    end
   end
 end

data/lib/aasm/localizer.rb

@@ -5,7 +5,7 @@ module AASM
         list << :"#{i18n_scope(klass)}.events.#{i18n_klass(ancestor)}.#{event}"
         list
       end
-      translate_queue(checklist) || I18n.translate(checklist.shift, :default => event.to_s.humanize)
+      translate_queue(checklist) || I18n.translate(checklist.shift, :default => default_display_name(event))
     end
 
     def human_state_name(klass, state)
@@ -14,7 +14,7 @@ module AASM
         list << item_for(klass, state, ancestor, :old_style => true)
         list
       end
-      translate_queue(checklist) || I18n.translate(checklist.shift, :default => state.to_s.humanize)
+      translate_queue(checklist) || I18n.translate(checklist.shift, :default => default_display_name(state))
     end
 
   private
@@ -46,8 +46,18 @@ module AASM
     end
 
     def ancestors_list(klass)
+      has_active_record_base = defined?(::ActiveRecord::Base)
       klass.ancestors.select do |ancestor|
-        ancestor.respond_to?(:model_name) unless ancestor.name == 'ActiveRecord::Base'
+        not_active_record_base = has_active_record_base ? (ancestor != ::ActiveRecord::Base) : true
+        ancestor.respond_to?(:model_name) && not_active_record_base
+      end
+    end
+
+    def default_display_name(object) # Can use better arguement name
+      if object.respond_to?(:default_display_name)
+        object.default_display_name
+      else
+        object.to_s.gsub(/_/, ' ').capitalize
       end
     end
   end

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', '~> 1.0'` 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

data/lib/aasm/persistence/base.rb

@@ -34,7 +34,7 @@ module AASM
       # This allows for nil aasm states - be sure to add validation to your model
       def aasm_read_state(name=:default)
         state = send(self.class.aasm(name).attribute_name)
-        if state.blank?
+        if !state || state.empty?
           aasm_new_record? ? aasm(name).determine_state_name(self.class.aasm(name).initial_state) : nil
         else
           state.to_sym
@@ -59,7 +59,9 @@ module AASM
     # make sure to create a (named) scope for each state
     def state_with_scope(*args)
       names = state_without_scope(*args)
-      names.each { |name| create_scope(name) if create_scope?(name) }
+      names.each do |name|
+        create_scopes(name)
+      end
     end
     alias_method :state_without_scope, :state
     alias_method :state, :state_with_scope
@@ -71,7 +73,16 @@ module AASM
     end
 
     def create_scope(name)
-      @klass.aasm_create_scope(@name, name)
+      @klass.aasm_create_scope(@name, name) if create_scope?(name)
+    end
+
+    def create_scopes(name)
+      if namespace?
+        # Create default scopes even when namespace? for backward compatibility
+        namepaced_name = "#{namespace}_#{name}"
+        create_scope(namepaced_name)
+      end
+      create_scope(name)
     end
   end # Base
 

data/lib/aasm/persistence/core_data_query_persistence.rb

@@ -77,7 +77,8 @@ module AASM
         #
         def aasm_ensure_initial_state
           AASM::StateMachineStore.fetch(self.class, true).machine_names.each do |state_machine_name|
-            send("#{self.class.aasm(state_machine_name).attribute_name}=", aasm(state_machine_name).enter_initial_state.to_s) if send(self.class.aasm(state_machine_name).attribute_name).blank?
+            next if !send(self.class.aasm(state_machine_name).attribute_name) || send(self.class.aasm(state_machine_name).attribute_name).empty?
+            send("#{self.class.aasm(state_machine_name).attribute_name}=", aasm(state_machine_name).enter_initial_state.to_s)
           end
         end
       end # InstanceMethods

data/lib/aasm/persistence/dynamoid_persistence.rb

@@ -83,7 +83,7 @@ module AASM
         #
         def aasm_ensure_initial_state
           AASM::StateMachineStore.fetch(self.class, true).machine_names.each do |state_machine_name|
-            aasm(state_machine_name).enter_initial_state if send(self.class.aasm(state_machine_name).attribute_name).blank?
+            aasm(state_machine_name).enter_initial_state if !send(self.class.aasm(state_machine_name).attribute_name) || send(self.class.aasm(state_machine_name).attribute_name).empty?
           end
         end
       end # InstanceMethods

data/lib/aasm/persistence/mongoid_persistence.rb

@@ -106,7 +106,7 @@ module AASM
             # mongoid has_many relationship does not load child object attributes when
             # only ids are loaded, for example parent.child_ids will not load child object attributes.
             # This feature is introduced in mongoid > 4.
-            if attribute_names.include?(attribute_name) && attributes[attribute_name].blank?
+            if attribute_names.include?(attribute_name) && !attributes[attribute_name] || attributes[attribute_name].empty?
               # attribute_missing? is defined in mongoid > 4
               return if Mongoid::VERSION.to_f >= 4 && attribute_missing?(attribute_name)
               send("#{self.class.aasm(state_machine_name).attribute_name}=", aasm(state_machine_name).enter_initial_state.to_s)

data/lib/aasm/persistence/no_brainer_persistence.rb

@@ -0,0 +1,105 @@
+require 'aasm/persistence/orm'
+module AASM
+  module Persistence
+    module NoBrainerPersistence
+      # This method:
+      #
+      # * extends the model with ClassMethods
+      # * includes InstanceMethods
+      #
+      # Adds
+      #
+      #   before_validation :aasm_ensure_initial_state
+      #
+      # As a result, it doesn't matter when you define your methods - the following 2 are equivalent
+      #
+      #   class Foo
+      #     include NoBrainer::Document
+      #     def aasm_write_state(state)
+      #       "bar"
+      #     end
+      #     include AASM
+      #   end
+      #
+      #   class Foo
+      #     include NoBrainer::Document
+      #     include AASM
+      #     def aasm_write_state(state)
+      #       "bar"
+      #     end
+      #   end
+      #
+      def self.included(base)
+        base.send(:include, AASM::Persistence::Base)
+        base.send(:include, AASM::Persistence::ORM)
+        base.send(:include, AASM::Persistence::NoBrainerPersistence::InstanceMethods)
+        base.extend AASM::Persistence::NoBrainerPersistence::ClassMethods
+
+        base.after_initialize :aasm_ensure_initial_state
+      end
+
+      module ClassMethods
+        def aasm_create_scope(state_machine_name, scope_name)
+          scope_options = lambda {
+            where(aasm(state_machine_name).attribute_name.to_sym => scope_name.to_s)
+          }
+          send(:scope, scope_name, scope_options)
+        end
+      end
+
+      module InstanceMethods
+
+        private
+
+        def aasm_save
+          self.save
+        end
+
+        def aasm_raise_invalid_record
+          raise NoBrainer::Error::DocumentInvalid.new(self)
+        end
+
+        def aasm_supports_transactions?
+          false
+        end
+
+        def aasm_update_column(attribute_name, value)
+          write_attribute(attribute_name, value)
+          save(validate: false)
+
+          true
+        end
+
+        def aasm_read_attribute(name)
+          read_attribute(name)
+        end
+
+        def aasm_write_attribute(name, value)
+          write_attribute(name, value)
+        end
+
+        # Ensures that if the aasm_state column is nil and the record is new
+        # that the initial state gets populated before validation on create
+        #
+        #   foo = Foo.new
+        #   foo.aasm_state # => nil
+        #   foo.valid?
+        #   foo.aasm_state # => "open" (where :open is the initial state)
+        #
+        #
+        #   foo = Foo.find(:first)
+        #   foo.aasm_state # => 1
+        #   foo.aasm_state = nil
+        #   foo.valid?
+        #   foo.aasm_state # => nil
+        #
+        def aasm_ensure_initial_state
+          AASM::StateMachineStore.fetch(self.class, true).machine_names.each do |name|
+            aasm_column = self.class.aasm(name).attribute_name
+            aasm(name).enter_initial_state if !read_attribute(aasm_column) || read_attribute(aasm_column).empty?
+          end
+        end
+      end # InstanceMethods
+    end
+  end # Persistence
+end # AASM