aasm 4.12.3 → 5.0.1

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

@@ -7,11 +7,11 @@ module AASM
 
     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}")
+      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/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

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).blank?
+          end
+        end
+      end # InstanceMethods
+    end
+  end # Persistence
+end # AASM

data/lib/aasm/persistence/plain_persistence.rb

@@ -5,7 +5,8 @@ module AASM
       # may be overwritten by persistence mixins
       def aasm_read_state(name=:default)
         # all the following lines behave like @current_state ||= aasm(name).enter_initial_state
-        current = aasm(name).instance_variable_get("@current_state_#{name}")
+        current = aasm(name).instance_variable_defined?("@current_state_#{name}") &&
+                  aasm(name).instance_variable_get("@current_state_#{name}")
         return current if current
         aasm(name).instance_variable_set("@current_state_#{name}", aasm(name).enter_initial_state)
       end

data/lib/aasm/persistence/sequel_persistence.rb

@@ -15,7 +15,6 @@ module AASM
         end
 
         def before_create
-          aasm_ensure_initial_state
           super
         end
 

data/lib/aasm/rspec/allow_event.rb

@@ -1,13 +1,17 @@
 RSpec::Matchers.define :allow_event do |event|
   match do |obj|
     @state_machine_name ||= :default
-    obj.aasm(@state_machine_name).may_fire_event?(event)
+    obj.aasm(@state_machine_name).may_fire_event?(event, *@args)
   end
 
   chain :on do |state_machine_name|
     @state_machine_name = state_machine_name
   end
 
+  chain :with do |*args|
+    @args = args
+  end
+
   description do
     "allow event #{expected} (on :#{@state_machine_name})"
   end

data/lib/aasm/rspec/allow_transition_to.rb

@@ -1,13 +1,17 @@
 RSpec::Matchers.define :allow_transition_to do |state|
   match do |obj|
     @state_machine_name ||= :default
-    obj.aasm(@state_machine_name).states(:permitted => true).include?(state)
+    obj.aasm(@state_machine_name).states({:permitted => true}, *@args).include?(state)
   end
 
   chain :on do |state_machine_name|
     @state_machine_name = state_machine_name
   end
 
+  chain :with do |*args|
+    @args = args
+  end
+
   description do
     "allow transition to #{expected} (on :#{@state_machine_name})"
   end

data/lib/aasm/version.rb

@@ -1,3 +1,3 @@
 module AASM
-  VERSION = "4.12.3"
+  VERSION = "5.0.1"
 end

data/lib/generators/nobrainer/aasm_generator.rb

@@ -0,0 +1,28 @@
+require 'rails/generators/named_base'
+require 'generators/aasm/orm_helpers'
+
+module NoBrainer
+  module Generators
+    class AASMGenerator < Rails::Generators::NamedBase
+      include AASM::Generators::OrmHelpers
+      namespace 'nobrainer:aasm'
+      argument :column_name, type: :string, default: 'aasm_state'
+
+      def generate_model
+        invoke 'nobrainer:model', [name] unless model_exists?
+      end
+
+      def inject_aasm_content
+        inject_into_file model_path, model_contents, after: "include NoBrainer::Document::Timestamps\n" if model_exists?
+      end
+
+      def inject_field_types
+        inject_into_file model_path, migration_data, after: "include NoBrainer::Document::Timestamps\n" if model_exists?
+      end
+
+      def migration_data
+        "  field :#{column_name}"
+      end
+    end
+  end
+end

data/lib/motion-aasm.rb

@@ -16,6 +16,7 @@ exclude_files = [
   'aasm/persistence/active_record_persistence.rb',
   'aasm/persistence/dynamoid_persistence.rb',
   'aasm/persistence/mongoid_persistence.rb',
+  'aasm/persistence/no_brainer_persistence.rb',
   'aasm/persistence/sequel_persistence.rb',
   'aasm/persistence/redis_persistence.rb'
 ]

data/spec/database.rb

@@ -11,6 +11,9 @@ ActiveRecord::Migration.suppress_messages do
   ActiveRecord::Migration.create_table "multiple_simple_new_dsls", :force => true do |t|
     t.string "status"
   end
+  ActiveRecord::Migration.create_table "implemented_abstract_class_dsls", :force => true do |t|
+    t.string "status"
+  end
 
   ActiveRecord::Migration.create_table "complex_active_record_examples", :force => true do |t|
     t.string "left"