aasm 3.2.1 → 3.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3953eaa965802447de8e3783a35c91dcc89e87a4
-  data.tar.gz: 1b70e517fc29f1fad325a0a46d126cab2eebf029
+  metadata.gz: 83a1f3168fccb10e8b1514ced2d81ec931c5c53a
+  data.tar.gz: 216b3cdd8404f5b2cd963c99a975946848a06e69
 SHA512:
-  metadata.gz: 220319a5169ac9f1928a5beaaacf81c72d47ab3cf972dea079633fcc82ac8bfa3d42c97c0ffa38b9526e1a50b729ba331cc7ae29a1267dddd4d3e9ae52a7cd70
-  data.tar.gz: 0eff6b102e298af64e76e6f71cff21989d260c626efada6ed5dc763d092d351fac20a9696f1882ab8110e535b20897def8c5c7d2c013d7df82e4b6c437590a2f
+  metadata.gz: ea1641220521468b48b11ce9e8fb868a85d1e34d44ddc8256cb2a26ccc055f2cddcf3b557358a651239d2d6cc5d3bedf6f53e9baaf9122b6329c5d3cdd2ed25e
+  data.tar.gz: 2f4e51a87d973d04a16cd64692d0fbcf48df87ab7ee8d412411ca7cb742005b68f7a7ee2ae3d953b0ab01bd8f7956ffd98dd95ba6eda0e3e9b7a6b3533eaa0ea

data/CHANGELOG.md

@@ -4,6 +4,21 @@
 
  * deprecated old aasm_* class methods (old-style DSL), in preparation for AASM v4.0.0
 
+## 3.3.2
+
+ * bugfix: avoid conflicts with `failed` and `fired` event names (see [issue #157](https://github.com/aasm/aasm/issues/157)), thanks to [@MichaelXavier](https://github.com/MichaelXavier)
+ * bugfix: not using transactions unless saving to the database (see [issue #162](https://github.com/aasm/aasm/issues/162) and [issue #164](https://github.com/aasm/aasm/issues/164)), thanks to [@roberthoner](https://github.com/roberthoner)
+ * bugfix: `after_commit` should only run if saving to the database (see [issue #151](https://github.com/aasm/aasm/issues/151)), thanks to [@ivantsepp](https://github.com/ivantsepp)
+
+## 3.3.1
+
+ * bugfix: permissible events will respect given `guards` (see [issue #150](https://github.com/aasm/aasm/issues/150))
+
+## 3.3.0
+
+ * support for Rails 4.1 enum fields (see [issue #124](https://github.com/aasm/aasm/issues/124), thanks to [@bkon](https://github.com/bkon))
+ * bugfix: allow lazy-evaluation for Rails 3 scopes (see [issue #144](https://github.com/aasm/aasm/issues/144), thanks to [@laurens](https://github.com/laurens))
+
 ## 3.2.1
 
  * bugfix: permissible_events and events did not contain events with an empty "from" transition (see [issue #140](https://github.com/aasm/aasm/issues/140) and [issue #141](https://github.com/aasm/aasm/issues/141), thanks to [@daniel-rikowski](https://github.com/daniel-rikowski))

data/README.md

@@ -147,7 +147,9 @@ Also, you can pass parameters to events:
   job.run(:running, :defragmentation)
 ```
 
-In this case the `set_process` would be called with `:defagmentation` argument.
+In this case the `set_process` would be called with `:defragmentation` argument.
+
+Note that when passing arguments to a state transition, the first argument must be the desired end state. In the above example, we wish to transition to `:running` state and run the callback with `:defragmentation` argument. You can also pass in `nil` as the desired end state, and AASM will try to transition to the first end state defined for that event.
 
 In case of an error during the event processing the error is rescued and passed to `:error`
 callback, which can handle it or re-raise it for further propagation.
@@ -212,7 +214,7 @@ You can even provide a number of guards, which all have to succeed to proceed
     end
 ```
 
-If you want to provide guards for all transitions withing an event, you can use event guards
+If you want to provide guards for all transitions within an event, you can use event guards
 
 ```ruby
     event :sleep, :guards => [:walked_the_dog?] do
@@ -278,6 +280,40 @@ class Job < ActiveRecord::Base
 end
 ```
 
+#### ActiveRecord enums
+
+You can use
+[enumerations](http://edgeapi.rubyonrails.org/classes/ActiveRecord/Enum.html)
+in Rails 4.1+ for your state column:
+
+```ruby
+class Job < ActiveRecord::Base
+  include AASM
+
+  enum state: {
+    sleeping: 5,
+    running: 99
+  }
+
+  aasm :column => :state, :enum => true do
+    state :sleeping, :initial => true
+    state :running
+  end
+end
+```
+
+You can explicitly pass the name of the method which provides access
+to the enumeration mapping as a value of ```enum```, or you can simply
+set it to ```true```. In the latter case AASM will try to use
+pluralized column name to access possible enum states.
+
+Furthermore, if your column has integer type (which is normally the
+case when you're working with Rails enums), you can omit ```:enum```
+setting --- AASM auto-detects this situation and enabled enum
+support. If anything goes wrong, you can disable enum functionality
+and fall back to the default behavior by setting ```:enum```
+to ```false```.
+
 ### Sequel
 
 AASM also supports [Sequel](http://sequel.jeremyevans.net/) besides _ActiveRecord_ and _Mongoid_.

data/lib/aasm/aasm.rb

@@ -155,16 +155,16 @@ private
       event.fire_callbacks(:before, self)
 
       if new_state_name = event.fire(self, *args)
-        fired(event, old_state, new_state_name, options, &block)
+        aasm_fired(event, old_state, new_state_name, options, &block)
       else
-        failed(event_name, old_state)
+        aasm_failed(event_name, old_state)
       end
     rescue StandardError => e
       event.fire_callbacks(:error, self, e) || raise(e)
     end
   end
 
-  def fired(event, old_state, new_state_name, options)
+  def aasm_fired(event, old_state, new_state_name, options)
     persist = options[:persist]
 
     new_state = aasm.state_object_for_name(new_state_name)
@@ -200,7 +200,7 @@ private
     persist_successful
   end
 
-  def failed(event_name, old_state)
+  def aasm_failed(event_name, old_state)
     if self.respond_to?(:aasm_event_failed)
       self.aasm_event_failed(event_name, old_state.name)
     end

data/lib/aasm/base.rb

@@ -18,6 +18,8 @@ module AASM
 
       # use requires_new for nested transactions
       configure :requires_new_transaction, true
+
+      configure :enum, nil
     end
 
     def initial_state(new_initial_state=nil)

data/lib/aasm/instance_base.rb

@@ -35,7 +35,7 @@ module AASM
     def states(options={})
       if options[:permissible]
         # ugliness level 1000
-        transitions = @instance.class.aasm.events.values.map {|e| e.transitions_from_state(current_state) }
+        transitions = @instance.class.aasm.events.values_at(*permissible_events).compact.map {|e| e.transitions_from_state(current_state) }
         tos = transitions.map {|t| t[0] ? t[0].to : nil}.flatten.compact.map(&:to_sym).uniq
         @instance.class.aasm.states.select {|s| tos.include?(s.name.to_sym)}
       else

data/lib/aasm/persistence/active_record_persistence.rb

@@ -85,10 +85,11 @@ module AASM
         # NOTE: intended to be called from an event
         def aasm_write_state(state)
           old_value = read_attribute(self.class.aasm_column)
-          write_attribute(self.class.aasm_column, state.to_s)
+          aasm_write_attribute state
 
-          success = if AASM::StateMachine[self.class].config.skip_validation_on_save
-            self.class.where(self.class.primary_key => self.id).update_all(self.class.aasm_column => state.to_s) == 1
+          success = if aasm_skipping_validations
+            value = aasm_raw_attribute_value state
+            self.class.where(self.class.primary_key => self.id).update_all(self.class.aasm_column => value) == 1
           else
             self.save
           end
@@ -113,10 +114,42 @@ module AASM
         #
         # NOTE: intended to be called from an event
         def aasm_write_state_without_persistence(state)
-          write_attribute(self.class.aasm_column, state.to_s)
+          aasm_write_attribute state
         end
 
       private
+        def aasm_enum
+          case AASM::StateMachine[self.class].config.enum
+            when false then nil
+            when true then aasm_guess_enum_method
+            when nil then aasm_guess_enum_method if aasm_column_looks_like_enum
+            else AASM::StateMachine[self.class].config.enum
+          end
+        end
+
+        def aasm_column_looks_like_enum
+          self.class.columns_hash[self.class.aasm_column.to_s].type == :integer
+        end
+
+        def aasm_guess_enum_method
+          self.class.aasm_column.to_s.pluralize.to_sym
+        end
+
+        def aasm_skipping_validations
+          AASM::StateMachine[self.class].config.skip_validation_on_save
+        end
+
+        def aasm_write_attribute(state)
+          write_attribute self.class.aasm_column, aasm_raw_attribute_value(state)
+        end
+
+        def aasm_raw_attribute_value(state)
+          if aasm_enum
+            value = self.class.send(aasm_enum)[state]
+          else
+            value = state.to_s
+          end
+        end
 
         # Ensures that if the aasm_state column is nil and the record is new
         # that the initial state gets populated before validation on create
@@ -138,11 +171,9 @@ module AASM
         end
 
         def aasm_fire_event(name, options, *args, &block)
-          success = self.class.transaction(:requires_new => requires_new?) do
-            super
-          end
+          success = options[:persist] ? self.class.transaction(:requires_new => requires_new?) { super } : super
 
-          if success
+          if success && options[:persist]
             new_state = aasm.state_object_for_name(aasm.current_state)
             new_state.fire_callbacks(:after_commit, self)
           end

data/lib/aasm/persistence/base.rb

@@ -91,14 +91,10 @@ module AASM
         if @klass.ancestors.map {|klass| klass.to_s}.include?("ActiveRecord::Base")
 
           conditions = {"#{@klass.table_name}.#{@klass.aasm_column}" => name.to_s}
-          if ActiveRecord::VERSION::MAJOR >= 4
+          if ActiveRecord::VERSION::MAJOR >= 3
             @klass.class_eval do
               scope name, lambda { where(conditions) }
             end
-          elsif ActiveRecord::VERSION::MAJOR >= 3
-            @klass.class_eval do
-              scope name, where(conditions)
-            end
           else
             @klass.class_eval do
               named_scope name, :conditions => conditions

data/lib/aasm/persistence/sequel_persistence.rb

@@ -84,7 +84,7 @@ module AASM
         # NOTE: intended to be called from an event
         def aasm_write_state state
           aasm_column = self.class.aasm_column
-          update_ony({aasm_column => state.to_s}, aasm_column)
+          update_only({aasm_column => state.to_s}, aasm_column)
         end
 
         # Writes <tt>state</tt> to the state column, but does not persist it to the database

data/lib/aasm/version.rb

@@ -1,3 +1,3 @@
 module AASM
-  VERSION = "3.2.1"
+  VERSION = "3.3.2"
 end

data/spec/models/foo.rb

@@ -3,13 +3,14 @@ class Foo
   aasm do
     state :open, :initial => true, :exit => :exit
     state :closed, :enter => :enter
+    state :final
 
     event :close, :success => :success_callback do
       transitions :from => [:open], :to => [:closed]
     end
 
     event :null do
-      transitions :from => [:open], :to => :closed, :guard => :always_false
+      transitions :from => [:open], :to => [:closed, :final], :guard => :always_false
     end
   end
 

data/spec/unit/event_naming_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+class SimpleStateMachine
+  include AASM
+
+  aasm do
+    state :init, :initial => true
+    state :failed
+
+    event :failed do
+      transitions :from => :init, :to => :failed
+    end
+  end
+end
+
+describe "event naming" do
+  let(:state_machine) { SimpleStateMachine.new }
+
+  it "allows an event of failed without blowing the stack" do
+    state_machine.failed
+
+    expect { state_machine.failed }.to raise_error(AASM::InvalidTransition)
+  end
+end

data/spec/unit/inspection_spec.rb

@@ -22,10 +22,12 @@ describe 'inspection for common cases' do
       states = foo.aasm.states
       expect(states).to include(:open)
       expect(states).to include(:closed)
+      expect(states).to include(:final)
 
       states = foo.aasm.states(:permissible => 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
@@ -77,7 +79,7 @@ end
 describe 'aasm.states_for_select' do
   it "should return a select friendly array of states" do
     expect(Foo.aasm).to respond_to(:states_for_select)
-    expect(Foo.aasm.states_for_select).to eq([['Open', 'open'], ['Closed', 'closed']])
+    expect(Foo.aasm.states_for_select).to eq([['Open', 'open'], ['Closed', 'closed'], ['Final', 'final']])
   end
 end
 

data/spec/unit/persistence/active_record_persistence_spec.rb

@@ -23,6 +23,227 @@ describe "instance methods" do
     expect(gate).to respond_to(:aasm_write_state_without_persistence)
   end
 
+  describe "aasm_column_looks_like_enum" do
+    subject { lambda{ gate.send(:aasm_column_looks_like_enum) } }
+
+    let(:column_name) { "value" }
+    let(:columns_hash) { Hash[column_name, column] }
+
+    before :each do
+      gate.class.stub(:aasm_column).and_return(column_name.to_sym)
+      gate.class.stub(: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
+      end
+    end
+
+    context "when AASM column has string type" do
+      let(:column) { double(Object, type: :string) }
+
+      it "returns false" do
+        expect(subject.call).to be_false
+      end
+    end
+  end
+
+  describe "aasm_guess_enum_method" do
+    subject { lambda{ gate.send(:aasm_guess_enum_method) } }
+
+    before :each do
+      gate.class.stub(:aasm_column).and_return(:value)
+    end
+
+    it "pluralizes AASM column name" do
+      expect(subject.call).to eq :values
+    end
+  end
+
+  describe "aasm_enum" do
+    subject { lambda{ gate.send(:aasm_enum) } }
+
+    context "when AASM enum setting contains an explicit enum method name" do
+      let(:enum) { :test }
+
+      before :each do
+        AASM::StateMachine[Gate].config.stub(:enum).and_return(enum)
+      end
+
+      it "returns whatever value was set in AASM config" do
+        expect(subject.call).to eq enum
+      end
+    end
+
+    context "when AASM enum setting is simply set to true" do
+      before :each do
+        AASM::StateMachine[Gate].config.stub(:enum).and_return(true)
+        Gate.stub(:aasm_column).and_return(:value)
+        gate.stub(:aasm_guess_enum_method).and_return(:values)
+      end
+
+      it "infers enum method name from pluralized column name" do
+        expect(subject.call).to eq :values
+        expect(gate).to have_received :aasm_guess_enum_method
+      end
+    end
+
+    context "when AASM enum setting is explicitly disabled" do
+      before :each do
+        AASM::StateMachine[Gate].config.stub(:enum).and_return(false)
+      end
+
+      it "returns nil" do
+        expect(subject.call).to be_nil
+      end
+    end
+
+    context "when AASM enum setting is not enabled" do
+      before :each do
+        AASM::StateMachine[Gate].config.stub(:enum).and_return(nil)
+        Gate.stub(:aasm_column).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)
+          gate.stub(:aasm_guess_enum_method).and_return(:values)
+        end
+
+        it "infers enum method name from pluralized column name" do
+          expect(subject.call).to eq :values
+          expect(gate).to have_received :aasm_guess_enum_method
+        end
+      end
+
+      context "when AASM column doesn't look like enum'" do
+        before :each do
+          gate.stub(:aasm_column_looks_like_enum)
+            .and_return(false)
+        end
+
+        it "returns nil, as we're not using enum" do
+          expect(subject.call).to be_nil
+        end
+      end
+    end
+  end
+
+  context "when AASM is configured to use enum" do
+    let(:state_sym) { :running }
+    let(:state_code) { 2 }
+    let(:enum_name) { :states }
+    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)
+    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)
+        end
+
+        it "passes state code instead of state symbol to update_all" do
+          # stub_chain does not allow us to give expectations on call
+          # 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)
+
+          gate.aasm_write_state state_sym
+
+          expect(obj).to have_received(:update_all)
+            .with(Hash[gate.class.aasm_column, state_code])
+        end
+      end
+
+      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)
+
+          gate.aasm_write_state state_sym
+
+          expect(gate).to have_received(:aasm_write_attribute).with(state_sym)
+          expect(gate).to_not have_received :write_attribute
+        end
+      end
+    end
+
+    describe "aasm_write_state_without_persistence" do
+      it "delegates state update to the helper method" do
+        gate.aasm_write_state_without_persistence state_sym
+
+        expect(gate).to have_received(:aasm_write_attribute).with(state_sym)
+        expect(gate).to_not have_received :write_attribute
+      end
+    end
+
+    describe "aasm_raw_attribute_value" do
+      it "converts state symbol to state code" do
+        expect(gate.send(:aasm_raw_attribute_value, state_sym))
+          .to eq state_code
+      end
+    end
+  end
+
+  context "when AASM is configured to use string field" do
+    let(:state_sym) { :running }
+
+    before :each do
+      gate
+        .stub(:aasm_enum)
+        .and_return(nil)
+    end
+
+    describe "aasm_raw_attribute_value" do
+      it "converts state symbol to string" do
+        expect(gate.send(:aasm_raw_attribute_value, state_sym))
+          .to eq state_sym.to_s
+      end
+    end
+  end
+
+  describe "aasm_write_attribute helper method" do
+    let(:sym) { :sym }
+    let(:value) { 42 }
+
+    before :each do
+      gate.stub(:write_attribute)
+      gate.stub(:aasm_raw_attribute_value)
+        .and_return(value)
+
+      gate.send(:aasm_write_attribute, sym)
+    end
+
+    it "generates attribute value using a helper method" do
+      expect(gate).to have_received(:aasm_raw_attribute_value).with(sym)
+    end
+
+    it "writes attribute to the model" do
+      expect(gate).to have_received(:write_attribute).with(:aasm_state, value)
+    end
+  end
+
   it "should return the initial state when new and the aasm field is nil" do
     expect(gate.aasm.current_state).to eq(:opened)
   end
@@ -217,6 +438,31 @@ describe 'transitions with persistence' do
         expect(validator.name).to eq("name")
       end
 
+      it "should not fire if not saving" do
+        validator = Validator.create(:name => 'name')
+        expect(validator).to be_sleeping
+        validator.run
+        expect(validator).to be_running
+        expect(validator.name).to eq("name")
+      end
+
+    end
+
+    context "when not persisting" do
+      it 'should not rollback all changes' do
+        expect(transactor).to be_sleeping
+        expect(worker.status).to eq('sleeping')
+
+        # Notice here we're calling "run" and not "run!" with a bang.
+        expect {transactor.run}.to raise_error(StandardError, 'failed on purpose')
+        expect(transactor).to be_running
+        expect(worker.reload.status).to eq('running')
+      end
+
+      it 'should not create a database transaction' do
+        expect(transactor.class).not_to receive(:transaction)
+        expect {transactor.run}.to raise_error(StandardError, 'failed on purpose')
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aasm
 version: !ruby/object:Gem::Version
-  version: 3.2.1
+  version: 3.3.2
 platform: ruby
 authors:
 - Scott Barron
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-14 00:00:00.000000000 Z
+date: 2014-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -166,6 +166,7 @@ files:
 - spec/unit/api_spec.rb
 - spec/unit/callbacks_spec.rb
 - spec/unit/complex_example_spec.rb
+- spec/unit/event_naming_spec.rb
 - spec/unit/event_spec.rb
 - spec/unit/guard_spec.rb
 - spec/unit/initial_state_spec.rb
@@ -237,6 +238,7 @@ test_files:
 - spec/unit/api_spec.rb
 - spec/unit/callbacks_spec.rb
 - spec/unit/complex_example_spec.rb
+- spec/unit/event_naming_spec.rb
 - spec/unit/event_spec.rb
 - spec/unit/guard_spec.rb
 - spec/unit/initial_state_spec.rb