end_state 0.4.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 56937726694a33d9ac097f1f224d5602bb9600c3
-  data.tar.gz: 6f3e4fcf53831c33e11e4fdbac2485a1d6fecd3a
+  metadata.gz: 51e9a6a8a317af60132c723aabd5a615ec93f4e3
+  data.tar.gz: 96a3350ec5237b631314c8b5ab574598eb47b219
 SHA512:
-  metadata.gz: 0c2afcefdfaaf9de627121c7e0d13494f4ca632718d79f82c55ee847d935cda7a56ddbf0fefbb4591c88d823d0fee1ba813010ac7631e1fa8b47a48d765ce56c
-  data.tar.gz: 3503000ac420f5746ab0a3389966151d5a1d7a10aefb5e4a438180fd7ab6017cbe5362bc551ce56d6def5c5cd1dccf2cc554c74cfcba3b09c684d46cb315b1bd
+  metadata.gz: 29e1d05f5fe9da4df8f33783fde04cb1fd9b0f458ee79cfa9d0c728c003e29d62526259fc01b5e0240613583248f4987f9f3883d154957d39477ee2ed895a1e9
+  data.tar.gz: 1c82abe3ebcd9475e20865a77559a596d8bbfd718717a011cfa14d8d1938417ebdc57e6faa420a2fc3cb0fa54ad7484cfbad33bc84dfcde47c092bc29f53db5d

data/README.md

@@ -118,9 +118,9 @@ class Machine < EndState::StateMachine
 end
 ```
 
-## Finalizers
+## Concluders
 
-Finalizers can be created by subclassing `EndState::Finalizer`. Your class will be provided access to:
+Concluders can be created by subclassing `EndState::Concluder`. Your class will be provided access to:
 
 * `object` - The wrapped object that has been transitioned.
 * `state` - The previous state.
@@ -128,8 +128,8 @@ Finalizers can be created by subclassing `EndState::Finalizer`. Your class will
 
 Your class should implement the `call` method which should return true or false as to whether it was successful or not.
 
-If your finalizer returns false, the transition will be "rolled back" and the failing transition, as well as all previous transitions
-will be rolled back. The roll back is performed by calling `rollback` on the finalizer. During the roll back the finalizer will be
+If your concluder returns false, the transition will be "rolled back" and the failing transition, as well as all previous transitions
+will be rolled back. The roll back is performed by calling `rollback` on the concluder. During the roll back the concluder will be
 set up a little differently and you have access to:
 
 * `object` - The wrapped object that has been rolled back.
@@ -137,15 +137,15 @@ set up a little differently and you have access to:
 * `params` - A hash of params passed when calling transition on the machine.
 
 The wrapped object has an array `failure_messages` available for tracking reasons for invalid transitions. You may shovel
-a reason (string) into this if you want to provide information on why your finalizer failed. You can also use the helper method in
-the `Finalizer` class called `add_error` which takes a string.
+a reason (string) into this if you want to provide information on why your concluder failed. You can also use the helper method in
+the `Concluder` class called `add_error` which takes a string.
 
 The wrapped object has an array `success_messages` available for tracking reasons for valid transitions. You may shovel
-a reason (string) into this if you want to provide information on why your finalizer succeeded. You can also use the helper method in
-the `Finalizer` class called `add_success` which takes a string.
+a reason (string) into this if you want to provide information on why your concluder succeeded. You can also use the helper method in
+the `Concluder` class called `add_success` which takes a string.
 
 ```ruby
-class WrapUp < EndState::Finalizer
+class WrapUp < EndState::Concluder
   def call
     # Some important processing
     true
@@ -157,17 +157,17 @@ class WrapUp < EndState::Finalizer
 end
 ```
 
-A finalizer can be added to the transition definition:
+A concluder can be added to the transition definition:
 
 ```ruby
 class Machine < EndState::StateMachine
   transition a: :b do |t|
-    t.finalizer WrapUp
+    t.concluder WrapUp
   end
 end
 ```
 
-Since it is a common use case, a finalizer is included which will call `save` on the wrapped object if it responds to `save`.
+Since it is a common use case, a concluder is included which will call `save` on the wrapped object if it responds to `save`.
 You can use this with a convience method in your transition definition:
 
 ```ruby
@@ -252,10 +252,10 @@ end
 ## Exceptions for failing Transitions
 
 By default `transition` will only raise an error, `EndState::UnknownState`, if called with a state that doesn't exist.
-All other failures, such as missing transition, guard failure, or finalizer failure will silently just return `false` and not
+All other failures, such as missing transition, guard failure, or concluder failure will silently just return `false` and not
 transition to the new state.
 
-You also have the option to use `transition!` which will instead raise an error for failures. If your guards and/or finalizers
+You also have the option to use `transition!` which will instead raise an error for failures. If your guards and/or concluders
 add to the `failure_messages` array then they will be included in the error message.
 
 Additionally, if you would like to treat all transitions as hard and raise an error you can set that in the machine definition.
@@ -292,10 +292,10 @@ In the spec for your state machine:
 ```ruby
 describe Machine do
   specify { expect(Machine).to have_transition(a: :b).with_guard(MyGuard) }
-  specify { expect(Machine).to have_transition(a: :b).with_finalizer(MyFinalizer) }
-  specify { expect(Machine).to have_transition(a: :b).with_guard(MyGuard).with_finalizer(MyFinalizer) }
+  specify { expect(Machine).to have_transition(a: :b).with_concluder(MyConcluder) }
+  specify { expect(Machine).to have_transition(a: :b).with_guard(MyGuard).with_concluder(MyConcluder) }
   specify { expect(Machine).to have_transition(a: :b).with_guards(MyGuard, AnotherGuard) }
-  specify { expect(Machine).to have_transition(a: :b).with_finalizers(MyFinalizer, AnotherFinalizer) }
+  specify { expect(Machine).to have_transition(a: :b).with_concluders(MyConcluder, AnotherConcluder) }
   specify { expect(Machine).not_to have_transition(a: :c) }
 end
 ```

data/examples/example1.rb

@@ -7,7 +7,7 @@ class Easy < EndState::Guard
   end
 end
 
-class NoOp < EndState::Finalizer
+class NoOp < EndState::Concluder
   def call
     true
   end
@@ -35,7 +35,7 @@ class Machine < EndState::StateMachine
   end
 
   transition [:b, :c] => :a do |t|
-    t.finalizer NoOp, not_very_important_param: 'Ignore me'
+    t.concluder NoOp, not_very_important_param: 'Ignore me'
     t.persistence_on
   end
 end

data/examples/machine_spec.rb

@@ -8,7 +8,7 @@ class Easy < EndState::Guard
   end
 end
 
-class NoOp < EndState::Finalizer
+class NoOp < EndState::Concluder
   def call
     true
   end
@@ -17,12 +17,12 @@ end
 class Machine < EndState::StateMachine
   transition a: :b do |t|
     t.guard Easy
-    t.finalizer NoOp
+    t.concluder NoOp
   end
 end
 
 describe Machine do
-  specify { expect(Machine).to have_transition(a: :b).with_guard(Easy).with_finalizer(NoOp) }
-  specify { expect(Machine).to have_transition(a: :b).with_guards(Easy, Easy).with_finalizers(NoOp, NoOp) }
+  specify { expect(Machine).to have_transition(a: :b).with_guard(Easy).with_concluder(NoOp) }
+  specify { expect(Machine).to have_transition(a: :b).with_guards(Easy, Easy).with_concluders(NoOp, NoOp) }
   specify { expect(Machine).not_to have_transition(a: :c) }
 end

data/lib/end_state/{finalizer.rb → concluder.rb}

@@ -1,5 +1,5 @@
 module EndState
-  class Finalizer
+  class Concluder
     include Messages
     attr_reader :object, :state, :params
 
@@ -17,4 +17,8 @@ module EndState
       true
     end
   end
+
+  # Backward compatibility
+  # Finalizer is deprecated
+  Finalizer = Concluder
 end

data/lib/end_state/{finalizers → concluders}/persistence.rb

@@ -1,6 +1,6 @@
 module EndState
-  module Finalizers
-    class Persistence < EndState::Finalizer
+  module Concluders
+    class Persistence < EndState::Concluder
       def call
         return false unless object.respond_to? :save
         !!(object.save)
@@ -12,4 +12,8 @@ module EndState
       end
     end
   end
+
+  # Backward compatibility
+  # Finalizer is deprecated
+  Finalizers = Concluders
 end

data/lib/end_state/concluders.rb

@@ -0,0 +1 @@
+require 'end_state/concluders/persistence'

data/lib/end_state/errors.rb

@@ -4,5 +4,9 @@ module EndState
   class UnknownTransition < Error; end
   class InvalidEvent < Error; end
   class GuardFailed < Error; end
-  class FinalizerFailed < Error; end
+  class ConcluderFailed < Error; end
+
+  # Backward compatibility
+  # Finalizer is deprecated
+  FinalizerFailed = ConcluderFailed
 end

data/lib/end_state/state_machine.rb

@@ -94,7 +94,7 @@ module EndState
       return block_transistion(transition, state, mode) unless transition
       return guard_failed(state, mode) unless transition.allowed?(self, params)
       return false unless transition.action.new(self, state).call
-      return finalize_failed(state, mode) unless transition.finalize(self, previous_state, params)
+      return conclude_failed(state, mode) unless transition.conclude(self, previous_state, params)
       true
     end
 
@@ -152,9 +152,9 @@ module EndState
       fail GuardFailed, "The transition to #{state} was blocked: #{failure_messages.join(', ')}"
     end
 
-    def finalize_failed(state, mode)
+    def conclude_failed(state, mode)
       return false unless mode == :hard
-      fail FinalizerFailed, "The transition to #{state} was rolled back: #{failure_messages.join(', ')}"
+      fail ConcluderFailed, "The transition to #{state} was rolled back: #{failure_messages.join(', ')}"
     end
   end
 end

data/lib/end_state/transition.rb

@@ -1,13 +1,13 @@
 module EndState
   class Transition
     attr_reader :state, :blocked_event_message
-    attr_accessor :action, :guards, :finalizers
+    attr_accessor :action, :guards, :concluders
 
     def initialize(state)
       @state = state
       @action = Action
       @guards = []
-      @finalizers = []
+      @concluders = []
     end
 
     def allowed?(object, params={})
@@ -18,10 +18,10 @@ module EndState
       guards.all? { |guard| guard.new(object, state, params).will_allow? }
     end
 
-    def finalize(object, previous_state, params={})
-      finalizers.each_with_object([]) do |finalizer, finalized|
-        finalized << finalizer
-        return rollback(finalized, object, previous_state, params) unless run_finalizer(finalizer, object, state, params)
+    def conclude(object, previous_state, params={})
+      concluders.each_with_object([]) do |concluder, concluded|
+        concluded << concluder
+        return rollback(concluded, object, previous_state, params) unless run_concluder(concluder, object, state, params)
       end
       true
     end
@@ -34,28 +34,34 @@ module EndState
       guards << guard
     end
 
-    def finalizer(finalizer)
-      finalizers << finalizer
+    def concluder(concluder)
+      concluders << concluder
     end
 
     def persistence_on
-      finalizer Finalizers::Persistence
+      concluder Concluders::Persistence
     end
 
     def blocked(message)
       @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(finalized, object, previous_state, params)
+    def rollback(concluded, object, previous_state, params)
       action.new(object, previous_state).rollback
-      finalized.reverse.each { |finalizer| finalizer.new(object, state, params).rollback }
+      concluded.reverse.each { |concluder| concluder.new(object, state, params).rollback }
       false
     end
 
-    def run_finalizer(finalizer, object, state, params)
-      finalizer.new(object, state, params).call
+    def run_concluder(concluder, object, state, params)
+      concluder.new(object, state, params).call
     end
   end
 end

data/lib/end_state/version.rb

@@ -1,3 +1,3 @@
 module EndState
-  VERSION = '0.4.0'
+  VERSION = '0.9.0'
 end

data/lib/end_state.rb

@@ -3,8 +3,8 @@ require 'end_state/version'
 require 'end_state/errors'
 require 'end_state/messages'
 require 'end_state/guard'
-require 'end_state/finalizer'
-require 'end_state/finalizers'
+require 'end_state/concluder'
+require 'end_state/concluders'
 require 'end_state/transition'
 require 'end_state/action'
 require 'end_state/state_machine'

data/lib/end_state_matchers.rb

@@ -4,13 +4,13 @@ module EndStateMatchers
   end
 
   class TransitionMatcher
-    attr_reader :transition, :machine, :failure_messages, :guards, :finalizers
+    attr_reader :transition, :machine, :failure_messages, :guards, :concluders
 
     def initialize(transition)
       @transition = transition
       @failure_messages = []
       @guards = []
-      @finalizers = []
+      @concluders = []
     end
 
     def matches?(actual)
@@ -36,23 +36,29 @@ module EndStateMatchers
       self
     end
 
-    def with_finalizer(finalizer)
-      @finalizers << finalizer
+    def with_concluder(concluder)
+      @concluders << concluder
       self
     end
 
-    def with_finalizers(*finalizers)
-      @finalizers += Array(finalizers)
+    def with_concluders(*concluders)
+      @concluders += Array(concluders)
       self
     end
 
+    # Backward compatibility
+    # Finalizer is deprecated
+    alias_method :with_finalizer, :with_concluder
+    alias_method :with_finalizers, :with_concluders
+    alias_method :finalizers, :concluders
+
     private
 
     def verify
       result = true
       if machine.transitions.keys.include? transition
         result = (result && verify_guards) if guards.any?
-        result = (result && verify_finalizers) if finalizers.any?
+        result = (result && verify_concluders) if concluders.any?
         result
       else
         failure_messages << "expected that #{machine.name} would have transition :#{transition.keys.first} => :#{transition.values.first}"
@@ -71,11 +77,11 @@ module EndStateMatchers
       result
     end
 
-    def verify_finalizers
+    def verify_concluders
       result = true
-      finalizers.each do |finalizer|
-        unless machine.transitions[transition].finalizers.any? { |f| f == finalizer }
-          failure_messages << "expected that transition :#{transition.keys.first} => :#{transition.values.first} would have finalizer #{finalizer.name}"
+      concluders.each do |concluder|
+        unless machine.transitions[transition].concluders.any? { |f| f == concluder }
+          failure_messages << "expected that transition :#{transition.keys.first} => :#{transition.values.first} would have concluder #{concluder.name}"
           result = false
         end
       end

data/spec/end_state/{finalizer_spec.rb → concluder_spec.rb}

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 module EndState
-  describe Finalizer do
-    subject(:finalizer) { Finalizer.new(object, state, params) }
+  describe Concluder do
+    subject(:concluder) { Concluder.new(object, state, params) }
     let(:object) { Struct.new('Machine', :failure_messages, :success_messages, :state, :store_states_as_strings).new }
     let(:state) { :a }
     let(:params) { {} }
@@ -13,14 +13,14 @@ module EndState
 
     describe '#add_error' do
       it 'adds an error' do
-        finalizer.add_error('error')
+        concluder.add_error('error')
         expect(object.failure_messages).to eq ['error']
       end
     end
 
     describe '#add_success' do
       it 'adds an success' do
-        finalizer.add_error('success')
+        concluder.add_error('success')
         expect(object.failure_messages).to eq ['success']
       end
     end

data/spec/end_state/{finalizers → concluders}/persistence_spec.rb

@@ -1,16 +1,16 @@
 require 'spec_helper'
 
 module EndState
-  module Finalizers
+  module Concluders
     describe Persistence do
-      subject(:finalizer) { Persistence.new(object, state, params) }
+      subject(:concluder) { Persistence.new(object, state, params) }
       let(:object) { double :object, save: nil }
       let(:state) { :b }
       let(:params) { {} }
 
       describe '#call' do
         it 'calls save on the object' do
-          finalizer.call
+          concluder.call
           expect(object).to have_received(:save)
         end
 
@@ -18,14 +18,14 @@ module EndState
           let(:object) { Object.new }
 
           it 'returns false' do
-            expect(finalizer.call).to be_false
+            expect(concluder.call).to be_false
           end
         end
       end
 
       describe '#rollback' do
         it 'calls save on the object' do
-          finalizer.rollback
+          concluder.rollback
           expect(object).to have_received(:save)
         end
 
@@ -33,7 +33,7 @@ module EndState
           let(:object) { Object.new }
 
           it 'returns true' do
-            expect(finalizer.rollback).to be_true
+            expect(concluder.rollback).to be_true
           end
         end
       end

data/spec/end_state/state_machine_spec.rb

@@ -311,18 +311,18 @@ module EndState
           end
         end
 
-        context 'and a finalizer is configured' do
-          let(:finalizer) { double :finalizer, new: finalizer_instance }
-          let(:finalizer_instance) { double :finalizer_instance, call: nil, rollback: nil }
+        context 'and a concluder is configured' do
+          let(:concluder) { double :concluder, new: concluder_instance }
+          let(:concluder_instance) { double :concluder_instance, call: nil, rollback: nil }
           before do
             StateMachine.transition a: :b do |transition|
-              transition.finalizer finalizer
+              transition.concluder concluder
             end
           end
 
-          context 'and the finalizer is successful' do
+          context 'and the concluder is successful' do
             before do
-              finalizer_instance.stub(:call).and_return(true)
+              concluder_instance.stub(:call).and_return(true)
             end
 
             it 'transitions the state' do
@@ -331,9 +331,9 @@ module EndState
             end
           end
 
-          context 'and the finalizer fails' do
+          context 'and the concluder fails' do
             before do
-              finalizer_instance.stub(:call).and_return(false)
+              concluder_instance.stub(:call).and_return(false)
             end
 
             it 'does not transition the state' do
@@ -405,18 +405,18 @@ module EndState
           end
         end
 
-        context 'and a finalizer is configured' do
-          let(:finalizer) { double :finalizer, new: finalizer_instance }
-          let(:finalizer_instance) { double :finalizer_instance, call: nil, rollback: nil }
+        context 'and a concluder is configured' do
+          let(:concluder) { double :concluder, new: concluder_instance }
+          let(:concluder_instance) { double :concluder_instance, call: nil, rollback: nil }
           before do
             StateMachine.transition a: :b do |transition|
-              transition.finalizer finalizer
+              transition.concluder concluder
             end
           end
 
-          context 'and the finalizer is successful' do
+          context 'and the concluder is successful' do
             before do
-              finalizer_instance.stub(:call).and_return(true)
+              concluder_instance.stub(:call).and_return(true)
             end
 
             it 'transitions the state' do
@@ -425,13 +425,13 @@ module EndState
             end
           end
 
-          context 'and the finalizer fails' do
+          context 'and the concluder fails' do
             before do
-              finalizer_instance.stub(:call).and_return(false)
+              concluder_instance.stub(:call).and_return(false)
             end
 
             it 'does not transition the state' do
-              expect { machine.transition! :b }.to raise_error(FinalizerFailed)
+              expect { machine.transition! :b }.to raise_error(ConcluderFailed)
               expect(object.state).to eq :a
             end
           end

data/spec/end_state/transition_spec.rb

@@ -82,50 +82,50 @@ module EndState
       end
     end
 
-    describe '#finalizer' do
-      let(:finalizer) { double :finalizer }
+    describe '#concluder' do
+      let(:concluder) { double :concluder }
 
-      it 'adds a finalizer' do
-        expect { transition.finalizer finalizer }.to change(transition.finalizers, :count).by(1)
+      it 'adds a concluder' do
+        expect { transition.concluder concluder }.to change(transition.concluders, :count).by(1)
       end
     end
 
     describe '#persistence_on' do
-      it 'adds a Persistence finalizer' do
-        expect { transition.persistence_on }.to change(transition.finalizers, :count).by(1)
+      it 'adds a Persistence concluder' do
+        expect { transition.persistence_on }.to change(transition.concluders, :count).by(1)
       end
     end
 
-    describe '#finalize' do
-      let(:finalizer) { double :finalizer, new: finalizer_instance }
-      let(:finalizer_instance) { double :finalizer_instance, call: nil, rollback: nil }
+    describe '#conclude' do
+      let(:concluder) { double :concluder, new: concluder_instance }
+      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)
-        transition.finalizers << finalizer
+        transition.concluders << concluder
       end
 
-      context 'when all finalizers succeed' do
-        before { finalizer_instance.stub(:call).and_return(true) }
+      context 'when all concluders succeed' do
+        before { concluder_instance.stub(:call).and_return(true) }
 
-        specify { expect(transition.finalize object, :a).to be_true }
+        specify { expect(transition.conclude object, :a).to be_true }
       end
 
-      context 'when not all finalizers succeed' do
-        before { finalizer_instance.stub(:call).and_return(false) }
+      context 'when not all concluders succeed' do
+        before { concluder_instance.stub(:call).and_return(false) }
 
-        specify { expect(transition.finalize object, :a).to be_false }
+        specify { expect(transition.conclude object, :a).to be_false }
 
         it 'rolls them back' do
-          transition.finalize object, :a
-          expect(finalizer_instance).to have_received(:rollback)
+          transition.conclude object, :a
+          expect(concluder_instance).to have_received(:rollback)
         end
       end
 
       context 'when params are provided' do
-        it 'creates a finalizer with the params' do
-          transition.finalize object, :b, { foo: 'bar' }
-          expect(finalizer).to have_received(:new).twice.with(object, :a, { foo: 'bar'} )
+        it 'creates a concluder with the params' do
+          transition.conclude object, :b, { foo: 'bar' }
+          expect(concluder).to have_received(:new).twice.with(object, :a, { foo: 'bar'} )
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: end_state
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.9.0
 platform: ruby
 authors:
 - alexpeachey
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-04 00:00:00.000000000 Z
+date: 2014-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -87,10 +87,10 @@ files:
 - examples/machine_spec.rb
 - lib/end_state.rb
 - lib/end_state/action.rb
+- lib/end_state/concluder.rb
+- lib/end_state/concluders.rb
+- lib/end_state/concluders/persistence.rb
 - lib/end_state/errors.rb
-- lib/end_state/finalizer.rb
-- lib/end_state/finalizers.rb
-- lib/end_state/finalizers/persistence.rb
 - lib/end_state/graph.rb
 - lib/end_state/guard.rb
 - lib/end_state/messages.rb
@@ -100,8 +100,8 @@ files:
 - lib/end_state_matchers.rb
 - lib/tasks/end_state.rake
 - spec/end_state/action_spec.rb
-- spec/end_state/finalizer_spec.rb
-- spec/end_state/finalizers/persistence_spec.rb
+- spec/end_state/concluder_spec.rb
+- spec/end_state/concluders/persistence_spec.rb
 - spec/end_state/guard_spec.rb
 - spec/end_state/state_machine_spec.rb
 - spec/end_state/transition_spec.rb
@@ -133,8 +133,8 @@ specification_version: 4
 summary: A State Machine implementation
 test_files:
 - spec/end_state/action_spec.rb
-- spec/end_state/finalizer_spec.rb
-- spec/end_state/finalizers/persistence_spec.rb
+- spec/end_state/concluder_spec.rb
+- spec/end_state/concluders/persistence_spec.rb
 - spec/end_state/guard_spec.rb
 - spec/end_state/state_machine_spec.rb
 - spec/end_state/transition_spec.rb

data/lib/end_state/finalizers.rb

@@ -1 +0,0 @@
-require 'end_state/finalizers/persistence'