aasm 3.0.24 → 3.1.0

data/lib/aasm/persistence/active_record_persistence.rb

@@ -36,6 +36,12 @@ module AASM
         else
           base.before_validation_on_create(:aasm_ensure_initial_state)
         end
+
+        # ensure initial aasm state even when validations are skipped
+        base.before_create(:aasm_ensure_initial_state)
+
+        # ensure state is in the list of states
+        base.validate :aasm_validate_states
       end
 
       module ClassMethods
@@ -71,10 +77,10 @@ module AASM
         # Writes <tt>state</tt> to the state column and persists it to the database
         #
         #   foo = Foo.find(1)
-        #   foo.aasm_current_state # => :opened
+        #   foo.aasm.current_state # => :opened
         #   foo.close!
-        #   foo.aasm_current_state # => :closed
-        #   Foo.find(1).aasm_current_state # => :closed
+        #   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)
@@ -97,13 +103,13 @@ module AASM
         # 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.aasm.current_state # => :opened
         #   foo.close
-        #   foo.aasm_current_state # => :closed
-        #   Foo.find(1).aasm_current_state # => :opened
+        #   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
+        #   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)
@@ -132,7 +138,7 @@ module AASM
         end
 
         def aasm_fire_event(name, options, *args, &block)
-          success = self.class.transaction(:requires_new => true) do
+          success = self.class.transaction(:requires_new => requires_new?) do
             super
           end
 
@@ -143,6 +149,18 @@ module AASM
 
           success
         end
+
+        def requires_new?
+          AASM::StateMachine[self.class].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")
+            end
+          end
+        end
       end # InstanceMethods
 
     end

data/lib/aasm/persistence/base.rb

@@ -35,7 +35,7 @@ module AASM
       def aasm_read_state
         state = send(self.class.aasm_column)
         if new_record?
-          state.blank? ? aasm.determine_state_name(self.class.aasm_initial_state) : state.to_sym
+          state.blank? ? aasm.determine_state_name(self.class.aasm.initial_state) : state.to_sym
         else
           state.nil? ? nil : state.to_sym
         end

data/lib/aasm/persistence/mongoid_persistence.rb

@@ -36,6 +36,8 @@ module AASM
         # 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
@@ -66,10 +68,10 @@ module AASM
         # using update_attribute (which bypasses validation)
         #
         #   foo = Foo.find(1)
-        #   foo.aasm_current_state # => :opened
+        #   foo.aasm.current_state # => :opened
         #   foo.close!
-        #   foo.aasm_current_state # => :closed
-        #   Foo.find(1).aasm_current_state # => :closed
+        #   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)
@@ -87,13 +89,13 @@ module AASM
         # 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.aasm.current_state # => :opened
         #   foo.close
-        #   foo.aasm_current_state # => :closed
-        #   Foo.find(1).aasm_current_state # => :opened
+        #   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
+        #   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)

data/lib/aasm/state.rb

@@ -50,6 +50,7 @@ module AASM
     def localized_name
       AASM::Localizer.new.human_state_name(@clazz, self)
     end
+    alias human_name localized_name
 
     def for_select
       [display_name, name.to_s]

data/lib/aasm/transition.rb

@@ -4,20 +4,24 @@ module AASM
     alias_method :options, :opts
 
     def initialize(opts)
-      @from, @to, @guard, @on_transition = opts[:from], opts[:to], opts[:guard], opts[:on_transition]
+      @from = opts[:from]
+      @to = opts[:to]
+      @guards = Array(opts[:guard] || opts[:guards])
+      @on_transition = opts[:on_transition]
       @opts = opts
     end
 
     # TODO: should be named allowed? or similar
     def perform(obj, *args)
-      case @guard
+      @guards.each do |guard|
+        case guard
         when Symbol, String
-          obj.send(@guard, *args)
+          return false unless obj.send(guard, *args)
         when Proc
-          @guard.call(obj, *args)
-        else
-          true
+          return false unless guard.call(obj, *args)
+        end
       end
+      true
     end
 
     def execute(obj, *args)
@@ -37,6 +41,9 @@ module AASM
     private
 
     def _execute(obj, on_transition, *args)
+      obj.aasm.from_state = @from if obj.aasm.respond_to?(:from_state=)
+      obj.aasm.to_state = @to if obj.aasm.respond_to?(:to_state=)
+
       case on_transition
       when Proc
         on_transition.arity == 0 ? on_transition.call : on_transition.call(obj, *args)

data/lib/aasm/version.rb

@@ -1,3 +1,3 @@
 module AASM
-  VERSION = "3.0.24"
+  VERSION = "3.1.0"
 end

data/lib/aasm.rb

@@ -13,6 +13,3 @@ require 'ostruct'
     persistence
     aasm
   ).each { |file| require File.join(File.dirname(__FILE__), 'aasm', file) }
-
-# load the deprecated methods and modules
-Dir[File.join(File.dirname(__FILE__), 'aasm', 'deprecated', '*.rb')].sort.each { |f| require File.expand_path(f) }

data/spec/database.rb

@@ -0,0 +1,33 @@
+ActiveRecord::Migration.suppress_messages do
+  %w{gates readers writers transients simples simple_new_dsls no_scopes thieves localizer_test_models persisted_states provided_and_persisted_states}.each do |table_name|
+    ActiveRecord::Migration.create_table table_name, :force => true do |t|
+      t.string "aasm_state"
+    end
+  end
+
+  ActiveRecord::Migration.create_table "validators", :force => true do |t|
+    t.string "name"
+    t.string "status"
+  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 "workers", :force => true do |t|
+    t.string "name"
+    t.string "status"
+  end
+
+  ActiveRecord::Migration.create_table "invalid_persistors", :force => true do |t|
+    t.string "name"
+    t.string "status"
+  end
+
+  ActiveRecord::Migration.create_table "fathers", :force => true do |t|
+    t.string "aasm_state"
+    t.string "type"
+  end
+end

data/spec/models/guardian.rb

@@ -0,0 +1,48 @@
+class Guardian
+  include AASM
+
+  aasm do
+    state :alpha, :initial => true
+    state :beta
+
+    event :use_one_guard_that_succeeds do
+      transitions :from => :alpha, :to => :beta, :guard => :succeed
+    end
+    event :use_one_guard_that_fails do
+      transitions :from => :alpha, :to => :beta, :guard => :fail
+    end
+
+    event :use_guards_that_succeed do
+      transitions :from => :alpha, :to => :beta, :guards => [:succeed, :another_succeed]
+    end
+    event :use_guards_where_the_first_fails do
+      transitions :from => :alpha, :to => :beta, :guards => [:succeed, :fail]
+    end
+    event :use_guards_where_the_second_fails do
+      transitions :from => :alpha, :to => :beta, :guards => [:fail, :succeed]
+    end
+
+    event :use_event_guards_that_succeed, :guards => [:succeed, :another_succeed] do
+      transitions :from => :alpha, :to => :beta
+    end
+    event :use_event_and_transition_guards_that_succeed, :guards => [:succeed, :another_succeed] do
+      transitions :from => :alpha, :to => :beta, :guards => [:more_succeed]
+    end
+    event :use_event_guards_where_the_first_fails, :guards => [:succeed, :fail] do
+      transitions :from => :alpha, :to => :beta
+    end
+    event :use_event_guards_where_the_second_fails, :guards => [:fail, :succeed] do
+      transitions :from => :alpha, :to => :beta, :guard => :another_succeed
+    end
+    event :use_event_and_transition_guards_where_third_fails, :guards => [:succeed, :another_succeed] do
+      transitions :from => :alpha, :to => :beta, :guards => [:fail]
+    end
+  end
+
+  def fail; false; end
+
+  def succeed; true; end
+  def another_succeed; true; end
+  def more_succeed; true; end
+
+end

data/spec/models/mongoid/no_scope_mongoid.rb

@@ -2,7 +2,7 @@ class NoScopeMongoid
   include Mongoid::Document
   include AASM
 
-  field :status, type: String
+  field :status, :type => String
 
   aasm :create_scopes => false, :column => :status do
     state :ignored_scope

data/spec/models/mongoid/simple_mongoid.rb

@@ -2,9 +2,10 @@ class SimpleMongoid
   include Mongoid::Document
   include AASM
 
-  field :status, type: String
+  field :status, :type => String
 
-  aasm_column :status
-  aasm_state :unknown_scope
-  aasm_state :new
+  aasm column: :status do
+    state :unknown_scope
+    state :new
+  end
 end

data/spec/models/mongoid/simple_new_dsl_mongoid.rb

@@ -2,7 +2,7 @@ class SimpleNewDslMongoid
   include Mongoid::Document
   include AASM
 
-  field :status, type: String
+  field :status, :type => String
 
   aasm :column => :status
   aasm do

data/spec/models/not_auto_loaded/process.rb

@@ -2,16 +2,18 @@ module Models
   class Process
     include AASM
 
-    aasm_state :sleeping
-    aasm_state :running
-    aasm_state :suspended
+    aasm do
+      state :sleeping
+      state :running
+      state :suspended
 
-    aasm_event :start do
-      transitions :from => :sleeping, :to => :running
-    end
+      event :start do
+        transitions :from => :sleeping, :to => :running
+      end
 
-    aasm_event :stop do
-      transitions :from => :running, :to => :suspended
+      event :stop do
+        transitions :from => :running, :to => :suspended
+      end
     end
 
   end

data/spec/models/persistence.rb

@@ -36,13 +36,6 @@ class Transient < ActiveRecord::Base
   include AASM
 end
 
-class Simple < ActiveRecord::Base
-  include AASM
-  aasm_column :status
-  aasm_state :unknown_scope
-  aasm_state :new
-end
-
 class SimpleNewDsl < ActiveRecord::Base
   include AASM
   aasm :column => :status
@@ -59,9 +52,6 @@ class NoScope < ActiveRecord::Base
   end
 end
 
-class Derivate < Simple
-end
-
 class DerivateNewDsl < SimpleNewDsl
 end
 
@@ -72,8 +62,10 @@ class Thief < ActiveRecord::Base
     set_table_name "thieves"
   end
   include AASM
-  aasm_initial_state  Proc.new { |thief| thief.skilled ? :rich : :jailed }
-  aasm_state          :rich
-  aasm_state          :jailed
+  aasm do
+    state :rich
+    state :jailed
+    initial_state Proc.new {|thief| thief.skilled ? :rich : :jailed }
+  end
   attr_accessor :skilled, :aasm_state
 end

data/spec/spec_helper.rb

@@ -16,7 +16,7 @@ def load_schema
   config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
   ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
   ActiveRecord::Base.establish_connection(config['sqlite3'])
-  load(File.dirname(__FILE__) + "/schema.rb")
+  require File.dirname(__FILE__) + "/database.rb"
 end
 
 # custom spec helpers

data/spec/unit/api_spec.rb

@@ -3,19 +3,19 @@ require 'models/active_record/api.rb'
 
 describe "reading the current state" do
   it "uses the AASM default" do
-    DefaultState.new.aasm.current_state.should eql :alpha
+    expect(DefaultState.new.aasm.current_state).to eql :alpha
   end
 
   it "uses the provided method" do
-    ProvidedState.new.aasm.current_state.should eql :beta
+    expect(ProvidedState.new.aasm.current_state).to eql :beta
   end
 
   it "uses the persistence storage" do
-    PersistedState.new.aasm.current_state.should eql :alpha
+    expect(PersistedState.new.aasm.current_state).to eql :alpha
   end
 
   it "uses the provided method even if persisted" do
-    ProvidedAndPersistedState.new.aasm.current_state.should eql :gamma
+    expect(ProvidedAndPersistedState.new.aasm.current_state).to eql :gamma
   end
 end
 
@@ -23,25 +23,25 @@ describe "writing and persisting the current state" do
   it "uses the AASM default" do
     o = DefaultState.new
     o.release!
-    o.persisted_store.should be_nil
+    expect(o.persisted_store).to be_nil
   end
 
   it "uses the provided method" do
     o = ProvidedState.new
     o.release!
-    o.persisted_store.should eql :beta
+    expect(o.persisted_store).to eql :beta
   end
 
   it "uses the persistence storage" do
     o = PersistedState.new
     o.release!
-    o.persisted_store.should be_nil
+    expect(o.persisted_store).to be_nil
   end
 
   it "uses the provided method even if persisted" do
     o = ProvidedAndPersistedState.new
     o.release!
-    o.persisted_store.should eql :beta
+    expect(o.persisted_store).to eql :beta
   end
 end
 
@@ -49,24 +49,24 @@ describe "writing the current state without persisting it" do
   it "uses the AASM default" do
     o = DefaultState.new
     o.release
-    o.transient_store.should be_nil
+    expect(o.transient_store).to be_nil
   end
 
   it "uses the provided method" do
     o = ProvidedState.new
     o.release
-    o.transient_store.should eql :beta
+    expect(o.transient_store).to eql :beta
   end
 
   it "uses the persistence storage" do
     o = PersistedState.new
     o.release
-    o.transient_store.should be_nil
+    expect(o.transient_store).to be_nil
   end
 
   it "uses the provided method even if persisted" do
     o = ProvidedAndPersistedState.new
     o.release
-    o.transient_store.should eql :beta
+    expect(o.transient_store).to eql :beta
   end
 end

data/spec/unit/callbacks_spec.rb

@@ -1,36 +1,18 @@
 require 'spec_helper'
 
-describe 'callbacks for the old DSL' do
-  let(:callback) {CallbackOldDsl.new}
-
-  it "should get close callbacks" do
-    callback.should_receive(:exit_open).once.ordered
-    callback.should_receive(:before).once.ordered
-    callback.should_receive(:before_exit_open).once.ordered                   # these should be before the state changes
-    callback.should_receive(:before_enter_closed).once.ordered
-    callback.should_receive(:enter_closed).once.ordered
-    callback.should_receive(:aasm_write_state).once.ordered.and_return(true)  # this is when the state changes
-    callback.should_receive(:after_exit_open).once.ordered                    # these should be after the state changes
-    callback.should_receive(:after_enter_closed).once.ordered
-    callback.should_receive(:after).once.ordered
-
-    callback.close!
-  end
-end
-
 describe 'callbacks for the new DSL' do
   let(:callback) {CallbackNewDsl.new}
 
   it "be called in order" do
-    callback.should_receive(:exit_open).once.ordered
-    callback.should_receive(:before).once.ordered
-    callback.should_receive(:before_exit_open).once.ordered                   # these should be before the state changes
-    callback.should_receive(:before_enter_closed).once.ordered
-    callback.should_receive(:enter_closed).once.ordered
-    callback.should_receive(:aasm_write_state).once.ordered.and_return(true)  # this is when the state changes
-    callback.should_receive(:after_exit_open).once.ordered                    # these should be after the state changes
-    callback.should_receive(:after_enter_closed).once.ordered
-    callback.should_receive(:after).once.ordered
+    expect(callback).to receive(:exit_open).once.ordered
+    expect(callback).to receive(:before).once.ordered
+    expect(callback).to receive(:before_exit_open).once.ordered                   # these should be before the state changes
+    expect(callback).to receive(:before_enter_closed).once.ordered
+    expect(callback).to receive(:enter_closed).once.ordered
+    expect(callback).to receive(:aasm_write_state).once.ordered.and_return(true)  # this is when the state changes
+    expect(callback).to receive(:after_exit_open).once.ordered                    # these should be after the state changes
+    expect(callback).to receive(:after_enter_closed).once.ordered
+    expect(callback).to receive(:after).once.ordered
 
     callback.close!
   end
@@ -40,8 +22,10 @@ describe 'event callbacks' do
   describe "with an error callback defined" do
     before do
       class Foo
-        aasm_event :safe_close, :success => :success_callback, :error => :error_callback do
-          transitions :to => :closed, :from => [:open]
+        aasm do
+          event :safe_close, :success => :success_callback, :error => :error_callback do
+            transitions :to => :closed, :from => [:open]
+          end
         end
       end
 
@@ -51,20 +35,20 @@ describe 'event callbacks' do
     it "should run error_callback if an exception is raised and error_callback defined" do
       def @foo.error_callback(e); end
 
-      @foo.stub(:enter).and_raise(e=StandardError.new)
-      @foo.should_receive(:error_callback).with(e)
+      allow(@foo).to receive(:enter).and_raise(e=StandardError.new)
+      expect(@foo).to receive(:error_callback).with(e)
 
       @foo.safe_close!
     end
 
     it "should raise NoMethodError if exceptionis raised and error_callback is declared but not defined" do
-      @foo.stub(:enter).and_raise(StandardError)
-      lambda{@foo.safe_close!}.should raise_error(NoMethodError)
+      allow(@foo).to receive(:enter).and_raise(StandardError)
+      expect{@foo.safe_close!}.to raise_error(NoMethodError)
     end
 
     it "should propagate an error if no error callback is declared" do
-        @foo.stub(:enter).and_raise("Cannot enter safe")
-        lambda{@foo.close!}.should raise_error(StandardError, "Cannot enter safe")
+        allow(@foo).to receive(:enter).and_raise("Cannot enter safe")
+        expect{@foo.close!}.to raise_error(StandardError, "Cannot enter safe")
     end
   end
 
@@ -75,18 +59,18 @@ describe 'event callbacks' do
     end
 
     it 'should call it for successful bang fire' do
-      @foo.should_receive(:aasm_event_fired).with(:close, :open, :closed)
+      expect(@foo).to receive(:aasm_event_fired).with(:close, :open, :closed)
       @foo.close!
     end
 
     it 'should call it for successful non-bang fire' do
-      @foo.should_receive(:aasm_event_fired)
+      expect(@foo).to receive(:aasm_event_fired)
       @foo.close
     end
 
     it 'should not call it for failing bang fire' do
-      @foo.aasm.stub(:set_current_state_with_persistence).and_return(false)
-      @foo.should_not_receive(:aasm_event_fired)
+      allow(@foo.aasm).to receive(:set_current_state_with_persistence).and_return(false)
+      expect(@foo).not_to receive(:aasm_event_fired)
       @foo.close!
     end
   end
@@ -98,18 +82,18 @@ describe 'event callbacks' do
     end
 
     it 'should call it when transition failed for bang fire' do
-      @foo.should_receive(:aasm_event_failed).with(:null, :open)
-      lambda {@foo.null!}.should raise_error(AASM::InvalidTransition)
+      expect(@foo).to receive(:aasm_event_failed).with(:null, :open)
+      expect {@foo.null!}.to raise_error(AASM::InvalidTransition)
     end
 
     it 'should call it when transition failed for non-bang fire' do
-      @foo.should_receive(:aasm_event_failed).with(:null, :open)
-      lambda {@foo.null}.should raise_error(AASM::InvalidTransition)
+      expect(@foo).to receive(:aasm_event_failed).with(:null, :open)
+      expect {@foo.null}.to raise_error(AASM::InvalidTransition)
     end
 
     it 'should not call it if persist fails for bang fire' do
-      @foo.aasm.stub(:set_current_state_with_persistence).and_return(false)
-      @foo.should_receive(:aasm_event_failed)
+      allow(@foo.aasm).to receive(:set_current_state_with_persistence).and_return(false)
+      expect(@foo).to receive(:aasm_event_failed)
       @foo.close!
     end
   end