end_state 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 809272ea728fbfd921f3cf13974883104447861e
-  data.tar.gz: 9660e13251dccad1d37fa22c5e5bfdf7cbe917ad
+  metadata.gz: b1d64ebcbb974d3190a824a6cf1c77742c009339
+  data.tar.gz: 6acbeb81100f52bf97956a2bcbe7c5680bf02cba
 SHA512:
-  metadata.gz: 6f452a250ae2e681e53b79902312903ab8a98ad19c2cf37d72748af0208f6405170cb8b1470c96b6ce7e0e6ef84bfd04f424af9d5bea60633a789758c0c132a0
-  data.tar.gz: 3103761a9adc01570e0d4788a961dc594d72b706eacc34f99a69d15e1a5df52c4a3aa64ba3035140840a63a60de3dd42941990669152f667ab80a8409790fba9
+  metadata.gz: 16a4bc9c85e10fce41a81659aa9bb70b182a3378030e2531f4b5077c2749cda53de5dec0b49e94862d6d71aaf698c047c5b5532dffd0079b5fc7dd459a4caf56
+  data.tar.gz: 953922dc24b1bccd281564ee4769d515e45ef4fa4cd30d28c945368e2bba89defb92c6da22464ff8f83ecbaa96d5b1ec0b0bd689c32c8acd8f18d4e229d01f95

data/README.md

@@ -29,7 +29,7 @@ Create a state machine by subclassing `EndState::StateMachine`.
 
 ```ruby
 class Machine < EndState::StateMachine
-  transition a: :b
+  transition a: :b, as: :go
   transition b: :c
   transition [:b, :c] => :a
 end
@@ -58,6 +58,8 @@ machine.can_transition? :a  # => true
 machine.b!                  # => false
 machine.a!                  # => true
 machine.state               # => :a
+machine.go!                 # => :true
+machine.state               # => :b
 ```
 
 ## Guards
@@ -66,7 +68,7 @@ Guards can be created by subclassing `EndState::Guard`. Your class will be provi
 
 * `object` - The wrapped object.
 * `state` - The desired state.
-* `params` - A hash of params as set in the transition definition.
+* `params` - A hash of params passed when calling transition on the machine.
 
 Your class should implement the `will_allow?` method which must return true or false.
 
@@ -95,7 +97,7 @@ A guard can be added to the transition definition:
 class Machine < EndState::StateMachine
   transition a: :b do |t|
     t.guard EasyGuard
-    t.guard SomeOtherGuard, option1: 'Some Option', option2: 'Some Other Option'
+    t.guard SomeOtherGuard
   end
 end
 ```
@@ -106,7 +108,7 @@ Finalizers can be created by subclassing `EndState::Finalizer`. Your class will
 
 * `object` - The wrapped object that has been transitioned.
 * `state` - The previous state.
-* `params` - A hash of params as set in the transition definition.
+* `params` - A hash of params passed when calling transition on the machine.
 
 Your class should implement the `call` method which should return true or false as to whether it was successful or not.
 
@@ -116,7 +118,7 @@ set up a little differently and you have access to:
 
 * `object` - The wrapped object that has been rolled back.
 * `state` - The attempted desired state.
-* `params` - A hash of params as set in the transition definition.
+* `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.
@@ -139,7 +141,7 @@ A finalizer can be added to the transition definition:
 ```ruby
 class Machine < EndState::StateMachine
   transition a: :b do |t|
-    t.finalizer WrapUp, option1: 'Some Option', option2: 'Some Other Option'
+    t.finalizer WrapUp
   end
 end
 ```

data/lib/end_state/state_machine.rb

@@ -2,19 +2,28 @@ module EndState
   class StateMachine < SimpleDelegator
     attr_accessor :failure_messages
 
-    def self.transition(state_map, &block)
+    def self.transition(state_map)
+      initial_states = Array(state_map.keys.first)
       final_state = state_map.values.first
+      transition_alias = state_map[:as] if state_map.keys.length > 1
       transition = Transition.new(final_state)
-      Array(state_map.keys.first).each do |state|
+      initial_states.each do |state|
         transitions[{ state => final_state }] = transition
       end
-      yield transition if block
+      unless transition_alias.nil?
+        aliases[transition_alias] = final_state
+      end
+      yield transition if block_given?
     end
 
     def self.transitions
       @transitions ||= {}
     end
 
+    def self.aliases
+      @aliases ||= {}
+    end
+
     def self.state_attribute(attribute)
       define_method(:state) { send(attribute.to_sym) }
       define_method(:state=) { |val| send("#{attribute}=".to_sym, val) }
@@ -32,6 +41,11 @@ module EndState
       transitions.keys.map { |state_map| state_map.values.first }.uniq
     end
 
+    def self.transition_state_for(check_state)
+      return check_state if states.include? check_state
+      return aliases[check_state] if aliases.keys.include? check_state
+    end
+
     def object
       __getobj__
     end
@@ -43,28 +57,29 @@ module EndState
       transition.will_allow? state
     end
 
-    def transition(state, mode = :soft)
+    def transition(state, params = {}, mode = :soft)
       @failure_messages = []
       previous_state = self.state
       transition = self.class.transitions[{ previous_state => state }]
       return block_transistion(transition, state, mode) unless transition
-      return guard_failed(state, mode) unless transition.allowed?(self)
+      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)
+      return finalize_failed(state, mode) unless transition.finalize(self, previous_state, params)
       true
     end
 
-    def transition!(state)
-      transition state, :hard
+    def transition!(state, params = {})
+      transition state, params, :hard
     end
 
     def method_missing(method, *args, &block)
       check_state = method.to_s[0..-2].to_sym
-      return super unless self.class.states.include? check_state
+      check_state = self.class.transition_state_for(check_state)
+      return super if check_state.nil?
       if method.to_s.end_with?('?')
         state == check_state
       elsif method.to_s.end_with?('!')
-        transition check_state
+        transition check_state, args[0]
       else
         super
       end

data/lib/end_state/transition.rb

@@ -10,18 +10,18 @@ module EndState
       @finalizers = []
     end
 
-    def allowed?(object)
-      guards.all? { |guard| guard[:guard].new(object, state, guard[:params]).allowed? }
+    def allowed?(object, params={})
+      guards.all? { |guard| guard.new(object, state, params).allowed? }
     end
 
-    def will_allow?(object)
-      guards.all? { |guard| guard[:guard].new(object, state, guard[:params]).will_allow? }
+    def will_allow?(object, params={})
+      guards.all? { |guard| guard.new(object, state, params).will_allow? }
     end
 
-    def finalize(object, previous_state)
+    def finalize(object, previous_state, params={})
       finalizers.each_with_object([]) do |finalizer, finalized|
         finalized << finalizer
-        return rollback(finalized, object, previous_state) unless run_finalizer(finalizer, object, state)
+        return rollback(finalized, object, previous_state, params) unless run_finalizer(finalizer, object, state, params)
       end
       true
     end
@@ -30,12 +30,12 @@ module EndState
       @action = action
     end
 
-    def guard(guard, params = {})
-      guards << { guard: guard, params: params }
+    def guard(guard)
+      guards << guard
     end
 
-    def finalizer(finalizer, params = {})
-      finalizers << { finalizer: finalizer, params: params }
+    def finalizer(finalizer)
+      finalizers << finalizer
     end
 
     def persistence_on
@@ -44,14 +44,14 @@ module EndState
 
     private
 
-    def rollback(finalized, object, previous_state)
+    def rollback(finalized, object, previous_state, params)
       action.new(object, previous_state).rollback
-      finalized.reverse.each { |f| f[:finalizer].new(object, state, f[:params]).rollback }
+      finalized.reverse.each { |finalizer| finalizer.new(object, state, params).rollback }
       false
     end
 
-    def run_finalizer(finalizer, object, state)
-      finalizer[:finalizer].new(object, state, finalizer[:params]).call
+    def run_finalizer(finalizer, object, state, params)
+      finalizer.new(object, state, params).call
     end
   end
 end

data/lib/end_state/version.rb

@@ -1,3 +1,3 @@
 module EndState
-  VERSION = '0.0.2'
+  VERSION = '0.1.0'
 end

data/lib/end_state_matchers.rb

@@ -63,7 +63,7 @@ module EndStateMatchers
     def verify_guards
       result = true
       guards.each do |guard|
-        unless machine.transitions[transition].guards.any? { |g| g[:guard] == guard }
+        unless machine.transitions[transition].guards.any? { |g| g == guard }
           failure_messages << "expected that transition :#{transition.keys.first} => :#{transition.values.first} would have guard #{guard.name}"
           result = false
         end
@@ -74,7 +74,7 @@ module EndStateMatchers
     def verify_finalizers
       result = true
       finalizers.each do |finalizer|
-        unless machine.transitions[transition].finalizers.any? { |f| f[:finalizer] == 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}"
           result = false
         end

data/spec/end_state/state_machine_spec.rb

@@ -5,7 +5,10 @@ module EndState
   describe StateMachine do
     subject(:machine) { StateMachine.new(object) }
     let(:object) { OpenStruct.new(state: nil) }
-    before { StateMachine.instance_variable_set '@transitions'.to_sym, nil }
+    before do
+      StateMachine.instance_variable_set '@transitions'.to_sym, nil
+      StateMachine.instance_variable_set '@aliases'.to_sym, nil
+    end
 
     describe '.transition' do
       let(:state_map) { { a: :b } }
@@ -23,6 +26,13 @@ module EndState
       it 'adds the transition to the state machine' do
         expect(StateMachine.transitions[state_map]).to eq yielded.transition
       end
+
+      context 'when the :as option is used' do
+        it 'creates an alias' do
+          StateMachine.transition(state_map.merge(as: :go))
+          expect(StateMachine.aliases[:go]).to eq :b
+        end
+      end
     end
 
     describe '.state_attribute' do
@@ -111,13 +121,24 @@ module EndState
     describe '#{state}!' do
       let(:object) { OpenStruct.new(state: :a) }
       before do
-        StateMachine.transition a: :b
+        StateMachine.transition a: :b, as: :go
       end
 
       it 'transitions the state' do
         machine.b!
         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' })
+      end
+
+      it 'works with an alias' do
+        machine.go!
+        expect(machine.state).to eq :b
+      end
     end
 
     describe '#can_transition?' do
@@ -167,8 +188,9 @@ module EndState
           let(:guard) { double :guard, new: guard_instance }
           let(:guard_instance) { double :guard_instance, allowed?: nil }
           before do
-            StateMachine.transition a: :b
-            StateMachine.transitions[{ a: :b }].guards << { guard: guard, params: {} }
+            StateMachine.transition a: :b do |transition|
+              transition.guard guard
+            end
           end
 
           context 'and the object satisfies the guard' do
@@ -194,19 +216,28 @@ module EndState
               expect(object.state).to eq :a
             end
           end
+
+          context 'and params are passed in' do
+            let(:params) { { foo: 'bar' } }
+            it 'sends the guard the params' do
+              machine.transition :b, params, :soft
+              expect(guard).to have_received(:new).with(machine, :b, params)
+            end  
+          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 }
           before do
             StateMachine.transition a: :b do |transition|
-              transition.persistence_on
+              transition.finalizer finalizer
             end
           end
 
           context 'and the finalizer is successful' do
             before do
-              object.state = :a
-              object.stub(:save).and_return(true)
+              finalizer_instance.stub(:call).and_return(true)
             end
 
             it 'transitions the state' do
@@ -217,8 +248,7 @@ module EndState
 
           context 'and the finalizer fails' do
             before do
-              object.state = :a
-              object.stub(:save).and_return(false)
+              finalizer_instance.stub(:call).and_return(false)
             end
 
             it 'does not transition the state' do
@@ -262,7 +292,7 @@ module EndState
           let(:guard_instance) { double :guard_instance, allowed?: nil }
           before do
             StateMachine.transition a: :b
-            StateMachine.transitions[{ a: :b }].guards << { guard: guard, params: {} }
+            StateMachine.transitions[{ a: :b }].guards << guard
           end
 
           context 'and the object satisfies the guard' do
@@ -291,16 +321,17 @@ module EndState
         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 }
           before do
             StateMachine.transition a: :b do |transition|
-              transition.persistence_on
+              transition.finalizer finalizer
             end
           end
 
           context 'and the finalizer is successful' do
             before do
-              object.state = :a
-              object.stub(:save).and_return(true)
+              finalizer_instance.stub(:call).and_return(true)
             end
 
             it 'transitions the state' do
@@ -311,8 +342,7 @@ module EndState
 
           context 'and the finalizer fails' do
             before do
-              object.state = :a
-              object.stub(:save).and_return(false)
+              finalizer_instance.stub(:call).and_return(false)
             end
 
             it 'does not transition the state' do

data/spec/end_state/transition_spec.rb

@@ -21,54 +21,58 @@ module EndState
       it 'adds a guard' do
         expect { transition.guard guard }.to change(transition.guards, :count).by(1)
       end
-
-      context 'when params are provided' do
-        let(:params) { {} }
-
-        it 'adds a guard' do
-          expect { transition.guard guard, params }.to change(transition.guards, :count).by(1)
-        end
-      end
     end
 
     describe '#allowed?' do
       let(:guard) { double :guard, new: guard_instance }
       let(:guard_instance) { double :guard_instance, allowed?: nil }
-      before { transition.guards << { guard: guard, params: {} } }
+      let(:object) { double :object }
+      before { transition.guards << guard }
 
       context 'when all guards pass' do
-        let(:object) { double :object }
         before { guard_instance.stub(:allowed?).and_return(true) }
 
         specify { expect(transition.allowed? object).to be_true }
       end
 
       context 'when not all guards pass' do
-        let(:object) { double :object }
         before { guard_instance.stub(:allowed?).and_return(false) }
 
         specify { expect(transition.allowed? object).to be_false }
       end
+
+      context 'when params are provided' do
+        it 'creates the guard with the params' do
+          transition.allowed? object, { foo: 'bar' }
+          expect(guard).to have_received(:new).with(object, state, { foo: 'bar' })
+        end
+      end
     end
 
     describe '#will_allow?' do
       let(:guard) { double :guard, new: guard_instance }
       let(:guard_instance) { double :guard_instance, will_allow?: nil }
-      before { transition.guards << { guard: guard, params: {} } }
+      let(:object) { double :object }
+      before { transition.guards << guard }
 
       context 'when all guards pass' do
-        let(:object) { double :object }
         before { guard_instance.stub(:will_allow?).and_return(true) }
 
         specify { expect(transition.will_allow? object).to be_true }
       end
 
       context 'when not all guards pass' do
-        let(:object) { double :object }
         before { guard_instance.stub(:will_allow?).and_return(false) }
 
         specify { expect(transition.will_allow? object).to be_false }
       end
+
+      context 'when params are provided' do
+        it 'creates the guard with the params' do
+          transition.will_allow? object, { foo: 'bar' }
+          expect(guard).to have_received(:new).with(object, state, { foo: 'bar' })
+        end
+      end
     end
 
     describe '#finalizer' do
@@ -77,14 +81,6 @@ module EndState
       it 'adds a finalizer' do
         expect { transition.finalizer finalizer }.to change(transition.finalizers, :count).by(1)
       end
-
-      context 'when params are provided' do
-        let(:params) { {} }
-
-        it 'adds a finalizer' do
-          expect { transition.finalizer finalizer, params }.to change(transition.finalizers, :count).by(1)
-        end
-      end
     end
 
     describe '#persistence_on' do
@@ -97,7 +93,7 @@ module EndState
       let(:finalizer) { double :finalizer, new: finalizer_instance }
       let(:finalizer_instance) { double :finalizer_instance, call: nil, rollback: nil }
       let(:object) { OpenStruct.new(state: :b) }
-      before { transition.finalizers << { finalizer: finalizer, params: {} } }
+      before { transition.finalizers << finalizer }
 
       context 'when all finalizers succeed' do
         before { finalizer_instance.stub(:call).and_return(true) }
@@ -115,6 +111,13 @@ module EndState
           expect(finalizer_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'} )
+        end
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: end_state
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - alexpeachey
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-17 00:00:00.000000000 Z
+date: 2014-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler