aasm 4.0.8 → 4.5.2

data/lib/aasm/persistence/active_record_persistence.rb

@@ -10,7 +10,7 @@ module AASM
       #
       # Adds
       #
-      #   before_validation :aasm_ensure_initial_state, :on => :create
+      #   after_initialize :aasm_ensure_initial_state
       #
       # As a result, it doesn't matter when you define your methods - the following 2 are equivalent
       #
@@ -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,22 +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)
+            aasm_update_column(name, value)
           else
             self.save
           end
-          unless success
-            write_attribute(self.class.aasm.attribute_name, old_value)
-            return false
-          end
 
-          true
+          success ? true : aasm_rollback(name, old_value)
         end
 
         # Writes <tt>state</tt> to the state column, but does not persist it to the database
@@ -110,46 +77,56 @@ 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_update_column(name, value)
+          self.class.where(self.class.primary_key => self.id).update_all(self.class.aasm(name).attribute_name => value) == 1
+        end
+
+        def aasm_rollback(name, old_value)
+          write_attribute(self.class.aasm(name).attribute_name, old_value)
+          false
+        end
+
+        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
         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
+        # then the initial state gets populated before validation on create
         #
         #   foo = Foo.new
         #   foo.aasm_state # => nil
@@ -164,35 +141,48 @@ 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 attributes.key?(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 aasm_column_is_blank?(state_machine_name)
+              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_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?
+        end
+
+        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.fire_callbacks(:after_commit, self)
+            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::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|
+            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")
+              end
             end
           end
         end
+
+        def aasm_invalid_state?(state_machine_name)
+          aasm(state_machine_name).current_state && !aasm(state_machine_name).states.include?(aasm(state_machine_name).current_state)
+        end
       end # InstanceMethods
 
     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,27 +55,62 @@ 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 @klass.ancestors.map {|klass| klass.to_s}.include?("ActiveRecord::Base")
+      create_scope(name) if create_scope?(name)
+    end
+    alias_method :state_without_scope, :state
+    alias_method :state, :state_with_scope
+
+    private
+
+    def create_scope?(name)
+      @state_machine.config.create_scopes && !@klass.respond_to?(name)
+    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
 
-          conditions = {"#{@klass.table_name}.#{@klass.aasm.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
-        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}) }
-          @klass.send(:scope, name, scope_options)
+    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
-    alias_method :state_without_scope, :state
-    alias_method :state, :state_with_scope
+
+    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) })
+    end
   end # Base
 
 end # AASM

data/lib/aasm/persistence/mongo_mapper_persistence.rb

@@ -0,0 +1,157 @@
+require_relative 'base'
+
+module AASM
+  module Persistence
+    module MongoMapperPersistence
+      # This method:
+      #
+      # * extends the model with ClassMethods
+      # * includes InstanceMethods
+      #
+      # Adds
+      #
+      #   before_validation :aasm_ensure_initial_state, :on => :create
+      #
+      # As a result, it doesn't matter when you define your methods - the following 2 are equivalent
+      #
+      #   class Foo
+      #     include MongoMapper::Document
+      #     def aasm_write_state(state)
+      #       "bar"
+      #     end
+      #     include AASM
+      #   end
+      #
+      #   class Foo < ActiveRecord::Base
+      #     include MongoMapper::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::MongoMapperPersistence::InstanceMethods)
+
+        base.before_create :aasm_ensure_initial_state
+
+        # ensure state is in the list of states
+        base.validate :aasm_validate_states
+      end
+
+      module InstanceMethods
+
+        # Writes <tt>state</tt> to the state column and persists 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 # => :closed
+        #
+        # NOTE: intended to be called from an event
+        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(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(name).attribute_name, old_value)
+            return false
+          end
+
+          true
+        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)
+          aasm_write_attribute(state, name)
+        end
+
+        private
+        def aasm_enum(name=:default)
+          case AASM::StateMachine[self.class][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
+          end
+        end
+
+        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(name)
+          self.class.aasm(name).attribute_name.to_s.pluralize.to_sym
+        end
+
+        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, name=:default)
+          write_attribute self.class.aasm(name).attribute_name, aasm_raw_attribute_value(state, name)
+        end
+
+        def aasm_raw_attribute_value(state, name=:default)
+          if aasm_enum(name)
+            self.class.send(aasm_enum(name))[state]
+          else
+            state.to_s
+          end
+        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::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
+          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
+      end # InstanceMethods
+
+    end
+  end # Persistence
+end # AASM

data/lib/aasm/persistence/mongoid_persistence.rb

@@ -32,36 +32,9 @@ module AASM
       #
       def self.included(base)
         base.send(:include, AASM::Persistence::Base)
-        base.extend AASM::Persistence::MongoidPersistence::ClassMethods
         base.send(:include, AASM::Persistence::MongoidPersistence::InstanceMethods)
 
-        # Mongoid's Validatable gem dependency goes not have a before_validation_on_xxx hook yet.
-        # base.before_validation_on_create :aasm_ensure_initial_state
-        base.before_validation :aasm_ensure_initial_state
-        # ensure initial aasm state even when validations are skipped
-        base.before_create :aasm_ensure_initial_state
-      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 with_state_scope(state)
-          with_scope where(aasm.attribute_name.to_sym => state.to_s) do
-            yield if block_given?
-          end
-        end
-
+        base.after_initialize :aasm_ensure_initial_state
       end
 
       module InstanceMethods
@@ -76,12 +49,12 @@ 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)
-          write_attribute(self.class.aasm.attribute_name, state.to_s)
+        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.to_s)
 
           unless self.save(:validate => false)
-            write_attribute(self.class.aasm.attribute_name, old_value)
+            write_attribute(self.class.aasm(name).attribute_name, old_value)
             return false
           end
 
@@ -100,8 +73,8 @@ module AASM
         #   Foo.find(1).aasm.current_state # => :closed
         #
         # NOTE: intended to be called from an event
-        def aasm_write_state_without_persistence(state)
-          write_attribute(self.class.aasm.attribute_name, state.to_s)
+        def aasm_write_state_without_persistence(state, name=:default)
+          write_attribute(self.class.aasm(name).attribute_name, state.to_s)
         end
 
       private
@@ -122,16 +95,18 @@ module AASM
         #   foo.aasm_state # => nil
         #
         def aasm_ensure_initial_state
-          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
       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
+      # 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/plain_persistence.rb

@@ -2,21 +2,22 @@ module AASM
   module Persistence
     module PlainPersistence
 
-      def aasm_read_state
-        # all the following lines behave like @current_state ||= aasm.enter_initial_state
-        current = aasm.instance_variable_get("@current_state")
+      # 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}")
         return current if current
-        aasm.instance_variable_set("@current_state", aasm.enter_initial_state)
+        aasm(name).instance_variable_set("@current_state_#{name}", aasm(name).enter_initial_state)
       end
 
       # may be overwritten by persistence mixins
-      def aasm_write_state(new_state)
+      def aasm_write_state(new_state, name=:default)
         true
       end
 
       # may be overwritten by persistence mixins
-      def aasm_write_state_without_persistence(new_state)
-        true
+      def aasm_write_state_without_persistence(new_state, name=:default)
+        aasm(name).instance_variable_set("@current_state_#{name}", new_state)
       end
 
     end

data/lib/aasm/persistence/sequel_persistence.rb

@@ -44,10 +44,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? && state.to_s.strip.empty?
-            aasm.determine_state_name(self.class.aasm.initial_state)
+            aasm(name).determine_state_name(self.class.aasm(name).initial_state)
           elsif state.nil?
             nil
           else
@@ -71,8 +71,11 @@ module AASM
         #   foo.aasm_state # => nil
         #
         def aasm_ensure_initial_state
-          aasm.enter_initial_state if
-            send(self.class.aasm.attribute_name).to_s.strip.empty?
+          AASM::StateMachine[self.class].keys.each do |state_machine_name|
+            aasm(state_machine_name).enter_initial_state if
+              (new? || values.key?(self.class.aasm(state_machine_name).attribute_name)) &&
+              send(self.class.aasm(state_machine_name).attribute_name).to_s.strip.empty?
+          end
         end
 
         # Writes <tt>state</tt> to the state column and persists it to the database
@@ -84,8 +87,8 @@ module AASM
         #   Foo[1].aasm.current_state # => :closed
         #
         # NOTE: intended to be called from an event
-        def aasm_write_state state
-          aasm_column = self.class.aasm.attribute_name
+        def aasm_write_state state, name=:default
+          aasm_column = self.class.aasm(name).attribute_name
           update_only({aasm_column => state.to_s}, aasm_column)
         end
 
@@ -101,8 +104,8 @@ module AASM
         #   Foo[1].aasm.current_state # => :closed
         #
         # NOTE: intended to be called from an event
-        def aasm_write_state_without_persistence state
-          send("#{self.class.aasm.attribute_name}=", state.to_s)
+        def aasm_write_state_without_persistence state, name=:default
+          send("#{self.class.aasm(name).attribute_name}=", state.to_s)
         end
       end
     end

data/lib/aasm/persistence.rb

@@ -10,6 +10,8 @@ module AASM
           include_persistence base, :active_record
         elsif hierarchy.include?("Mongoid::Document")
           include_persistence base, :mongoid
+        elsif hierarchy.include?("MongoMapper::Document")
+          include_persistence base, :mongo_mapper
         elsif hierarchy.include?("Sequel::Model")
           include_persistence base, :sequel
         else

data/lib/aasm/rspec/allow_event.rb

@@ -0,0 +1,22 @@
+RSpec::Matchers.define :allow_event do |event|
+  match do |obj|
+    @state_machine_name ||= :default
+    obj.aasm(@state_machine_name).may_fire_event?(event)
+  end
+
+  chain :on do |state_machine_name|
+    @state_machine_name = state_machine_name
+  end
+
+  description do
+    "allow event #{expected} (on :#{@state_machine_name})"
+  end
+
+  failure_message do |obj|
+    "expected that the event :#{expected} would be allowed (on :#{@state_machine_name})"
+  end
+
+  failure_message_when_negated do |obj|
+    "expected that the event :#{expected} would not be allowed (on :#{@state_machine_name})"
+  end
+end