aasm 4.0.5 → 4.1.0

data/spec/models/callbacks/basic.rb

@@ -6,6 +6,15 @@ module Callbacks
       @fail_event_guard = options[:fail_event_guard]
       @fail_transition_guard = options[:fail_transition_guard]
       @log = options[:log]
+      reset_data
+    end
+
+    def reset_data
+      @data = []
+    end
+
+    def data
+      @data.join(' ')
     end
 
     aasm do
@@ -35,28 +44,32 @@ module Callbacks
     end
 
     def log(text)
+      @data << text
       puts text if @log
     end
 
-    def before_enter_open; log('before_enter_open'); end
-    def enter_open; log('enter_open'); end
-    def before_exit_open; log('before_exit_open'); end
-    def after_enter_open; log('after_enter_open'); end
-    def exit_open; log('exit_open'); end
-    def after_exit_open; log('after_exit_open'); end
-
-    def before_enter_closed; log('before_enter_closed'); end
-    def enter_closed; log('enter_closed'); end
-    def before_exit_closed; log('before_exit_closed'); end
-    def exit_closed; log('exit_closed'); end
-    def after_enter_closed; log('after_enter_closed'); end
-    def after_exit_closed; log('after_exit_closed'); end
-
-    def event_guard; log('event_guard'); !@fail_event_guard; end
-    def transition_guard; log('transition_guard'); !@fail_transition_guard; end
-    def after_transition; log('after_transition'); end
-
-    def before_event; log('before_event'); end
-    def after_event; log('after_event'); end
+    def aasm_write_state(*args); log('aasm_write_state'); true; end
+
+    def before_enter_open;    log('before_enter_open');   end
+    def enter_open;           log('enter_open');          end
+    def before_exit_open;     log('before_exit_open');    end
+    def after_enter_open;     log('after_enter_open');    end
+    def exit_open;            log('exit_open');           end
+    def after_exit_open;      log('after_exit_open');     end
+
+    def before_enter_closed;  log('before_enter_closed'); end
+    def enter_closed;         log('enter_closed');        end
+    def before_exit_closed;   log('before_exit_closed');  end
+    def exit_closed;          log('exit_closed');         end
+    def after_enter_closed;   log('after_enter_closed');  end
+    def after_exit_closed;    log('after_exit_closed');   end
+
+    def event_guard;          log('event_guard');         !@fail_event_guard;      end
+    def transition_guard;     log('transition_guard');    !@fail_transition_guard; end
+
+    def after_transition;     log('after_transition');    end
+
+    def before_event;         log('before_event');        end
+    def after_event;          log('after_event');         end
   end
 end

data/spec/models/callbacks/private_method.rb

@@ -0,0 +1,44 @@
+module Callbacks
+  class PrivateMethod
+    include AASM
+
+    def initialize(options={})
+      @fail_event_guard = options[:fail_event_guard]
+      @fail_transition_guard = options[:fail_transition_guard]
+      @log = options[:log]
+      reset_data
+    end
+
+    def reset_data
+      @data = []
+    end
+
+    def data
+      @data.join(' ')
+    end
+
+    aasm do
+      state :open, :initial => true
+      state :closed
+
+      event :close, :after => :after_event do
+        transitions :to => :closed, :from => [:open]
+      end
+
+      event :open, :after => :after_event do
+        transitions :to => :open, :from => :closed
+      end
+    end
+
+    def log(text)
+      @data << text
+      puts text if @log
+    end
+
+    def aasm_write_state(*args); log('aasm_write_state'); true; end
+
+    private
+
+    def after_event; log('after_event'); end
+  end
+end

data/spec/models/callbacks/with_args.rb

@@ -2,6 +2,19 @@ module Callbacks
   class WithArgs
     include AASM
 
+    def initialize(options={})
+      @log = options[:log]
+      reset_data
+    end
+
+    def reset_data
+      @data = []
+    end
+
+    def data
+      @data.join(' ')
+    end
+
     aasm do
       state :open, :initial => true,
         :before_enter => :before_enter_open,
@@ -25,9 +38,12 @@ module Callbacks
     end
 
     def log(text)
-      # puts text
+      @data << text
+      puts text if @log
     end
 
+    def aasm_write_state(*args); log('aasm_write_state'); true; end
+
     def before_enter_open; log('before_enter_open'); end
     def before_exit_open; log('before_exit_open'); end
     def after_enter_open; log('after_enter_open'); end
@@ -38,8 +54,8 @@ module Callbacks
     def after_enter_closed; log('after_enter_closed'); end
     def after_exit_closed; log('after_exit_closed'); end
 
-    def before(*args); log('before'); end
-    def transition_proc(arg1, arg2); log('transition_proc'); end
-    def after(*args); log('after'); end
+    def before(arg1, *args); log("before(#{arg1.inspect},#{args.map(&:inspect).join(',')})"); end
+    def transition_proc(arg1, arg2); log("transition_proc(#{arg1.inspect},#{arg2.inspect})"); end
+    def after(*args); log("after(#{args.map(&:inspect).join(',')})"); end
   end
 end

data/spec/models/mongo_mapper/no_scope_mongo_mapper.rb

@@ -0,0 +1,10 @@
+class NoScopeMongoMapper
+  include MongoMapper::Document
+  include AASM
+
+  key :status, String
+
+  aasm :create_scopes => false, :column => :status do
+    state :ignored_scope
+  end
+end

data/spec/models/mongo_mapper/simple_mongo_mapper.rb

@@ -0,0 +1,11 @@
+class SimpleMongoMapper
+  include MongoMapper::Document
+  include AASM
+
+  key :status, String
+
+  aasm column: :status do
+    state :unknown_scope
+    state :next
+  end
+end

data/spec/models/mongo_mapper/simple_new_dsl_mongo_mapper.rb

@@ -0,0 +1,12 @@
+class SimpleNewDslMongoMapper
+  include MongoMapper::Document
+  include AASM
+
+  key :status, String
+
+  aasm :column => :status
+  aasm do
+    state :unknown_scope
+    state :next
+  end
+end

data/spec/models/mongoid/simple_new_dsl_mongoid.rb

@@ -6,7 +6,7 @@ class SimpleNewDslMongoid
 
   aasm :column => :status
   aasm do
-    state :unknown_scope
+    state :unknown_scope, :initial => true
     state :new
   end
 end

data/spec/models/persistence.rb

@@ -18,6 +18,24 @@ class Gate < ActiveRecord::Base
   end
 end
 
+class FalseState < ActiveRecord::Base
+  include AASM
+
+  def initialize(*args)
+    super
+    self.aasm_state = false
+  end
+
+  aasm do
+    state :opened
+    state :closed
+
+    event :view do
+      transitions :to => :read, :from => [:needs_attention]
+    end
+  end
+end
+
 class WithEnum < ActiveRecord::Base
   include AASM
 

data/spec/spec_helper.rb

@@ -3,7 +3,6 @@ $LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib
 require 'aasm'
 
 require 'rspec'
-require 'rspec/autorun'
 
 require 'coveralls'
 Coveralls.wear!
@@ -12,6 +11,8 @@ Coveralls.wear!
 # require 'ruby-debug/completion'
 # require 'pry'
 
+SEQUEL_DB = defined?(JRUBY_VERSION) ? 'jdbc:sqlite::memory:' : 'sqlite:/'
+
 def load_schema
   config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
   ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")

data/spec/unit/callbacks_spec.rb

@@ -52,6 +52,18 @@ describe 'callbacks for the new DSL' do
     }.to raise_error(AASM::InvalidTransition)
   end
 
+  it "it handles private callback methods as well" do
+    show_debug_log = false
+
+    callback = Callbacks::PrivateMethod.new(:log => show_debug_log)
+    callback.aasm.current_state
+
+    # puts "------- close!"
+    expect {
+      callback.close!
+    }.to_not raise_error
+  end
+
   context "if the transition guard fails" do
     it "does not run any state callback if guard is defined inline" do
       show_debug_log = false
@@ -128,51 +140,44 @@ describe 'callbacks for the new DSL' do
   end
 
   it "should properly pass arguments" do
-    cb = Callbacks::WithArgs.new
-
-    # TODO: use expect syntax here
-    cb.should_receive(:before).with(:arg1, :arg2).once.ordered
-    cb.should_receive(:before_exit_open).once.ordered                   # these should be before the state changes
-    cb.should_receive(:transition_proc).with(:arg1, :arg2).once.ordered
-    cb.should_receive(:before_enter_closed).once.ordered
-    cb.should_receive(:aasm_write_state).once.ordered.and_return(true)  # this is when the state changes
-    cb.should_receive(:after_exit_open).once.ordered                    # these should be after the state changes
-    cb.should_receive(:after_enter_closed).once.ordered
-    cb.should_receive(:after).with(:arg1, :arg2).once.ordered
+    cb = Callbacks::WithArgs.new(:log => false)
+    cb.aasm.current_state
 
+    cb.reset_data
     cb.close!(:arg1, :arg2)
+    expect(cb.data).to eql 'before(:arg1,:arg2) before_exit_open transition_proc(:arg1,:arg2) before_enter_closed aasm_write_state after_exit_open after_enter_closed after(:arg1,:arg2)'
   end
 
   it "should call the callbacks given the to-state as argument" do
     cb = Callbacks::WithStateArg.new
-    cb.should_receive(:before_method).with(:arg1).once.ordered
-    cb.should_receive(:transition_method).never
-    cb.should_receive(:transition_method2).with(:arg1).once.ordered
-    cb.should_receive(:after_method).with(:arg1).once.ordered
+    expect(cb).to receive(:before_method).with(:arg1).once.ordered
+    expect(cb).to receive(:transition_method).never
+    expect(cb).to receive(:transition_method2).with(:arg1).once.ordered
+    expect(cb).to receive(:after_method).with(:arg1).once.ordered
     cb.close!(:out_to_lunch, :arg1)
 
     cb = Callbacks::WithStateArg.new
     some_object = double('some object')
-    cb.should_receive(:before_method).with(some_object).once.ordered
-    cb.should_receive(:transition_method2).with(some_object).once.ordered
-    cb.should_receive(:after_method).with(some_object).once.ordered
+    expect(cb).to receive(:before_method).with(some_object).once.ordered
+    expect(cb).to receive(:transition_method2).with(some_object).once.ordered
+    expect(cb).to receive(:after_method).with(some_object).once.ordered
     cb.close!(:out_to_lunch, some_object)
   end
 
   it "should call the proper methods just with arguments" do
     cb = Callbacks::WithStateArg.new
-    cb.should_receive(:before_method).with(:arg1).once.ordered
-    cb.should_receive(:transition_method).with(:arg1).once.ordered
-    cb.should_receive(:transition_method).never
-    cb.should_receive(:after_method).with(:arg1).once.ordered
+    expect(cb).to receive(:before_method).with(:arg1).once.ordered
+    expect(cb).to receive(:transition_method).with(:arg1).once.ordered
+    expect(cb).to receive(:transition_method).never
+    expect(cb).to receive(:after_method).with(:arg1).once.ordered
     cb.close!(:arg1)
 
     cb = Callbacks::WithStateArg.new
     some_object = double('some object')
-    cb.should_receive(:before_method).with(some_object).once.ordered
-    cb.should_receive(:transition_method).with(some_object).once.ordered
-    cb.should_receive(:transition_method).never
-    cb.should_receive(:after_method).with(some_object).once.ordered
+    expect(cb).to receive(:before_method).with(some_object).once.ordered
+    expect(cb).to receive(:transition_method).with(some_object).once.ordered
+    expect(cb).to receive(:transition_method).never
+    expect(cb).to receive(:after_method).with(some_object).once.ordered
     cb.close!(some_object)
   end
 end
@@ -181,6 +186,10 @@ describe 'event callbacks' do
   describe "with an error callback defined" do
     before do
       class Foo
+        # this hack is needed to allow testing of parameters, since RSpec
+        # destroys a method's arity when mocked
+        attr_accessor :data
+
         aasm do
           event :safe_close, :success => :success_callback, :error => :error_callback do
             transitions :to => :closed, :from => [:open]
@@ -191,16 +200,42 @@ describe 'event callbacks' do
       @foo = Foo.new
     end
 
-    it "should run error_callback if an exception is raised and error_callback defined" do
-      def @foo.error_callback(e); end
+    context "error_callback defined" do
+      it "should run error_callback if an exception is raised" do
+        def @foo.error_callback(e)
+          @data = [e]
+        end
 
-      allow(@foo).to receive(:before_enter).and_raise(e = StandardError.new)
-      expect(@foo).to receive(:error_callback).with(e)
+        allow(@foo).to receive(:before_enter).and_raise(e = StandardError.new)
 
-      @foo.safe_close!
+        @foo.safe_close!
+        expect(@foo.data).to eql [e]
+      end
+
+      it "should run error_callback without parameters if callback does not support any" do
+        def @foo.error_callback(e)
+          @data = []
+        end
+
+        allow(@foo).to receive(:before_enter).and_raise(e = StandardError.new)
+
+        @foo.safe_close!('arg1', 'arg2')
+        expect(@foo.data).to eql []
+      end
+
+      it "should run error_callback with parameters if callback supports them" do
+        def @foo.error_callback(e, arg1, arg2)
+          @data = [arg1, arg2]
+        end
+
+        allow(@foo).to receive(:before_enter).and_raise(e = StandardError.new)
+
+        @foo.safe_close!('arg1', 'arg2')
+        expect(@foo.data).to eql ['arg1', 'arg2']
+      end
     end
 
-    it "should raise NoMethodError if exceptionis raised and error_callback is declared but not defined" do
+    it "should raise NoMethodError if exception is raised and error_callback is declared but not defined" do
       allow(@foo).to receive(:before_enter).and_raise(StandardError)
       expect{@foo.safe_close!}.to raise_error(NoMethodError)
     end
@@ -256,4 +291,5 @@ describe 'event callbacks' do
       @foo.close!
     end
   end
+
 end

data/spec/unit/complex_example_spec.rb

@@ -8,7 +8,7 @@ describe 'on initialization' do
   end
 
   it 'should have an activation code' do
-    expect(auth.has_activation_code?).to be_true
+    expect(auth.has_activation_code?).to be_truthy
     expect(auth.activation_code).not_to be_nil
   end
 end
@@ -19,24 +19,24 @@ describe 'when being unsuspended' do
   it 'should be able to be unsuspended' do
     auth.activate!
     auth.suspend!
-    expect(auth.may_unsuspend?).to be_true
+    expect(auth.may_unsuspend?).to be true
   end
 
   it 'should not be able to be unsuspended into active' do
     auth.suspend!
-    expect(auth.may_unsuspend?(:active)).not_to be_true
+    expect(auth.may_unsuspend?(:active)).not_to be true
   end
 
   it 'should be able to be unsuspended into active if polite' do
     auth.suspend!
-    expect(auth.may_wait?(:waiting, :please)).to be_true
+    expect(auth.may_wait?(:waiting, :please)).to be true
     auth.wait!(nil, :please)
   end
 
   it 'should not be able to be unsuspended into active if not polite' do
     auth.suspend!
-    expect(auth.may_wait?(:waiting)).not_to be_true
-    expect(auth.may_wait?(:waiting, :rude)).not_to be_true
+    expect(auth.may_wait?(:waiting)).not_to be true
+    expect(auth.may_wait?(:waiting, :rude)).not_to be true
     expect {auth.wait!(nil, :rude)}.to raise_error(AASM::InvalidTransition)
     expect {auth.wait!}.to raise_error(AASM::InvalidTransition)
   end
@@ -46,7 +46,7 @@ describe 'when being unsuspended' do
     auth.suspend!
     auth.unsuspend!
 
-    expect(auth.may_unpassify?).not_to be_true
+    expect(auth.may_unpassify?).not_to be true
     expect {auth.unpassify!}.to raise_error(AASM::InvalidTransition)
   end
 
@@ -74,11 +74,11 @@ describe 'when being unsuspended' do
   end
 
   it "should be able to fire known events" do
-    expect(auth.aasm.may_fire_event?(:activate)).to be_true
+    expect(auth.aasm.may_fire_event?(:activate)).to be true
   end
 
   it "should not be able to fire unknown events" do
-    expect(auth.aasm.may_fire_event?(:unknown)).to be_false
+    expect(auth.aasm.may_fire_event?(:unknown)).to be false
   end
 
 end

data/spec/unit/event_spec.rb

@@ -43,18 +43,18 @@ describe 'transition inspection' do
 
   it 'should support inspecting transitions from other states' do
     expect(event.transitions_from_state(:sleeping).map(&:to)).to eq([:running])
-    expect(event.transitions_from_state?(:sleeping)).to be_true
+    expect(event.transitions_from_state?(:sleeping)).to be_truthy
 
     expect(event.transitions_from_state(:cleaning).map(&:to)).to eq([])
-    expect(event.transitions_from_state?(:cleaning)).to be_false
+    expect(event.transitions_from_state?(:cleaning)).to be_falsey
   end
 
   it 'should support inspecting transitions to other states' do
     expect(event.transitions_to_state(:running).map(&:from)).to eq([:sleeping])
-    expect(event.transitions_to_state?(:running)).to be_true
+    expect(event.transitions_to_state?(:running)).to be_truthy
 
     expect(event.transitions_to_state(:cleaning).map(&:to)).to eq([])
-    expect(event.transitions_to_state?(:cleaning)).to be_false
+    expect(event.transitions_to_state?(:cleaning)).to be_falsey
   end
 end
 
@@ -67,10 +67,10 @@ describe 'transition inspection without from' do
 
   it 'should support inspecting transitions from other states' do
     expect(event.transitions_from_state(:sleeping).map(&:to)).to eq([:running])
-    expect(event.transitions_from_state?(:sleeping)).to be_true
+    expect(event.transitions_from_state?(:sleeping)).to be_truthy
 
     expect(event.transitions_from_state(:cleaning).map(&:to)).to eq([:running])
-    expect(event.transitions_from_state?(:cleaning)).to be_true
+    expect(event.transitions_from_state?(:cleaning)).to be_truthy
   end
 
 end

data/spec/unit/inspection_spec.rb

@@ -67,11 +67,11 @@ describe "special cases" do
     expect(Argument.aasm.states).to include(:valid)
 
     argument = Argument.new
-    expect(argument.invalid?).to be_true
+    expect(argument.invalid?).to be_truthy
     expect(argument.aasm.current_state).to eq(:invalid)
 
     argument.valid!
-    expect(argument.valid?).to be_true
+    expect(argument.valid?).to be_truthy
     expect(argument.aasm.current_state).to eq(:valid)
   end
 end