aasm 4.9.0 → 4.10.0

data/lib/aasm/core/event.rb

@@ -8,6 +8,7 @@ module AASM::Core
       @name = name
       @state_machine = state_machine
       @transitions = []
+      @valid_transitions = {}
       @guards = Array(options[:guard] || options[:guards] || options[:if])
       @unless = Array(options[:unless]) #TODO: This could use a better name
 
@@ -62,6 +63,12 @@ module AASM::Core
       invoke_callbacks(@options[callback_name], record, args)
     end
 
+    def fire_transition_callbacks(obj, *args)
+      from_state = obj.aasm(state_machine.name).current_state
+      transition = @valid_transitions[from_state]
+      @valid_transitions[from_state].invoke_success_callbacks(obj, *args) if transition
+    end
+
     def ==(event)
       if event.is_a? Symbol
         name == event
@@ -103,7 +110,6 @@ module AASM::Core
       definitions
     end
 
-    # Execute if test == false, otherwise return true/false depending on whether it would fire
     def _fire(obj, options={}, to_state=nil, *args)
       result = options[:test_only] ? false : nil
       if @transitions.map(&:from).any?
@@ -130,6 +136,7 @@ module AASM::Core
           if options[:test_only]
             # result = true
           else
+            Array(transition.to).each {|to| @valid_transitions[to] = transition }
             transition.execute(obj, *args)
           end
 

data/lib/aasm/core/transition.rb

@@ -6,7 +6,7 @@ module AASM::Core
     alias_method :options, :opts
 
     def initialize(event, opts, &block)
-      add_options_from_dsl(opts, [:on_transition, :guard, :after], &block) if block
+      add_options_from_dsl(opts, [:on_transition, :guard, :after, :success], &block) if block
 
       @event = event
       @from = opts[:from]
@@ -22,6 +22,9 @@ module AASM::Core
       @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
 
@@ -43,6 +46,10 @@ module AASM::Core
       @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={})
@@ -53,13 +60,13 @@ module AASM::Core
 
       case code
       when Symbol, String
-        result = (record.__send__(:method, code.to_sym).arity == 0 ? record.__send__(code) : result = record.__send__(code, *args))
+        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 its does return 0 even in
+          # 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))
 
@@ -85,7 +92,14 @@ module AASM::Core
           instance = code.new(record, *args)
         end
         result = instance.call
-        failures << instance.method(:call).source_location.join('#') unless result
+
+        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]
@@ -103,5 +117,19 @@ module AASM::Core
       end
     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
+          @success.map {|a| _fire_callbacks(a, obj, args)}
+        else
+          true
+      end
+    end
+
   end
 end # AASM

data/lib/aasm/errors.rb

@@ -3,18 +3,18 @@ module AASM
   class UnknownStateMachineError < RuntimeError; end
 
   class InvalidTransition < RuntimeError
-    attr_reader :object, :event_name, :state_machine_name, :failures
+    attr_reader :object, :event_name, :originating_state, :failures
 
     def initialize(object, event_name, state_machine_name, failures = [])
-      @object, @event_name, @state_machine_name, @failures = object, event_name, state_machine_name, failures
+      @object, @event_name, @originating_state, @failures = object, event_name, object.aasm(state_machine_name).current_state, failures
     end
 
     def message
-      "Event '#{event_name}' cannot transition from '#{object.aasm(state_machine_name).current_state}'. #{reasoning}"
+      "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

@@ -7,15 +7,25 @@ module AASM
         hierarchy = base.ancestors.map {|klass| klass.to_s}
 
         if hierarchy.include?("ActiveRecord::Base")
+          require_persistence :active_record
           include_persistence base, :active_record
         elsif hierarchy.include?("Mongoid::Document")
+          require_persistence :mongoid
           include_persistence base, :mongoid
         elsif hierarchy.include?("MongoMapper::Document")
+          require_persistence :mongo_mapper
           include_persistence base, :mongo_mapper
         elsif hierarchy.include?("Sequel::Model")
+          require_persistence :sequel
           include_persistence base, :sequel
         elsif hierarchy.include?("Dynamoid::Document")
+          require_persistence :dynamoid
           include_persistence base, :dynamoid
+        elsif hierarchy.include?("Redis::Objects")
+          require_persistence :redis
+          include_persistence base, :redis
+        elsif hierarchy.include?("CDQManagedObject")
+          include_persistence base, :core_data_query
         else
           include_persistence base, :plain
         end
@@ -23,8 +33,11 @@ module AASM
 
       private
 
-      def include_persistence(base, type)
+      def require_persistence(type)
         require File.join(File.dirname(__FILE__), 'persistence', "#{type}_persistence")
+      end
+
+      def include_persistence(base, type)
         base.send(:include, constantize("#{capitalize(type)}Persistence"))
       end
 

data/lib/aasm/persistence/active_record_persistence.rb

@@ -1,5 +1,3 @@
-require_relative 'base'
-
 module AASM
   module Persistence
     module ActiveRecordPersistence
@@ -31,15 +29,31 @@ module AASM
       def self.included(base)
         base.send(:include, AASM::Persistence::Base)
         base.send(:include, AASM::Persistence::ActiveRecordPersistence::InstanceMethods)
+        base.extend AASM::Persistence::ActiveRecordPersistence::ClassMethods
 
-        base.after_initialize do
-          aasm_ensure_initial_state
-        end
+        base.after_initialize :aasm_ensure_initial_state
 
         # ensure state is in the list of states
         base.validate :aasm_validate_states
       end
 
+      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
+            class_eval do
+              scope scope_name, lambda { where(conditions) }
+            end
+          else
+            class_eval do
+              named_scope scope_name, :conditions => conditions
+            end
+          end
+        end
+      end
+
       module InstanceMethods
 
         # Writes <tt>state</tt> to the state column and persists it to the database
@@ -93,11 +107,11 @@ module AASM
         end
 
         def aasm_enum(name=:default)
-          case AASM::StateMachine[self.class][name].config.enum
+          case AASM::StateMachineStore.fetch(self.class, true).machine(name).config.enum
             when false then nil
             when true then aasm_guess_enum_method(name)
             when nil then aasm_guess_enum_method(name) if aasm_column_looks_like_enum(name)
-            else AASM::StateMachine[self.class][name].config.enum
+            else AASM::StateMachineStore.fetch(self.class, true).machine(name).config.enum
           end
         end
 
@@ -113,7 +127,7 @@ module AASM
         end
 
         def aasm_skipping_validations(state_machine_name)
-          AASM::StateMachine[self.class][state_machine_name].config.skip_validation_on_save
+          AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.skip_validation_on_save
         end
 
         def aasm_write_attribute(state, name=:default)
@@ -142,7 +156,7 @@ module AASM
         #   foo.aasm_state # => nil
         #
         def aasm_ensure_initial_state
-          AASM::StateMachine[self.class].keys.each do |state_machine_name|
+          AASM::StateMachineStore.fetch(self.class, true).machine_names.each do |state_machine_name|
             # checking via respond_to? does not work in Rails <= 3
             # if respond_to?(self.class.aasm(state_machine_name).attribute_name) && send(self.class.aasm(state_machine_name).attribute_name).blank? # Rails 4
             if aasm_column_is_blank?(state_machine_name)
@@ -189,18 +203,18 @@ module AASM
         end
 
         def requires_new?(state_machine_name)
-          AASM::StateMachine[self.class][state_machine_name].config.requires_new_transaction
+          AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.requires_new_transaction
         end
 
         def requires_lock?(state_machine_name)
-          AASM::StateMachine[self.class][state_machine_name].config.requires_lock
+          AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.requires_lock
         end
 
         def aasm_validate_states
-          AASM::StateMachine[self.class].keys.each do |state_machine_name|
+          AASM::StateMachineStore.fetch(self.class, true).machine_names.each do |state_machine_name|
             unless aasm_skipping_validations(state_machine_name)
               if aasm_invalid_state?(state_machine_name)
-                self.errors.add(AASM::StateMachine[self.class][state_machine_name].config.column , "is invalid")
+                self.errors.add(AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.column , "is invalid")
               end
             end
           end

data/lib/aasm/persistence/base.rb

@@ -63,53 +63,11 @@ module AASM
     private
 
     def create_scope?(name)
-      @state_machine.config.create_scopes && !@klass.respond_to?(name)
+      @state_machine.config.create_scopes && !@klass.respond_to?(name) && @klass.respond_to?(:aasm_create_scope)
     end
 
     def create_scope(name)
-      if ancestors_include?("ActiveRecord::Base")
-        create_for_active_record(name)
-      elsif ancestors_include?("Mongoid::Document")
-        create_for_mongoid(name)
-      elsif ancestors_include?("MongoMapper::Document")
-        create_for_mongomapper(name)
-      end
-    end
-
-    def ancestors_include?(class_name)
-      @klass.ancestors.map { |klass| klass.to_s }.include?(class_name)
-    end
-
-    def create_for_active_record(name)
-      conditions = {
-        @klass.table_name => { @klass.aasm(@name).attribute_name => name.to_s }
-      }
-      if ActiveRecord::VERSION::MAJOR >= 3
-        @klass.class_eval do
-          scope name, lambda { where(conditions) }
-        end
-      else
-        @klass.class_eval do
-          named_scope name, :conditions => conditions
-        end
-      end
-    end
-
-    def create_for_mongoid(name)
-      klass = @klass
-      state_machine_name = @name
-      scope_options = lambda {
-        klass.send(
-          :where,
-          { klass.aasm(state_machine_name).attribute_name.to_sym => name.to_s }
-        )
-      }
-      @klass.send(:scope, name, scope_options)
-    end
-
-    def create_for_mongomapper(name)
-      conditions = { @klass.aasm(@name).attribute_name.to_sym => name.to_s }
-      @klass.scope(name, lambda { @klass.where(conditions) })
+      @klass.aasm_create_scope(@name, name)
     end
   end # Base
 

data/lib/aasm/persistence/core_data_query_persistence.rb

@@ -0,0 +1,93 @@
+module AASM
+  module Persistence
+    module CoreDataQueryPersistence
+      # This method:
+      #
+      # * extends the model with ClassMethods
+      # * includes InstanceMethods
+      #
+      # Adds
+      #
+      #   after_initialize :aasm_ensure_initial_state
+      #
+
+      def self.included(base)
+        base.send(:include, AASM::Persistence::Base)
+        base.send(:include, AASM::Persistence::CoreDataQueryPersistence::InstanceMethods)
+        base.extend AASM::Persistence::CoreDataQueryPersistence::ClassMethods
+
+        base.after_initialize :aasm_ensure_initial_state
+      end
+
+      module ClassMethods
+        def aasm_create_scope(state_machine_name, scope_name)
+          scope(scope_name.to_sym, lambda { where(aasm(state_machine_name).attribute_name.to_sym).eq(scope_name.to_s) })
+        end
+      end
+
+      module InstanceMethods
+
+        # Writes <tt>state</tt> to the state column and persists it to the database
+        # using update_attribute (which bypasses validation)
+        #
+        #   foo = Foo.find(1)
+        #   foo.aasm.current_state # => :opened
+        #   foo.close!
+        #   foo.aasm.current_state # => :closed
+        #   Foo.find(1).aasm.current_state # => :closed
+        #
+        # NOTE: intended to be called from an event
+        def aasm_write_state(state, name=:default)
+          raise "Cowardly refusing to save the current CoreDataQuery context"
+          aasm_write_state_without_persistence(state, name)
+        end
+
+        # Writes <tt>state</tt> to the state column, but does not persist it to the database
+        #
+        #   foo = Foo.find(1)
+        #   foo.aasm.current_state # => :opened
+        #   foo.close
+        #   foo.aasm.current_state # => :closed
+        #   Foo.find(1).aasm.current_state # => :opened
+        #   foo.save
+        #   foo.aasm.current_state # => :closed
+        #   Foo.find(1).aasm.current_state # => :closed
+        #
+        # NOTE: intended to be called from an event
+        def aasm_write_state_without_persistence(state, name=:default)
+          write_attribute(self.class.aasm(name).attribute_name, state.to_s)
+        end
+
+      private
+
+        # 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 |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?
+          end
+        end
+      end # InstanceMethods
+
+      # module NamedScopeMethods
+      #   def aasm_state_with_named_scope name, options = {}
+      #     aasm_state_without_named_scope name, options
+      #     self.named_scope name, :conditions => { "#{table_name}.#{self.aasm.attribute_name}" => name.to_s} unless self.respond_to?(name)
+      #   end
+      # end
+    end
+  end # Persistence
+end # AASM

data/lib/aasm/persistence/dynamoid_persistence.rb

@@ -1,5 +1,3 @@
-require_relative 'base'
-
 module AASM
   module Persistence
     module DynamoidPersistence
@@ -16,7 +14,7 @@ module AASM
         #
         base.class_eval %Q(
           def method_missing(method_name, *arguments, &block)
-            if (AASM::StateMachine[self.class].keys.map { |state_machine_name| self.class.aasm(state_machine_name).attribute_name.to_s + "=" }).include? method_name.to_s
+            if (AASM::StateMachineStore.fetch(self.class, true).machine_names.map { |state_machine_name| self.class.aasm(state_machine_name).attribute_name.to_s + "=" }).include? method_name.to_s
               attribute_name = method_name.to_s.gsub("=", '')
               write_attribute(attribute_name.to_sym, *arguments)
             else
@@ -84,7 +82,7 @@ module AASM
         #   foo.aasm_state # => nil
         #
         def aasm_ensure_initial_state
-          AASM::StateMachine[self.class].keys.each do |state_machine_name|
+          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?
           end
         end

data/lib/aasm/persistence/mongo_mapper_persistence.rb

@@ -1,5 +1,3 @@
-require_relative 'base'
-
 module AASM
   module Persistence
     module MongoMapperPersistence
@@ -33,6 +31,7 @@ module AASM
       def self.included(base)
         base.send(:include, AASM::Persistence::Base)
         base.send(:include, AASM::Persistence::MongoMapperPersistence::InstanceMethods)
+        base.extend AASM::Persistence::MongoMapperPersistence::ClassMethods
 
         base.before_create :aasm_ensure_initial_state
 
@@ -40,6 +39,13 @@ module AASM
         base.validate :aasm_validate_states
       end
 
+      module ClassMethods
+        def aasm_create_scope(state_machine_name, scope_name)
+          conditions = { aasm(state_machine_name).attribute_name.to_sym => scope_name.to_s }
+          scope(scope_name, lambda { where(conditions) })
+        end
+      end
+
       module InstanceMethods
 
         # Writes <tt>state</tt> to the state column and persists it to the database
@@ -87,11 +93,11 @@ module AASM
 
         private
         def aasm_enum(name=:default)
-          case AASM::StateMachine[self.class][name].config.enum
+          case AASM::StateMachineStore.fetch(self.class, true).machine(name).config.enum
           when false then nil
           when true then aasm_guess_enum_method(name)
           when nil then aasm_guess_enum_method(name) if aasm_column_looks_like_enum(name)
-          else AASM::StateMachine[self.class][name].config.enum
+          else AASM::StateMachineStore.fetch(self.class, true).machine(name).config.enum
           end
         end
 
@@ -104,7 +110,7 @@ module AASM
         end
 
         def aasm_skipping_validations(state_machine_name)
-          AASM::StateMachine[self.class][state_machine_name].config.skip_validation_on_save
+          AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.skip_validation_on_save
         end
 
         def aasm_write_attribute(state, name=:default)
@@ -135,17 +141,17 @@ module AASM
         #   foo.aasm_state # => nil
         #
         def aasm_ensure_initial_state
-          AASM::StateMachine[self.class].keys.each do |state_machine_name|
+          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?
           end
         end
 
         def aasm_validate_states
-          AASM::StateMachine[self.class].keys.each do |state_machine_name|
+          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?
-            unless AASM::StateMachine[self.class][state_machine_name].config.skip_validation_on_save
+            unless AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.skip_validation_on_save
               if aasm(state_machine_name).current_state && !aasm(state_machine_name).states.include?(aasm(state_machine_name).current_state)
-                self.errors.add(AASM::StateMachine[self.class][state_machine_name].config.column , "is invalid")
+                self.errors.add(AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.column , "is invalid")
               end
             end
           end