end_state 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 51e9a6a8a317af60132c723aabd5a615ec93f4e3
-  data.tar.gz: 96a3350ec5237b631314c8b5ab574598eb47b219
+  metadata.gz: c3fceb0c3ef5dd0efcf27176e899e75ad55f1243
+  data.tar.gz: 600cc39bea6aeca957285707a280c29b07092ad1
 SHA512:
-  metadata.gz: 29e1d05f5fe9da4df8f33783fde04cb1fd9b0f458ee79cfa9d0c728c003e29d62526259fc01b5e0240613583248f4987f9f3883d154957d39477ee2ed895a1e9
-  data.tar.gz: 1c82abe3ebcd9475e20865a77559a596d8bbfd718717a011cfa14d8d1938417ebdc57e6faa420a2fc3cb0fa54ad7484cfbad33bc84dfcde47c092bc29f53db5d
+  metadata.gz: 05317e5548b4924e211f422a2a9c4eb6f6ddcc872f4fdff91828acf27768cde90ec608f10c35d50b098576e797a6c2ec4ae9a8a010fd9046c09c0e4a01e282f5
+  data.tar.gz: d3432693ec760a0ea06ba9790f075a3837571b0b53518b06f781ccaa9654832ff96b875eea229afb5ffe147fd1fbdc25bb9be93b4a6ea250552695c0cf3f7b2f

data/examples/machine_spec.rb

@@ -16,13 +16,14 @@ end
 
 class Machine < EndState::StateMachine
   transition a: :b do |t|
+    t.require_params :some_param
     t.guard Easy
     t.concluder NoOp
   end
 end
 
 describe Machine do
-  specify { expect(Machine).to have_transition(a: :b).with_guard(Easy).with_concluder(NoOp) }
+  specify { expect(Machine).to have_transition(a: :b).with_guard(Easy).with_concluder(NoOp).with_required_params(:some_param) }
   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/state_machine.rb

@@ -80,7 +80,7 @@ module EndState
     def can_transition?(state, params = {})
       previous_state = self.state.to_sym
       state = state.to_sym
-      transition = self.class.transitions[{ previous_state => state }]
+      transition = transition_for(previous_state, state)
       return block_transistion(transition, state, :soft) unless transition
       transition.will_allow? state, params
     end
@@ -90,7 +90,7 @@ module EndState
       @success_messages = []
       previous_state = self.state ? self.state.to_sym : self.state
       state = state.to_sym
-      transition = self.class.transitions[{ previous_state => state }]
+      transition = transition_for(previous_state, state)
       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
@@ -109,7 +109,7 @@ module EndState
       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]
+        transition check_state, (args[0] || {})
       else
         super
       end
@@ -132,6 +132,11 @@ module EndState
       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
       message = self.class.transitions[self.class.events[event].first].blocked_event_message

data/lib/end_state/transition.rb

@@ -1,20 +1,24 @@
 module EndState
   class Transition
     attr_reader :state, :blocked_event_message
-    attr_accessor :action, :guards, :concluders
+    attr_accessor :action, :guards, :concluders, :allowed_params, :required_params
 
     def initialize(state)
       @state = state
       @action = Action
       @guards = []
       @concluders = []
+      @allowed_params = []
+      @required_params = []
     end
 
     def allowed?(object, params={})
+      raise "Missing params: #{missing_params(params).join(',')}" unless missing_params(params).empty?
       guards.all? { |guard| guard.new(object, state, params).allowed? }
     end
 
     def will_allow?(object, params={})
+      return false unless missing_params(params).empty?
       guards.all? { |guard| guard.new(object, state, params).will_allow? }
     end
 
@@ -30,18 +34,31 @@ module EndState
       @action = action
     end
 
-    def guard(guard)
-      guards << guard
+    def guard(*guards)
+      Array(guards).flatten.each { |guard| self.guards << guard }
     end
 
-    def concluder(concluder)
-      concluders << concluder
+    def concluder(*concluders)
+      Array(concluders).flatten.each { |concluder| self.concluders << concluder }
     end
 
     def persistence_on
       concluder Concluders::Persistence
     end
 
+    def allow_params(*params)
+      Array(params).flatten.each do |param|
+        self.allowed_params << param unless self.allowed_params.include? param
+      end
+    end
+
+    def require_params(*params)
+      Array(params).flatten.each do |param|
+        self.allowed_params << param unless self.allowed_params.include? param
+        self.required_params << param unless self.required_params.include? param
+      end
+    end
+
     def blocked(message)
       @blocked_event_message = message
     end
@@ -63,5 +80,9 @@ module EndState
     def run_concluder(concluder, object, state, params)
       concluder.new(object, state, params).call
     end
+
+    def missing_params(params)
+      required_params.select { |key| params[key].nil? }
+    end
   end
 end

data/lib/end_state/version.rb

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

data/lib/end_state_matchers.rb

@@ -4,13 +4,14 @@ module EndStateMatchers
   end
 
   class TransitionMatcher
-    attr_reader :transition, :machine, :failure_messages, :guards, :concluders
+    attr_reader :transition, :machine, :failure_messages, :guards, :concluders, :required_params
 
     def initialize(transition)
       @transition = transition
       @failure_messages = []
       @guards = []
       @concluders = []
+      @required_params = []
     end
 
     def matches?(actual)
@@ -32,7 +33,7 @@ module EndStateMatchers
     end
 
     def with_guards(*guards)
-      @guards += Array(guards)
+      @guards += Array(guards).flatten
       self
     end
 
@@ -42,7 +43,12 @@ module EndStateMatchers
     end
 
     def with_concluders(*concluders)
-      @concluders += Array(concluders)
+      @concluders += Array(concluders).flatten
+      self
+    end
+
+    def with_required_params(*params)
+      @required_params += Array(params).flatten
       self
     end
 
@@ -59,6 +65,7 @@ module EndStateMatchers
       if machine.transitions.keys.include? transition
         result = (result && verify_guards) if guards.any?
         result = (result && verify_concluders) if concluders.any?
+        result = (result && verify_required_params) if required_params.any?
         result
       else
         failure_messages << "expected that #{machine.name} would have transition :#{transition.keys.first} => :#{transition.values.first}"
@@ -87,6 +94,17 @@ module EndStateMatchers
       end
       result
     end
+
+    def verify_required_params
+      result = true
+      required_params.each do |param|
+        unless machine.transitions[transition].required_params.any? { |p| p == param }
+          failure_messages << "expected that transition :#{transition.keys.first} => :#{transition.values.first} would have required param #{param}"
+          result = false
+        end
+      end
+      result
+    end
   end
 end
 

data/spec/end_state/state_machine_spec.rb

@@ -189,6 +189,12 @@ module EndState
         expect(machine).to have_received(:transition).with(:b, { foo: 'bar', bar: 'foo' })
       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
@@ -231,6 +237,22 @@ module EndState
       context 'when asking about a disallowed transition' do
         specify { expect(machine.can_transition? :c).to be_false }
       end
+
+      context 'when using :any_state' do
+        before { StateMachine.transition any_state: :d }
+
+        context 'and the initial state is :a' do
+          let(:object) { OpenStruct.new(state: :a) }
+
+          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 }
+        end
+      end
     end
 
     describe '#transition' do
@@ -267,6 +289,28 @@ module EndState
               expect(object.state).to eq 'b'
             end
           end
+
+          context 'and using :any_state' do
+            before { StateMachine.transition any_state: :d }
+
+            context 'and the initial state is :a' do
+              before { object.state = :a }
+
+              it 'transitions the state' do
+                machine.transition :d
+                expect(object.state).to eq :d
+              end
+            end
+
+            context 'and the initial state is :b' do
+              before { object.state = :b }
+
+              it 'transitions the state' do
+                machine.transition :d
+                expect(object.state).to eq :d
+              end
+            end
+          end
         end
 
         context 'and a guard is configured' do

data/spec/end_state/transition_spec.rb

@@ -24,10 +24,15 @@ module EndState
 
     describe '#guard' do
       let(:guard) { double :guard }
+      let(:another_guard) { double :another_guard }
 
       it 'adds a guard' do
         expect { transition.guard guard }.to change(transition.guards, :count).by(1)
       end
+
+      it 'adds multiple guards' do
+        expect { transition.guard guard, another_guard }.to change(transition.guards, :count).by(2)
+      end
     end
 
     describe '#allowed?' do
@@ -40,6 +45,27 @@ module EndState
         before { guard_instance.stub(:allowed?).and_return(true) }
 
         specify { expect(transition.allowed? object).to be_true }
+
+        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
+
+          context 'and some params are required' do
+            before { transition.require_params :foo, :bar }
+
+            context 'and not all required are provided' do
+              it 'throws an exception' do
+                expect { transition.allowed? object, foo: 'something' }.to raise_error('Missing params: bar')
+              end
+            end
+
+            context 'and all required are provided' do
+              specify { expect(transition.allowed? object, foo: 1, bar: 2).to be_true }
+            end
+          end
+        end
       end
 
       context 'when not all guards pass' do
@@ -47,13 +73,6 @@ module EndState
 
         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
@@ -66,6 +85,25 @@ module EndState
         before { guard_instance.stub(:will_allow?).and_return(true) }
 
         specify { expect(transition.will_allow? object).to be_true }
+
+        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
+
+          context 'and some params are required' do
+            before { transition.require_params :foo, :bar }
+
+            context 'and not all required are provided' do
+              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 }
+            end
+          end
+        end
       end
 
       context 'when not all guards pass' do
@@ -84,10 +122,15 @@ module EndState
 
     describe '#concluder' do
       let(:concluder) { double :concluder }
+      let(:another_concluder) { double :another_concluder }
 
       it 'adds a concluder' do
         expect { transition.concluder concluder }.to change(transition.concluders, :count).by(1)
       end
+
+      it 'adds multiple concluders' do
+        expect { transition.concluder concluder, another_concluder }.to change(transition.concluders, :count).by(2)
+      end
     end
 
     describe '#persistence_on' do
@@ -96,6 +139,22 @@ module EndState
       end
     end
 
+    describe '#allow_params' do
+      it 'adds supplied keys to the allowed_params array' do
+        expect { transition.allow_params :foo, :bar }.to change(transition.allowed_params, :count).by(2)
+      end
+    end
+
+    describe '#require_params' do
+      it 'adds supplied keys to the required_params array' do
+        expect { transition.require_params :foo, :bar }.to change(transition.required_params, :count).by(2)
+      end
+
+      it 'adds supplied keys to the allowed_params array' do
+        expect { transition.allow_params :foo, :bar }.to change(transition.allowed_params, :count).by(2)
+      end
+    end
+
     describe '#conclude' do
       let(:concluder) { double :concluder, new: concluder_instance }
       let(:concluder_instance) { double :concluder_instance, call: nil, rollback: nil }

metadata

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