aasm 4.8.0 → 4.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4976d2633b75f1b3ee17661e698a4aa3c5ff96bb
-  data.tar.gz: 19598287ca29eb957579fef45c2054efa227b8f2
+  metadata.gz: d4a393ed849111b8beee789a849433679c36f940
+  data.tar.gz: 905f16c76e62d5481bcfe55f4bb935039b0c7726
 SHA512:
-  metadata.gz: 71e5ccc6259fbb7400b7e2c4c14da15a1ad2275a59ca94d23469afc1e1c5212f3a8a38b68f7fc5ed99b466bcef3df350c331d9525b324274d85dc47ded71132b
-  data.tar.gz: a3688432d71fe26211b511d665b13b9a171a3e79196dc4eac3fb6fae5f63b60ae82f4e15d20a5e7b627b02dfdf1d47e8643b67bad9d45d6585848dfb8a501864
+  metadata.gz: 1e64e9fffd9c560a166ab728105d3891ca9a6a8784c27b70f83d9fd91ed7ccde1c839662f8e7e099ef4128db6bc91a690a30c8fbb3c0f83e4bfeba7d2c0ad67f
+  data.tar.gz: 574cafabbe8b20e1bf9db7ef87ff10c358dd814fd3bc86fc2f843824c9be8deb4ad645c9a0273a7ecf861bfb6136b519476f1b749a0d3706e798b24a3dd92da8

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # CHANGELOG
 
+## 4.9.0
+
+ * add support for callback classes (`after` only) (see [issue #316](https://github.com/aasm/aasm/pull/316) for details, thanks to [@mlr](https://github.com/mlr))
+ * allow easier extension of _AASM_ (utilising the idea of _ApplicationRecords_ from _Rails 5_) (see [issue #296](https://github.com/aasm/aasm/pull/296) for details, thanks to [@mlr](https://github.com/mlr))
+ * support pessimistic locking for _ActiveRecord_ (see [issue #283](https://github.com/aasm/aasm/pull/283) for details, thanks to [@HoyaBoya](https://github.com/HoyaBoya))
+ * fix: support database sharding for _ActiveRecord_ (see [issue #289](https://github.com/aasm/aasm/pull/289) for details, thanks to [@scambra](https://github.com/scambra))
+ * fix: some issues with RubyMotion (see [issue #318](https://github.com/aasm/aasm/pull/318) for details, thanks to [@Infotaku](https://github.com/Infotaku))
+ * fix: Rails generator now features the correct namespace (see [issue #328](https://github.com/aasm/aasm/pull/328) and [issue #329](https://github.com/aasm/aasm/pull/329) for details, thanks to [@anilmaurya](https://github.com/anilmaurya))
+
+
 ## 4.8.0
 
  * add support for [dynamoid](http://joshsymonds.com/Dynamoid/) (see [issue #300](https://github.com/aasm/aasm/pull/300) for details, thanks to [@LeeChSien](https://github.com/LeeChSien))

data/README.md

@@ -106,6 +106,7 @@ class Job
       end
 
       transitions :from => :sleeping, :to => :running, :after => Proc.new {|*args| set_process(*args) }
+      transitions :from => :running, :to => :finished, :after => LogRunTime
     end
 
     event :sleep do
@@ -136,12 +137,34 @@ class Job
   end
 
 end
+
+class LogRunTime
+  def call
+    log "Job was running for X seconds"
+  end
+end
 ```
 
 In this case `do_something` is called before actually entering the state `sleeping`,
 while `notify_somebody` is called after the transition `run` (from `sleeping` to `running`)
 is finished.
 
+AASM will also initialize `LogRunTime` and run the `call` method for you after the transition from `runnung` to `finished` in the example above. You can pass arguments to the class by defining an initialize method on it, like this:
+
+```
+class LogRunTime
+  # optional args parameter can be omitted, but if you define initialize
+  # you must accept the model instance as the first parameter to it.
+  def initialize(job, args = {})
+    @job = job
+  end
+  
+  def call
+    log "Job was running for #{@job.run_time} seconds"
+  end
+end
+```
+
 Here you can see a list of all possible callbacks, together with their order of calling:
 
 ```ruby
@@ -394,6 +417,71 @@ SimpleMultipleExample.aasm(:work).states
 *Final note*: Support for multiple state machines per class is a pretty new feature
 (since version `4.3`), so please bear with us in case it doesn't work as expected.
 
+### Extending AASM
+
+AASM allows you to easily extend `AASM::Base` for your own application purposes.
+
+Let's suppose we have common logic across many AASM models. We can embody this logic in a sub-class of `AASM::Base`.
+
+```
+class CustomAASMBase < AASM::Base
+  # A custom transiton that we want available across many AASM models.
+  def count_transitions!
+    klass.class_eval do
+      aasm :with_klass => CustomAASMBase do
+        after_all_transitions :increment_transition_count
+      end
+    end
+  end
+
+  # A custom annotation that we want available across many AASM models.
+  def requires_guards!
+    klass.class_eval do
+      attr_reader :authorizable_called,
+        :transition_count,
+        :fillable_called
+
+      def authorizable?
+        @authorizable_called = true
+      end
+
+      def fillable?
+        @fillable_called = true
+      end
+
+      def increment_transition_count
+        @transition_count ||= 0
+        @transition_count += 1
+      end
+    end
+  end
+end
+```
+
+When we declare our model that has an AASM state machine, we simply declare the AASM block with a `:with` key to our own class.
+
+```
+class SimpleCustomExample
+  include AASM
+
+  # Let's build an AASM state machine with our custom class.
+  aasm :with_klass => CustomAASMBase do
+    requires_guards!
+    count_transitions!
+
+    state :initialised, :initial => true
+    state :filled_out
+    state :authorised
+
+    event :fill_out do
+      transitions :from => :initialised, :to => :filled_out, :guard => :fillable?
+    end
+    event :authorise do
+      transitions :from => :filled_out, :to => :authorised, :guard => :authorizable?
+    end
+  end
+end
+```
 
 
 ### ActiveRecord
@@ -693,6 +781,41 @@ end
 
 which then leads to `transaction(:requires_new => false)`, the Rails default.
 
+### Pessimistic Locking
+
+AASM supports [Active Record pessimistic locking via `with_lock`](http://api.rubyonrails.org/classes/ActiveRecord/Locking/Pessimistic.html#method-i-with_lock) for database persistence layers.
+
+| Option | Purpose |
+| ------ | ------- |
+| `false` (default) | No lock is obtained | |
+| `true` | Obtain a blocking pessimistic lock e.g. `FOR UPDATE` |
+| String | Obtain a lock based on the SQL string e.g. `FOR UPDATE NOWAIT` |
+
+
+```ruby
+class Job < ActiveRecord::Base
+  include AASM
+
+  aasm :requires_lock => true do
+    ...
+  end
+
+  ...
+end
+```
+
+```ruby
+class Job < ActiveRecord::Base
+  include AASM
+
+  aasm :requires_lock => 'FOR UPDATE NOWAIT' do
+    ...
+  end
+
+  ...
+end
+```
+
 
 ### Column name & migration
 
@@ -761,8 +884,12 @@ Job.aasm.states_for_select
 
 To use AASM with a RubyMotion project, use it with the [motion-bundler](https://github.com/archan937/motion-bundler) gem.
 
-Warning: Due to the way key-value observation (KVO) works in iOS, 
+Warnings:
+- Due to the way key-value observation (KVO) works in iOS,
 you currently CANNOT use AASM with an object you are observing. (Yes.. that's pretty sad).
+- Due to RubyMotion Proc's lack of 'source_location' method, it may be harder
+to find out the origin of a "cannot transition from" error. I would recommend using
+the 'instance method symbol / string' way whenever possible when defining guardians and callbacks.
 
 
 ### Testing

data/lib/aasm/aasm.rb

@@ -38,6 +38,12 @@ module AASM
 
       AASM::StateMachine[self][state_machine_name] ||= AASM::StateMachine.new(state_machine_name)
 
+      # use a default despite the DSL configuration default.
+      # this is because configuration hasn't been setup for the AASM class but we are accessing a DSL option already for the class.
+      aasm_klass = options[:with_klass] || AASM::Base
+
+      raise ArgumentError, "The class #{aasm_klass} must inherit from AASM::Base!" unless aasm_klass.ancestors.include?(AASM::Base)
+
       @aasm ||= {}
       if @aasm[state_machine_name]
         # make sure to use provided options
@@ -46,7 +52,7 @@ module AASM
         end
       else
         # create a new base
-        @aasm[state_machine_name] = AASM::Base.new(
+        @aasm[state_machine_name] = aasm_klass.new(
           self,
           state_machine_name,
           AASM::StateMachine[self][state_machine_name],

data/lib/aasm/base.rb

@@ -1,12 +1,13 @@
 module AASM
   class Base
 
-    attr_reader :state_machine
+    attr_reader :klass,
+      :state_machine
 
     def initialize(klass, name, state_machine, options={}, &block)
       @klass = klass
       @name = name
-      # @state_machine = @klass.aasm(@name).state_machine
+      # @state_machine = klass.aasm(@name).state_machine
       @state_machine = state_machine
       @state_machine.config.column ||= (options[:column] || default_column).to_sym
       # @state_machine.config.column = options[:column].to_sym if options[:column] # master
@@ -24,15 +25,23 @@ module AASM
       # use requires_new for nested transactions (in ActiveRecord)
       configure :requires_new_transaction, true
 
+      # use pessimistic locking (in ActiveRecord)
+      # true for FOR UPDATE lock
+      # string for a specific lock type i.e. FOR UPDATE NOWAIT
+      configure :requires_lock, false
+
       # set to true to forbid direct assignment of aasm_state column (in ActiveRecord)
       configure :no_direct_assignment, false
 
+      # allow a AASM::Base sub-class to be used for state machine
+      configure :with_klass, AASM::Base
+
       configure :enum, nil
 
       # make sure to raise an error if no_direct_assignment is enabled
       # and attribute is directly assigned though
       aasm_name = @name
-      @klass.send :define_method, "#{@state_machine.config.column}=", ->(state_name) do
+      klass.send :define_method, "#{@state_machine.config.column}=", ->(state_name) do
         if self.class.aasm(:"#{aasm_name}").state_machine.config.no_direct_assignment
           raise AASM::NoDirectAssignmentError.new(
             'direct assignment of AASM column has been disabled (see AASM configuration for this class)'
@@ -63,19 +72,19 @@ module AASM
 
     # define a state
     def state(name, options={})
-      @state_machine.add_state(name, @klass, options)
+      @state_machine.add_state(name, klass, options)
 
-      if @klass.instance_methods.include?("#{name}?")
-        warn "#{@klass.name}: The aasm state name #{name} is already used!"
+      if klass.instance_methods.include?("#{name}?")
+        warn "#{klass.name}: The aasm state name #{name} is already used!"
       end
 
       aasm_name = @name
-      @klass.send :define_method, "#{name}?", ->() do
+      klass.send :define_method, "#{name}?", ->() do
         aasm(:"#{aasm_name}").current_state == :"#{name}"
       end
 
-      unless @klass.const_defined?("STATE_#{name.upcase}")
-        @klass.const_set("STATE_#{name.upcase}", name)
+      unless klass.const_defined?("STATE_#{name.upcase}")
+        klass.const_set("STATE_#{name.upcase}", name)
       end
     end
 
@@ -83,8 +92,8 @@ module AASM
     def event(name, options={}, &block)
       @state_machine.add_event(name, options, &block)
 
-      if @klass.instance_methods.include?("may_#{name}?".to_sym)
-        warn "#{@klass.name}: The aasm event name #{name} is already used!"
+      if klass.instance_methods.include?("may_#{name}?".to_sym)
+        warn "#{klass.name}: The aasm event name #{name} is already used!"
       end
 
       # an addition over standard aasm so that, before firing an event, you can ask
@@ -92,16 +101,16 @@ module AASM
       # on the transition will let this happen.
       aasm_name = @name
 
-      @klass.send :define_method, "may_#{name}?", ->(*args) do
+      klass.send :define_method, "may_#{name}?", ->(*args) do
         aasm(:"#{aasm_name}").may_fire_event?(:"#{name}", *args)
       end
 
-      @klass.send :define_method, "#{name}!", ->(*args, &block) do
+      klass.send :define_method, "#{name}!", ->(*args, &block) do
         aasm(:"#{aasm_name}").current_event = :"#{name}!"
         aasm_fire_event(:"#{aasm_name}", :"#{name}", {:persist => true}, *args, &block)
       end
 
-      @klass.send :define_method, "#{name}", ->(*args, &block) do
+      klass.send :define_method, "#{name}", ->(*args, &block) do
         aasm(:"#{aasm_name}").current_event = :"#{name}"
         aasm_fire_event(:"#{aasm_name}", :"#{name}", {:persist => false}, *args, &block)
       end
@@ -145,7 +154,7 @@ module AASM
 
     # aasm.event(:event_name).human?
     def human_event_name(event) # event_name?
-      AASM::Localizer.new.human_event_name(@klass, event)
+      AASM::Localizer.new.human_event_name(klass, event)
     end
 
     def states_for_select

data/lib/aasm/configuration.rb

@@ -15,9 +15,15 @@ module AASM
     # for ActiveRecord: use requires_new for nested transactions?
     attr_accessor :requires_new_transaction
 
+    # for ActiveRecord: use pessimistic locking
+    attr_accessor :requires_lock
+
     # forbid direct assignment in aasm_state column (in ActiveRecord)
     attr_accessor :no_direct_assignment
 
+    # allow a AASM::Base sub-class to be used for state machine
+    attr_accessor :with_klass
+
     attr_accessor :enum
   end
-end
+end

data/lib/aasm/core/transition.rb

@@ -53,13 +53,39 @@ module AASM::Core
 
       case code
       when Symbol, String
-        arity = record.__send__(:method, code.to_sym).arity
-        result = (arity == 0 ? record.__send__(code) : result = record.__send__(code, *args))
+        result = (record.__send__(:method, code.to_sym).arity == 0 ? record.__send__(code) : result = record.__send__(code, *args))
         failures << code unless result
         result
       when Proc
-        result = (code.parameters.size == 0 ? record.instance_exec(&code) : record.instance_exec(*args, &code))
-        failures << code.source_location.join('#') unless result
+        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
+          # presence of optional parameters.
+          result = (code.parameters.size == 0 ? record.instance_exec(&code) : record.instance_exec(*args, &code))
+
+          failures << code.source_location.join('#') unless result
+        else
+          # In RubyMotion's Proc, the 'parameter' method does not exists, however its
+          # 'arity' method works just like the one from Method, only returning 0 when
+          # there is no parameters whatsoever, optional or not.
+          result = (code.arity == 0 ? record.instance_exec(&code) : record.instance_exec(*args, &code))
+
+          # Sadly, RubyMotion's Proc does not define the method 'source_location' either.
+          failures << code unless result
+        end
+
+        result
+      when Class
+        arity = code.instance_method(:initialize).arity
+        if arity == 0
+          instance = code.new
+        elsif arity == 1
+          instance = code.new(record)
+        else
+          instance = code.new(record, *args)
+        end
+        result = instance.call
+        failures << instance.method(:call).source_location.join('#') unless result
         result
       when Array
         if options[:guard]

data/lib/aasm/persistence/active_record_persistence.rb

@@ -165,7 +165,15 @@ module AASM
           end
 
           begin
-            success = options[:persist] ? self.class.transaction(:requires_new => requires_new?(state_machine_name)) { super } : super
+            success = if options[:persist]
+              self.class.transaction(:requires_new => requires_new?(state_machine_name)) do
+                lock!(requires_lock?(state_machine_name)) if requires_lock?(state_machine_name)
+                super
+              end
+            else
+              super
+            end
+
             if options[:persist] && success
               event.fire_callbacks(:after_commit, self, *args)
               event.fire_global_callbacks(:after_all_commits, self, *args)
@@ -184,6 +192,10 @@ module AASM
           AASM::StateMachine[self.class][state_machine_name].config.requires_new_transaction
         end
 
+        def requires_lock?(state_machine_name)
+          AASM::StateMachine[self.class][state_machine_name].config.requires_lock
+        end
+
         def aasm_validate_states
           AASM::StateMachine[self.class].keys.each do |state_machine_name|
             unless aasm_skipping_validations(state_machine_name)

data/lib/aasm/persistence/base.rb

@@ -82,7 +82,7 @@ module AASM
 
     def create_for_active_record(name)
       conditions = {
-        "#{@klass.table_name}.#{@klass.aasm(@name).attribute_name}" => name.to_s
+        @klass.table_name => { @klass.aasm(@name).attribute_name => name.to_s }
       }
       if ActiveRecord::VERSION::MAJOR >= 3
         @klass.class_eval do

data/lib/aasm/version.rb

@@ -1,3 +1,3 @@
 module AASM
-  VERSION = "4.8.0"
+  VERSION = "4.9.0"
 end

data/lib/generators/aasm/aasm_generator.rb

@@ -3,8 +3,7 @@ require 'rails/generators/named_base'
 module AASM
   module Generators
     class AASMGenerator < Rails::Generators::NamedBase
-
-      source_root File.expand_path("../templates", __FILE__)
+      namespace "aasm"
       argument :column_name, type: :string, default: 'aasm_state'
 
       desc "Generates a model with the given NAME (if one does not exist) with aasm " <<

data/lib/generators/active_record/aasm_generator.rb

@@ -5,7 +5,7 @@ module ActiveRecord
   module Generators
     class AASMGenerator < ActiveRecord::Generators::Base
       include AASM::Generators::OrmHelpers
-
+      namespace "active_record:aasm"
       argument :column_name, type: :string, default: 'aasm_state'
 
       source_root File.expand_path("../templates", __FILE__)
@@ -16,11 +16,11 @@ module ActiveRecord
         else
           migration_template "migration.rb", "db/migrate/aasm_create_#{table_name}.rb"
         end
-      end 
+      end
 
       def generate_model
         invoke "active_record:model", [name], migration: false unless model_exists?
-      end 
+      end
 
       def inject_aasm_content
         content = model_contents

data/lib/generators/mongoid/aasm_generator.rb

@@ -5,20 +5,20 @@ module Mongoid
   module Generators
     class AASMGenerator < Rails::Generators::NamedBase
       include AASM::Generators::OrmHelpers
-
+      namespace "mongoid:aasm"
       argument :column_name, type: :string, default: 'aasm_state'
 
       def generate_model
         invoke "mongoid:model", [name] unless model_exists?
-      end 
+      end
 
       def inject_aasm_content
         inject_into_file model_path, model_contents, after: "include Mongoid::Document\n" if model_exists?
-      end 
+      end
 
       def inject_field_types
         inject_into_file model_path, migration_data, after: "include Mongoid::Document\n" if model_exists?
-      end 
+      end
 
       def migration_data
         "  field :#{column_name}"

data/spec/database.rb

@@ -17,24 +17,19 @@ ActiveRecord::Migration.suppress_messages do
     t.string "right"
   end
 
-  ActiveRecord::Migration.create_table "validators", :force => true do |t|
-    t.string "name"
-    t.string "status"
-  end
-  ActiveRecord::Migration.create_table "multiple_validators", :force => true do |t|
-    t.string "name"
-    t.string "status"
+  %w(validators multiple_validators).each do |table_name|
+    ActiveRecord::Migration.create_table table_name, :force => true do |t|
+      t.string "name"
+      t.string "status"
+    end
   end
 
-  ActiveRecord::Migration.create_table "transactors", :force => true do |t|
-    t.string "name"
-    t.string "status"
-    t.integer "worker_id"
-  end
-  ActiveRecord::Migration.create_table "multiple_transactors", :force => true do |t|
-    t.string "name"
-    t.string "status"
-    t.integer "worker_id"
+  %w(transactors no_lock_transactors lock_transactors lock_no_wait_transactors multiple_transactors).each do |table_name|
+    ActiveRecord::Migration.create_table table_name, :force => true do |t|
+      t.string "name"
+      t.string "status"
+      t.integer "worker_id"
+    end
   end
 
   ActiveRecord::Migration.create_table "workers", :force => true do |t|

data/spec/models/simple_custom_example.rb

@@ -0,0 +1,53 @@
+class CustomAASMBase < AASM::Base
+  # A custom transiton that we want available across many AASM models.
+  def count_transitions!
+    klass.class_eval do
+      aasm :with_klass => CustomAASMBase do
+        after_all_transitions :increment_transition_count
+      end
+    end
+  end
+
+  # A custom annotation that we want available across many AASM models.
+  def requires_guards!
+    klass.class_eval do
+      attr_reader :authorizable_called,
+        :transition_count,
+        :fillable_called
+
+      def authorizable?
+        @authorizable_called = true
+      end
+
+      def fillable?
+        @fillable_called = true
+      end
+
+      def increment_transition_count
+        @transition_count ||= 0
+        @transition_count += 1
+      end
+    end
+  end
+end
+
+class SimpleCustomExample
+  include AASM
+
+  # Let's build an AASM state machine with our custom class.
+  aasm :with_klass => CustomAASMBase do
+    requires_guards!
+    count_transitions!
+
+    state :initialised, :initial => true
+    state :filled_out
+    state :authorised
+
+    event :fill_out do
+      transitions :from => :initialised, :to => :filled_out, :guard => :fillable?
+    end
+    event :authorise do
+      transitions :from => :filled_out, :to => :authorised, :guard => :authorizable?
+    end
+  end
+end

data/spec/models/transactor.rb

@@ -26,6 +26,54 @@ private
 
 end
 
+class NoLockTransactor < ActiveRecord::Base
+
+  belongs_to :worker
+
+  include AASM
+
+  aasm :column => :status do
+    state :sleeping, :initial => true
+    state :running
+
+    event :run do
+      transitions :to => :running, :from => :sleeping
+    end
+  end
+end
+
+class LockTransactor < ActiveRecord::Base
+
+  belongs_to :worker
+
+  include AASM
+
+  aasm :column => :status, requires_lock: true do
+    state :sleeping, :initial => true
+    state :running
+
+    event :run do
+      transitions :to => :running, :from => :sleeping
+    end
+  end
+end
+
+class LockNoWaitTransactor < ActiveRecord::Base
+
+  belongs_to :worker
+
+  include AASM
+
+  aasm :column => :status, requires_lock: 'FOR UPDATE NOWAIT' do
+    state :sleeping, :initial => true
+    state :running
+
+    event :run do
+      transitions :to => :running, :from => :sleeping
+    end
+  end
+end
+
 class MultipleTransactor < ActiveRecord::Base
 
   belongs_to :worker

data/spec/unit/persistence/active_record_persistence_spec.rb

@@ -425,6 +425,39 @@ describe 'transitions with persistence' do
     expect(persistor).not_to be_sleeping
   end
 
+  describe 'pessimistic locking' do
+    let(:worker) { Worker.create!(:name => 'worker', :status => 'sleeping') }
+
+    subject { transactor.run! }
+
+    context 'no lock' do
+      let(:transactor) { NoLockTransactor.create!(:name => 'no_lock_transactor', :worker => worker) }
+
+      it 'should not invoke lock!' do
+        expect(transactor).to_not receive(:lock!)
+        subject
+      end
+    end
+
+    context 'a default lock' do
+      let(:transactor) { LockTransactor.create!(:name => 'lock_transactor', :worker => worker) }
+
+      it 'should invoke lock! with true' do
+        expect(transactor).to receive(:lock!).with(true).and_call_original
+        subject
+      end
+    end
+
+    context 'a FOR UPDATE NOWAIT lock' do
+      let(:transactor) { LockNoWaitTransactor.create!(:name => 'lock_no_wait_transactor', :worker => worker) }
+
+      it 'should invoke lock! with FOR UPDATE NOWAIT' do
+        expect(transactor).to receive(:lock!).with('FOR UPDATE NOWAIT').and_call_original
+        subject
+      end
+    end
+  end
+
   describe 'transactions' do
     let(:worker) { Worker.create!(:name => 'worker', :status => 'sleeping') }
     let(:transactor) { Transactor.create!(:name => 'transactor', :worker => worker) }

data/spec/unit/simple_custom_example_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe 'Custom AASM::Base' do
+  context 'when aasm_with invoked with SimpleCustomExample' do
+    let(:simple_custom) { SimpleCustomExample.new }
+
+    subject do
+      simple_custom.fill_out!
+      simple_custom.authorise
+    end
+
+    it 'has invoked authorizable?' do
+      expect { subject }.to change { simple_custom.authorizable_called }.from(nil).to(true)
+    end
+
+    it 'has invoked fillable?' do
+      expect { subject }.to change { simple_custom.fillable_called }.from(nil).to(true)
+    end
+
+    it 'has two transition counts' do
+      expect { subject }.to change { simple_custom.transition_count }.from(nil).to(2)
+    end
+  end
+
+  context 'when aasm_with invoked with non AASM::Base' do
+    subject do
+      Class.new do
+        include AASM
+
+        aasm :with_klass => String do
+        end
+      end
+    end
+
+    it 'should raise an ArgumentError' do
+      expect { subject }.to raise_error(ArgumentError, 'The class String must inherit from AASM::Base!')
+    end
+  end
+end

data/spec/unit/transition_spec.rb

@@ -300,3 +300,66 @@ describe AASM::Core::Transition, '- when executing the transition with an :after
   end
 
 end
+
+describe AASM::Core::Transition, '- when executing the transition with a Class' do
+  let(:state_machine) { AASM::StateMachine.new(:name) }
+  let(:event) { AASM::Core::Event.new(:event, state_machine) }
+
+  class AfterTransitionClass
+    def initialize(record)
+      @record = record
+    end
+
+    def call
+      "from: #{@record.aasm.from_state} to: #{@record.aasm.to_state}"
+    end
+  end
+
+  class AfterTransitionClassWithArgs
+    def initialize(record, args)
+      @record = record
+      @args = args
+    end
+
+    def call
+      "arg1: #{@args[:arg1]}, arg2: #{@args[:arg2]}"
+    end
+  end
+
+  class AfterTransitionClassWithoutArgs
+    def call
+      'success'
+    end
+  end
+
+  it 'passes the record to the initialize method on the class to give access to the from_state and to_state' do
+    opts = {:from => 'foo', :to => 'bar', :after => AfterTransitionClass}
+    transition = AASM::Core::Transition.new(event, opts)
+    obj = double('object', :aasm => AASM::InstanceBase.new('object'))
+
+    return_value = transition.execute(obj)
+
+    expect(return_value).to eq('from: foo to: bar')
+  end
+
+  it 'should pass args to the initialize method on the class if it accepts them' do
+    opts = {:from => 'foo', :to => 'bar', :after => AfterTransitionClassWithArgs}
+    st = AASM::Core::Transition.new(event, opts)
+    args = {:arg1 => '1', :arg2 => '2'}
+    obj = double('object', :aasm => 'aasm')
+
+    return_value = st.execute(obj, args)
+
+    expect(return_value).to eq('arg1: 1, arg2: 2')
+  end
+
+  it 'should NOT pass args if the call method of the class if it does NOT accept them' do
+    opts = {:from => 'foo', :to => 'bar', :after => AfterTransitionClassWithoutArgs}
+    st = AASM::Core::Transition.new(event, opts)
+    obj = double('object', :aasm => 'aasm')
+
+    return_value = st.execute(obj)
+
+    expect(return_value).to eq('success')
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aasm
 version: !ruby/object:Gem::Version
-  version: 4.8.0
+  version: 4.9.0
 platform: ruby
 authors:
 - Scott Barron
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-05 00:00:00.000000000 Z
+date: 2016-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -215,6 +215,7 @@ files:
 - spec/models/sequel/sequel_multiple.rb
 - spec/models/sequel/sequel_simple.rb
 - spec/models/silencer.rb
+- spec/models/simple_custom_example.rb
 - spec/models/simple_example.rb
 - spec/models/simple_multiple_example.rb
 - spec/models/state_machine_with_failed_event.rb
@@ -260,6 +261,7 @@ files:
 - spec/unit/readme_spec.rb
 - spec/unit/reloading_spec.rb
 - spec/unit/rspec_matcher_spec.rb
+- spec/unit/simple_custom_example_spec.rb
 - spec/unit/simple_example_spec.rb
 - spec/unit/simple_multiple_example_spec.rb
 - spec/unit/state_spec.rb
@@ -286,7 +288,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: State machine mixin for Ruby objects
@@ -362,6 +364,7 @@ test_files:
 - spec/models/sequel/sequel_multiple.rb
 - spec/models/sequel/sequel_simple.rb
 - spec/models/silencer.rb
+- spec/models/simple_custom_example.rb
 - spec/models/simple_example.rb
 - spec/models/simple_multiple_example.rb
 - spec/models/state_machine_with_failed_event.rb
@@ -407,6 +410,7 @@ test_files:
 - spec/unit/readme_spec.rb
 - spec/unit/reloading_spec.rb
 - spec/unit/rspec_matcher_spec.rb
+- spec/unit/simple_custom_example_spec.rb
 - spec/unit/simple_example_spec.rb
 - spec/unit/simple_multiple_example_spec.rb
 - spec/unit/state_spec.rb