finite_machine 0.11.3 → 0.12.0

data/spec/unit/define_spec.rb

@@ -1,49 +1,49 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine, 'define' do
+# frozen_string_literal: true
 
+RSpec.describe FiniteMachine, '.define' do
   context 'with block' do
     it "creates system state machine" do
-      fsm = FiniteMachine.define do
+      stub_const("TrafficLights", FiniteMachine.define do
         initial :green
 
-        events {
-          event :slow,  :green  => :yellow
-          event :stop,  :yellow => :red
-          event :ready, :red    => :yellow
-          event :go,    :yellow => :green
-        }
-      end
+        event :slow,  :green  => :yellow
+        event :stop,  :yellow => :red
+        event :ready, :red    => :yellow
+        event :go,    :yellow => :green
+      end)
 
-      expect(fsm.current).to eql(:green)
+      lights_fsm_a = TrafficLights.new
+      lights_fsm_b = TrafficLights.new
 
-      fsm.slow
-      expect(fsm.current).to eql(:yellow)
-      fsm.stop
-      expect(fsm.current).to eql(:red)
-      fsm.ready
-      expect(fsm.current).to eql(:yellow)
-      fsm.go
-      expect(fsm.current).to eql(:green)
+      expect(lights_fsm_a.current).to eql(:green)
+      expect(lights_fsm_b.current).to eql(:green)
+
+      lights_fsm_a.slow
+      expect(lights_fsm_a.current).to eql(:yellow)
+      expect(lights_fsm_b.current).to eql(:green)
+
+      lights_fsm_a.stop
+      expect(lights_fsm_a.current).to eql(:red)
+      expect(lights_fsm_b.current).to eql(:green)
     end
   end
 
   context 'without block' do
     it "creates state machine" do
       called = []
-      fsm = FiniteMachine.define
-      fsm.initial(:green)
-      fsm.event(:slow, :green => :yellow)
-      fsm.event(:stop, :yellow => :red)
-      fsm.event(:ready,:red    => :yellow)
-      fsm.event(:go,   :yellow => :green)
-      fsm.on_enter(:yellow) { |event| called << 'on_enter_yellow' }
-      fsm.handle(FiniteMachine::InvalidStateError) { |exception|
+      stub_const("TrafficLights", FiniteMachine.define)
+      TrafficLights.initial(:green)
+      TrafficLights.event(:slow, :green => :yellow)
+      TrafficLights.event(:stop, :yellow => :red)
+      TrafficLights.event(:ready,:red    => :yellow)
+      TrafficLights.event(:go,   :yellow => :green)
+      TrafficLights.on_enter(:yellow) { |event| called << 'on_enter_yellow' }
+      TrafficLights.handle(FiniteMachine::InvalidStateError) { |exception|
         called << 'error_handler'
       }
-      fsm.init
+
+      fsm = TrafficLights.new
+
       expect(fsm.current).to eql(:green)
       fsm.slow
       expect(fsm.current).to eql(:yellow)

data/spec/unit/definition_spec.rb

@@ -1,6 +1,4 @@
-# encoding: utf-8
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe FiniteMachine::Definition, 'definition' do
 
@@ -8,26 +6,20 @@ RSpec.describe FiniteMachine::Definition, 'definition' do
     class Engine < FiniteMachine::Definition
       initial :neutral
 
-      events {
-        event :forward, [:reverse, :neutral] => :one
-        event :shift, :one => :two
-        event :shift, :two => :one
-        event :back,  [:neutral, :one] => :reverse
-      }
-
-      callbacks {
-        on_enter :reverse do |event|
-          target.turn_reverse_lights_on
-        end
-
-        on_exit :reverse do |event|
-          target.turn_reverse_lights_off
-        end
-      }
-
-      handlers {
-        handle FiniteMachine::InvalidStateError do |exception| end
-      }
+      event :forward, [:reverse, :neutral] => :one
+      event :shift, :one => :two
+      event :shift, :two => :one
+      event :back,  [:neutral, :one] => :reverse
+
+      on_enter :reverse do |event|
+        target.turn_reverse_lights_on
+      end
+
+      on_exit :reverse do |event|
+        target.turn_reverse_lights_off
+      end
+
+      handle FiniteMachine::InvalidStateError do |exception| end
     end
   end
 
@@ -36,6 +28,8 @@ RSpec.describe FiniteMachine::Definition, 'definition' do
     engine_b = Engine.new
     expect(engine_a).not_to be(engine_b)
 
+    expect(engine_a.current).to eq(:neutral)
+
     engine_a.forward
     expect(engine_a.current).to eq(:one)
     expect(engine_b.current).to eq(:neutral)
@@ -57,8 +51,7 @@ RSpec.describe FiniteMachine::Definition, 'definition' do
     end)
 
     car = Car.new
-    engine = Engine.new
-    engine.target car
+    engine = Engine.new(car)
     expect(engine.current).to eq(:neutral)
 
     engine.forward
@@ -74,30 +67,20 @@ RSpec.describe FiniteMachine::Definition, 'definition' do
     class GenericStateMachine < FiniteMachine::Definition
       initial :red
 
-      events {
-        event :start, :red => :green
-      }
+      event :start, :red => :green
 
-      callbacks {
-        on_enter { |event| target << 'generic' }
-      }
+      on_enter { |event| target << 'generic' }
     end
 
     class SpecificStateMachine < GenericStateMachine
-      events {
-        event :stop, :green => :yellow
-      }
+      event :stop, :green => :yellow
 
-      callbacks {
-        on_enter(:yellow) { |event| target << 'specific' }
-      }
+      on_enter(:yellow) { |event| target << 'specific' }
     end
 
-    generic_fsm = GenericStateMachine.new
-    specific_fsm = SpecificStateMachine.new
     called = []
-    generic_fsm.target called
-    specific_fsm.target called
+    generic_fsm  = GenericStateMachine.new(called)
+    specific_fsm = SpecificStateMachine.new(called)
 
     expect(generic_fsm.states).to match_array([:none, :red, :green])
     expect(specific_fsm.states).to match_array([:none, :red, :green, :yellow])

data/spec/unit/event_names_spec.rb

@@ -1,19 +1,15 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'spec_helper'
-
-RSpec.describe FiniteMachine, '.event_names' do
+RSpec.describe FiniteMachine, '#events' do
   it "retrieves all event names" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :start, :red => :green
-        event :stop,  :green => :red
-      }
+      event :start, :red => :green
+      event :stop,  :green => :red
     end
 
     expect(fsm.current).to eql(:green)
-    expect(fsm.event_names).to eql([:init, :start, :stop])
+    expect(fsm.events).to match_array([:init, :start, :stop])
   end
 end

data/spec/unit/events_map/add_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+RSpec.describe FiniteMachine::EventsMap, '#add' do
+  it "adds transitions" do
+    transition = double(:transition)
+    events_map = described_class.new
+
+    events_map.add(:validated, transition)
+    expect(events_map[:validated]).to eq([transition])
+
+    events_map.add(:validated, transition)
+    expect(events_map[:validated]).to eq([transition, transition])
+  end
+
+  it "allows to map add operations" do
+    events_map = described_class.new
+    transition = double(:transition)
+
+    events_map.add(:go, transition).add(:start, transition)
+
+    expect(events_map.size).to eq(2)
+  end
+end

data/spec/unit/events_map/choice_transition_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+RSpec.describe FiniteMachine::EventsMap, '#choice_transition?' do
+  it "checks if transition has many branches" do
+    transition_a = double(:transition_a, matches?: true)
+    transition_b = double(:transition_b, matches?: true)
+
+    events_map = described_class.new
+    events_map.add(:go, transition_a)
+    events_map.add(:go, transition_b)
+
+    expect(events_map.choice_transition?(:go, :green)).to eq(true)
+  end
+
+  it "checks that transition has no branches" do
+    transition_a = double(:transition_a, matches?: false)
+    transition_b = double(:transition_b, matches?: true)
+
+    events_map = described_class.new
+    events_map.add(:go, transition_a)
+    events_map.add(:go, transition_b)
+
+    expect(events_map.choice_transition?(:go, :green)).to eq(false)
+  end
+end

data/spec/unit/events_map/clear_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+RSpec.describe FiniteMachine::EventsMap, '#clear' do
+  it "clears map events" do
+    event = double(:event)
+    events_map = described_class.new
+    events_map.add(:validated, event)
+    expect(events_map.empty?).to be(false)
+
+    events_map.clear
+    expect(events_map.empty?).to be(true)
+  end
+end

data/spec/unit/events_map/events_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+RSpec.describe FiniteMachine::EventsMap, '#events' do
+  it "has no event names" do
+    events_map = described_class.new
+    expect(events_map.events).to eq([])
+  end
+
+  it "returns all event names" do
+    events_map = described_class.new
+    transition = double(:transition)
+    events_map.add(:ready, transition)
+    events_map.add(:go, transition)
+    expect(events_map.events).to match_array([:ready, :go])
+  end
+end

data/spec/unit/events_map/inspect_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+RSpec.describe FiniteMachine::EventsMap, '#inspect' do
+  it "inspects empty events map" do
+    events_map = described_class.new
+    expect(events_map.inspect).to eq("<#FiniteMachine::EventsMap @events_map={}>")
+  end
+
+  it "inspect events map" do
+    transition = double(:transition)
+    events_map = described_class.new
+    events_map.add(:validated, transition)
+    expect(events_map.inspect).to eq("<#FiniteMachine::EventsMap @events_map=#{{validated: [transition]}}>")
+  end
+
+  it "prints events map" do
+    transition = double(:transition)
+    events_map = described_class.new
+    events_map.add(:validated, transition)
+    expect(events_map.to_s).to eq("#{{validated: [transition]}}")
+  end
+end

data/spec/unit/{events_chain → events_map}/match_transition_spec.rb

@@ -1,37 +1,35 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::EventsChain, '.match_transition' do
+RSpec.describe FiniteMachine::EventsMap, '#match_transition' do
   it "matches transition without conditions" do
     transition_a = double(:transition_a, matches?: false)
     transition_b = double(:transition_b, matches?: true)
-    events_chain = described_class.new
+    events_map = described_class.new
 
-    events_chain.add(:a, transition_a)
-    events_chain.add(:a, transition_b)
+    events_map.add(:a, transition_a)
+    events_map.add(:a, transition_b)
 
-    expect(events_chain.match_transition(:a, :green)).to eq(transition_b)
+    expect(events_map.match_transition(:a, :green)).to eq(transition_b)
   end
 
   it "fails to match any transition" do
-    events_chain = described_class.new
+    events_map = described_class.new
 
-    expect(events_chain.match_transition(:a, :green)).to eq(nil)
+    expect(events_map.match_transition(:a, :green)).to eq(nil)
   end
 
   it "matches transition with conditions" do
     transition_a = double(:transition_a, matches?: true)
     transition_b = double(:transition_b, matches?: true)
-    events_chain = described_class.new
+    events_map = described_class.new
 
-    events_chain.add(:a, transition_a)
-    events_chain.add(:a, transition_b)
+    events_map.add(:a, transition_a)
+    events_map.add(:a, transition_b)
 
     allow(transition_a).to receive(:check_conditions).and_return(false)
     allow(transition_b).to receive(:check_conditions).and_return(true)
 
-    expect(events_chain.match_transition_with(:a, :green, 'Piotr')).to eq(transition_b)
+    expect(events_map.match_transition_with(:a, :green, 'Piotr')).to eq(transition_b)
     expect(transition_a).to have_received(:check_conditions).with('Piotr')
   end
 end

data/spec/unit/{events_chain → events_map}/move_to_spec.rb

@@ -1,20 +1,17 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::EventsChain, '.move_to' do
+# frozen_string_literal: true
 
+RSpec.describe FiniteMachine::EventsMap, '#move_to' do
   it "moves to state by matching individual transition" do
     transition_a = double(:transition_a, matches?: false)
     transition_b = double(:transition_b, matches?: true)
 
-    events_chain = described_class.new
-    events_chain.add(:go, transition_a)
-    events_chain.add(:go, transition_b)
+    events_map = described_class.new
+    events_map.add(:go, transition_a)
+    events_map.add(:go, transition_b)
 
     allow(transition_b).to receive(:to_state).with(:yellow).and_return(:red)
 
-    expect(events_chain.move_to(:go, :yellow)).to eq(:red)
+    expect(events_map.move_to(:go, :yellow)).to eq(:red)
     expect(transition_b).to have_received(:to_state).with(:yellow)
   end
 
@@ -22,16 +19,16 @@ RSpec.describe FiniteMachine::EventsChain, '.move_to' do
     transition_a = double(:transition_a, matches?: true)
     transition_b = double(:transition_b, matches?: true)
 
-    events_chain = described_class.new
-    events_chain.add(:go, transition_a)
-    events_chain.add(:go, transition_b)
+    events_map = described_class.new
+    events_map.add(:go, transition_a)
+    events_map.add(:go, transition_b)
 
     allow(transition_a).to receive(:check_conditions).and_return(false)
     allow(transition_b).to receive(:check_conditions).and_return(true)
 
     allow(transition_b).to receive(:to_state).with(:green).and_return(:red)
 
-    expect(events_chain.move_to(:go, :green)).to eq(:red)
+    expect(events_map.move_to(:go, :green)).to eq(:red)
     expect(transition_b).to have_received(:to_state).with(:green)
   end
 
@@ -39,10 +36,10 @@ RSpec.describe FiniteMachine::EventsChain, '.move_to' do
     transition_a = double(:transition_a, matches?: false)
     transition_b = double(:transition_b, matches?: false)
 
-    events_chain = described_class.new
-    events_chain.add(:go, transition_a)
-    events_chain.add(:go, transition_b)
+    events_map = described_class.new
+    events_map.add(:go, transition_a)
+    events_map.add(:go, transition_b)
 
-    expect(events_chain.move_to(:go, :green)).to eq(:green)
+    expect(events_map.move_to(:go, :green)).to eq(:green)
   end
 end

data/spec/unit/events_map/states_for_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+RSpec.describe FiniteMachine::EventsMap do
+  it "finds current states for event name" do
+    transition = spy(:transition, states: {:red => :yellow, :yellow => :green})
+    events_map = described_class.new
+    events_map.add(:start, transition)
+
+    expect(events_map.states_for(:start)).to eq([:red, :yellow])
+  end
+
+  it "fails to find any states for event name" do
+    events_map = described_class.new
+
+    expect(events_map.states_for(:start)).to eq([])
+  end
+end