finite_machine 0.11.2 → 0.14.0

data/spec/unit/definition_spec.rb

@@ -1,115 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::Definition, 'definition' do
-
-  before 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
-      }
-    end
-  end
-
-  it "creates unique instances" do
-    engine_a = Engine.new
-    engine_b = Engine.new
-    expect(engine_a).not_to be(engine_b)
-
-    engine_a.forward
-    expect(engine_a.current).to eq(:one)
-    expect(engine_b.current).to eq(:neutral)
-  end
-
-  it "allows to create standalone machine" do
-    stub_const("Car", Class.new do
-      def turn_reverse_lights_off
-        @reverse_lights = false
-      end
-
-      def turn_reverse_lights_on
-        @reverse_lights = true
-      end
-
-      def reverse_lights?
-        @reverse_lights ||= false
-      end
-    end)
-
-    car = Car.new
-    engine = Engine.new
-    engine.target car
-    expect(engine.current).to eq(:neutral)
-
-    engine.forward
-    expect(engine.current).to eq(:one)
-    expect(car.reverse_lights?).to eq(false)
-
-    engine.back
-    expect(engine.current).to eq(:reverse)
-    expect(car.reverse_lights?).to eq(true)
-  end
-
-  it "supports inheritance of definitions" do
-    class GenericStateMachine < FiniteMachine::Definition
-      initial :red
-
-      events {
-        event :start, :red => :green
-      }
-
-      callbacks {
-        on_enter { |event| target << 'generic' }
-      }
-    end
-
-    class SpecificStateMachine < GenericStateMachine
-      events {
-        event :stop, :green => :yellow
-      }
-
-      callbacks {
-        on_enter(:yellow) { |event| target << 'specific' }
-      }
-    end
-
-    generic_fsm = GenericStateMachine.new
-    specific_fsm = SpecificStateMachine.new
-    called = []
-    generic_fsm.target called
-    specific_fsm.target called
-
-    expect(generic_fsm.states).to match_array([:none, :red, :green])
-    expect(specific_fsm.states).to match_array([:none, :red, :green, :yellow])
-
-    expect(specific_fsm.current).to eq(:red)
-
-    specific_fsm.start
-    expect(specific_fsm.current).to eq(:green)
-    expect(called).to match_array(['generic'])
-
-    specific_fsm.stop
-    expect(specific_fsm.current).to eq(:yellow)
-    expect(called).to match_array(['generic', 'generic', 'specific'])
-  end
-end

data/spec/unit/event_names_spec.rb

@@ -1,19 +0,0 @@
-# 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/event_queue_spec.rb

@@ -1,52 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::EventQueue do
-
-  subject(:event_queue) { described_class.new }
-
-  it "dispatches all events" do
-    called = []
-    event1 = double(:event1, dispatch: called << 'event1_dispatched')
-    event2 = double(:event2, dispatch: called << 'event2_dispatched')
-    expect(event_queue.size).to be_zero
-    event_queue << event1
-    event_queue << event2
-    event_queue.join(0.001)
-    expect(called).to match_array(['event1_dispatched', 'event2_dispatched'])
-  end
-
-  it "logs error" do
-    event = double(:event)
-    expect(FiniteMachine::Logger).to receive(:error)
-    event_queue << event
-    event_queue.join(0.01)
-    expect(event_queue).to be_empty
-  end
-
-  it "notifies listeners" do
-    called = []
-    event1 = double(:event1, dispatch: true)
-    event2 = double(:event2, dispatch: true)
-    event3 = double(:event3, dispatch: true)
-    event_queue.subscribe(:listener1) { |event| called << event }
-    event_queue << event1 << event2 << event3
-    event_queue.join(0.02)
-    event_queue.shutdown
-    expect(called).to match_array([event1, event2, event3])
-  end
-
-  it "allows to shutdown event queue" do
-    event1 = double(:event1, dispatch: true)
-    event2 = double(:event2, dispatch: true)
-    event3 = double(:event3, dispatch: true)
-    expect(event_queue.alive?).to be(true)
-    event_queue << event1
-    event_queue << event2
-    event_queue.shutdown
-    event_queue << event3
-    event_queue.join(0.001)
-    expect(event_queue.alive?).to be(false)
-  end
-end

data/spec/unit/events_chain/add_spec.rb

@@ -1,25 +0,0 @@
-# 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

@@ -1,22 +0,0 @@
-# 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)
-
-    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

@@ -1,28 +0,0 @@
-# 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

@@ -1,15 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::EventsChain, '#clear' do
-  it "clears chain events" do
-    event = double(:event)
-    events_chain = described_class.new
-    events_chain.add(:validated, event)
-    expect(events_chain.empty?).to be(false)
-
-    events_chain.clear
-    expect(events_chain.empty?).to be(true)
-  end
-end

data/spec/unit/events_chain/events_spec.rb

@@ -1,18 +0,0 @@
-# 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

@@ -1,24 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-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 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 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

@@ -1,37 +0,0 @@
-# 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

@@ -1,48 +0,0 @@
-# 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

@@ -1,17 +0,0 @@
-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

@@ -1,459 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.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 to add event without events scope" do
-    fsm = FiniteMachine.define do
-      initial :green
-
-      event :slow, :green  => :yellow
-      event :stop, :yellow => :red
-    end
-
-    expect(fsm.current).to eql(:green)
-  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 for hash syntax" do
-    fsm = FiniteMachine.define do
-      initial :red
-
-      events {
-        event :start, :red    => :yellow
-        event :run,   :yellow => :green
-        event :stop,  :green  => :red
-        event :go,    :any    => :green
-      }
-    end
-
-    expect(fsm.current).to eql(:red)
-
-    fsm.go
-    expect(fsm.current).to eql(:green)
-    fsm.stop
-    fsm.start
-    expect(fsm.current).to eql(:yellow)
-    fsm.go
-    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 "doesn't raise error on invalid transition for non-dangerous version" 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
-
-  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
-
-  context 'for dangerous version' do
-    it "raises error on invalid transition without callbacks" do
-      called = []
-      fsm = FiniteMachine.define do
-        initial :green
-
-        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
-  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
-        event :cycle, [:yellow, :red, :pink] => :green
-      }
-    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)
-    fsm.cycle
-    expect(fsm.current).to eql(:green)
-    fsm.stop
-    expect(fsm.current).to eql(:yellow)
-  end
-
-  it "groups transitions under one event name" do
-    fsm = FiniteMachine.define do
-      initial :initial
-
-      events {
-        event :bump, :initial => :low,
-                     :low     => :medium,
-                     :medium  => :high
-      }
-    end
-
-    expect(fsm.current).to eq(:initial)
-    fsm.bump; expect(fsm.current).to eq(:low)
-    fsm.bump; expect(fsm.current).to eq(:medium)
-    fsm.bump; expect(fsm.current).to eq(:high)
-  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_before(:drive) { FiniteMachine::CANCELLED }
-        on_after(:stop)   { }
-      }
-    end
-
-    expect(fsm.current).to eql(:neutral)
-    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
-    digits = []
-    callbacks = []
-    phone = FiniteMachine.define do
-      initial :on_hook
-
-      events {
-        event :digit,    :on_hook => :dialing
-        event :digit,    :dialing => :dialing
-        event :off_hook, :dialing => :alerting
-      }
-
-      callbacks {
-        on_before_digit { |event, digit| digits << digit}
-        on_before_off_hook { |event| callbacks << "dialing #{digits.join}" }
-      }
-    end
-
-    expect(phone.current).to eq(:on_hook)
-    phone.digit(9)
-    expect(phone.current).to eq(:dialing)
-    phone.digit(1)
-    expect(phone.current).to eq(:dialing)
-    phone.digit(1)
-    expect(phone.current).to eq(:dialing)
-    phone.off_hook
-    expect(phone.current).to eq(:alerting)
-    expect(digits).to match_array(digits)
-    expect(callbacks).to match_array(["dialing 911"])
-  end
-
-  it "detects dangerous event names" 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 :start, :red => :green
-        event :stop,  :green => :red
-      }
-    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