aasm 4.0.5 → 4.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0fd3025d299701a391be90b67871d0110925522e
-  data.tar.gz: d56adcb31986d0bc257e4c4a32e79462a6715709
+  metadata.gz: 2d4a2455383d1017cdc688cf4f01c8d9d4ce9a03
+  data.tar.gz: a100390b837f02f283afebc66dc8495df2b950e9
 SHA512:
-  metadata.gz: f2e8c7bd2e7ce8f614b8b72a48ffbf396c9194c5369a128bbe6d201443e067a48caea69b9f3f9ec4c6af30956b358deb4d8544172599fe7120bd4edbc4c9717d
-  data.tar.gz: b6d9db8e0f1cd99e263d3cb9e16ff837adab1ce57faf918ca222f48a9bb674ebf29bbdae640d4987bd6f676d35896dec9d3060347e709229ad831160702b11a4
+  metadata.gz: 4d9cbefb8cfc6644923134aa679d8cbc5c672da11f428f969974777edcda43b947b2a88df6743006e384f2b5a4ecb9bc36b8c937332e144bd8af7abe5a7215d0
+  data.tar.gz: bc56510d4cf59437d92e1b2853e87b478709dbd2dc98841aa7e3b1a2c8405011a5cbef75f882b8e4c0ee755a7b16014359ac843e9fe43f05e396674de09413de

data/.travis.yml

@@ -1,4 +1,6 @@
+sudo: false
 language: ruby
+cache: bundler
 
 rvm:
   # - 1.8.7

data/CHANGELOG.md

@@ -5,6 +5,11 @@
  * `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.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/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

@@ -15,7 +15,7 @@ Gem::Specification.new do |s|
 
   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/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/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)
+            raise NoMethodError.new("NoMethodError: undefined method `#{code}' for #{self.inspect}:#{self.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/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
 

data/lib/aasm/version.rb

@@ -1,3 +1,3 @@
 module AASM
-  VERSION = "4.0.5"
+  VERSION = "4.0.6"
 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

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/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/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!

data/spec/unit/callbacks_spec.rb

@@ -128,51 +128,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 +174,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 +188,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)
+
+        @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)
-      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!('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

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_truthy
   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_truthy
   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_truthy
     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_truthy
+    expect(auth.may_wait?(:waiting, :rude)).not_to be_truthy
     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_truthy
     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_truthy
   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_falsey
   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

data/spec/unit/persistence/active_record_persistence_spec.rb

@@ -30,15 +30,15 @@ describe "instance methods" do
     let(:columns_hash) { Hash[column_name, column] }
 
     before :each do
-      gate.class.aasm.stub(:attribute_name).and_return(column_name.to_sym)
-      gate.class.stub(:columns_hash).and_return(columns_hash)
+      allow(gate.class.aasm).to receive(:attribute_name).and_return(column_name.to_sym)
+      allow(gate.class).to receive(:columns_hash).and_return(columns_hash)
     end
 
     context "when AASM column has integer type" do
       let(:column) { double(Object, type: :integer) }
 
       it "returns true" do
-        expect(subject.call).to be_true
+        expect(subject.call).to be_truthy
       end
     end
 
@@ -46,7 +46,7 @@ describe "instance methods" do
       let(:column) { double(Object, type: :string) }
 
       it "returns false" do
-        expect(subject.call).to be_false
+        expect(subject.call).to be_falsey
       end
     end
   end
@@ -55,7 +55,7 @@ describe "instance methods" do
     subject { lambda{ gate.send(:aasm_guess_enum_method) } }
 
     before :each do
-      gate.class.aasm.stub(:attribute_name).and_return(:value)
+      allow(gate.class.aasm).to receive(:attribute_name).and_return(:value)
     end
 
     it "pluralizes AASM column name" do
@@ -75,7 +75,7 @@ describe "instance methods" do
     context "when AASM enum setting is simply set to true" do
       let(:with_true_enum) { WithTrueEnum.new }
       before :each do
-        WithTrueEnum.aasm.stub(:attribute_name).and_return(:value)
+        allow(WithTrueEnum.aasm).to receive(:attribute_name).and_return(:value)
       end
 
       it "infers enum method name from pluralized column name" do
@@ -93,12 +93,12 @@ describe "instance methods" do
 
     context "when AASM enum setting is not enabled" do
       before :each do
-        Gate.aasm.stub(:attribute_name).and_return(:value)
+        allow(Gate.aasm).to receive(:attribute_name).and_return(:value)
       end
 
       context "when AASM column looks like enum" do
         before :each do
-          gate.stub(:aasm_column_looks_like_enum).and_return(true)
+          allow(gate).to receive(:aasm_column_looks_like_enum).and_return(true)
         end
 
         it "infers enum method name from pluralized column name" do
@@ -108,7 +108,7 @@ describe "instance methods" do
 
       context "when AASM column doesn't look like enum'" do
         before :each do
-          gate.stub(:aasm_column_looks_like_enum)
+          allow(gate).to receive(:aasm_column_looks_like_enum)
             .and_return(false)
         end
 
@@ -126,24 +126,17 @@ describe "instance methods" do
     let(:enum) { Hash[state_sym, state_code] }
 
     before :each do
-      gate
-        .stub(:aasm_enum)
-        .and_return(enum_name)
-      gate.stub(:aasm_write_attribute)
-      gate.stub(:write_attribute)
-
-      gate
-        .class
-        .stub(enum_name)
-        .and_return(enum)
+      allow(gate).to receive(:aasm_enum).and_return(enum_name)
+      allow(gate).to receive(:aasm_write_attribute)
+      allow(gate).to receive(:write_attribute)
+
+      allow(Gate).to receive(enum_name).and_return(enum)
     end
 
     describe "aasm_write_state" do
       context "when AASM is configured to skip validations on save" do
         before :each do
-          gate
-            .stub(:aasm_skipping_validations)
-            .and_return(true)
+          allow(gate).to receive(:aasm_skipping_validations).and_return(true)
         end
 
         it "passes state code instead of state symbol to update_all" do
@@ -151,10 +144,7 @@ describe "instance methods" do
           # parameters in the middle of the chain, so we need to use
           # intermediate object instead.
           obj = double(Object, update_all: 1)
-          gate
-            .class
-            .stub(:where)
-            .and_return(obj)
+          allow(Gate).to receive(:where).and_return(obj)
 
           gate.aasm_write_state state_sym
 
@@ -166,7 +156,7 @@ describe "instance methods" do
       context "when AASM is not skipping validations" do
         it "delegates state update to the helper method" do
           # Let's pretend that validation is passed
-          gate.stub(:save).and_return(true)
+          allow(gate).to receive(:save).and_return(true)
 
           gate.aasm_write_state state_sym
 
@@ -197,9 +187,7 @@ describe "instance methods" do
     let(:state_sym) { :running }
 
     before :each do
-      gate
-        .stub(:aasm_enum)
-        .and_return(nil)
+      allow(gate).to receive(:aasm_enum).and_return(nil)
     end
 
     describe "aasm_raw_attribute_value" do
@@ -215,9 +203,8 @@ describe "instance methods" do
     let(:value) { 42 }
 
     before :each do
-      gate.stub(:write_attribute)
-      gate.stub(:aasm_raw_attribute_value)
-        .and_return(value)
+      allow(gate).to receive(:write_attribute)
+      allow(gate).to receive(:aasm_raw_attribute_value).and_return(value)
 
       gate.send(:aasm_write_attribute, sym)
     end
@@ -270,6 +257,16 @@ describe "instance methods" do
 
 end
 
+describe "direct state column access" do
+  it "accepts false states" do
+    f = FalseState.create!
+    expect(f.aasm_state).to eql false
+    expect {
+      f.aasm.events.map(&:name)
+    }.to_not raise_error
+  end
+end
+
 describe 'subclasses' do
   it "should have the same states as its parent class" do
     expect(DerivateNewDsl.aasm.states).to eq(SimpleNewDsl.aasm.states)
@@ -289,7 +286,7 @@ describe "named scopes with the new DSL" do
   context "Does not already respond_to? the scope name" do
     it "should add a scope" do
       expect(SimpleNewDsl).to respond_to(:unknown_scope)
-      expect(SimpleNewDsl.unknown_scope.is_a?(ActiveRecord::Relation)).to be_true
+      expect(SimpleNewDsl.unknown_scope.is_a?(ActiveRecord::Relation)).to be_truthy
     end
   end
 
@@ -348,7 +345,7 @@ describe 'transitions with persistence' do
 
     validator.name = nil
     expect(validator).not_to be_valid
-    expect(validator.run!).to be_false
+    expect(validator.run!).to be_falsey
     expect(validator).to be_sleeping
 
     validator.reload
@@ -357,7 +354,7 @@ describe 'transitions with persistence' do
 
     validator.name = 'another name'
     expect(validator).to be_valid
-    expect(validator.run!).to be_true
+    expect(validator.run!).to be_truthy
     expect(validator).to be_running
 
     validator.reload
@@ -372,7 +369,7 @@ describe 'transitions with persistence' do
 
     persistor.name = nil
     expect(persistor).not_to be_valid
-    expect(persistor.run!).to be_true
+    expect(persistor.run!).to be_truthy
     expect(persistor).to be_running
 
     persistor = InvalidPersistor.find(persistor.id)
@@ -477,7 +474,7 @@ describe "invalid states with persistence" do
   it "should not store states" do
     validator = Validator.create(:name => 'name')
     validator.status = 'invalid_state'
-    expect(validator.save).to be_false
+    expect(validator.save).to be_falsey
     expect {validator.save!}.to raise_error(ActiveRecord::RecordInvalid)
 
     validator.reload
@@ -487,7 +484,7 @@ describe "invalid states with persistence" do
   it "should store invalid states if configured" do
     persistor = InvalidPersistor.create(:name => 'name')
     persistor.status = 'invalid_state'
-    expect(persistor.save).to be_true
+    expect(persistor.save).to be_truthy
 
     persistor.reload
     expect(persistor.status).to eq('invalid_state')

data/spec/unit/subclassing_spec.rb

@@ -19,7 +19,7 @@ describe 'subclassing' do
   end
 
   it 'should know how to respond to `may_add_details?`' do
-    expect(son.may_add_details?).to be_true
+    expect(son.may_add_details?).to be_truthy
   end
 
   it 'should not break if I call Son#update_state' do

data/spec/unit/transition_spec.rb

@@ -10,19 +10,19 @@ describe 'transitions' do
 
   it 'should not raise an exception when not whiny' do
     silencer = Silencer.new
-    expect(silencer.smile!).to be_false
+    expect(silencer.smile!).to be_falsey
     expect(silencer).to be_silent
   end
 
   it 'should not raise an exception when superclass not whiny' do
     sub = SubClassing.new
-    expect(sub.smile!).to be_false
+    expect(sub.smile!).to be_falsey
     expect(sub).to be_silent
   end
 
   it 'should not raise an exception when from is nil even if whiny' do
     silencer = Silencer.new
-    expect(silencer.smile_any!).to be_true
+    expect(silencer.smile_any!).to be_truthy
     expect(silencer).to be_smiling
   end
 
@@ -43,7 +43,7 @@ describe 'transitions' do
       silencer.smile! do
         success = true
       end
-    }.not_to change { success }.to(true)
+    }.not_to change { success }
   end
 
 end
@@ -64,14 +64,14 @@ describe AASM::Core::Transition do
   it 'should set on_transition with deprecation warning' do
     opts = {:from => 'foo', :to => 'bar'}
     st = AASM::Core::Transition.allocate
-    st.should_receive(:warn).with('[DEPRECATION] :on_transition is deprecated, use :after instead')
+    expect(st).to 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]
+    expect(st.opts[:after]).to eql [:after_callback]
   end
 
   it 'should set after and guard from dsl' do
@@ -81,8 +81,8 @@ describe AASM::Core::Transition do
       after :after_callback
     end
 
-    st.opts[:guard].should == ['g', :gg]
-    st.opts[:after].should == [:after_callback] # TODO fix this bad code coupling
+    expect(st.opts[:guard]).to eql ['g', :gg]
+    expect(st.opts[:after]).to eql [:after_callback] # TODO fix this bad code coupling
   end
 
   it 'should pass equality check if from and to are the same' do
@@ -124,7 +124,7 @@ describe AASM::Core::Transition, '- when performing guard checks' do
     opts = {:from => 'foo', :to => 'bar'}
     st = AASM::Core::Transition.new(opts)
 
-    expect(st.allowed?(nil)).to be_true
+    expect(st.allowed?(nil)).to be_truthy
   end
 
   it 'should call the method on the object if guard is a symbol' do
@@ -185,7 +185,7 @@ describe AASM::Core::Transition, '- when executing the transition with a Proc' d
     args = {:arg1 => '1', :arg2 => '2'}
     obj = double('object', :aasm => 'aasm')
 
-    obj.should_receive(:test).with(args)
+    expect(obj).to receive(:test).with(args)
 
     st.execute(obj, args)
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aasm
 version: !ruby/object:Gem::Version
-  version: 4.0.5
+  version: 4.0.6
 platform: ruby
 authors:
 - Scott Barron
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-06 00:00:00.000000000 Z
+date: 2014-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -46,20 +46,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.14'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2.99'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.14'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2.99'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement