end_state 0.12.0 → 1.0.0

data/lib/end_state/transition_configuration_set.rb

@@ -0,0 +1,83 @@
+module EndState
+  class TransitionConfigurationSet
+
+    def initialize
+      @end_state_map = { any_state: {} }      # [start_state][event] = end_state
+      @configuration_map = { any_state: {} }  # [start_state][end_state] = configuration
+    end
+
+    def add(start_state, end_state, configuration, event = nil)
+      if event
+        end_state_map[start_state] ||= {}
+        end_state_map[start_state][event] = end_state
+      end
+
+      configuration_map[start_state] ||= {}
+      configuration_map[start_state][end_state] = configuration
+    end
+
+    def get_configuration(start_state, end_state)
+      local_map = configuration_map[start_state] || {}
+      local_map[end_state] || configuration_map[:any_state][end_state]
+    end
+
+    def get_end_state(start_state, event)
+      local_map = end_state_map[start_state] || {}
+      local_map[event] || end_state_map[:any_state][event]
+    end
+
+    def start_states
+      states = configuration_map.keys
+      states.delete(:any_state)
+      states += end_states unless configuration_map[:any_state].empty?
+      states.uniq
+    end
+
+    def end_states
+      configuration_map.map { |_, v| v.keys }.flatten.uniq
+    end
+
+    def events
+      end_state_map.map { |_, v| v.keys }.flatten.uniq
+    end
+
+    def event_conflicts?(start_state, event)
+      !!get_end_state(start_state, event) || (start_state == :any_state && events.include?(event))
+    end
+
+    def each &block
+      all_transitions.each(&block)
+    end
+
+    private
+
+    attr_reader :configuration_map, :end_state_map
+
+    def all_transitions
+      all_start_states = start_states
+
+      configuration_map.map do |start_state, local_config|
+        states = (start_state == :any_state) ? all_start_states : [start_state]
+        states.map { |s| transitions_for s, local_config }
+      end.flatten(2)
+    end
+
+    def transitions_for start_state, local_map
+      local_map.map do |end_state, config|
+        [start_state, end_state, config, event_for(start_state, end_state)]
+      end
+    end
+
+    def event_for start_state, end_state
+      (end_state_map[start_state] || {}).each do |k, v|
+        return k if v == end_state
+      end
+
+      end_state_map[:any_state].each do |k, v|
+        return k if v == end_state
+      end
+
+      nil
+    end
+  end
+end

data/lib/end_state/version.rb

@@ -1,3 +1,3 @@
 module EndState
-  VERSION = '0.12.0'
+  VERSION = '1.0.0'
 end

data/lib/end_state.rb

@@ -6,14 +6,17 @@ require 'end_state/guard'
 require 'end_state/concluder'
 require 'end_state/concluders'
 require 'end_state/transition'
-require 'end_state/state_mapping'
+require 'end_state/transition_configuration'
+require 'end_state/transition_configuration_set'
 require 'end_state/action'
+require 'end_state/state_machine_configuration'
 require 'end_state/state_machine'
 
 begin
   require 'graphviz'
   require 'end_state/graph'
 rescue LoadError
+  require 'end_state/no_graph'
 end
 
 module EndState

data/lib/end_state_matchers.rb

@@ -4,14 +4,15 @@ module EndStateMatchers
   end
 
   class TransitionMatcher
-    attr_reader :transition, :machine, :failure_messages, :guards, :concluders, :required_params
+    attr_reader :start_state, :end_state, :event, :machine, :failure_messages, :guards, :concluders, :required_params
 
     def initialize(transition)
-      @transition = transition
-      @failure_messages = []
+      @start_state, @end_state = transition.first
+      @event = nil
       @guards = []
       @concluders = []
       @required_params = []
+      @failure_messages = []
     end
 
     def matches?(actual)
@@ -24,11 +25,11 @@ module EndStateMatchers
     end
 
     def description
-      "have transition :#{transition.keys.first} => :#{transition.values.first}"
+      "have transition #{start_state} => #{end_state}"
     end
 
-    def with_guard(guard)
-      @guards << guard
+    def with_event(event)
+      @event = event
       self
     end
 
@@ -37,11 +38,6 @@ module EndStateMatchers
       self
     end
 
-    def with_concluder(concluder)
-      @concluders << concluder
-      self
-    end
-
     def with_concluders(*concluders)
       @concluders += Array(concluders).flatten
       self
@@ -52,6 +48,10 @@ module EndStateMatchers
       self
     end
 
+    alias_method :with_guard, :with_guards
+    alias_method :with_concluder, :with_concluders
+    alias_method :with_required_param, :with_required_params
+
     # Backward compatibility
     # Finalizer is deprecated
     alias_method :with_finalizer, :with_concluder
@@ -60,50 +60,63 @@ module EndStateMatchers
 
     private
 
+    def transition_configuration
+      @tc = machine.transition_configurations.get_configuration(start_state, end_state)
+    end
+
+    def has_event?(event)
+      machine.transition_configurations.get_end_state(start_state, event) == end_state
+    end
+
+    def has_guard?(guard)
+      transition_configuration.guards.include?(guard)
+    end
+
+    def has_concluder?(concluder)
+      transition_configuration.concluders.include?(concluder)
+    end
+
+    def has_required_param?(param)
+      transition_configuration.required_params.include?(param)
+    end
+
+    def add_failure(suffix)
+      failure_messages << "expected transition #{start_state} => #{end_state} #{suffix}"
+    end
+
     def verify
-      result = true
-      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
+      if transition_configuration.nil?
+        add_failure('to be defined')
       else
-        failure_messages << "expected that #{machine.name} would have transition :#{transition.keys.first} => :#{transition.values.first}"
-        false
+        verify_event if event
+        verify_guards
+        verify_concluders
+        verify_required_params
       end
+
+      failure_messages.empty?
+    end
+
+    def verify_event
+      add_failure("to have event name: #{event}") unless has_event?(event)
     end
 
     def verify_guards
-      result = true
-      guards.each do |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
+      guards.map do |guard|
+        add_failure("to have guard #{guard.name}") unless has_guard?(guard)
       end
-      result
     end
 
     def verify_concluders
-      result = true
-      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
+      concluders.map do |concluder|
+        add_failure("to have concluder #{concluder.name}") unless has_concluder?(concluder)
       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
+        add_failure("to have required param #{param}") unless has_required_param?(param)
       end
-      result
     end
   end
 end

data/spec/end_state/concluder_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 module EndState
   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(:object) { OpenStruct.new(failure_messages: [], success_messages: []) }
     let(:state) { :a }
     let(:params) { {} }
     before do
@@ -20,8 +20,14 @@ module EndState
 
     describe '#add_success' do
       it 'adds an success' do
-        concluder.add_error('success')
-        expect(object.failure_messages).to eq ['success']
+        concluder.add_success('success')
+        expect(object.success_messages).to eq ['success']
+      end
+    end
+
+    describe 'call' do
+      it 'returns false' do
+        expect(concluder.call).to be false
       end
     end
   end

data/spec/end_state/graph_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe EndState::Graph do
+  class TestMachine < EndState::StateMachine
+    transition a: :b
+    transition b: :c
+    transition c: :d, as: :go
+    transition any_state: :a
+    transition any_state: :e, as: :exit
+  end
+
+  subject(:graph) { EndState::Graph.new(TestMachine) }
+
+  describe '#draw' do
+    let(:description) { graph.draw.to_s }
+
+    it 'contains all the nodes' do
+      ['a [label = "a"];', 'b [label = "b"];', 'c [label = "c"];', 'd [label = "d"];', 'e [label = "e"];'].each do |s|
+        expect(description).to include(s)
+      end
+    end
+
+    it 'contains all the edges without labels' do
+      ['a -> b;', 'b -> c;', 'a -> a;', 'b -> a;', 'c -> a;', 'd -> a;', 'e -> a;'].each do |s|
+        expect(description).to include(s)
+      end
+    end
+
+    it 'contains all the edges with labels' do
+      ['c -> d [label = "go"];', 'a -> e [label = "exit"];', 'b -> e [label = "exit"];', 'c -> e [label = "exit"];', 'd -> e [label = "exit"];', 'e -> e [label = "exit"];'].each do |s|
+        expect(description).to include(s)
+      end
+    end
+  end
+end

data/spec/end_state/guard_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 module EndState
   describe Guard do
     subject(:guard) { Guard.new(object, state, params) }
-    let(:object) { Struct.new('Machine', :failure_messages, :success_messages, :state, :store_states_as_strings).new }
+    let(:object) { OpenStruct.new(failure_messages: [], success_messages: []) }
     let(:state) { :a }
     let(:params) { {} }
     before do
@@ -20,8 +20,34 @@ module EndState
 
     describe '#add_success' do
       it 'adds an success' do
-        guard.add_error('success')
-        expect(object.failure_messages).to eq ['success']
+        guard.add_success('success')
+        expect(object.success_messages).to eq ['success']
+      end
+    end
+
+    describe 'will_allow?' do
+      it 'returns false' do
+        expect(guard.will_allow?).to be false
+      end
+    end
+
+    describe 'allowed?' do
+      context 'will_allow? returns true' do
+        before { allow(guard).to receive(:will_allow?).and_return(true) }
+
+        it 'calls passed and returns true' do
+          expect(guard).to receive(:passed)
+          expect(guard.allowed?).to be true
+        end
+      end
+
+      context 'will_allow? returns false' do
+        before { allow(guard).to receive(:will_allow?).and_return(false) }
+
+        it 'calls failed and returns false' do
+          expect(guard).to receive(:failed)
+          expect(guard.allowed?).to be false
+        end
       end
     end
   end

data/spec/end_state/state_machine_configuration_spec.rb

@@ -0,0 +1,183 @@
+require 'spec_helper'
+require 'ostruct'
+
+module EndState
+  describe StateMachineConfiguration do
+    subject(:machine) { StateMachine.new(object) }
+    let(:object) { OpenStruct.new(state: nil) }
+    before do
+      StateMachine.instance_variable_set '@transition_configurations'.to_sym, nil
+      StateMachine.instance_variable_set '@events'.to_sym, nil
+      StateMachine.instance_variable_set '@store_states_as_strings'.to_sym, nil
+      StateMachine.instance_variable_set '@initial_state'.to_sym, :__nil__
+      StateMachine.instance_variable_set '@mode'.to_sym, :soft
+    end
+
+    describe '.transition' do
+      let(:options) { { a: :b } }
+
+      before do
+        @transition_configuration = nil
+        StateMachine.transition(options) { |tc| @transition_configuration = tc }
+      end
+
+      it 'does not require a block' do
+        expect { StateMachine.transition(options) }.not_to raise_error
+      end
+
+      context 'single transition' do
+        it 'yields a transition configuraton' do
+          expect(@transition_configuration).to be_a TransitionConfiguration
+        end
+
+        context 'with as' do
+          let(:options) { { a: :b, as: :go } }
+
+          it 'creates an alias' do
+            expect(StateMachine).to have_transition(a: :b).with_event(:go)
+          end
+
+          context 'another single transition with as' do
+            before { StateMachine.transition({c: :d, as: :go}) }
+
+            it 'appends to the event' do
+              expect(StateMachine).to have_transition(a: :b).with_event(:go)
+              expect(StateMachine).to have_transition(c: :d).with_event(:go)
+            end
+          end
+
+          context 'another single transition with as that conflicts' do
+            it 'raises an error' do
+              expect{ StateMachine.transition({a: :c, as: :go}) }.to raise_error EventConflict,
+                "Attempting to define event 'go' on state 'a', but it is already defined. " \
+                "(Check duplicates and use of 'any_state')"
+            end
+          end
+
+          context 'another single transition with as that conflicts' do
+            it 'raises an error' do
+              expect{ StateMachine.transition({any_state: :c, as: :go}) }.to raise_error EventConflict,
+                "Attempting to define event 'go' on state 'any_state', but it is already defined. " \
+                "(Check duplicates and use of 'any_state')"
+            end
+          end
+        end
+      end
+
+      context 'multiple start states' do
+        let(:options) { { [:a, :b] => :c } }
+
+        it 'yields a transition configuraton' do
+          expect(@transition_configuration).to be_a TransitionConfiguration
+        end
+
+        it 'has both transitions' do
+          expect(StateMachine).to have_transition(a: :c)
+          expect(StateMachine).to have_transition(b: :c)
+        end
+
+        context 'with as' do
+          let(:options) { { [:a, :b] => :c, as: :go } }
+
+          it 'creates an alias' do
+            expect(StateMachine).to have_transition(a: :c).with_event(:go)
+            expect(StateMachine).to have_transition(b: :c).with_event(:go)
+          end
+        end
+      end
+
+      context 'multiple transitions' do
+        let(:options) { { a: :b, c: :d } }
+
+        it 'yields a transition configuraton' do
+          expect(@transition_configuration).to be_a TransitionConfiguration
+        end
+
+        it 'has both transitions' do
+          expect(StateMachine).to have_transition(a: :b)
+          expect(StateMachine).to have_transition(c: :d)
+        end
+
+        context 'with as' do
+          let(:options) { { a: :b, c: :d, as: :go } }
+
+          it 'creates an alias' do
+            expect(StateMachine).to have_transition(a: :b).with_event(:go)
+            expect(StateMachine).to have_transition(c: :d).with_event(:go)
+          end
+        end
+      end
+    end
+
+    describe '.state_attribute' do
+      context 'when set to :foobar' do
+        let(:object) { OpenStruct.new(foobar: :a) }
+        before { StateMachine.state_attribute :foobar }
+
+        it 'answers state with foobar' do
+          expect(machine.state).to eq object.foobar
+        end
+
+        it 'answers state= with foobar=' do
+          machine.state = :b
+          expect(object.foobar).to eq :b
+        end
+
+        after do
+          StateMachine.send(:remove_method, :state)
+          StateMachine.send(:remove_method, :state=)
+        end
+      end
+    end
+
+    describe '.states' do
+      before do
+        StateMachine.transition(a: :b)
+        StateMachine.transition(b: :c)
+      end
+
+      specify { expect(StateMachine.states).to eq [:a, :b, :c] }
+    end
+
+    describe '.start_states' do
+      before do
+        StateMachine.transition(a: :b)
+        StateMachine.transition(b: :c)
+      end
+
+      specify { expect(StateMachine.start_states).to eq [:a, :b] }
+    end
+
+    describe '.end_states' do
+      before do
+        StateMachine.transition(a: :b)
+        StateMachine.transition(b: :c)
+      end
+
+      specify { expect(StateMachine.end_states).to eq [:b, :c] }
+    end
+
+    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
+      end
+    end
+
+    describe '.store_states_as_strings' do
+      it 'is false by default' do
+        expect(StateMachine.store_states_as_strings).to be false
+      end
+    end
+
+    describe '.initial_state' do
+      context 'when set to :first' do
+        before { StateMachine.set_initial_state :first }
+
+        it 'has that initial state' do
+          expect(machine.state).to eq :first
+        end
+      end
+    end
+  end
+end