end_state 0.10.1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4ab1a46deb255c511c400aa621f8115710df91b1
-  data.tar.gz: cf724f635788d18944aa6184c39d8a2eb99b5467
+  metadata.gz: fd8b390f8750c3af0948f56fa4e7471f5d4dfce8
+  data.tar.gz: ed30307b64e15e69829f25f61dcd883f3ce42fc2
 SHA512:
-  metadata.gz: 2a98ddb418c8ebd011a13d61d11132f325c16d00de89470199d849b80052f3c9a372766c9673d8b2649d5b545732c504358041846e45c4cdfcb61c63658208cc
-  data.tar.gz: d87346b6f8a48c9f2fb6d0e72a1f39b5216f2cf1af4ed23a42aa457bc47deb73d035c51648185cd9288244606ea626e9e2533baa0cd17364261a6aed803ac341
+  metadata.gz: d00715edd410e6dcffba526a15a5a5ad9475ce70665363423751a08b0a70912024b8c433126c8e11231b045d7278ee00821f3afb8845f1e3b578aaf56f01cad2
+  data.tar.gz: f4139a6f1fca2ca85e3883885d48106f293d0e7605060863cfd4ca6b7b350f24bfc8d10f6b65786329ebd6338c669e11bd9de2f34bc0f22c359c2eb08f7d3591

data/README.md

@@ -51,15 +51,17 @@ machine = Machine.new(StatefulObject.new(:a))
 machine.transition :b       # => true
 machine.state               # => :b
 machine.b?                  # => true
-machine.c!                  # => true
+machine.transition :c       # => true
 machine.state               # => :c
 machine.can_transition? :b  # => false
 machine.can_transition? :a  # => true
-machine.b!                  # => false
-machine.a!                  # => true
+machine.transition :b       # => false
+machine.transition! :b      # => raises InvalidTransition
+machine.transition :a       # => true
 machine.state               # => :a
-machine.go!                 # => :true
+machine.go                  # => true
 machine.state               # => :b
+machine.go!                 # => raises InvalidTransition
 ```
 
 ## Initial State
@@ -86,13 +88,13 @@ class Machine < EndState::StateMachine
 end
 
 machine = Machine.new(StatefulObject.new(:a))
-machine.d!      # true
-machine.state   # :d
+machine.transition :d      # true
+machine.state              # :d
 
 machine = Machine.new(StatefulObject.new(:a))
-machine.b!      # true
-machine.d!      # true
-machine.state   # :d
+machine.transition :b      # true
+machine.transition :d      # true
+machine.state              # :d
 ```
 
 ## Guards
@@ -234,10 +236,11 @@ end
 By using the `as` option in a transition definition you are creating an event representing that transition.
 This can allow you to exercise the machine in a more natural "verb" style interaction. When using `as` event
 definitions you can optionally set a `blocked` message on the transition. When the event is executed, if the
-machine is not in a state maching the initial state of the event, the message is added to the `failure_messages`
-array on the machine.
+machine is not in the initial state of the event, the message is added to the `failure_messages`
+array on the machine. Events, like `transition` have both a standard and a bang (`!`) style. The bang style
+will raise an exception if there is a problem.
 
-```
+```ruby
 class Machine < EndState::StateMachine
   transition a: :b, as: :go do |t|
     t.blocked 'Cannot go!'
@@ -246,10 +249,11 @@ end
 
 machine = Machine.new(StatefulObject.new(:a))
 
-machine.go!                 # => true
+machine.go                  # => true
 machine.state               # => :b
-machine.go!                 # => false
+machine.go                  # => false
 machine.failure_messages    # => ['Cannot go!']
+machine.go!                 # => raises InvalidTransition
 ```
 
 ## Parameters
@@ -261,25 +265,28 @@ When defining a transition you can indicate what parameters you are expecting wi
 If you require any params then attempting to transition without them provided will raise an error. Specifying allowed
 params is purely for documentation purposes.
 
-```
+```ruby
 class Machine < EndState::StateMachine
-  transition a: :b do |t|
+  transition a: :b, as: :go do |t|
     t.allow_params :foo, :bar
   end
 end
 ```
 
-```
+```ruby
 class Machine < EndState::StateMachine
-  transition a: :b do |t|
+  transition a: :b, as: :go do |t|
     t.require_params :foo, :bar
   end
 end
 
 machine = Machine.new(StatefulObject.new(:a))
+machine.transition :b                         # => error raised: 'Missing params: foo, bar'
+machine.transition :b, foo: 1, bar: 'value'   # => true
 
-machine.b!                        # => error raised: 'Missing params: foo, bar'
-machine.b! foo: 1, bar: 'value'   # => true
+machine = Machine.new(StatefulObject.new(:a))
+machine.go                        # => error raised: 'Missing params: foo, bar'
+machine.go foo: 1, bar: 'value'   # => true
 ```
 
 ## State storage

data/examples/example1.rb

@@ -25,7 +25,7 @@ end
 
 class Machine < EndState::StateMachine
   transition a: :b do |t|
-    t.guard Easy, important_param: 'FOO!'
+    t.guard Easy
     t.persistence_on
   end
 
@@ -35,7 +35,7 @@ class Machine < EndState::StateMachine
   end
 
   transition [:b, :c] => :a do |t|
-    t.concluder NoOp, not_very_important_param: 'Ignore me'
+    t.concluder NoOp
     t.persistence_on
   end
 end

data/lib/end_state/concluder.rb

@@ -17,8 +17,4 @@ module EndState
       true
     end
   end
-
-  # Backward compatibility
-  # Finalizer is deprecated
-  Finalizer = Concluder
 end

data/lib/end_state/concluders/persistence.rb

@@ -12,8 +12,4 @@ module EndState
       end
     end
   end
-
-  # Backward compatibility
-  # Finalizer is deprecated
-  Finalizers = Concluders
 end

data/lib/end_state/errors.rb

@@ -1,12 +1,7 @@
 module EndState
   class Error < StandardError; end
   class UnknownState < Error; end
-  class UnknownTransition < Error; end
-  class InvalidEvent < Error; end
+  class InvalidTransition < Error; end
   class GuardFailed < Error; end
   class ConcluderFailed < Error; end
-
-  # Backward compatibility
-  # Finalizer is deprecated
-  FinalizerFailed = ConcluderFailed
 end

data/lib/end_state/graph.rb

@@ -12,9 +12,9 @@ module EndState
     def draw
       machine.transitions.keys.each do |t|
         left, right = t.to_a.flatten
-        nodes[left] ||= add_node(left.to_s)
-        nodes[right] ||= add_node(right.to_s)
-        edge = add_edge nodes[left], nodes[right]
+        nodes[left] ||= add_nodes(left.to_s)
+        nodes[right] ||= add_nodes(right.to_s)
+        edge = add_edges nodes[left], nodes[right]
         if event_labels
           event = machine.events.detect do |event, transition|
             transition.include? t
@@ -25,4 +25,4 @@ module EndState
       self
     end
   end
-end
+end

data/lib/end_state/state_machine.rb

@@ -80,8 +80,8 @@ module EndState
     def can_transition?(state, params = {})
       previous_state = self.state.to_sym
       state = state.to_sym
-      transition = transition_for(previous_state, state)
-      return block_transistion(transition, state, :soft) unless transition
+      transition = __sm_transition_for(previous_state, state)
+      return __sm_block_transistion(transition, state, :soft) unless transition
       transition.will_allow? state, params
     end
 
@@ -90,11 +90,12 @@ module EndState
       @success_messages = []
       previous_state = self.state ? self.state.to_sym : self.state
       state = state.to_sym
-      transition = transition_for(previous_state, state)
-      return block_transistion(transition, state, mode) unless transition
-      return guard_failed(state, mode) unless transition.allowed?(self, params)
+      transition = __sm_transition_for(previous_state, state)
+      mode = __sm_actual_mode(mode)
+      return __sm_block_transistion(transition, state, mode) unless transition
+      return __sm_guard_failed(state, mode) unless transition.allowed?(self, params)
       return false unless transition.action.new(self, state).call
-      return conclude_failed(state, mode) unless transition.conclude(self, previous_state, params)
+      return __sm_conclude_failed(state, mode) unless transition.conclude(self, previous_state, params)
       true
     end
 
@@ -103,62 +104,78 @@ module EndState
     end
 
     def method_missing(method, *args, &block)
-      check_state = method.to_s[0..-2].to_sym
-      return super unless is_state_or_event?(check_state)
-      return current_state?(check_state) if method.to_s.end_with?('?')
-      check_state = state_for_event(check_state) || check_state
-      return false if check_state == :__invalid_event__
-      if method.to_s.end_with?('!')
-        transition check_state, (args[0] || {})
-      else
-        super
-      end
+      return super unless __sm_predicate_or_event?(method)
+      return __sm_current_state?(method) if __sm_state_predicate(method)
+      new_state, mode = __sm_event(method)
+      return false if new_state == :__invalid_event__
+      transition new_state, (args[0] || {}), mode
     end
 
     private
 
-    def is_state_or_event?(check_state)
-      self.class.states.include?(check_state) or self.class.events[check_state]
+    def __sm_predicate_or_event?(method)
+      __sm_state_predicate(method) ||
+      __sm_event(method)
+    end
+
+    def __sm_state_predicate(method)
+      state = method.to_s[0..-2].to_sym
+      return unless self.class.states.include?(state) && method.to_s.end_with?('?')
+      state
+    end
+
+    def __sm_event(method)
+      event = __sm_state_for_event(method.to_sym, __sm_actual_mode(:soft))
+      return event, __sm_actual_mode(:soft) if event
+      return unless method.to_s.end_with?('!')
+      event = __sm_state_for_event(method.to_s[0..-2].to_sym, :hard)
+      return event, :hard if event
+      nil
+    end
+
+    def __sm_actual_mode(mode)
+      return :hard if self.class.mode == :hard
+      mode
     end
 
-    def current_state?(check_state)
-      state.to_sym == check_state
+    def __sm_current_state?(method)
+      state.to_sym == __sm_state_predicate(method)
     end
 
-    def state_for_event(event)
+    def __sm_state_for_event(event, mode)
       transitions = self.class.events[event]
       return false unless transitions
       start_states = transitions.map { |t| t.keys.first }
-      return invalid_event(event) unless start_states.include?(state.to_sym) || start_states.include?(:any_state)
+      return __sm_invalid_event(event, mode) unless start_states.include?(state.to_sym) || start_states.include?(:any_state)
       transitions.first.values.first
     end
 
-    def transition_for(from, to)
-      self.class.transitions[{ from => to }] ||
-      self.class.transitions[{ any_state: to }]
-    end
-
-    def invalid_event(event)
-      fail InvalidEvent, "Transition by event: #{event} is invalid." if self.class.mode == :hard
+    def __sm_invalid_event(event, mode)
+      fail InvalidTransition, "Transition by event: #{event} is invalid." if mode == :hard
       message = self.class.transitions[self.class.events[event].first].blocked_event_message
       @failure_messages = [message] if message
       :__invalid_event__
     end
 
-    def block_transistion(transition, state, mode)
+    def __sm_transition_for(from, to)
+      self.class.transitions[{ from => to }] ||
+      self.class.transitions[{ any_state: to }]
+    end
+
+    def __sm_block_transistion(transition, state, mode)
       if self.class.end_states.include? state
-        fail UnknownTransition, "The transition: #{object.state} => #{state} is unknown." if mode == :hard
+        fail InvalidTransition, "The transition: #{object.state} => #{state} is invalid." if mode == :hard
         return false
       end
       fail UnknownState, "The state: #{state} is unknown."
     end
 
-    def guard_failed(state, mode)
+    def __sm_guard_failed(state, mode)
       return false unless mode == :hard
       fail GuardFailed, "The transition to #{state} was blocked: #{failure_messages.join(', ')}"
     end
 
-    def conclude_failed(state, mode)
+    def __sm_conclude_failed(state, mode)
       return false unless mode == :hard
       fail ConcluderFailed, "The transition to #{state} was rolled back: #{failure_messages.join(', ')}"
     end

data/lib/end_state/transition.rb

@@ -63,12 +63,6 @@ module EndState
       @blocked_event_message = message
     end
 
-    # Backward compatibility
-    # Finalizer is deprecated
-    alias_method :finalizers, :concluders
-    alias_method :finalize, :conclude
-    alias_method :finalizer, :concluder
-
     private
 
     def rollback(concluded, object, previous_state, params)

data/lib/end_state/version.rb

@@ -1,3 +1,3 @@
 module EndState
-  VERSION = '0.10.1'
+  VERSION = '0.11.0'
 end

data/spec/end_state/action_spec.rb

@@ -6,7 +6,7 @@ module EndState
     let(:object) { OpenStruct.new(state: nil) }
     let(:state) { :a }
 
-    before { object.stub_chain(:class, :store_states_as_strings).and_return(false) }
+    before { allow(object).to receive_message_chain(:class, store_states_as_strings: false) }
 
     describe '#call' do
       it 'changes the state to the new state' do
@@ -22,4 +22,4 @@ module EndState
       end
     end
   end
-end
+end

data/spec/end_state/concluders/persistence_spec.rb

@@ -18,7 +18,7 @@ module EndState
           let(:object) { Object.new }
 
           it 'returns false' do
-            expect(concluder.call).to be_false
+            expect(concluder.call).to be false
           end
         end
       end
@@ -33,7 +33,7 @@ module EndState
           let(:object) { Object.new }
 
           it 'returns true' do
-            expect(concluder.rollback).to be_true
+            expect(concluder.rollback).to be true
           end
         end
       end

data/spec/end_state/state_machine_spec.rb

@@ -23,7 +23,7 @@ module EndState
       end
 
       it 'does not require a block' do
-        expect(StateMachine.transition(b: :c)).not_to raise_error
+        expect { StateMachine.transition(b: :c) }.not_to raise_error
       end
 
       it 'adds the transition to the state machine' do
@@ -89,13 +89,13 @@ module EndState
     describe '.store_states_as_strings!' do
       it 'sets the flag' do
         StateMachine.store_states_as_strings!
-        expect(StateMachine.store_states_as_strings).to be_true
+        expect(StateMachine.store_states_as_strings).to be true
       end
     end
 
     describe '#store_states_as_strings' do
       it 'is false by default' do
-        expect(StateMachine.store_states_as_strings).to be_false
+        expect(StateMachine.store_states_as_strings).to be false
       end
     end
 
@@ -136,15 +136,15 @@ module EndState
       context 'when the object has state :a' do
         let(:object) { OpenStruct.new(state: :a) }
 
-        specify { expect(machine.a?).to be_true }
-        specify { expect(machine.b?).to be_false }
+        specify { expect(machine.a?).to be true }
+        specify { expect(machine.b?).to be false }
       end
 
       context 'when the object has state :b' do
         let(:object) { OpenStruct.new(state: :b) }
 
-        specify { expect(machine.b?).to be_true }
-        specify { expect(machine.a?).to be_false }
+        specify { expect(machine.b?).to be true }
+        specify { expect(machine.a?).to be false }
       end
 
       context 'when the state shares a name with an event' do
@@ -153,7 +153,7 @@ module EndState
         context 'and the object, in that state, cannot transition on the event' do
           let(:object) { OpenStruct.new(state: :stop) }
 
-          specify { expect(machine.stop?).to be_true }
+          specify { expect(machine.stop?).to be true }
         end
       end
 
@@ -170,7 +170,7 @@ module EndState
       end
     end
 
-    describe '#{state}!' do
+    describe '#{event}' do
       let(:object) { OpenStruct.new(state: :a) }
       before do
         StateMachine.transition a: :b, as: :go do |t|
@@ -179,49 +179,90 @@ module EndState
       end
 
       it 'transitions the state' do
-        machine.b!
+        machine.go
         expect(machine.state).to eq :b
       end
 
       it 'accepts params' do
-        machine.stub(:transition)
-        machine.b! foo: 'bar', bar: 'foo'
-        expect(machine).to have_received(:transition).with(:b, { foo: 'bar', bar: 'foo' })
+        allow(machine).to receive(:transition)
+        machine.go foo: 'bar', bar: 'foo'
+        expect(machine).to have_received(:transition).with(:b, { foo: 'bar', bar: 'foo' }, :soft)
       end
 
       it 'defaults params to {}' do
-        machine.stub(:transition)
-        machine.b!
-        expect(machine).to have_received(:transition).with(:b, {})
-      end
-
-      it 'works with an event' do
-        machine.go!
-        expect(machine.state).to eq :b
+        allow(machine).to receive(:transition)
+        machine.go
+        expect(machine).to have_received(:transition).with(:b, {}, :soft)
       end
 
       context 'when the intial state is :c' do
         let(:object) { OpenStruct.new(state: :c) }
 
         it 'blocks invalid events' do
-          machine.go!
+          machine.go
           expect(machine.state).to eq :c
         end
 
         it 'adds a failure message specified by blocked' do
-          machine.go!
+          machine.go
           expect(machine.failure_messages).to eq ['Invalid event!']
         end
 
         context 'and all transitions are forced to run in :hard mode' do
           before { machine.class.treat_all_transitions_as_hard! }
 
-          it 'raises an InvalidEvent error' do
-            expect { machine.go! }.to raise_error(InvalidEvent)
+          it 'raises an InvalidTransition error' do
+            expect { machine.go }.to raise_error(InvalidTransition)
           end
         end
       end
 
+      context 'when using any_state with an event' do
+        before do
+          StateMachine.transition any_state: :end, as: :jump_to_end
+        end
+
+        it 'transitions the state to :end' do
+          machine.jump_to_end
+          expect(machine.state).to eq :end
+        end
+      end
+    end
+
+    describe '#{event}!' do
+      let(:object) { OpenStruct.new(state: :a) }
+      before do
+        StateMachine.transition a: :b, as: :go do |t|
+          t.blocked 'Invalid event!'
+        end
+      end
+
+      it 'transitions the state' do
+        machine.go!
+        expect(machine.state).to eq :b
+      end
+
+      it 'accepts params' do
+        allow(machine).to receive(:transition)
+        machine.go! foo: 'bar', bar: 'foo'
+        expect(machine).to have_received(:transition).with(:b, { foo: 'bar', bar: 'foo' }, :hard)
+      end
+
+      it 'defaults params to {}' do
+        allow(machine).to receive(:transition)
+        machine.go!
+        expect(machine).to have_received(:transition).with(:b, {}, :hard)
+      end
+
+      context 'when the intial state is :c' do
+        let(:object) { OpenStruct.new(state: :c) }
+
+        it 'blocks invalid events' do
+          expect { machine.go! }.to raise_error
+          expect(machine.state).to eq :c
+        end
+      end
+
       context 'when using any_state with an event' do
         before do
           StateMachine.transition any_state: :end, as: :jump_to_end
@@ -242,11 +283,11 @@ module EndState
       end
 
       context 'when asking about an allowed transition' do
-        specify { expect(machine.can_transition? :b).to be_true }
+        specify { expect(machine.can_transition? :b).to be true }
       end
 
       context 'when asking about a disallowed transition' do
-        specify { expect(machine.can_transition? :c).to be_false }
+        specify { expect(machine.can_transition? :c).to be false }
       end
 
       context 'when using :any_state' do
@@ -255,13 +296,13 @@ module EndState
         context 'and the initial state is :a' do
           let(:object) { OpenStruct.new(state: :a) }
 
-          specify { expect(machine.can_transition? :d).to be_true }
+          specify { expect(machine.can_transition? :d).to be true }
         end
 
         context 'and the initial state is :b' do
           let(:object) { OpenStruct.new(state: :b) }
 
-          specify { expect(machine.can_transition? :d).to be_true }
+          specify { expect(machine.can_transition? :d).to be true }
         end
       end
     end
@@ -276,7 +317,7 @@ module EndState
           before { StateMachine.transition a: :b }
 
           it 'returns false' do
-            expect(machine.transition(:b)).to be_false
+            expect(machine.transition(:b)).to be false
           end
         end
       end
@@ -335,7 +376,7 @@ module EndState
 
           context 'and the object satisfies the guard' do
             before do
-              guard_instance.stub(:allowed?).and_return(true)
+              allow(guard_instance).to receive(:allowed?).and_return(true)
               object.state = :a
             end
 
@@ -347,7 +388,7 @@ module EndState
 
           context 'and the object does not satisfy the guard' do
             before do
-              guard_instance.stub(:allowed?).and_return(false)
+              allow(guard_instance).to receive(:allowed?).and_return(false)
               object.state = :a
             end
 
@@ -377,7 +418,7 @@ module EndState
 
           context 'and the concluder is successful' do
             before do
-              concluder_instance.stub(:call).and_return(true)
+              allow(concluder_instance).to receive(:call).and_return(true)
             end
 
             it 'transitions the state' do
@@ -388,7 +429,7 @@ module EndState
 
           context 'and the concluder fails' do
             before do
-              concluder_instance.stub(:call).and_return(false)
+              allow(concluder_instance).to receive(:call).and_return(false)
             end
 
             it 'does not transition the state' do
@@ -410,7 +451,7 @@ module EndState
           before { StateMachine.transition a: :b }
 
           it 'returns false' do
-            expect { machine.transition!(:b) }.to raise_error(UnknownTransition)
+            expect { machine.transition!(:b) }.to raise_error(InvalidTransition)
           end
         end
       end
@@ -437,7 +478,7 @@ module EndState
 
           context 'and the object satisfies the guard' do
             before do
-              guard_instance.stub(:allowed?).and_return(true)
+              allow(guard_instance).to receive(:allowed?).and_return(true)
               object.state = :a
             end
 
@@ -449,7 +490,7 @@ module EndState
 
           context 'and the object does not satisfy the guard' do
             before do
-              guard_instance.stub(:allowed?).and_return(false)
+              allow(guard_instance).to receive(:allowed?).and_return(false)
               object.state = :a
             end
 
@@ -471,7 +512,7 @@ module EndState
 
           context 'and the concluder is successful' do
             before do
-              concluder_instance.stub(:call).and_return(true)
+              allow(concluder_instance).to receive(:call).and_return(true)
             end
 
             it 'transitions the state' do
@@ -482,7 +523,7 @@ module EndState
 
           context 'and the concluder fails' do
             before do
-              concluder_instance.stub(:call).and_return(false)
+              allow(concluder_instance).to receive(:call).and_return(false)
             end
 
             it 'does not transition the state' do

data/spec/end_state/transition_spec.rb

@@ -42,9 +42,9 @@ module EndState
       before { transition.guards << guard }
 
       context 'when all guards pass' do
-        before { guard_instance.stub(:allowed?).and_return(true) }
+        before { allow(guard_instance).to receive(:allowed?).and_return(true) }
 
-        specify { expect(transition.allowed? object).to be_true }
+        specify { expect(transition.allowed? object).to be true }
 
         context 'when params are provided' do
           it 'creates the guard with the params' do
@@ -62,16 +62,16 @@ module EndState
             end
 
             context 'and all required are provided' do
-              specify { expect(transition.allowed? object, foo: 1, bar: 2).to be_true }
+              specify { expect(transition.allowed? object, foo: 1, bar: 2).to be true }
             end
           end
         end
       end
 
       context 'when not all guards pass' do
-        before { guard_instance.stub(:allowed?).and_return(false) }
+        before { allow(guard_instance).to receive(:allowed?).and_return(false) }
 
-        specify { expect(transition.allowed? object).to be_false }
+        specify { expect(transition.allowed? object).to be false }
       end
     end
 
@@ -82,9 +82,9 @@ module EndState
       before { transition.guards << guard }
 
       context 'when all guards pass' do
-        before { guard_instance.stub(:will_allow?).and_return(true) }
+        before { allow(guard_instance).to receive(:will_allow?).and_return(true) }
 
-        specify { expect(transition.will_allow? object).to be_true }
+        specify { expect(transition.will_allow? object).to be true }
 
         context 'when params are provided' do
           it 'creates the guard with the params' do
@@ -96,20 +96,20 @@ module EndState
             before { transition.require_params :foo, :bar }
 
             context 'and not all required are provided' do
-              specify { expect(transition.will_allow? object).to be_false }
+              specify { expect(transition.will_allow? object).to be false }
             end
 
             context 'and all required are provided' do
-              specify { expect(transition.will_allow? object, foo: 1, bar: 2).to be_true }
+              specify { expect(transition.will_allow? object, foo: 1, bar: 2).to be true }
             end
           end
         end
       end
 
       context 'when not all guards pass' do
-        before { guard_instance.stub(:will_allow?).and_return(false) }
+        before { allow(guard_instance).to receive(:will_allow?).and_return(false) }
 
-        specify { expect(transition.will_allow? object).to be_false }
+        specify { expect(transition.will_allow? object).to be false }
       end
 
       context 'when params are provided' do
@@ -160,20 +160,20 @@ module EndState
       let(:concluder_instance) { double :concluder_instance, call: nil, rollback: nil }
       let(:object) { OpenStruct.new(state: :b) }
       before do
-        object.stub_chain(:class, :store_states_as_strings).and_return(false)
+        allow(object).to receive_message_chain(:class, store_states_as_strings: false)
         transition.concluders << concluder
       end
 
       context 'when all concluders succeed' do
-        before { concluder_instance.stub(:call).and_return(true) }
+        before { allow(concluder_instance).to receive(:call).and_return(true) }
 
-        specify { expect(transition.conclude object, :a).to be_true }
+        specify { expect(transition.conclude object, :a).to be true }
       end
 
       context 'when not all concluders succeed' do
-        before { concluder_instance.stub(:call).and_return(false) }
+        before { allow(concluder_instance).to receive(:call).and_return(false) }
 
-        specify { expect(transition.conclude object, :a).to be_false }
+        specify { expect(transition.conclude object, :a).to be false }
 
         it 'rolls them back' do
           transition.conclude object, :a

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: end_state
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.11.0
 platform: ruby
 authors:
 - alexpeachey
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-25 00:00:00.000000000 Z
+date: 2014-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler