aasm 3.4.0 → 4.0.0

data/spec/unit/callbacks_spec.rb

@@ -1,12 +1,19 @@
 require 'spec_helper'
 
 describe 'callbacks for the new DSL' do
-  let(:callback) {CallbackNewDsl.new}
 
   it "be called in order" do
-    expect(callback).to receive(:exit_open).once.ordered
+    callback = CallbackNewDsl.new
+    callback.aasm.current_state
+
     expect(callback).to receive(:before).once.ordered
+    expect(callback).to receive(:event_guard).once.ordered.and_return(true)
+    expect(callback).to receive(:transition_guard).once.ordered.and_return(true)
     expect(callback).to receive(:before_exit_open).once.ordered                   # these should be before the state changes
+    expect(callback).to receive(:exit_open).once.ordered
+    expect(callback).to receive(:event_guard).once.ordered.and_return(true)
+    expect(callback).to receive(:transition_guard).once.ordered.and_return(true)
+    expect(callback).to receive(:transitioning).once.ordered
     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
@@ -14,8 +21,102 @@ describe 'callbacks for the new DSL' do
     expect(callback).to receive(:after_enter_closed).once.ordered
     expect(callback).to receive(:after).once.ordered
 
+    # puts "------- close!"
     callback.close!
   end
+
+  it "does not run any state callback if the event guard fails" do
+    callback = CallbackNewDsl.new(:log => false)
+    callback.aasm.current_state
+
+    expect(callback).to receive(:before).once.ordered
+    expect(callback).to receive(:event_guard).once.ordered.and_return(false)
+    expect(callback).to_not receive(:transition_guard)
+    expect(callback).to_not receive(:before_exit_open)
+    expect(callback).to_not receive(:exit_open)
+    expect(callback).to_not receive(:transitioning)
+    expect(callback).to_not receive(:before_enter_closed)
+    expect(callback).to_not receive(:enter_closed)
+    expect(callback).to_not receive(:aasm_write_state)
+    expect(callback).to_not receive(:after_exit_open)
+    expect(callback).to_not receive(:after_enter_closed)
+    expect(callback).to_not receive(:after)
+
+    expect {
+      callback.close!
+    }.to raise_error(AASM::InvalidTransition)
+  end
+
+  it "does not run any state callback if the transition guard fails" do
+    callback = CallbackNewDsl.new
+    callback.aasm.current_state
+
+    expect(callback).to receive(:before).once.ordered
+    expect(callback).to receive(:event_guard).once.ordered.and_return(true)
+    expect(callback).to receive(:transition_guard).once.ordered.and_return(false)
+    expect(callback).to_not receive(:before_exit_open)
+    expect(callback).to_not receive(:exit_open)
+    expect(callback).to_not receive(:transitioning)
+    expect(callback).to_not receive(:before_enter_closed)
+    expect(callback).to_not receive(:enter_closed)
+    expect(callback).to_not receive(:aasm_write_state)
+    expect(callback).to_not receive(:after_exit_open)
+    expect(callback).to_not receive(:after_enter_closed)
+    expect(callback).to_not receive(:after)
+
+    expect {
+      callback.close!
+    }.to raise_error(AASM::InvalidTransition)
+  end
+
+  it "should properly pass arguments" do
+    cb = CallbackNewDslArgs.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.close!(:arg1, :arg2)
+  end
+
+  it "should call the callbacks given the to-state as argument" do
+    cb = CallbackWithStateArg.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
+    cb.close!(:out_to_lunch, :arg1)
+
+    cb = CallbackWithStateArg.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
+    cb.close!(:out_to_lunch, some_object)
+  end
+
+  it "should call the proper methods just with arguments" do
+    cb = CallbackWithStateArg.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
+    cb.close!(:arg1)
+
+    cb = CallbackWithStateArg.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
+    cb.close!(some_object)
+  end
 end
 
 describe 'event callbacks' do
@@ -35,19 +136,19 @@ 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
 
-      allow(@foo).to receive(:enter).and_raise(e=StandardError.new)
+      allow(@foo).to receive(:before_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
-      allow(@foo).to receive(:enter).and_raise(StandardError)
+      allow(@foo).to receive(:before_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
-        allow(@foo).to receive(:enter).and_raise("Cannot enter safe")
+        allow(@foo).to receive(:before_enter).and_raise("Cannot enter safe")
         expect{@foo.close!}.to raise_error(StandardError, "Cannot enter safe")
     end
   end

data/spec/unit/event_spec.rb

@@ -280,24 +280,24 @@ describe 'parametrised events' do
     expect(pe.aasm.current_state).to eq(:showering)
   end
 
-  it 'should transition to default state when on_transition invoked' do
+  it 'should transition to default state when :after transition invoked' do
     pe.dress!(nil, 'purple', 'dressy')
     expect(pe.aasm.current_state).to eq(:working)
   end
 
-  it 'should call on_transition method with args' do
+  it 'should call :after transition method with args' do
     pe.wakeup!(:showering)
     expect(pe).to receive(:wear_clothes).with('blue', 'jeans')
     pe.dress!(:working, 'blue', 'jeans')
   end
 
-  it 'should call on_transition proc' do
+  it 'should call :after transition proc' do
     pe.wakeup!(:showering)
     expect(pe).to receive(:wear_clothes).with('purple', 'slacks')
     pe.dress!(:dating, 'purple', 'slacks')
   end
 
-  it 'should call on_transition with an array of methods' do
+  it 'should call :after transition with an array of methods' do
     pe.wakeup!(:showering)
     expect(pe).to receive(:condition_hair)
     expect(pe).to receive(:fix_hair)

data/spec/unit/inspection_spec.rb

@@ -24,13 +24,13 @@ describe 'inspection for common cases' do
       expect(states).to include(:closed)
       expect(states).to include(:final)
 
-      states = foo.aasm.states(:permissible => true)
+      states = foo.aasm.states(:permitted => true)
       expect(states).to include(:closed)
       expect(states).not_to include(:open)
       expect(states).not_to include(:final)
 
       foo.close
-      expect(foo.aasm.states(:permissible => true)).to be_empty
+      expect(foo.aasm.states(:permitted => true)).to be_empty
     end
 
     it "delivers all states for subclasses" do
@@ -39,12 +39,12 @@ describe 'inspection for common cases' do
       expect(states).to include(:closed)
       expect(states).to include(:foo)
 
-      states = two.aasm.states(:permissible => true)
+      states = two.aasm.states(:permitted => true)
       expect(states).to include(:closed)
       expect(states).not_to include(:open)
 
       two.close
-      expect(two.aasm.states(:permissible => true)).to be_empty
+      expect(two.aasm.states(:permitted => true)).to be_empty
     end
 
     it "delivers all events" do
@@ -96,11 +96,11 @@ describe 'aasm.from_states_for_state' do
   end
 end
 
-describe 'permissible events' do
+describe 'permitted events' do
   let(:foo) {Foo.new}
 
   it 'work' do
-    expect(foo.aasm.permissible_events).to include(:close)
-    expect(foo.aasm.permissible_events).not_to include(:null)
+    expect(foo.aasm.events(:permitted => true)).to include(:close)
+    expect(foo.aasm.events(:permitted => true)).not_to include(:null)
   end
 end

data/spec/unit/localizer_spec.rb

@@ -3,6 +3,7 @@ require 'active_record'
 require 'logger'
 require 'i18n'
 
+I18n.enforce_available_locales = false
 load_schema
 
 class LocalizerTestModel < ActiveRecord::Base

data/spec/unit/persistence/active_record_persistence_spec.rb

@@ -314,10 +314,28 @@ describe "named scopes with the new DSL" do
   end
 
   it "does not create scopes if requested" do
-    expect(NoScope).not_to respond_to(:ignored_scope)
+    expect(NoScope).not_to respond_to(:pending)
   end
 
-end
+end # scopes
+
+describe "direct assignment" do
+  it "is allowed by default" do
+    obj = NoScope.create
+    expect(obj.aasm_state.to_sym).to eql :pending
+
+    obj.aasm_state = :running
+    expect(obj.aasm_state.to_sym).to eql :running
+  end
+
+  it "is forbidden if configured" do
+    obj = NoDirectAssignment.create
+    expect(obj.aasm_state.to_sym).to eql :pending
+
+    expect {obj.aasm_state = :running}.to raise_error(AASM::NoDirectAssignmentError)
+    expect(obj.aasm_state.to_sym).to eql :pending
+  end
+end # direct assignment
 
 describe 'initial states' do
 

data/spec/unit/transition_spec.rb

@@ -61,6 +61,30 @@ describe AASM::Transition do
     expect(st.opts).to eq(opts)
   end
 
+  it 'should set on_transition with deprecation warning' do
+    opts = {:from => 'foo', :to => 'bar'}
+    st = AASM::Transition.allocate
+    st.should_receive(:warn).with('[DEPRECATION] :on_transition is deprecated, use :after instead')
+
+    st.send :initialize, opts do
+      guard :gg
+      on_transition :after_callback
+    end
+
+    st.opts[:after].should == [:after_callback]
+  end
+
+  it 'should set after and guard from dsl' do
+    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
+    st = AASM::Transition.new(opts) do
+      guard :gg
+      after :after_callback
+    end
+
+    st.opts[:guard].should == ['g', :gg]
+    st.opts[:after].should == [:after_callback] # TODO fix this bad code coupling
+  end
+
   it 'should pass equality check if from and to are the same' do
     opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
     st = AASM::Transition.new(opts)
@@ -100,7 +124,7 @@ describe AASM::Transition, '- when performing guard checks' do
     opts = {:from => 'foo', :to => 'bar'}
     st = AASM::Transition.new(opts)
 
-    expect(st.perform(nil)).to be_true
+    expect(st.allowed?(nil)).to be_true
   end
 
   it 'should call the method on the object if guard is a symbol' do
@@ -110,7 +134,17 @@ describe AASM::Transition, '- when performing guard checks' do
     obj = double('object')
     expect(obj).to receive(:test)
 
-    st.perform(obj)
+    expect(st.allowed?(obj)).to be false
+  end
+
+  it 'should call the method on the object if unless is a symbol' do
+    opts = {:from => 'foo', :to => 'bar', :unless => :test}
+    st = AASM::Transition.new(opts)
+
+    obj = double('object')
+    expect(obj).to receive(:test)
+
+    expect(st.allowed?(obj)).to be true
   end
 
   it 'should call the method on the object if guard is a string' do
@@ -120,47 +154,61 @@ describe AASM::Transition, '- when performing guard checks' do
     obj = double('object')
     expect(obj).to receive(:test)
 
-    st.perform(obj)
+    expect(st.allowed?(obj)).to be false
+  end
+
+  it 'should call the method on the object if unless is a string' do
+    opts = {:from => 'foo', :to => 'bar', :unless => 'test'}
+    st = AASM::Transition.new(opts)
+
+    obj = double('object')
+    expect(obj).to receive(:test)
+
+    expect(st.allowed?(obj)).to be true
   end
 
   it 'should call the proc passing the object if the guard is a proc' do
-    opts = {:from => 'foo', :to => 'bar', :guard => Proc.new {|o| o.test}}
+    opts = {:from => 'foo', :to => 'bar', :guard => Proc.new { test }}
     st = AASM::Transition.new(opts)
 
     obj = double('object')
     expect(obj).to receive(:test)
 
-    st.perform(obj)
+    expect(st.allowed?(obj)).to be false
   end
 end
 
 describe AASM::Transition, '- when executing the transition with a Proc' do
   it 'should call a Proc on the object with args' do
-    opts = {:from => 'foo', :to => 'bar', :on_transition => Proc.new {|o| o.test}}
+    opts = {:from => 'foo', :to => 'bar', :after => Proc.new {|a| test(a) }}
     st = AASM::Transition.new(opts)
     args = {:arg1 => '1', :arg2 => '2'}
     obj = double('object', :aasm => 'aasm')
 
-    expect(opts[:on_transition]).to receive(:call).with(any_args)
+    obj.should_receive(:test).with(args)
 
     st.execute(obj, args)
   end
 
   it 'should call a Proc on the object without args' do
-    opts = {:from => 'foo', :to => 'bar', :on_transition => Proc.new {||}}
+    # in order to test that the Proc has been called, we make sure
+    # that after running the :after callback the prc_object is set
+    prc_object = nil
+    prc = Proc.new { prc_object = self }
+
+    opts = {:from => 'foo', :to => 'bar', :after => prc }
     st = AASM::Transition.new(opts)
     args = {:arg1 => '1', :arg2 => '2'}
     obj = double('object', :aasm => 'aasm')
 
-    expect(opts[:on_transition]).to receive(:call).with(no_args)
-
     st.execute(obj, args)
+    expect(prc_object).to eql obj
   end
 end
 
-describe AASM::Transition, '- when executing the transition with an :on_transtion method call' do
+describe AASM::Transition, '- when executing the transition with an :after method call' do
   it 'should accept a String for the method name' do
-    opts = {:from => 'foo', :to => 'bar', :on_transition => 'test'}
+    opts = {:from => 'foo', :to => 'bar', :after => 'test'}
     st = AASM::Transition.new(opts)
     args = {:arg1 => '1', :arg2 => '2'}
     obj = double('object', :aasm => 'aasm')
@@ -171,7 +219,7 @@ describe AASM::Transition, '- when executing the transition with an :on_transtio
   end
 
   it 'should accept a Symbol for the method name' do
-    opts = {:from => 'foo', :to => 'bar', :on_transition => :test}
+    opts = {:from => 'foo', :to => 'bar', :after => :test}
     st = AASM::Transition.new(opts)
     args = {:arg1 => '1', :arg2 => '2'}
     obj = double('object', :aasm => 'aasm')
@@ -182,7 +230,7 @@ describe AASM::Transition, '- when executing the transition with an :on_transtio
   end
 
   it 'should pass args if the target method accepts them' do
-    opts = {:from => 'foo', :to => 'bar', :on_transition => :test}
+    opts = {:from => 'foo', :to => 'bar', :after => :test}
     st = AASM::Transition.new(opts)
     args = {:arg1 => '1', :arg2 => '2'}
     obj = double('object', :aasm => 'aasm')
@@ -197,7 +245,7 @@ describe AASM::Transition, '- when executing the transition with an :on_transtio
   end
 
   it 'should NOT pass args if the target method does NOT accept them' do
-    opts = {:from => 'foo', :to => 'bar', :on_transition => :test}
+    opts = {:from => 'foo', :to => 'bar', :after => :test}
     st = AASM::Transition.new(opts)
     args = {:arg1 => '1', :arg2 => '2'}
     obj = double('object', :aasm => 'aasm')
@@ -212,8 +260,8 @@ describe AASM::Transition, '- when executing the transition with an :on_transtio
   end
 
   it 'should allow accessing the from_state and the to_state' do
-    opts = {:from => 'foo', :to => 'bar', :on_transition => :test}
-    st = AASM::Transition.new(opts)
+    opts = {:from => 'foo', :to => 'bar', :after => :test}
+    transition = AASM::Transition.new(opts)
     args = {:arg1 => '1', :arg2 => '2'}
     obj = double('object', :aasm => AASM::InstanceBase.new('object'))
 
@@ -221,7 +269,7 @@ describe AASM::Transition, '- when executing the transition with an :on_transtio
       "from: #{aasm.from_state} to: #{aasm.to_state}"
     end
 
-    return_value = st.execute(obj, args)
+    return_value = transition.execute(obj, args)
 
     expect(return_value).to eq('from: foo to: bar')
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aasm
 version: !ruby/object:Gem::Version
-  version: 3.4.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Scott Barron
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-12 00:00:00.000000000 Z
+date: 2014-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -111,15 +111,20 @@ files:
 - Gemfile
 - HOWTO
 - LICENSE
+- PLANNED_CHANGES.md
 - README.md
+- README_FROM_VERSION_3_TO_4.md
 - Rakefile
 - aasm.gemspec
+- callbacks.txt
 - gemfiles/rails_3.2.gemfile
 - gemfiles/rails_4.0.gemfile
 - gemfiles/rails_4.1.gemfile
 - lib/aasm.rb
 - lib/aasm/aasm.rb
 - lib/aasm/base.rb
+- lib/aasm/configuration.rb
+- lib/aasm/dsl_helper.rb
 - lib/aasm/errors.rb
 - lib/aasm/event.rb
 - lib/aasm/instance_base.rb