aasm 4.2.0 → 4.3.0

data/lib/aasm/core/state.rb

@@ -1,10 +1,11 @@
 module AASM::Core
   class State
-    attr_reader :name, :options
+    attr_reader :name, :state_machine, :options
 
-    def initialize(name, klass, options={})
+    def initialize(name, klass, state_machine, options={})
       @name = name
       @klass = klass
+      @state_machine = state_machine
       update(options)
     end
 

data/lib/aasm/core/transition.rb

@@ -2,12 +2,13 @@ module AASM::Core
   class Transition
     include DslHelper
 
-    attr_reader :from, :to, :opts
+    attr_reader :from, :to, :event, :opts
     alias_method :options, :opts
 
-    def initialize(opts, &block)
+    def initialize(event, opts, &block)
       add_options_from_dsl(opts, [:on_transition, :guard, :after], &block) if block
 
+      @event = event
       @from = opts[:from]
       @to = opts[:to]
       @guards = Array(opts[:guards]) + Array(opts[:guard]) + Array(opts[:if])
@@ -44,8 +45,8 @@ module AASM::Core
 
     def invoke_callbacks_compatible_with_guard(code, record, args, options={})
       if record.respond_to?(:aasm)
-        record.aasm.from_state = @from if record.aasm.respond_to?(:from_state=)
-        record.aasm.to_state = @to if record.aasm.respond_to?(:to_state=)
+        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
 
       case code

data/lib/aasm/errors.rb

@@ -1,13 +1,16 @@
 module AASM
 
+  class UnknownStateMachineError < RuntimeError; end
+
   class InvalidTransition < RuntimeError
-    attr_reader :object, :event_name
-    def initialize(object, event_name)
-      @object, @event_name = object, event_name
+    attr_reader :object, :event_name, :state_machine_name
+
+    def initialize(object, event_name, state_machine_name)
+      @object, @event_name, @state_machine_name = object, event_name, state_machine_name
     end
 
     def message
-      "Event '#{event_name}' cannot transition from '#{object.aasm.current_state}'"
+      "Event '#{event_name}' cannot transition from '#{object.aasm(state_machine_name).current_state}'"
     end
   end
 

data/lib/aasm/instance_base.rb

@@ -3,21 +3,22 @@ module AASM
 
     attr_accessor :from_state, :to_state, :current_event
 
-    def initialize(instance)
+    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
+      @instance.aasm_read_state(@name)
     end
 
     def current_state=(state)
-      @instance.aasm_write_state_without_persistence(state)
-      @current_state = state
+      @instance.aasm_write_state_without_persistence(state, @name)
+      # @current_state = state
     end
 
     def enter_initial_state
-      state_name = determine_state_name(@instance.class.aasm.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)
@@ -29,24 +30,24 @@ module AASM
     end
 
     def human_state
-      AASM::Localizer.new.human_state_name(@instance.class, current_state)
+      AASM::Localizer.new.human_state_name(@instance.class, state_object_for_name(current_state))
     end
 
     def states(options={})
       if options[:permitted]
         # ugliness level 1000
         permitted_event_names = events(:permitted => true).map(&:name)
-        transitions = @instance.class.aasm.state_machine.events.values_at(*permitted_event_names).compact.map {|e| e.transitions_from_state(current_state) }
+        transitions = @instance.class.aasm(@name).state_machine.events.values_at(*permitted_event_names).compact.map {|e| e.transitions_from_state(current_state) }
         tos = transitions.map {|t| t[0] ? t[0].to : nil}.flatten.compact.map(&:to_sym).uniq
-        @instance.class.aasm.states.select {|s| tos.include?(s.name.to_sym)}
+        @instance.class.aasm(@name).states.select {|s| tos.include?(s.name.to_sym)}
       else
-        @instance.class.aasm.states
+        @instance.class.aasm(@name).states
       end
     end
 
     def events(options={})
       state = options[:state] || current_state
-      events = @instance.class.aasm.events.select {|e| e.transitions_from_state?(state) }
+      events = @instance.class.aasm(@name).events.select {|e| e.transitions_from_state?(state) }
 
       if options[:permitted]
         # filters the results of events_for_current_state so that only those that
@@ -58,7 +59,7 @@ module AASM
     end
 
     def state_object_for_name(name)
-      obj = @instance.class.aasm.states.find {|s| s == name}
+      obj = @instance.class.aasm(@name).states.find {|s| s == name}
       raise AASM::UndefinedState, "State :#{name} doesn't exist" if obj.nil?
       obj
     end
@@ -75,7 +76,7 @@ module AASM
     end
 
     def may_fire_event?(name, *args)
-      if event = @instance.class.aasm.state_machine.events[name]
+      if event = @instance.class.aasm(@name).state_machine.events[name]
         !!event.may_fire?(@instance, *args)
       else
         false # unknown event
@@ -83,7 +84,7 @@ module AASM
     end
 
     def set_current_state_with_persistence(state)
-      save_success = @instance.aasm_write_state(state)
+      save_success = @instance.aasm_write_state(state, @name)
       self.current_state = state if save_success
       save_success
     end

data/lib/aasm/localizer.rb

@@ -21,7 +21,7 @@ module AASM
 
     def item_for(klass, state, ancestor, options={})
       separator = options[:old_style] ? '.' : '/'
-      :"#{i18n_scope(klass)}.attributes.#{i18n_klass(ancestor)}.#{klass.aasm.attribute_name}#{separator}#{state}"
+      :"#{i18n_scope(klass)}.attributes.#{i18n_klass(ancestor)}.#{klass.aasm(state.state_machine.name).attribute_name}#{separator}#{state}"
     end
 
     def translate_queue(checklist)

data/lib/aasm/persistence/active_record_persistence.rb

@@ -30,7 +30,6 @@ module AASM
       #
       def self.included(base)
         base.send(:include, AASM::Persistence::Base)
-        base.extend AASM::Persistence::ActiveRecordPersistence::ClassMethods
         base.send(:include, AASM::Persistence::ActiveRecordPersistence::InstanceMethods)
 
         base.after_initialize do
@@ -41,34 +40,6 @@ module AASM
         base.validate :aasm_validate_states
       end
 
-      module ClassMethods
-
-        def find_in_state(number, state, *args)
-          with_state_scope state do
-            find(number, *args)
-          end
-        end
-
-        def count_in_state(state, *args)
-          with_state_scope state do
-            count(*args)
-          end
-        end
-
-        def calculate_in_state(state, *args)
-          with_state_scope state do
-            calculate(*args)
-          end
-        end
-
-        protected
-        def with_state_scope(state)
-          with_scope :find => {:conditions => ["#{table_name}.#{aasm_column} = ?", state.to_s]} do
-            yield if block_given?
-          end
-        end
-      end
-
       module InstanceMethods
 
         # Writes <tt>state</tt> to the state column and persists it to the database
@@ -80,18 +51,18 @@ module AASM
         #   Foo.find(1).aasm.current_state # => :closed
         #
         # NOTE: intended to be called from an event
-        def aasm_write_state(state)
-          old_value = read_attribute(self.class.aasm.attribute_name)
-          aasm_write_attribute state
+        def aasm_write_state(state, name=:default)
+          old_value = read_attribute(self.class.aasm(name).attribute_name)
+          aasm_write_attribute state, name
 
-          success = if aasm_skipping_validations
-            value = aasm_raw_attribute_value state
-            self.class.where(self.class.primary_key => self.id).update_all(self.class.aasm.attribute_name => value) == 1
+          success = if aasm_skipping_validations(name)
+            value = aasm_raw_attribute_value(state, name)
+            self.class.where(self.class.primary_key => self.id).update_all(self.class.aasm(name).attribute_name => value) == 1
           else
             self.save
           end
           unless success
-            write_attribute(self.class.aasm.attribute_name, old_value)
+            write_attribute(self.class.aasm(name).attribute_name, old_value)
             return false
           end
 
@@ -110,39 +81,39 @@ module AASM
         #   Foo.find(1).aasm.current_state # => :closed
         #
         # NOTE: intended to be called from an event
-        def aasm_write_state_without_persistence(state)
-          aasm_write_attribute state
+        def aasm_write_state_without_persistence(state, name=:default)
+          aasm_write_attribute(state, name)
         end
 
       private
-        def aasm_enum
-          case AASM::StateMachine[self.class].config.enum
+        def aasm_enum(name=:default)
+          case AASM::StateMachine[self.class][name].config.enum
             when false then nil
-            when true then aasm_guess_enum_method
-            when nil then aasm_guess_enum_method if aasm_column_looks_like_enum
-            else AASM::StateMachine[self.class].config.enum
+            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
           end
         end
 
-        def aasm_column_looks_like_enum
-          self.class.columns_hash[self.class.aasm.attribute_name.to_s].type == :integer
+        def aasm_column_looks_like_enum(name=:default)
+          self.class.columns_hash[self.class.aasm(name).attribute_name.to_s].type == :integer
         end
 
-        def aasm_guess_enum_method
-          self.class.aasm.attribute_name.to_s.pluralize.to_sym
+        def aasm_guess_enum_method(name=:default)
+          self.class.aasm(name).attribute_name.to_s.pluralize.to_sym
         end
 
-        def aasm_skipping_validations
-          AASM::StateMachine[self.class].config.skip_validation_on_save
+        def aasm_skipping_validations(state_machine_name)
+          AASM::StateMachine[self.class][state_machine_name].config.skip_validation_on_save
         end
 
-        def aasm_write_attribute(state)
-          write_attribute self.class.aasm.attribute_name, aasm_raw_attribute_value(state)
+        def aasm_write_attribute(state, name=:default)
+          write_attribute(self.class.aasm(name).attribute_name, aasm_raw_attribute_value(state, name))
         end
 
-        def aasm_raw_attribute_value(state)
-          if aasm_enum
-            self.class.send(aasm_enum)[state]
+        def aasm_raw_attribute_value(state, name=:default)
+          if aasm_enum(name)
+            self.class.send(aasm_enum(name))[state]
           else
             state.to_s
           end
@@ -164,32 +135,36 @@ module AASM
         #   foo.aasm_state # => nil
         #
         def aasm_ensure_initial_state
-          # checking via respond_to? does not work in Rails <= 3
-          # if respond_to?(self.class.aasm.attribute_name) && send(self.class.aasm.attribute_name).blank? # Rails 4
-          if attribute_names.include?(self.class.aasm.attribute_name.to_s) && send(self.class.aasm.attribute_name).blank?
-            aasm.enter_initial_state
+          AASM::StateMachine[self.class].keys.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 attribute_names.include?(self.class.aasm(state_machine_name).attribute_name.to_s) && send(self.class.aasm(state_machine_name).attribute_name).blank?
+              aasm(state_machine_name).enter_initial_state
+            end
           end
         end
 
-        def aasm_fire_event(name, options, *args, &block)
-          success = options[:persist] ? self.class.transaction(:requires_new => requires_new?) { super } : super
+        def aasm_fire_event(state_machine_name, name, options, *args, &block)
+          success = options[:persist] ? self.class.transaction(:requires_new => requires_new?(state_machine_name)) { super } : super
 
           if success && options[:persist]
-            event = self.class.aasm.state_machine.events[name]
+            event = self.class.aasm(state_machine_name).state_machine.events[name]
             event.fire_callbacks(:after_commit, self, *args)
           end
 
           success
         end
 
-        def requires_new?
-          AASM::StateMachine[self.class].config.requires_new_transaction
+        def requires_new?(state_machine_name)
+          AASM::StateMachine[self.class][state_machine_name].config.requires_new_transaction
         end
 
         def aasm_validate_states
-          unless aasm_skipping_validations
-            if aasm.current_state && !aasm.states.include?(aasm.current_state)
-              self.errors.add(AASM::StateMachine[self.class].config.column , "is invalid")
+          AASM::StateMachine[self.class].keys.each do |state_machine_name|
+            unless aasm_skipping_validations(state_machine_name)
+              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")
+              end
             end
           end
         end

data/lib/aasm/persistence/base.rb

@@ -32,10 +32,10 @@ module AASM
       # NOTE: intended to be called from an event
       #
       # This allows for nil aasm states - be sure to add validation to your model
-      def aasm_read_state
-        state = send(self.class.aasm.attribute_name)
+      def aasm_read_state(name=:default)
+        state = send(self.class.aasm(name).attribute_name)
         if new_record?
-          state.blank? ? aasm.determine_state_name(self.class.aasm.initial_state) : state.to_sym
+          state.blank? ? aasm(name).determine_state_name(self.class.aasm(name).initial_state) : state.to_sym
         else
           state.blank? ? nil : state.to_sym
         end
@@ -55,10 +55,10 @@ module AASM
     # make sure to create a (named) scope for each state
     def state_with_scope(name, *args)
       state_without_scope(name, *args)
-      if AASM::StateMachine[@klass].config.create_scopes && !@klass.respond_to?(name)
+      if @state_machine.config.create_scopes && !@klass.respond_to?(name)
         if @klass.ancestors.map {|klass| klass.to_s}.include?("ActiveRecord::Base")
 
-          conditions = {"#{@klass.table_name}.#{@klass.aasm.attribute_name}" => name.to_s}
+          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) }
@@ -69,10 +69,10 @@ module AASM
             end
           end
         elsif @klass.ancestors.map {|klass| klass.to_s}.include?("Mongoid::Document")
-          scope_options = lambda { @klass.send(:where, {@klass.aasm.attribute_name.to_sym => name.to_s}) }
+          scope_options = lambda { @klass.send(:where, {@klass.aasm(@name).attribute_name.to_sym => name.to_s}) }
           @klass.send(:scope, name, scope_options)
         elsif @klass.ancestors.map {|klass| klass.to_s}.include?("MongoMapper::Document")
-          conditions = { @klass.aasm.attribute_name.to_sym => name.to_s }
+          conditions = { @klass.aasm(@name).attribute_name.to_sym => name.to_s }
           @klass.scope(name, lambda { @klass.where(conditions) })
         end
       end

data/lib/aasm/persistence/mongo_mapper_persistence.rb

@@ -32,7 +32,6 @@ module AASM
       #
       def self.included(base)
         base.send(:include, AASM::Persistence::Base)
-        base.extend AASM::Persistence::MongoMapperPersistence::ClassMethods
         base.send(:include, AASM::Persistence::MongoMapperPersistence::InstanceMethods)
 
         base.before_create :aasm_ensure_initial_state
@@ -41,26 +40,6 @@ module AASM
         base.validate :aasm_validate_states
       end
 
-      module ClassMethods
-
-        def find_in_state(number, state, *args)
-          with_state_scope(state).find!(number, *args)
-        end
-
-        def count_in_state(state, *args)
-          with_state_scope(state).count(*args)
-        end
-
-        def calculate_in_state(state, *args)
-          with_state_scope(state).calculate(*args)
-        end
-
-        protected
-        def with_state_scope(state)
-          where(aasm.attribute_name.to_sym => state.to_s)
-        end
-      end
-
       module InstanceMethods
 
         # Writes <tt>state</tt> to the state column and persists it to the database
@@ -72,18 +51,18 @@ module AASM
         #   Foo.find(1).aasm.current_state # => :closed
         #
         # NOTE: intended to be called from an event
-        def aasm_write_state(state)
-          old_value = read_attribute(self.class.aasm.attribute_name)
-          aasm_write_attribute state
+        def aasm_write_state(state, name=:default)
+          old_value = read_attribute(self.class.aasm(name).attribute_name)
+          write_attribute(self.class.aasm(name).attribute_name, state)
 
-          success = if aasm_skipping_validations
-            value = aasm_raw_attribute_value state
-            self.class.where(self.class.primary_key => self.id).update_all(self.class.aasm.attribute_name => value) == 1
+          success = if aasm_skipping_validations(name)
+            value = aasm_raw_attribute_value(state, name)
+            self.class.where(self.class.primary_key => self.id).update_all(self.class.aasm(name).attribute_name => value) == 1
           else
             self.save
           end
           unless success
-            write_attribute(self.class.aasm.attribute_name, old_value)
+            write_attribute(self.class.aasm(name).attribute_name, old_value)
             return false
           end
 
@@ -102,39 +81,39 @@ module AASM
         #   Foo.find(1).aasm.current_state # => :closed
         #
         # NOTE: intended to be called from an event
-        def aasm_write_state_without_persistence(state)
-          aasm_write_attribute state
+        def aasm_write_state_without_persistence(state, name=:default)
+          aasm_write_attribute(state, name)
         end
 
         private
-        def aasm_enum
-          case AASM::StateMachine[self.class].config.enum
+        def aasm_enum(name=:default)
+          case AASM::StateMachine[self.class][name].config.enum
           when false then nil
-          when true then aasm_guess_enum_method
-          when nil then aasm_guess_enum_method if aasm_column_looks_like_enum
-          else AASM::StateMachine[self.class].config.enum
+          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
           end
         end
 
-        def aasm_column_looks_like_enum
-          self.class.keys[self.class.aasm.attribute_name.to_s].type == Integer
+        def aasm_column_looks_like_enum(name)
+          self.class.keys[self.class.aasm(name).attribute_name.to_s].type == Integer
         end
 
-        def aasm_guess_enum_method
-          self.class.aasm.attribute_name.to_s.pluralize.to_sym
+        def aasm_guess_enum_method(name)
+          self.class.aasm(name).attribute_name.to_s.pluralize.to_sym
         end
 
-        def aasm_skipping_validations
-          AASM::StateMachine[self.class].config.skip_validation_on_save
+        def aasm_skipping_validations(state_machine_name)
+          AASM::StateMachine[self.class][state_machine_name].config.skip_validation_on_save
         end
 
-        def aasm_write_attribute(state)
-          write_attribute self.class.aasm.attribute_name, aasm_raw_attribute_value(state)
+        def aasm_write_attribute(state, name=:default)
+          write_attribute self.class.aasm(name).attribute_name, aasm_raw_attribute_value(state, name)
         end
 
-        def aasm_raw_attribute_value(state)
-          if aasm_enum
-            self.class.send(aasm_enum)[state]
+        def aasm_raw_attribute_value(state, name=:default)
+          if aasm_enum(name)
+            self.class.send(aasm_enum(name))[state]
           else
             state.to_s
           end
@@ -156,14 +135,18 @@ module AASM
         #   foo.aasm_state # => nil
         #
         def aasm_ensure_initial_state
-          return send("#{self.class.aasm.attribute_name}=", aasm.enter_initial_state.to_s) if send(self.class.aasm.attribute_name).blank?
+          AASM::StateMachine[self.class].keys.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
-          send("#{self.class.aasm.attribute_name}=", aasm.enter_initial_state.to_s) if send(self.class.aasm.attribute_name).blank?
-          unless AASM::StateMachine[self.class].config.skip_validation_on_save
-            if aasm.current_state && !aasm.states.include?(aasm.current_state)
-              self.errors.add(AASM::StateMachine[self.class].config.column , "is invalid")
+          AASM::StateMachine[self.class].keys.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
+              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")
+              end
             end
           end
         end