finite_machine 0.0.1 → 0.1.0

data/spec/unit/can_spec.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine, 'can?' do
+
+  it "allows to check if event can be fired" do
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow,  :green  => :yellow
+        event :stop,  :yellow => :red
+        event :ready, :red    => :yellow
+        event :go,    :yellow => :green
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+
+    expect(fsm.can?(:slow)).to be_true
+    expect(fsm.can?(:stop)).to be_false
+    expect(fsm.can?(:ready)).to be_false
+    expect(fsm.can?(:go)).to be_false
+
+    fsm.slow
+    expect(fsm.current).to eql(:yellow)
+
+    expect(fsm.can?(:slow)).to be_false
+    expect(fsm.can?(:stop)).to be_true
+    expect(fsm.can?(:ready)).to be_false
+    expect(fsm.can?(:go)).to be_true
+
+    fsm.stop
+    expect(fsm.current).to eql(:red)
+
+    expect(fsm.can?(:slow)).to be_false
+    expect(fsm.can?(:stop)).to be_false
+    expect(fsm.can?(:ready)).to be_true
+    expect(fsm.can?(:go)).to be_false
+
+    fsm.ready
+    expect(fsm.current).to eql(:yellow)
+
+    expect(fsm.can?(:slow)).to be_false
+    expect(fsm.can?(:stop)).to be_true
+    expect(fsm.can?(:ready)).to be_false
+    expect(fsm.can?(:go)).to be_true
+  end
+end

data/spec/unit/define_spec.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine, 'define' do
+
+  it "creates system state machine" do
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow,  :green  => :yellow
+        event :stop,  :yellow => :red
+        event :ready, :red    => :yellow
+        event :go,    :yellow => :green
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+
+    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)
+  end
+
+  xit "creates multiple machines"
+end

data/spec/unit/events_spec.rb

@@ -0,0 +1,256 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine, 'events' do
+
+  it "allows for hash rocket syntax to describe transition" do
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow, :green  => :yellow
+        event :stop, :yellow => :red
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+    fsm.slow
+    expect(fsm.current).to eql(:yellow)
+    fsm.stop
+    expect(fsm.current).to eql(:red)
+  end
+
+  it "allows for (:from | :to) key pairs to describe transition" do
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow, from: :green, to: :yellow
+        event :stop, from: :yellow, to: :red
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+    fsm.slow
+    expect(fsm.current).to eql(:yellow)
+    fsm.stop
+    expect(fsm.current).to eql(:red)
+  end
+
+  it "permits no-op event without 'to' transition" do
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :noop,  from: :green
+        event :slow,  from: :green,  to: :yellow
+        event :stop,  from: :yellow, to: :red
+        event :ready, from: :red,    to: :yellow
+        event :go,    from: :yellow, to: :green
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+
+    expect(fsm.can?(:noop)).to be_true
+    expect(fsm.can?(:slow)).to be_true
+
+    fsm.noop
+    expect(fsm.current).to eql(:green)
+    fsm.slow
+    expect(fsm.current).to eql(:yellow)
+
+    expect(fsm.cannot?(:noop)).to be_true
+    expect(fsm.cannot?(:slow)).to be_true
+  end
+
+  it "permits event from any state with :any 'from'" do
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow,  from: :green,  to: :yellow
+        event :stop,  from: :yellow, to: :red
+        event :ready, from: :red,    to: :yellow
+        event :go,    from: :yellow, to: :green
+        event :run,   from: :any,    to: :green
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+
+    fsm.slow
+    expect(fsm.current).to eql(:yellow)
+    fsm.run
+    expect(fsm.current).to eql(:green)
+
+    fsm.slow
+    expect(fsm.current).to eql(:yellow)
+    fsm.stop
+    expect(fsm.current).to eql(:red)
+    fsm.run
+    expect(fsm.current).to eql(:green)
+
+    fsm.slow
+    expect(fsm.current).to eql(:yellow)
+    fsm.go
+    expect(fsm.current).to eql(:green)
+    fsm.run
+    expect(fsm.current).to eql(:green)
+  end
+
+  it "permits event from any state without 'from'" do
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow,  from: :green,  to: :yellow
+        event :stop,  from: :yellow, to: :red
+        event :ready, from: :red,    to: :yellow
+        event :go,    from: :yellow, to: :green
+        event :run,                  to: :green
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+
+    fsm.slow
+    expect(fsm.current).to eql(:yellow)
+    fsm.run
+    expect(fsm.current).to eql(:green)
+
+    fsm.slow
+    expect(fsm.current).to eql(:yellow)
+    fsm.stop
+    expect(fsm.current).to eql(:red)
+    fsm.run
+    expect(fsm.current).to eql(:green)
+
+    fsm.slow
+    expect(fsm.current).to eql(:yellow)
+    fsm.go
+    expect(fsm.current).to eql(:green)
+    fsm.run
+    expect(fsm.current).to eql(:green)
+  end
+
+  it "raises error on invalid transition" do
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow,  from: :green,  to: :yellow
+        event :stop,  from: :yellow, to: :red
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+
+    expect { fsm.stop }.to raise_error(FiniteMachine::TransitionError, /state 'green'/)
+  end
+
+  context 'when multiple from states' do
+    it "allows for array from key" do
+      fsm = FiniteMachine.define do
+        initial :green
+
+        events {
+          event :slow,  :green            => :yellow
+          event :stop,  [:green, :yellow] => :red
+          event :ready, :red              => :yellow
+          event :go,    [:yellow, :red]   => :green
+        }
+      end
+
+      expect(fsm.current).to eql(:green)
+
+      expect(fsm.can?(:slow)).to be_true
+      expect(fsm.can?(:stop)).to be_true
+      expect(fsm.cannot?(:ready)).to be_true
+      expect(fsm.cannot?(:go)).to be_true
+
+      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)
+
+      fsm.stop; expect(fsm.current).to eql(:red)
+      fsm.go;   expect(fsm.current).to eql(:green)
+    end
+
+    it "allows for hash of states" do
+      fsm = FiniteMachine.define do
+        initial :green
+
+        events {
+          event :slow,  :green  => :yellow
+          event :stop,  :green  => :red,   :yellow => :red
+          event :ready, :red    => :yellow
+          event :go,    :yellow => :green, :red    => :green
+        }
+      end
+
+      expect(fsm.current).to eql(:green)
+
+      expect(fsm.can?(:slow)).to be_true
+      expect(fsm.can?(:stop)).to be_true
+      expect(fsm.cannot?(:ready)).to be_true
+      expect(fsm.cannot?(:go)).to be_true
+
+      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)
+
+      fsm.stop; expect(fsm.current).to eql(:red)
+      fsm.go;   expect(fsm.current).to eql(:green)
+    end
+  end
+
+  it "groups events with the same name" do
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :stop,  :green  => :yellow
+        event :stop,  :yellow => :red
+        event :stop,  :red    => :pink
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+
+    expect(fsm.can?(:stop)).to be_true
+
+    fsm.stop
+    expect(fsm.current).to eql(:yellow)
+    fsm.stop
+    expect(fsm.current).to eql(:red)
+    fsm.stop
+    expect(fsm.current).to eql(:pink)
+  end
+
+  it "returns values for events" do
+    fsm = FiniteMachine.define do
+      initial :neutral
+
+      events {
+        event :start,  :neutral   => :engine_on
+        event :drive,  :engine_on => :running, if: -> { return false }
+        event :stop,   :any       => :neutral
+      }
+
+      callbacks {
+        on_enter(:drive) { }
+        on_exit(: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)
+  end
+end

data/spec/unit/finished_spec.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine, 'finished?' do
+
+  it "allows to specify terminal state" do
+    fsm = FiniteMachine.define do
+      initial :green
+      terminal :red
+
+      events {
+        event :slow, :green  => :yellow
+        event :stop, :yellow => :red
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+    expect(fsm.finished?).to be_false
+
+    fsm.slow
+    expect(fsm.current).to eql(:yellow)
+    expect(fsm.finished?).to be_false
+
+    fsm.stop
+    expect(fsm.current).to eql(:red)
+    expect(fsm.finished?).to be_true
+  end
+
+  it "checks without terminal state" do
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow, :green  => :yellow
+        event :stop, :yellow => :red
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+    expect(fsm.finished?).to be_false
+
+    fsm.slow
+    expect(fsm.current).to eql(:yellow)
+    expect(fsm.finished?).to be_false
+
+    fsm.stop
+    expect(fsm.current).to eql(:red)
+    expect(fsm.finished?).to be_false
+  end
+end

data/spec/unit/if_unless_spec.rb

@@ -0,0 +1,196 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine, ':if, :unless' do
+  before(:all) {
+    Car = Class.new do
+      def turn_engine_on
+        @engine_on = true
+      end
+
+      def turn_engine_off
+        @engine_on = false
+      end
+
+      def engine_on?
+        !!@engine_on
+      end
+    end
+  }
+
+  it "allows to cancel event with :if option" do
+    called = []
+
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow, :green => :yellow, if: -> { return false }
+        event :stop, :yellow => :red
+      }
+
+      callbacks {
+        # generic callbacks
+        on_enter      do |event| called << 'on_enter' end
+        on_transition do |event| called << 'on_transition' end
+        on_exit       do |event| called << 'on_exit' end
+
+        # state callbacks
+        on_enter :green do |event| called << 'on_enter_green' end
+        on_enter :yellow do |event| called << "on_enter_yellow" end
+
+        on_transition :green  do |event| called << 'on_transition_green' end
+        on_transition :yellow do |event| called << "on_transition_yellow" end
+
+        on_exit :green  do |event| called << 'on_exit_green' end
+        on_exit :yellow do |event| called << "on_exit_yellow" end
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+    called = []
+    fsm.slow
+    expect(fsm.current).to eql(:green)
+    expect(called).to eql([])
+  end
+
+  it "allows to cancel event with :unless option" do
+    called = []
+
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow, :green => :yellow, unless: -> { return true }
+        event :stop, :yellow => :red
+      }
+
+      callbacks {
+        # generic callbacks
+        on_enter      do |event| called << 'on_enter' end
+        on_transition do |event| called << 'on_transition' end
+        on_exit       do |event| called << 'on_exit' end
+
+        # state callbacks
+        on_enter :green do |event| called << 'on_enter_green' end
+        on_enter :yellow do |event| called << "on_enter_yellow" end
+
+        on_transition :green  do |event| called << 'on_transition_green' end
+        on_transition :yellow do |event| called << "on_transition_yellow" end
+
+        on_exit :green  do |event| called << 'on_exit_green' end
+        on_exit :yellow do |event| called << "on_exit_yellow" end
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+    called = []
+    fsm.slow
+    expect(fsm.current).to eql(:green)
+    expect(called).to eql([])
+  end
+
+  it "allows to combine conditionals" do
+    conditions = []
+
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow, :green => :yellow,
+          if: [ -> { conditions << 'first_if'; return true },
+                -> { conditions << 'second_if'; return true}],
+          unless: -> { conditions << 'first_unless'; return true }
+        event :stop, :yellow => :red
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+    fsm.slow
+    expect(fsm.current).to eql(:green)
+    expect(conditions).to eql([
+      'first_if',
+      'second_if',
+      'first_unless'
+    ])
+  end
+
+  it "specifies :if and :unless with proc" do
+    car = Car.new
+
+    fsm = FiniteMachine.define do
+      initial :neutral
+
+      target car
+
+      events {
+        event :start, :neutral => :one, if: -> (car) { car.engine_on? }
+        event :shift, :one => :two
+      }
+    end
+    car.turn_engine_off
+    expect(car.engine_on?).to be_false
+    expect(fsm.current).to eql(:neutral)
+    fsm.start
+    expect(fsm.current).to eql(:neutral)
+
+    car.turn_engine_on
+    expect(car.engine_on?).to be_true
+    expect(fsm.current).to eql(:neutral)
+    fsm.start
+    expect(fsm.current).to eql(:one)
+  end
+
+  it "specifies :if and :unless with symbol" do
+    car = Car.new
+
+    fsm = FiniteMachine.define do
+      initial :neutral
+
+      target car
+
+      events {
+        event :start, :neutral => :one, if: :engine_on?
+        event :shift, :one => :two
+      }
+    end
+    car.turn_engine_off
+    expect(car.engine_on?).to be_false
+    expect(fsm.current).to eql(:neutral)
+    fsm.start
+    expect(fsm.current).to eql(:neutral)
+
+    car.turn_engine_on
+    expect(car.engine_on?).to be_true
+    expect(fsm.current).to eql(:neutral)
+    fsm.start
+    expect(fsm.current).to eql(:one)
+  end
+
+  it "specifies :if and :unless with string" do
+    car = Car.new
+
+    fsm = FiniteMachine.define do
+      initial :neutral
+
+      target car
+
+      events {
+        event :start, :neutral => :one, if: "engine_on?"
+        event :shift, :one => :two
+      }
+    end
+    car.turn_engine_off
+    expect(car.engine_on?).to be_false
+    expect(fsm.current).to eql(:neutral)
+    fsm.start
+    expect(fsm.current).to eql(:neutral)
+
+    car.turn_engine_on
+    expect(car.engine_on?).to be_true
+    expect(fsm.current).to eql(:neutral)
+    fsm.start
+    expect(fsm.current).to eql(:one)
+  end
+end