aasm 4.0.5 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0fd3025d299701a391be90b67871d0110925522e
-  data.tar.gz: d56adcb31986d0bc257e4c4a32e79462a6715709
+  metadata.gz: a07996d6cd3f0270a6ec9d010a904cebd462b6a7
+  data.tar.gz: 57e8efc5d284371e23c50d41771beb3172787bdd
 SHA512:
-  metadata.gz: f2e8c7bd2e7ce8f614b8b72a48ffbf396c9194c5369a128bbe6d201443e067a48caea69b9f3f9ec4c6af30956b358deb4d8544172599fe7120bd4edbc4c9717d
-  data.tar.gz: b6d9db8e0f1cd99e263d3cb9e16ff837adab1ce57faf918ca222f48a9bb674ebf29bbdae640d4987bd6f676d35896dec9d3060347e709229ad831160702b11a4
+  metadata.gz: 0e1f53507bcbcf9deecce7193a5fed9f37ae5fbc91b6325f127820ead35113e19bea7dba6f87af9482affac31462b05e1b6c89a87ef61a47ad93d95c07f19179
+  data.tar.gz: 9da9eea4b58047190c441dc42c120fed864c318828340cc61505601f70179736d9cc70a0f60166bae13c6fc6aa3f3c8c4569047915a0af72ab152f30ce5422fd

data/.travis.yml

@@ -1,13 +1,16 @@
+sudo: false
 language: ruby
+cache: bundler
 
 rvm:
   # - 1.8.7
-  - 1.9.2
+  # - 1.9.2
   - 1.9.3
   - 2.0.0
   - 2.1
+  - 2.2
   # - jruby-18mode # JRuby in 1.8 mode
-  - jruby-19mode # JRuby in 1.9 mode
+  - jruby-1.7 # JRuby in 1.9 mode
   - rbx-2.2.1
 
 services: mongodb
@@ -15,21 +18,17 @@ services: mongodb
 gemfile:
   - gemfiles/rails_3.2.gemfile
   - gemfiles/rails_4.0.gemfile
+  - gemfiles/rails_4.0_bson1.gemfile
   - gemfiles/rails_4.1.gemfile
+  - gemfiles/rails_4.1_bson1.gemfile
+  - gemfiles/rails_4.2.gemfile
+  - gemfiles/rails_4.2_bson1.gemfile
 
 matrix:
   allow_failures:
     - rvm: rbx-2.2.1
-    - rvm: jruby-19mode
+    - rvm: jruby-1.7
   exclude:
-    - rvm: 1.8.7
-      gemfile: gemfiles/rails_4.0.gemfile
-    - rvm: 1.8.7
-      gemfile: gemfiles/rails_4.1.gemfile
-    - rvm: 1.9.2
-      gemfile: gemfiles/rails_4.0.gemfile
-    - rvm: 1.9.2
-      gemfile: gemfiles/rails_4.1.gemfile
     - rvm: 1.9.3
       gemfile: gemfiles/rails_4.1.gemfile
     - rvm: jruby-19mode

data/CHANGELOG.md

@@ -1,10 +1,27 @@
 # CHANGELOG
 
-## 4.1.0 (not yet released)
+## 4.2.0 (not yet released)
 
+## 4.1.0
+
+ * bugfix: initialize the aasm state column after initialization of the _Mongoid_ instance (see [issue #206](https://github.com/aasm/aasm/issues/206), thanks to [@Shwetakale ](https://github.com/Shwetakale ))
+ * added support for mongomapper ORM (see [issue #203](https://github.com/aasm/aasm/issues/203), thanks to [@reidmorrison ](https://github.com/reidmorrison ))
  * `aasm_column` has been removed. Use `aasm.attribute_name` instead
  * `aasm_human_event_name` has been removed. Use `aasm.human_event_name` instead
 
+## 4.0.8
+
+ * bugfix: may_event_name? should return true or false only (see [issue #200](https://github.com/aasm/aasm/issues/200) for details)
+
+## 4.0.7
+
+ * bugfix: take private methods into account when checking for callbacks (see [issue #197](https://github.com/aasm/aasm/issues/197) for details)
+
+## 4.0.6
+
+ * bugfix: `false` is treated as uninitialised state (same as `nil`) (see [issue #195](https://github.com/aasm/aasm/issues/195) for details)
+ * bugfix: an event's `:error` callback now retrieves all arguments passed to the event (see [issue #196](https://github.com/aasm/aasm/issues/196) for details)
+
 ## 4.0.5
 
  * bugfix: initialize the aasm state column after initialization of the _ActiveRecord_ instance only if the attribute has been loaded (see [issue #193](https://github.com/aasm/aasm/issues/193) for details)

data/Gemfile

@@ -1,12 +1,16 @@
 source "https://rubygems.org"
 
 gem "sqlite3",                          :platforms => :ruby
-gem "coveralls",                        :platforms => :ruby
+gem "coveralls"
 gem 'rubysl',                           :platforms => :rbx
 gem "jruby-openssl",                    :platforms => :jruby
 gem "activerecord-jdbcsqlite3-adapter", :platforms => :jruby
 gem "rails", "~>4.1"
-gem 'mongoid' if Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version.create('1.9.3')
+gem 'mongoid', '~>4.0' if Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version.create('1.9.3')
 gem 'sequel'
+# Since mongoid V4 requires incompatible bson V2, cannot have mongoid (V4 or greater)
+# and mongo_mapper ( or mongo ) in the same application
+#gem 'mongo_mapper', '~> 0.13'
+#gem 'bson_ext',                          :platforms => :ruby
 
 gemspec

data/README.md

@@ -9,8 +9,8 @@ This package contains AASM, a library for adding finite state machines to Ruby c
 
 AASM started as the *acts_as_state_machine* plugin but has evolved into a more generic library
 that no longer targets only ActiveRecord models. It currently provides adapters for
-[ActiveRecord](http://api.rubyonrails.org/classes/ActiveRecord/Base.html) and
-[Mongoid](http://mongoid.org/), but it can be used for any Ruby class, no matter what
+[ActiveRecord](http://api.rubyonrails.org/classes/ActiveRecord/Base.html),
+[Mongoid](http://mongoid.org/), and [Mongomapper](http://mongomapper.com/) but it can be used for any Ruby class, no matter what
 parent class it has (if any).
 
 ## Upgrade from version 3 to 4
@@ -435,7 +435,7 @@ to ```false```.
 
 ### Sequel
 
-AASM also supports [Sequel](http://sequel.jeremyevans.net/) besides _ActiveRecord_ and _Mongoid_.
+AASM also supports [Sequel](http://sequel.jeremyevans.net/) besides _ActiveRecord_, _Mongoid_, and _MongoMapper_.
 
 ```ruby
 class Job < Sequel::Model
@@ -466,6 +466,23 @@ class Job
 end
 ```
 
+### MongoMapper
+
+AASM also supports persistence to Mongodb if you're using MongoMapper. Make sure
+to include MongoMapper::Document before you include AASM.
+
+```ruby
+class Job
+  include MongoMapper::Document
+  include AASM
+
+  key :aasm_state,                   Symbol
+  aasm do
+    ...
+  end
+end
+```
+
 ### Automatic Scopes
 
 AASM will automatically create scope methods for each state in the model.
@@ -671,7 +688,7 @@ purpose.
 
 ## License ##
 
-Copyright (c) 2006-2014 Scott Barron
+Copyright (c) 2006-2015 Scott Barron
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README_FROM_VERSION_3_TO_4.md

@@ -139,7 +139,7 @@ to
 ```ruby
 job = Job.new
 
-job.aasm.events(:permitted => true)
+job.aasm.events(:permitted => true).map(&:name)
 # => [:run]
 ```
 

data/aasm.gemspec

@@ -9,13 +9,16 @@ Gem::Specification.new do |s|
   s.email       = %q{scott@elitists.net, ttilley@gmail.com, aasm@mt7.de}
   s.homepage    = %q{https://github.com/aasm/aasm}
   s.summary     = %q{State machine mixin for Ruby objects}
-  s.description = %q{AASM is a continuation of the acts as state machine rails plugin, built for plain Ruby objects.}
+  s.description = %q{AASM is a continuation of the acts-as-state-machine rails plugin, built for plain Ruby objects.}
   s.date        = Time.now
   s.licenses    = ["MIT"]
 
+  s.platform              = Gem::Platform::RUBY
+  s.required_ruby_version = '>= 1.9.3'
+
   s.add_development_dependency 'rake'
   s.add_development_dependency 'sdoc'
-  s.add_development_dependency 'rspec', '>= 2.14', '< 2.99'
+  s.add_development_dependency 'rspec'
 
   # debugging
   # s.add_development_dependency 'debugger'

data/gemfiles/rails_3.2.gemfile

@@ -7,7 +7,9 @@ gem 'rubinius-developer_tools',         :platforms => :rbx
 gem "jruby-openssl",                    :platforms => :jruby
 gem "activerecord-jdbcsqlite3-adapter", :platforms => :jruby
 gem "rails", "3.2.21"
-gem 'mongoid' if Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version.create('1.9.3')
+gem 'mongoid', '~>3.1' if Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version.create('1.9.3')
 gem 'sequel'
+gem 'mongo_mapper', '~>0.13'
+gem 'bson_ext',                          :platforms => :ruby
 
 gemspec :path => "../"

data/gemfiles/rails_4.0.gemfile

@@ -6,11 +6,8 @@ gem 'rubysl',                           :platforms => :rbx
 gem 'rubinius-developer_tools',         :platforms => :rbx
 gem "jruby-openssl",                    :platforms => :jruby
 gem "activerecord-jdbcsqlite3-adapter", :platforms => :jruby
-gem "rails", "4.0.12"
-
-# mongoid is not yet compatible with Rails >= 4
-# gem 'mongoid' if Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version.create('1.9.3')
-
+gem "rails", "4.0.13"
+gem 'mongoid', '~>4.0' if Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version.create('1.9.3')
 gem 'sequel'
 
 gemspec :path => "../"

data/gemfiles/rails_4.0_bson1.gemfile

@@ -0,0 +1,14 @@
+source "https://rubygems.org"
+
+gem "sqlite3",                          :platforms => :ruby
+gem "coveralls"
+gem 'rubysl',                           :platforms => :rbx
+gem 'rubinius-developer_tools',         :platforms => :rbx
+gem "jruby-openssl",                    :platforms => :jruby
+gem "activerecord-jdbcsqlite3-adapter", :platforms => :jruby
+gem "rails", "4.0.13"
+gem 'sequel'
+gem 'mongo_mapper', '~>0.13'
+gem 'bson_ext',                          :platforms => :ruby
+
+gemspec :path => "../"

data/gemfiles/rails_4.1.gemfile

@@ -6,11 +6,8 @@ gem 'rubysl',                           :platforms => :rbx
 gem 'rubinius-developer_tools',         :platforms => :rbx
 gem "jruby-openssl",                    :platforms => :jruby
 gem "activerecord-jdbcsqlite3-adapter", :platforms => :jruby
-gem "rails", "4.1.8"
-
-# mongoid is not yet compatible with Rails >= 4
-# gem 'mongoid' if Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version.create('1.9.3')
-
+gem "rails", "4.1.9"
+gem 'mongoid', '~>4.0' if Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version.create('1.9.3')
 gem 'sequel'
 
 gemspec :path => "../"

data/gemfiles/rails_4.1_bson1.gemfile

@@ -0,0 +1,14 @@
+source "https://rubygems.org"
+
+gem "sqlite3",                          :platforms => :ruby
+gem "coveralls"
+gem 'rubysl',                           :platforms => :rbx
+gem 'rubinius-developer_tools',         :platforms => :rbx
+gem "jruby-openssl",                    :platforms => :jruby
+gem "activerecord-jdbcsqlite3-adapter", :platforms => :jruby
+gem "rails", "4.1.9"
+gem 'sequel'
+gem 'mongo_mapper', '~> 0.13'
+gem 'bson_ext',                          :platforms => :ruby
+
+gemspec :path => "../"

data/gemfiles/rails_4.2.gemfile

@@ -0,0 +1,13 @@
+source "https://rubygems.org"
+
+gem "sqlite3",                          :platforms => :ruby
+gem "coveralls"
+gem 'rubysl',                           :platforms => :rbx
+gem 'rubinius-developer_tools',         :platforms => :rbx
+gem "jruby-openssl",                    :platforms => :jruby
+gem "activerecord-jdbcsqlite3-adapter", :platforms => :jruby
+gem "rails", "4.2.0"
+gem 'mongoid', '~>4.0' if Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version.create('1.9.3')
+gem 'sequel'
+
+gemspec :path => "../"

data/gemfiles/rails_4.2_bson1.gemfile

@@ -0,0 +1,14 @@
+source "https://rubygems.org"
+
+gem "sqlite3",                          :platforms => :ruby
+gem "coveralls"
+gem 'rubysl',                           :platforms => :rbx
+gem 'rubinius-developer_tools',         :platforms => :rbx
+gem "jruby-openssl",                    :platforms => :jruby
+gem "activerecord-jdbcsqlite3-adapter", :platforms => :jruby
+gem "rails", "4.2.0"
+gem 'sequel'
+gem 'mongo_mapper'
+gem 'bson_ext',                          :platforms => :ruby
+
+gemspec :path => "../"

data/lib/aasm/aasm.rb

@@ -81,7 +81,7 @@ private
         aasm_failed(event_name, old_state)
       end
     rescue StandardError => e
-      event.fire_callbacks(:error, self, e) || raise(e)
+      event.fire_callbacks(:error, self, e, *process_args(event, aasm.current_state, *args)) || raise(e)
     end
   end
 

data/lib/aasm/base.rb

@@ -56,12 +56,12 @@ module AASM
     def state(name, options={})
       @state_machine.add_state(name, @klass, options)
 
-      @klass.send(:define_method, "#{name.to_s}?") do
+      @klass.send(:define_method, "#{name}?") do
         aasm.current_state == name
       end
 
-      unless @klass.const_defined?("STATE_#{name.to_s.upcase}")
-        @klass.const_set("STATE_#{name.to_s.upcase}", name)
+      unless @klass.const_defined?("STATE_#{name.upcase}")
+        @klass.const_set("STATE_#{name.upcase}", name)
       end
     end
 
@@ -72,16 +72,16 @@ module AASM
       # an addition over standard aasm so that, before firing an event, you can ask
       # may_event? and get back a boolean that tells you whether the guard method
       # on the transition will let this happen.
-      @klass.send(:define_method, "may_#{name.to_s}?") do |*args|
+      @klass.send(:define_method, "may_#{name}?") do |*args|
         aasm.may_fire_event?(name, *args)
       end
 
-      @klass.send(:define_method, "#{name.to_s}!") do |*args, &block|
-        aasm.current_event = "#{name.to_s}!".to_sym
+      @klass.send(:define_method, "#{name}!") do |*args, &block|
+        aasm.current_event = "#{name}!".to_sym
         aasm_fire_event(name, {:persist => true}, *args, &block)
       end
 
-      @klass.send(:define_method, "#{name.to_s}") do |*args, &block|
+      @klass.send(:define_method, "#{name}") do |*args, &block|
         aasm.current_event = name.to_sym
         aasm_fire_event(name, {:persist => false}, *args, &block)
       end

data/lib/aasm/core/event.rb

@@ -124,14 +124,22 @@ module AASM::Core
     def invoke_callbacks(code, record, args)
       case code
         when Symbol, String
-          record.send(code, *args)
+          unless record.respond_to?(code, true)
+            raise NoMethodError.new("NoMethodError: undefined method `#{code}' for #{record.inspect}:#{record.class}")
+          end
+          arity = record.send(:method, code.to_sym).arity
+          record.send(code, *(arity < 0 ? args : args[0...arity]))
           true
+
         when Proc
-          record.instance_exec(*args, &code)
+          arity = code.arity
+          record.instance_exec(*(arity < 0 ? args : args[0...arity]), &code)
           true
+
         when Array
           code.each {|a| invoke_callbacks(a, record, args)}
           true
+
         else
           false
       end

data/lib/aasm/core/transition.rb

@@ -50,11 +50,9 @@ module AASM::Core
 
       case code
       when Symbol, String
-        # QUESTION : record.send(code, *args) ?
         arity = record.send(:method, code.to_sym).arity
         arity == 0 ? record.send(code) : record.send(code, *args)
       when Proc
-        # QUESTION : record.instance_exec(*args, &code) ?
         code.arity == 0 ? record.instance_exec(&code) : record.instance_exec(*args, &code)
       when Array
         if options[:guard]

data/lib/aasm/instance_base.rb

@@ -76,7 +76,7 @@ module AASM
 
     def may_fire_event?(name, *args)
       if event = @instance.class.aasm.state_machine.events[name]
-        event.may_fire?(@instance, *args)
+        !!event.may_fire?(@instance, *args)
       else
         false # unknown event
       end

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
       #
@@ -142,9 +142,9 @@ module AASM
 
         def aasm_raw_attribute_value(state)
           if aasm_enum
-            value = self.class.send(aasm_enum)[state]
+            self.class.send(aasm_enum)[state]
           else
-            value = state.to_s
+            state.to_s
           end
         end
 
@@ -166,7 +166,7 @@ module AASM
         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?
+          if attribute_names.include?(self.class.aasm.attribute_name.to_s) && send(self.class.aasm.attribute_name).blank?
             aasm.enter_initial_state
           end
         end

data/lib/aasm/persistence/base.rb

@@ -37,7 +37,7 @@ module AASM
         if new_record?
           state.blank? ? aasm.determine_state_name(self.class.aasm.initial_state) : state.to_sym
         else
-          state.nil? ? nil : state.to_sym
+          state.blank? ? nil : state.to_sym
         end
       end
 
@@ -71,6 +71,9 @@ module AASM
         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)
+        elsif @klass.ancestors.map {|klass| klass.to_s}.include?("MongoMapper::Document")
+          conditions = { @klass.aasm.attribute_name.to_sym => name.to_s }
+          @klass.scope(name, lambda { @klass.where(conditions) })
         end
       end
     end

data/lib/aasm/persistence/mongo_mapper_persistence.rb

@@ -0,0 +1,174 @@
+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.extend AASM::Persistence::MongoMapperPersistence::ClassMethods
+        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 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
+        #
+        #   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)
+          old_value = read_attribute(self.class.aasm.attribute_name)
+          aasm_write_attribute 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
+          else
+            self.save
+          end
+          unless success
+            write_attribute(self.class.aasm.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)
+          aasm_write_attribute state
+        end
+
+        private
+        def aasm_enum
+          case AASM::StateMachine[self.class].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
+          end
+        end
+
+        def aasm_column_looks_like_enum
+          self.class.keys[self.class.aasm.attribute_name.to_s].type == Integer
+        end
+
+        def aasm_guess_enum_method
+          self.class.aasm.attribute_name.to_s.pluralize.to_sym
+        end
+
+        def aasm_skipping_validations
+          AASM::StateMachine[self.class].config.skip_validation_on_save
+        end
+
+        def aasm_write_attribute(state)
+          write_attribute self.class.aasm.attribute_name, aasm_raw_attribute_value(state)
+        end
+
+        def aasm_raw_attribute_value(state)
+          if aasm_enum
+            self.class.send(aasm_enum)[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
+          return send("#{self.class.aasm.attribute_name}=", aasm.enter_initial_state.to_s) if send(self.class.aasm.attribute_name).blank?
+        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")
+            end
+          end
+        end
+      end # InstanceMethods
+
+    end
+  end # Persistence
+end # AASM

data/lib/aasm/persistence/mongoid_persistence.rb

@@ -35,11 +35,7 @@ module AASM
         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
+        base.after_initialize :aasm_ensure_initial_state
       end
 
       module ClassMethods

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/version.rb

@@ -1,3 +1,3 @@
 module AASM
-  VERSION = "4.0.5"
+  VERSION = "4.1.0"
 end

data/spec/database.rb

@@ -1,5 +1,5 @@
 ActiveRecord::Migration.suppress_messages do
-  %w{gates readers writers transients simples  no_scopes no_direct_assignments thieves localizer_test_models persisted_states provided_and_persisted_states with_enums with_true_enums with_false_enums}.each do |table_name|
+  %w{gates readers writers transients simples  no_scopes no_direct_assignments thieves localizer_test_models persisted_states provided_and_persisted_states with_enums with_true_enums with_false_enums false_states}.each do |table_name|
     ActiveRecord::Migration.create_table table_name, :force => true do |t|
       t.string "aasm_state"
     end