finite_machine 0.10.2 → 0.11.0

data/lib/finite_machine/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module FiniteMachine
-  VERSION = "0.10.2"
+  VERSION = "0.11.0"
 end

data/spec/spec_helper.rb

@@ -16,6 +16,7 @@ if RUBY_VERSION > '1.9' and (ENV['COVERAGE'] || ENV['TRAVIS'])
 end
 
 require 'finite_machine'
+require 'thwait'
 
 RSpec.configure do |config|
   config.run_all_when_everything_filtered = true

data/spec/unit/async_events_spec.rb

@@ -72,26 +72,32 @@ RSpec.describe FiniteMachine, 'async_events' do
 
   it "ensure queue per thread" do
     called = []
-    fsmFoo = FiniteMachine.define do
-      initial :green
-      events { event :slow, :green => :yellow }
+    fsmFoo = nil
+    fsmBar = nil
+    foo_thread = Thread.new {
+      fsmFoo = FiniteMachine.define do
+        initial :green
+        events { event :slow, :green => :yellow }
 
-      callbacks {
-        on_enter :yellow do |event, a| called << "(foo)on_enter_yellow_#{a}" end
-      }
-    end
-    fsmBar = FiniteMachine.define do
-      initial :green
-      events { event :slow, :green => :yellow }
+        callbacks {
+          on_enter :yellow do |event, a| called << "(foo)on_enter_yellow_#{a}" end
+        }
+      end
+      fsmFoo.async.slow(:foo)
+    }
+    bar_thread = Thread.new {
+      fsmBar = FiniteMachine.define do
+        initial :green
+        events { event :slow, :green => :yellow }
 
-      callbacks {
-        on_enter :yellow do |event, a| called << "(bar)on_enter_yellow_#{a}" end
-      }
-    end
-    foo_thread = Thread.new { fsmFoo.async.slow(:foo) }
-    bar_thread = Thread.new { fsmBar.async.slow(:bar) }
-    [foo_thread, bar_thread].each(&:join)
-    [fsmFoo, fsmBar].each { |fsm| fsm.event_queue.join 0.02 }
+        callbacks {
+          on_enter :yellow do |event, a| called << "(bar)on_enter_yellow_#{a}" end
+        }
+      end
+      fsmBar.async.slow(:bar)
+    }
+    ThreadsWait.all_waits(foo_thread, bar_thread)
+    sleep 0.01
     expect(called).to match_array([
       '(foo)on_enter_yellow_foo',
       '(bar)on_enter_yellow_bar'

data/spec/unit/callbacks_spec.rb

@@ -687,25 +687,6 @@ RSpec.describe FiniteMachine, 'callbacks' do
     ])
   end
 
-  it "cancels transition on state callback" do
-    fsm = FiniteMachine.define do
-      initial :green
-
-      events {
-        event :slow, :green  => :yellow
-        event :go,   :yellow => :green
-      }
-
-      callbacks {
-        on_exit :green do |event| FiniteMachine::CANCELLED end
-      }
-    end
-
-    expect(fsm.current).to eql(:green)
-    fsm.slow
-    expect(fsm.current).to eql(:green)
-  end
-
   it "cancels transition on event callback" do
     fsm = FiniteMachine.define do
       initial :green

data/spec/unit/event_names_spec.rb

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

data/spec/unit/events_chain/add_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe FiniteMachine::EventsChain, '.add' do
+  it "adds transitions" do
+    transition = double(:transition)
+    events_chain = described_class.new
+
+    events_chain.add(:validated, transition)
+    expect(events_chain[:validated]).to eq([transition])
+
+    events_chain.add(:validated, transition)
+    expect(events_chain[:validated]).to eq([transition, transition])
+  end
+
+  it "allows to chain add operations" do
+    events_chain = described_class.new
+    transition = double(:transition)
+
+    events_chain.add(:go, transition).add(:start, transition)
+
+    expect(events_chain.size).to eq(2)
+  end
+end

data/spec/unit/events_chain/cancel_transitions_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe FiniteMachine::EventsChain, '.cancel_transitions' do
+  it "sets cancel status for chosen transitions" do
+    events_chain = described_class.new
+    transition_a = spy(:transition_a, cancelled: false)
+    transition_b = spy(:transition_b, cancelled: false)
+    transition_c = spy(:transition_c, cancelled: false)
+
+    events_chain.add(:start, transition_a)
+    events_chain.add(:start, transition_b)
+    events_chain.add(:finish, transition_c)
+
+    events_chain.cancel_transitions(:start, true)
+
+    expect(transition_a).to have_received(:cancelled=).with(true)
+    expect(transition_b).to have_received(:cancelled=).with(true)
+    expect(transition_c).not_to have_received(:cancelled=)
+  end
+end

data/spec/unit/events_chain/choice_transition_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe FiniteMachine::EventsChain, '.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_chain = described_class.new
+    events_chain.add(:go, transition_a)
+    events_chain.add(:go, transition_b)
+
+    expect(events_chain.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_chain = described_class.new
+    events_chain.add(:go, transition_a)
+    events_chain.add(:go, transition_b)
+
+    expect(events_chain.choice_transition?(:go, :green)).to eq(false)
+  end
+end

data/spec/unit/events_chain/clear_spec.rb

@@ -2,25 +2,14 @@
 
 require 'spec_helper'
 
-RSpec.describe FiniteMachine::EventsChain, '#insert' do
-  let(:object)  { described_class }
-
-  let(:machine) { double(:machine) }
-
-  let(:transition) { double(:transition) }
-
-  subject(:chain) { object.new(machine) }
-
-  it "inserts transition" do
+RSpec.describe FiniteMachine::EventsChain, '#clear' do
+  it "clears chain events" do
     event = double(:event)
-    chain.add(:validated, event)
-    expect(chain[:validated]).to eq(event)
-
-    expect(event).to receive(:<<).with(transition)
-    chain.insert(:validated, transition)
-  end
+    events_chain = described_class.new
+    events_chain.add(:validated, event)
+    expect(events_chain.empty?).to be(false)
 
-  it "fails to insert transition" do
-    expect(chain.insert(:validated, transition)).to be(false)
+    events_chain.clear
+    expect(events_chain.empty?).to be(true)
   end
 end

data/spec/unit/events_chain/events_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe FiniteMachine::EventsChain, '.events' do
+  it "has no event names" do
+    events_chain = described_class.new
+    expect(events_chain.events).to eq([])
+  end
+
+  it "returns all event names" do
+    events_chain = described_class.new
+    transition = double(:transition)
+    events_chain.add(:ready, transition)
+    events_chain.add(:go, transition)
+    expect(events_chain.events).to match_array([:ready, :go])
+  end
+end

data/spec/unit/events_chain/inspect_spec.rb

@@ -2,26 +2,23 @@
 
 require 'spec_helper'
 
-RSpec.describe FiniteMachine::EventsChain, '#insert' do
-  let(:object)  { described_class }
-
-  let(:machine) { double(:machine) }
-
-  subject(:chain) { object.new(machine) }
-
-  it "inspects empty chain" do
-    expect(chain.inspect).to eq("<#FiniteMachine::EventsChain @chain={}>")
+RSpec.describe FiniteMachine::EventsChain, '#inspect' do
+  it "inspects empty events chain" do
+    events_chain = described_class.new
+    expect(events_chain.inspect).to eq("<#FiniteMachine::EventsChain @chain={}>")
   end
 
-  it "inspect chain" do
-    event = double(:event)
-    chain.add(:validated, event)
-    expect(chain.inspect).to eq("<#FiniteMachine::EventsChain @chain=#{{validated: event}}>")
+  it "inspect events chain" do
+    transition = double(:transition)
+    events_chain = described_class.new
+    events_chain.add(:validated, transition)
+    expect(events_chain.inspect).to eq("<#FiniteMachine::EventsChain @chain=#{{validated: [transition]}}>")
   end
 
-  it "prints chain" do
-    event = double(:event)
-    chain.add(:validated, event)
-    expect(chain.to_s).to eq("#{{validated: event}}")
+  it "prints events chain" do
+    transition = double(:transition)
+    events_chain = described_class.new
+    events_chain.add(:validated, transition)
+    expect(events_chain.to_s).to eq("#{{validated: [transition]}}")
   end
 end

data/spec/unit/events_chain/match_transition_spec.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe FiniteMachine::EventsChain, '.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_chain.add(:a, transition_a)
+    events_chain.add(:a, transition_b)
+
+    expect(events_chain.match_transition(:a, :green)).to eq(transition_b)
+  end
+
+  it "fails to match any transition" do
+    events_chain = described_class.new
+
+    expect(events_chain.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_chain.add(:a, transition_a)
+    events_chain.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(transition_a).to have_received(:check_conditions).with('Piotr')
+  end
+end

data/spec/unit/events_chain/move_to_spec.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe FiniteMachine::EventsChain, '.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)
+
+    allow(transition_b).to receive(:to_state).with(:yellow).and_return(:red)
+
+    expect(events_chain.move_to(:go, :yellow)).to eq(:red)
+    expect(transition_b).to have_received(:to_state).with(:yellow)
+  end
+
+  it "moves to state by matching choice transition" 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)
+
+    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(transition_b).to have_received(:to_state).with(:green)
+  end
+
+  it "moves to from state if no transition available" 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)
+
+    expect(events_chain.move_to(:go, :green)).to eq(:green)
+  end
+end

data/spec/unit/events_chain/states_for_spec.rb

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

data/spec/unit/events_spec.rb

@@ -169,37 +169,109 @@ RSpec.describe FiniteMachine, 'events' do
     expect(fsm.current).to eql(:green)
   end
 
-  it "raises error on invalid transition" do
+  it "doesn't raise error on invalid transition for non-dangerous version" do
+    called = []
     fsm = FiniteMachine.define do
       initial :green
 
       events {
-        event :slow,  from: :green,  to: :yellow
-        event :stop,  from: :yellow, to: :red
+        event :stop, from: :yellow, to: :red
+      }
+      callbacks {
+        on_before :stop do |event| called << 'on_before_stop' end
+        on_after  :stop do |event| called << 'on_before_stop' end
       }
     end
 
-    expect(fsm.current).to eql(:green)
+    expect(fsm.current).to eq(:green)
+    expect(fsm.stop).to eq(false)
+    expect(fsm.current).to eq(:green)
+    expect(called).to match_array(['on_before_stop'])
+  end
 
-    expect {
-      fsm.stop
-    }.to raise_error(FiniteMachine::InvalidStateError,
-                     /inappropriate current state 'green'/)
+  context 'for non-dangerous version' do
+    it "doesn't raise error on invalid transition and fires callbacks" do
+      called = []
+      fsm = FiniteMachine.define do
+        initial :green
+
+        events {
+          event :stop, from: :yellow, to: :red
+        }
+        callbacks {
+          on_before :stop do |event| called << 'on_before_stop' end
+          on_after  :stop do |event| called << 'on_before_stop' end
+        }
+      end
+
+      expect(fsm.current).to eq(:green)
+      expect(fsm.stop).to eq(false)
+      expect(fsm.current).to eq(:green)
+      expect(called).to match_array(['on_before_stop'])
+    end
+
+    it "raises error on invalid transition for dangerous version" do
+      called = []
+      fsm = FiniteMachine.define do
+        initial :green
+
+        events {
+          event :slow,  from: :green,  to: :yellow
+          event :stop,  from: :yellow, to: :red, silent: true
+        }
+        callbacks {
+          on_before :stop do |event| called << 'on_before_stop' end
+          on_after  :stop do |event| called << 'on_before_stop' end
+        }
+      end
+
+      expect(fsm.current).to eql(:green)
+      expect(fsm.stop).to eq(false)
+      expect(called).to match_array([])
+    end
   end
 
-  it "allows to transition to any state" do
-    fsm = FiniteMachine.define do
-      initial :green
+  context 'for dangerous version' do
+    it "raises error on invalid transition without callbacks" do
+      called = []
+      fsm = FiniteMachine.define do
+        initial :green
 
-      events {
-        event :slow,  from: :green,  to: :yellow
-        event :stop,  from: :yellow, to: :red
-      }
+        events {
+          event :start, :red => :yellow, silent: true
+        }
+        callbacks {
+          on_before :start do |event| called << 'on_before_start' end
+          on_after  :start do |event| called << 'on_after_start' end
+        }
+      end
+
+      expect(fsm.current).to eq(:green)
+      expect { fsm.start! }.to raise_error(FiniteMachine::InvalidStateError)
+      expect(called).to eq([])
+      expect(fsm.current).to eq(:green)
+    end
+
+    it "raises error on invalid transition with callbacks fired" do
+      called = []
+      fsm = FiniteMachine.define do
+        initial :green
+
+        events {
+          event :start, :red => :yellow
+        }
+        callbacks {
+          on_before :start do |event| called << 'on_before_start' end
+          on_after  :start do |event| called << 'on_after_start' end
+        }
+      end
+
+      expect(fsm.current).to eq(:green)
+      expect { fsm.start! }.to raise_error(FiniteMachine::InvalidStateError,
+                                           /inappropriate current state 'green'/)
+      expect(called).to eq(['on_before_start'])
+      expect(fsm.current).to eq(:green)
     end
-    expect(fsm.current).to eql(:green)
-    expect(fsm.can?(:stop)).to be false
-    fsm.stop!
-    expect(fsm.current).to eql(:red)
   end
 
   context 'when multiple from states' do
@@ -314,16 +386,16 @@ RSpec.describe FiniteMachine, 'events' do
       }
 
       callbacks {
-        on_before(:drive) { }
+        on_before(:drive) { FiniteMachine::CANCELLED }
         on_after(:stop)   { }
       }
     end
 
     expect(fsm.current).to eql(:neutral)
-    expect(fsm.start).to eql(FiniteMachine::SUCCEEDED)
-    expect(fsm.drive).to eql(FiniteMachine::CANCELLED)
-    expect(fsm.stop).to eql(FiniteMachine::SUCCEEDED)
-    expect(fsm.stop).to eql(FiniteMachine::NOTRANSITION)
+    expect(fsm.start).to eql(true)
+    expect(fsm.drive).to eql(false)
+    expect(fsm.stop).to eql(true)
+    expect(fsm.stop).to eql(true)
   end
 
   it "allows for self transition events" do
@@ -358,10 +430,30 @@ RSpec.describe FiniteMachine, 'events' do
   end
 
   it "detects dangerous event names" do
-    expect { FiniteMachine.define do
+    expect {
+      FiniteMachine.define do
+        events {
+          event :trigger, :a => :b
+        }
+      end
+    }.to raise_error(FiniteMachine::AlreadyDefinedError)
+  end
+
+  it "executes event block" do
+    fsm = FiniteMachine.define do
+      initial :red
+
       events {
-        event :transition, :a => :b
+        event :start, :red => :green
+        event :stop,  :green => :red
       }
-    end }.to raise_error(FiniteMachine::AlreadyDefinedError)
+    end
+
+    expect(fsm.current).to eq(:red)
+    called = []
+    fsm.start do |from, to|
+      called << "execute_start_#{from}_#{to}"
+    end
+    expect(called).to eq(['execute_start_red_green'])
   end
 end