statesman 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 105f8a5aeb999d07eaeb59d69bbe52ff42317895
-  data.tar.gz: b6ac7988cea6d0a5a260ceda12be3c1ca64b38d5
+  metadata.gz: a7c29dcf767aa7177b818dafdc99e8645dddfcc8
+  data.tar.gz: 1d4db155c8fb031a4e58dafa44febca452110dcd
 SHA512:
-  metadata.gz: 00608fb54abb049e5615c96c0903e6564a565838c4cf6db53da2151fefef2ffdabf529b18752eae466bedcd22e26237a44fb1ce1af25fcc0f1494e3164d0454a
-  data.tar.gz: 7715676c1ea620c9509e470e285474f31fa991795abc60bb9bd45f692d90bc10453a33918567eb3a11c0cbb19a027ecf03822684b859f0d106df4a481db1c748
+  metadata.gz: 1aff94dc8f2c327b232c93123fa781a5f583f4b9fa08b39df79d8dd93c8600992ca67e05b277531fb58da92014eb5c1240a9d622cff3195a84266624bef7e4ef
+  data.tar.gz: 6882412cf48ed98015601b22a26c4d038405d1b9208a723d0fdeeddb875629e47fb267ba97ceac712bbac5572d6c3f647188047e6f17532a528baa2c6b9897ab

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## v0.4.0, 27 February 2014
+*Additions*
+- Adds after_commit flag to after_transition for callbacks to be executed after the transaction has been
+committed on the ActiveRecord adapter. These callbacks will still be executed on non transactional adapters.
+
 ## v0.3.0, 20 February 2014
 *Additions*
 - Adds Machine#allowed_transitions method (patch by [@prikha](https://github.com/prikha))

data/lib/statesman/adapters/active_record.rb

@@ -6,26 +6,28 @@ module Statesman
       attr_reader :transition_class
       attr_reader :parent_model
 
-      def initialize(transition_class, parent_model)
+      def initialize(transition_class, parent_model, observer)
         unless transition_class.serialized_attributes.include?("metadata")
           raise UnserializedMetadataError,
                 "#{transition_class.name}#metadata is not serialized"
         end
         @transition_class = transition_class
         @parent_model = parent_model
+        @observer = observer
       end
 
-      def create(to, before_cbs, after_cbs, metadata = {})
+      def create(from, to, metadata = {})
         transition = transitions_for_parent.build(to_state: to,
                                                   sort_key: next_sort_key,
                                                   metadata: metadata)
 
         ::ActiveRecord::Base.transaction do
-          before_cbs.each { |cb| cb.call(@parent_model, transition) }
+          @observer.execute(:before, from, to, transition)
           transition.save!
-          after_cbs.each { |cb| cb.call(@parent_model, transition) }
+          @observer.execute(:after, from, to, transition)
           @last_transition = nil
         end
+        @observer.execute(:after_commit, from, to, transition)
 
         transition
       end

data/lib/statesman/adapters/memory.rb

@@ -9,19 +9,20 @@ module Statesman
 
       # We only accept mode as a parameter to maintain a consistent interface
       # with other adapters which require it.
-      def initialize(transition_class, parent_model)
+      def initialize(transition_class, parent_model, observer)
         @history = []
         @transition_class = transition_class
         @parent_model = parent_model
+        @observer = observer
       end
 
-      def create(to, before_cbs, after_cbs, metadata = {})
+      def create(from, to, metadata = {})
         transition = transition_class.new(to, next_sort_key, metadata)
 
-        before_cbs.each { |cb| cb.call(@parent_model, transition) }
+        @observer.execute(:before, from, to, transition)
         @history << transition
-        after_cbs.each { |cb| cb.call(@parent_model, transition) }
-
+        @observer.execute(:after, from, to, transition)
+        @observer.execute(:after_commit, from, to, transition)
         transition
       end
 

data/lib/statesman/adapters/mongoid.rb

@@ -6,22 +6,24 @@ module Statesman
       attr_reader :transition_class
       attr_reader :parent_model
 
-      def initialize(transition_class, parent_model)
+      def initialize(transition_class, parent_model, observer)
         @transition_class = transition_class
         @parent_model = parent_model
+        @observer = observer
         unless transition_class_hash_fields.include?('statesman_metadata')
           raise UnserializedMetadataError, metadata_field_error_message
         end
       end
 
-      def create(to, before_cbs, after_cbs, metadata = {})
+      def create(from, to, metadata = {})
         transition = transitions_for_parent.build(to_state: to,
                                                   sort_key: next_sort_key,
                                                   statesman_metadata: metadata)
 
-        before_cbs.each { |cb| cb.call(@parent_model, transition) }
+        @observer.execute(:before, from, to, transition)
         transition.save!
-        after_cbs.each { |cb| cb.call(@parent_model, transition) }
+        @observer.execute(:after, from, to, transition)
+        @observer.execute(:after_commit, from, to, transition)
         @last_transition = nil
         transition
       end

data/lib/statesman/machine.rb

@@ -32,16 +32,13 @@ module Statesman
         @successors ||= {}
       end
 
-      def before_callbacks
-        @before_callbacks ||= []
-      end
-
-      def after_callbacks
-        @after_callbacks ||= []
-      end
-
-      def guards
-        @guards ||= []
+      def callbacks
+        @callbacks ||= {
+          before:       [],
+          after:        [],
+          after_commit: [],
+          guards:       []
+        }
       end
 
       def transition(options = { from: nil, to: nil })
@@ -60,15 +57,17 @@ module Statesman
         to   = to_s_or_nil(options[:to])
 
         validate_callback_condition(from: from, to: to)
-        before_callbacks << Callback.new(from: from, to: to, callback: block)
+        callbacks[:before] << Callback.new(from: from, to: to, callback: block)
       end
 
-      def after_transition(options = { from: nil, to: nil }, &block)
+      def after_transition(options = { from: nil, to: nil,
+                                       after_commit: false }, &block)
         from = to_s_or_nil(options[:from])
         to   = to_s_or_nil(options[:to])
 
         validate_callback_condition(from: from, to: to)
-        after_callbacks << Callback.new(from: from, to: to, callback: block)
+        phase = options[:after_commit] ? :after_commit : :after
+        callbacks[phase] << Callback.new(from: from, to: to, callback: block)
       end
 
       def guard_transition(options = { from: nil, to: nil }, &block)
@@ -76,7 +75,7 @@ module Statesman
         to   = to_s_or_nil(options[:to])
 
         validate_callback_condition(from: from, to: to)
-        guards << Guard.new(from: from, to: to, callback: block)
+        callbacks[:guards] << Guard.new(from: from, to: to, callback: block)
       end
 
       def validate_callback_condition(options = { from: nil, to: nil })
@@ -143,8 +142,9 @@ module Statesman
                         transition_class: Statesman::Adapters::MemoryTransition
                       })
       @object = object
+      @transition_class = options[:transition_class]
       @storage_adapter = Statesman.storage_adapter.new(
-                                            options[:transition_class], object)
+                                            @transition_class, object, self)
     end
 
     def current_state
@@ -183,14 +183,16 @@ module Statesman
                           to: new_state,
                           metadata: metadata)
 
-      before_cbs = before_callbacks_for(from: initial_state, to: new_state)
-      after_cbs = after_callbacks_for(from: initial_state, to: new_state)
-
-      @storage_adapter.create(new_state, before_cbs, after_cbs, metadata)
+      @storage_adapter.create(initial_state, new_state, metadata)
 
       true
     end
 
+    def execute(phase, initial_state, new_state, transition)
+      callbacks = callbacks_for(phase, from: initial_state, to: new_state)
+      callbacks.each { |cb| cb.call(@object, transition) }
+    end
+
     def transition_to(new_state, metadata = nil)
       self.transition_to!(new_state, metadata)
     rescue
@@ -204,15 +206,11 @@ module Statesman
     end
 
     def guards_for(options = { from: nil, to: nil })
-      select_callbacks_for(self.class.guards, options)
-    end
-
-    def before_callbacks_for(options = { from: nil, to: nil })
-      select_callbacks_for(self.class.before_callbacks, options)
+      select_callbacks_for(self.class.callbacks[:guards], options)
     end
 
-    def after_callbacks_for(options = { from: nil, to: nil })
-      select_callbacks_for(self.class.after_callbacks, options)
+    def callbacks_for(phase, options = { from: nil, to: nil })
+      select_callbacks_for(self.class.callbacks[phase], options)
     end
 
     def select_callbacks_for(callbacks, options = { from: nil, to: nil })

data/lib/statesman/version.rb

@@ -1,3 +1,3 @@
 module Statesman
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/spec/statesman/adapters/active_record_spec.rb

@@ -9,7 +9,11 @@ describe Statesman::Adapters::ActiveRecord do
   end
 
   before { MyActiveRecordModelTransition.serialize(:metadata, JSON) }
-
+  let(:observer) do
+    result = double(Statesman::Machine)
+    result.stub(:execute)
+    result
+  end
   let(:model) { MyActiveRecordModel.create(current_state: :pending) }
   it_behaves_like "an adapter", described_class, MyActiveRecordModelTransition
 
@@ -20,18 +24,20 @@ describe Statesman::Adapters::ActiveRecord do
       it "raises an exception if metadata is not serialized" do
         expect do
           described_class.new(MyActiveRecordModelTransition,
-                              MyActiveRecordModel)
+                              MyActiveRecordModel, observer)
         end.to raise_exception(Statesman::UnserializedMetadataError)
       end
     end
   end
 
   describe "#last" do
-    let(:adapter) { described_class.new(MyActiveRecordModelTransition, model) }
+    let(:adapter) do
+      described_class.new(MyActiveRecordModelTransition, model, observer)
+    end
 
     context "with a previously looked up transition" do
       before do
-        adapter.create(:y, [], [])
+        adapter.create(:x, :y)
         adapter.last
       end
 
@@ -42,7 +48,7 @@ describe Statesman::Adapters::ActiveRecord do
       end
 
       context "and a new transition" do
-        before { adapter.create(:z, [], []) }
+        before { adapter.create(:y, :z, []) }
         it "retrieves the new transition from the database" do
           expect(adapter.last.to_state).to eq("z")
         end

data/spec/statesman/adapters/mongoid_spec.rb

@@ -9,7 +9,11 @@ describe Statesman::Adapters::Mongoid, mongo: true do
   after do
     Mongoid.purge!
   end
-
+  let(:observer) do
+    result = double(Statesman::Machine)
+    result.stub(:execute)
+    result
+  end
   let(:model) { MyMongoidModel.create(current_state: :pending) }
   it_behaves_like "an adapter", described_class, MyMongoidModelTransition
 
@@ -21,18 +25,21 @@ describe Statesman::Adapters::Mongoid, mongo: true do
 
       it "raises an exception if metadata is not serialized" do
         expect do
-          described_class.new(MyMongoidModelTransition, MyMongoidModel)
+          described_class.new(MyMongoidModelTransition, MyMongoidModel,
+                              observer)
         end.to raise_exception(Statesman::UnserializedMetadataError)
       end
     end
   end
 
   describe "#last" do
-    let(:adapter) { described_class.new(MyMongoidModelTransition, model) }
+    let(:adapter) do
+      described_class.new(MyMongoidModelTransition, model, observer)
+    end
 
     context "with a previously looked up transition" do
       before do
-        adapter.create(:y, [], [])
+        adapter.create(:x, :y)
         adapter.last
       end
 
@@ -43,7 +50,7 @@ describe Statesman::Adapters::Mongoid, mongo: true do
       end
 
       context "and a new transition" do
-        before { adapter.create(:z, [], []) }
+        before { adapter.create(:y, :z) }
         it "retrieves the new transition from the database" do
           expect(adapter.last.to_state).to eq("z")
         end

data/spec/statesman/adapters/shared_examples.rb

@@ -12,9 +12,12 @@ require "spec_helper"
 #   last:             Returns the latest transition history item
 #
 shared_examples_for "an adapter" do |adapter_class, transition_class|
-  let(:adapter) { adapter_class.new(transition_class, model) }
-  let(:before_cbs) { [] }
-  let(:after_cbs) { [] }
+  let(:observer) do
+    result = double(Statesman::Machine)
+    result.stub(:execute)
+    result
+  end
+  let(:adapter) { adapter_class.new(transition_class, model, observer) }
 
   describe "#initialize" do
     subject { adapter }
@@ -24,8 +27,9 @@ shared_examples_for "an adapter" do |adapter_class, transition_class|
   end
 
   describe "#create" do
+    let(:from) { :x }
     let(:to) { :y }
-    let(:create) { adapter.create(to, before_cbs, after_cbs) }
+    let(:create) { adapter.create(from, to) }
     subject { -> { create } }
 
     it { should change(adapter.history, :count).by(1) }
@@ -43,43 +47,35 @@ shared_examples_for "an adapter" do |adapter_class, transition_class|
       end
 
       context "with a previous transition" do
-        before { adapter.create(:x, before_cbs, after_cbs) }
+        before { adapter.create(from, to) }
         its(:sort_key) { should be(10) }
       end
     end
 
     context "with before callbacks" do
-      let(:callback) { double(call: true) }
-      let(:before_cbs) { [callback] }
-
       it "is called before the state transition" do
-        callback.should_receive(:call).with do |passed_model, transition|
-          expect(passed_model).to be(model)
-          expect(transition).to be_a(adapter.transition_class)
-          expect(adapter.history.length).to eq(0)
+        observer.should_receive(:execute).with do
+            |phase, from_state, to_state, transition|
+          expect(adapter.history.length).to eq(0) if phase == :before
         end.once
-
-        adapter.create(:x, before_cbs, after_cbs)
+        adapter.create(from, to)
         expect(adapter.history.length).to eq(1)
       end
     end
 
     context "with after callbacks" do
-      let(:callback) { double(call: true) }
-      let(:after_cbs) { [callback] }
-
       it "is called after the state transition" do
-        callback.should_receive(:call).with do |passed_model, transition|
-          expect(passed_model).to be(model)
-          expect(adapter.last).to eq(transition)
+        observer.should_receive(:execute).with do
+            |phase, from_state, to_state, transition|
+          expect(adapter.last).to eq(transition) if phase == :after
         end.once
-        adapter.create(:x, before_cbs, after_cbs)
+        adapter.create(from, to)
       end
     end
 
     context "with metadata" do
       let(:metadata) { { "some" => "hash" } }
-      subject { adapter.create(to, before_cbs, after_cbs, metadata) }
+      subject { adapter.create(from, to, metadata) }
       its(:metadata) { should eq(metadata) }
     end
   end
@@ -89,12 +85,11 @@ shared_examples_for "an adapter" do |adapter_class, transition_class|
     it { should eq([]) }
 
     context "with transitions" do
-      let!(:transition) { adapter.create(:y, before_cbs, after_cbs) }
+      let!(:transition) { adapter.create(:x, :y) }
       it { should eq([transition]) }
 
       context "sorting" do
-        let!(:transition) { adapter.create(:y, before_cbs, after_cbs) }
-        let!(:transition2) { adapter.create(:y, before_cbs, after_cbs) }
+        let!(:transition2) { adapter.create(:x, :y) }
         subject { adapter.history }
         it { should eq(adapter.history.sort_by(&:sort_key)) }
       end
@@ -103,8 +98,8 @@ shared_examples_for "an adapter" do |adapter_class, transition_class|
 
   describe "#last" do
     before do
-      adapter.create(:y, before_cbs, after_cbs)
-      adapter.create(:z, before_cbs, after_cbs)
+      adapter.create(:x, :y)
+      adapter.create(:y, :z)
     end
     subject { adapter.last }
 

data/spec/statesman/machine_spec.rb

@@ -127,13 +127,12 @@ describe Statesman::Machine do
     it "stores callbacks" do
       expect do
         machine.send(assignment_method) {}
-      end.to change(machine.send(callback_store), :count).by(1)
+      end.to change(machine.callbacks[callback_store], :count).by(1)
     end
 
     it "stores callback instances" do
       machine.send(assignment_method) {}
-
-      machine.send(callback_store).each do |callback|
+      machine.callbacks[callback_store].each do |callback|
         expect(callback).to be_a(Statesman::Callback)
       end
     end
@@ -174,11 +173,11 @@ describe Statesman::Machine do
   end
 
   describe ".before_transition" do
-    it_behaves_like "a callback store", :before_transition, :before_callbacks
+    it_behaves_like "a callback store", :before_transition, :before
   end
 
   describe ".after_transition" do
-    it_behaves_like "a callback store", :after_transition, :after_callbacks
+    it_behaves_like "a callback store", :after_transition, :after
   end
 
   describe ".guard_transition" do
@@ -194,14 +193,14 @@ describe Statesman::Machine do
     context "transition class" do
       it "sets a default" do
         Statesman.storage_adapter.should_receive(:new).once
-          .with(Statesman::Adapters::MemoryTransition, my_model)
+          .with(Statesman::Adapters::MemoryTransition, my_model, anything)
         machine.new(my_model)
       end
 
       it "sets the passed class" do
         my_transition_class = Class.new
         Statesman.storage_adapter.should_receive(:new).once
-          .with(my_transition_class, my_model)
+          .with(my_transition_class, my_model, anything)
         machine.new(my_model, transition_class: my_transition_class)
       end
     end
@@ -396,28 +395,6 @@ describe Statesman::Machine do
           end
         end
       end
-
-      context "with a before callback" do
-        let(:callbacks) { [] }
-        before { instance.stub(:before_callbacks_for).and_return(callbacks) }
-
-        it "is passed to the adapter" do
-          Statesman::Adapters::Memory.any_instance.should_receive(:create)
-            .with("y", callbacks, anything, anything)
-          instance.transition_to!(:y)
-        end
-      end
-
-      context "with an after callback" do
-        let(:callbacks) { [] }
-        before { instance.stub(:after_callbacks_for).and_return(callbacks) }
-
-        it "is passed to the adapter" do
-          Statesman::Adapters::Memory.any_instance.should_receive(:create)
-            .with("y", anything, callbacks, anything)
-          instance.transition_to!(:y)
-        end
-      end
     end
   end
 
@@ -442,7 +419,7 @@ describe Statesman::Machine do
     end
   end
 
-  shared_examples "a callback filter" do |definer, getter|
+  shared_examples "a callback filter" do |definer, phase|
     before do
       machine.class_eval do
         state :x
@@ -454,7 +431,7 @@ describe Statesman::Machine do
     end
 
     let(:instance) { machine.new(my_model) }
-    let(:callbacks) { instance.send(getter, from: :x, to: :y) }
+    let(:callbacks) { instance.send(:callbacks_for, phase, from: :x, to: :y) }
 
     context "with no defined callbacks" do
       specify { expect(callbacks).to eq([]) }
@@ -480,16 +457,16 @@ describe Statesman::Machine do
   end
 
   describe "#guards_for" do
-    it_behaves_like "a callback filter", :guard_transition, :guards_for
+    it_behaves_like "a callback filter", :guard_transition, :guards
   end
 
   describe "#before_callbacks_for" do
     it_behaves_like "a callback filter", :before_transition,
-                    :before_callbacks_for
+                    :before
   end
 
   describe "#after_callbacks_for" do
     it_behaves_like "a callback filter", :after_transition,
-                    :after_callbacks_for
+                    :after
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: statesman
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Harry Marr
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-20 00:00:00.000000000 Z
+date: 2014-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler