finite_machine 0.11.3 → 0.12.0

data/spec/unit/alias_target_spec.rb

@@ -1,6 +1,4 @@
-# encoding: utf-8
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe FiniteMachine::Definition, '#alias_target' do
 
@@ -22,67 +20,51 @@ RSpec.describe FiniteMachine::Definition, '#alias_target' do
 
   it "aliases target" do
     car = Car.new
-    fsm = FiniteMachine.new
-    fsm.target(car)
+    fsm = FiniteMachine.new(car, alias_target: :delorean)
 
     expect(fsm.target).to eq(car)
     expect { fsm.car }.to raise_error(NoMethodError)
-
-    fsm.alias_target(:delorean)
     expect(fsm.delorean).to eq(car)
   end
 
   it "scopes the target alias to a state machine instance" do
     delorean = Car.new
     batmobile = Car.new
-    fsm_a = FiniteMachine.new
-    fsm_a.target(delorean)
-    fsm_b = FiniteMachine.new
-    fsm_b.target(batmobile)
-
-    fsm_a.alias_target(:delorean)
-    fsm_b.alias_target(:batmobile)
+    fsm_a = FiniteMachine.new(delorean, alias_target: :delorean)
+    fsm_b = FiniteMachine.new(batmobile, alias_target: :batmobile)
 
     expect(fsm_a.delorean).to eq(delorean)
-    expect { fsm_a.batmobile }.to raise_error(NoMethodError)
+    expect { fsm_a.batmobile }.to raise_error(NameError)
 
     expect(fsm_b.batmobile).to eq(batmobile)
-    expect { fsm_b.delorean }.to raise_error(NoMethodError)
+    expect { fsm_b.delorean }.to raise_error(NameError)
   end
 
   context 'when inside definition' do
     before do
-      class Engine < FiniteMachine::Definition
+      stub_const("Engine", Class.new(FiniteMachine::Definition) do
         initial :neutral
 
-        alias_target :car
+        event :forward, [:reverse, :neutral] => :one
+        event :shift, :one => :two
+        event :shift, :two => :one
+        event :back,  [:neutral, :one] => :reverse
 
-        events {
-          event :forward, [:reverse, :neutral] => :one
-          event :shift, :one => :two
-          event :shift, :two => :one
-          event :back,  [:neutral, :one] => :reverse
-        }
+        on_enter :reverse do |event|
+          car.turn_reverse_lights_on
+        end
 
-        callbacks {
-          on_enter :reverse do |event|
-            car.turn_reverse_lights_on
-          end
+        on_exit :reverse do |event|
+          car.turn_reverse_lights_off
+        end
 
-          on_exit :reverse do |event|
-            car.turn_reverse_lights_off
-          end
-        }
-
-        handlers {
-          handle FiniteMachine::InvalidStateError do |exception| end
-        }
-      end
+        handle FiniteMachine::InvalidStateError do |exception| end
+      end)
     end
 
     it "creates unique instances" do
-      engine_a = Engine.new
-      engine_b = Engine.new
+      engine_a = Engine.new(alias_target: :car)
+      engine_b = Engine.new(alias_target: :car)
       expect(engine_a).not_to be(engine_b)
 
       engine_a.forward
@@ -92,8 +74,7 @@ RSpec.describe FiniteMachine::Definition, '#alias_target' do
 
     it "allows to create standalone machine" do
       car = Car.new
-      engine = Engine.new
-      engine.target car
+      engine = Engine.new(car, alias_target: :car)
       expect(engine.current).to eq(:neutral)
 
       engine.forward

data/spec/unit/async_callbacks_spec.rb

@@ -1,23 +1,18 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 RSpec.describe FiniteMachine, 'async callbacks' do
-
   it "permits async callback" do
     called = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green, silent: false
 
-      events {
-        event :slow,  :green  => :yellow
-        event :go,    :yellow => :green
-      }
+      event :slow,  :green  => :yellow
+      event :go,    :yellow => :green
 
-      callbacks {
-        on_enter  :green,  :async  do |event| called << 'on_enter_green' end
-        on_before :slow,   :async  do |event| called << 'on_before_slow'  end
-        on_exit   :yellow, :async  do |event| called << 'on_exit_yellow' end
-        on_after  :go,     :async  do |event| called << 'on_after_go'     end
-      }
+      on_enter  :green,  :async  do |event| called << 'on_enter_green' end
+      on_before :slow,   :async  do |event| called << 'on_before_slow'  end
+      on_exit   :yellow, :async  do |event| called << 'on_exit_yellow' end
+      on_after  :go,     :async  do |event| called << 'on_after_go'     end
     end
     fsm.slow
     fsm.go

data/spec/unit/auto_methods_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+RSpec.describe FiniteMachine, ':auto_methods' do
+  it "allows turning off automatic methods generation" do
+    fsm = FiniteMachine.new(auto_methods: false) do
+      initial :green
+
+      event :slow,  :green  => :yellow
+      event :stop,  :yellow => :red
+      event :ready, :red    => :yellow
+      event :go,    :yellow => :green
+
+      # allows for fluid callback names
+      once_on_enter_yellow do |event| 'once_on_enter_yellow' end
+    end
+
+    expect(fsm.respond_to?(:slow)).to eq(false)
+    expect { fsm.slow }.to raise_error(NoMethodError)
+    expect(fsm.current).to eq(:green)
+
+    fsm.trigger(:slow)
+    expect(fsm.current).to eq(:yellow)
+  end
+
+  it "allows to use any method name without auto method generation" do
+    fsm = FiniteMachine.new(auto_methods: false) do
+      initial :green
+
+      event :fail, :green => :red
+    end
+
+    fsm.trigger(:fail)
+    expect(fsm.current).to eq(:red)
+  end
+
+  it "detects dangerous event names" do
+    expect {
+      FiniteMachine.new do
+        event :trigger, :a => :b
+      end
+    }.to raise_error(FiniteMachine::AlreadyDefinedError)
+  end
+end
+

data/spec/unit/callable/call_spec.rb

@@ -1,6 +1,4 @@
-# encoding: utf-8
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe FiniteMachine::Callable, '#call' do
 

data/spec/unit/callbacks_spec.rb

@@ -1,192 +1,180 @@
-# encoding: utf-8
-
-require 'spec_helper'
+# frozen_string_literal
 
 RSpec.describe FiniteMachine, 'callbacks' do
-
   it "triggers default init event" do
     called = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green, defer: true, silent: false
 
-      callbacks {
-        # generic state 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
+      # generic state 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
 
-        # generic event callbacks
-        on_before do |event| called << 'on_before' end
-        on_after  do |event| called << 'on_after' end
+      # generic event callbacks
+      on_before any_event do |event| called << 'on_before' end
+      on_after  do |event| called << 'on_after' end
 
-        # state callbacks
-        on_enter :none  do |event| called << 'on_enter_none' end
-        on_enter :green do |event| called << 'on_enter_green' end
+      # state callbacks
+      on_enter :none  do |event| called << 'on_enter_none' end
+      on_enter :green do |event| called << 'on_enter_green' end
 
-        on_transition :none  do |event| called << 'on_transition_none' end
-        on_transition :green do |event| called << 'on_transition_green' end
+      on_transition :none  do |event| called << 'on_transition_none' end
+      on_transition :green do |event| called << 'on_transition_green' end
 
-        on_exit :none  do |event| called << 'on_exit_none' end
-        on_exit :green do |event| called << 'on_exit_green' end
+      on_exit :none  do |event| called << 'on_exit_none' end
+      on_exit :green do |event| called << 'on_exit_green' end
 
-        # event callbacks
-        on_before :init do |event| called << 'on_before_init' end
-        on_after  :init do |event| called << 'on_after_init' end
-      }
+      # event callbacks
+      on_before :init do |event| called << 'on_before_init' end
+      on_after  :init do |event| called << 'on_after_init' end
     end
 
     expect(fsm.current).to eql(:none)
     fsm.init
     expect(called).to eql([
-      'on_before_init',
       'on_before',
-      'on_exit_none',
+      'on_before_init',
       'on_exit',
-      'on_transition_green',
+      'on_exit_none',
       'on_transition',
-      'on_enter_green',
+      'on_transition_green',
       'on_enter',
-      'on_after_init',
-      'on_after'
+      'on_enter_green',
+      'on_after',
+      'on_after_init'
     ])
   end
 
   it "executes callbacks in order" do
     called = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green, silent: false
 
-      events {
-        event :slow,  :green  => :yellow
-        event :stop,  :yellow => :red
-        event :ready, :red    => :yellow
-        event :go,    :yellow => :green
-      }
-
-      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
-
-        on_before do |event| called << 'on_before' end
-        on_after  do |event| called << 'on_after' end
-
-        # state callbacks
-        on_enter :green  do |event| called << 'on_enter_green' end
-        on_enter :yellow do |event| called << "on_enter_yellow" end
-        on_enter :red    do |event| called << "on_enter_red" end
-
-        on_transition :green  do |event| called << 'on_transition_green' end
-        on_transition :yellow do |event| called << "on_transition_yellow" end
-        on_transition :red    do |event| called << "on_transition_red" end
-
-        on_exit :green  do |event| called << 'on_exit_green' end
-        on_exit :yellow do |event| called << "on_exit_yellow" end
-        on_exit :red    do |event| called << "on_exit_red" end
-
-        # event callbacks
-        on_before :slow  do |event| called << 'on_before_slow' end
-        on_before :stop  do |event| called << "on_before_stop" end
-        on_before :ready do |event| called << "on_before_ready" end
-        on_before :go    do |event| called << "on_before_go" end
-
-        on_after :slow  do |event| called << 'on_after_slow' end
-        on_after :stop  do |event| called << "on_after_stop" end
-        on_after :ready do |event| called << "on_after_ready" end
-        on_after :go    do |event| called << "on_after_go" end
-      }
+      event :slow,  :green  => :yellow
+      event :stop,  :yellow => :red
+      event :ready, :red    => :yellow
+      event :go,    :yellow => :green
+
+      # 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
+
+      on_before do |event| called << 'on_before' end
+      on_after  do |event| called << 'on_after' end
+
+      # state callbacks
+      on_enter :green  do |event| called << 'on_enter_green' end
+      on_enter :yellow do |event| called << "on_enter_yellow" end
+      on_enter :red    do |event| called << "on_enter_red" end
+
+      on_transition :green  do |event| called << 'on_transition_green' end
+      on_transition :yellow do |event| called << "on_transition_yellow" end
+      on_transition :red    do |event| called << "on_transition_red" end
+
+      on_exit :green  do |event| called << 'on_exit_green' end
+      on_exit :yellow do |event| called << "on_exit_yellow" end
+      on_exit :red    do |event| called << "on_exit_red" end
+
+      # event callbacks
+      on_before :slow  do |event| called << 'on_before_slow' end
+      on_before :stop  do |event| called << "on_before_stop" end
+      on_before :ready do |event| called << "on_before_ready" end
+      on_before :go    do |event| called << "on_before_go" end
+
+      on_after :slow  do |event| called << 'on_after_slow' end
+      on_after :stop  do |event| called << "on_after_stop" end
+      on_after :ready do |event| called << "on_after_ready" end
+      on_after :go    do |event| called << "on_after_go" end
     end
 
     expect(fsm.current).to eq(:green)
     expect(called).to eq([
       'on_before',
       'on_exit',
-      'on_transition_green',
       'on_transition',
-      'on_enter_green',
+      'on_transition_green',
       'on_enter',
+      'on_enter_green',
       'on_after'
     ])
 
     called = []
     fsm.slow
     expect(called).to eql([
-      'on_before_slow',
       'on_before',
-      'on_exit_green',
+      'on_before_slow',
       'on_exit',
-      'on_transition_yellow',
+      'on_exit_green',
       'on_transition',
-      'on_enter_yellow',
+      'on_transition_yellow',
       'on_enter',
-      'on_after_slow',
-      'on_after'
+      'on_enter_yellow',
+      'on_after',
+      'on_after_slow'
     ])
 
     called = []
     fsm.stop
     expect(called).to eql([
-      'on_before_stop',
       'on_before',
-      'on_exit_yellow',
+      'on_before_stop',
       'on_exit',
-      'on_transition_red',
+      'on_exit_yellow',
       'on_transition',
-      'on_enter_red',
+      'on_transition_red',
       'on_enter',
-      'on_after_stop',
-      'on_after'
+      'on_enter_red',
+      'on_after',
+      'on_after_stop'
     ])
 
     called = []
     fsm.ready
     expect(called).to eql([
-      'on_before_ready',
       'on_before',
-      'on_exit_red',
+      'on_before_ready',
       'on_exit',
-      'on_transition_yellow',
+      'on_exit_red',
       'on_transition',
-      'on_enter_yellow',
+      'on_transition_yellow',
       'on_enter',
-      'on_after_ready',
-      'on_after'
+      'on_enter_yellow',
+      'on_after',
+      'on_after_ready'
     ])
 
     called = []
     fsm.go
     expect(called).to eql([
-      'on_before_go',
       'on_before',
-      'on_exit_yellow',
+      'on_before_go',
       'on_exit',
-      'on_transition_green',
+      'on_exit_yellow',
       'on_transition',
-      'on_enter_green',
+      'on_transition_green',
       'on_enter',
-      'on_after_go',
-      'on_after'
+      'on_enter_green',
+      'on_after',
+      'on_after_go'
     ])
   end
 
   it "maintains transition execution sequence from UML statechart" do
     called = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :previous, silent: false
 
-      events {
-        event :go, :previous => :next, if: -> { called << 'guard'; true}
-      }
-
-      callbacks {
-        on_exit   { |event| called << "exit_#{event.from}" }
-        on_before { |event| called << "before_#{event.name}" }
-        on_transition { |event| called << "transition_#{event.from}_#{event.to}"}
-        on_enter  { |event| called << "enter_#{event.to}"}
-        on_after  { |event| called << "after_#{event.name}" }
-      }
+      event :go, :previous => :next, if: -> { called << 'guard'; true}
+
+      on_exit   { |event| called << "exit_#{event.from}" }
+      on_before { |event| called << "before_#{event.name}" }
+      on_transition { |event| called << "transition_#{event.from}_#{event.to}"}
+      on_enter  { |event| called << "enter_#{event.to}"}
+      on_after  { |event| called << "after_#{event.name}" }
     end
+
     expect(fsm.current).to eq(:previous)
     fsm.go
     expect(called).to eq([
@@ -206,40 +194,36 @@ RSpec.describe FiniteMachine, 'callbacks' do
 
   it "allows multiple callbacks for the same state" do
     called = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green, silent: false
 
-      events {
-        event :slow,  :green  => :yellow
-        event :stop,  :yellow => :red
-        event :ready, :red    => :yellow
-        event :go,    :yellow => :green
-      }
-
-      callbacks {
-        # generic state 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
-
-        # generic event callbacks
-        on_before do |event| called << 'on_before' end
-        on_after  do |event| called << 'on_after' end
-
-        # state callbacks
-        on_exit       :green  do |event| called << 'on_exit_green_1' end
-        on_exit       :green  do |event| called << 'on_exit_green_2' end
-        on_enter      :yellow do |event| called << 'on_enter_yellow_1' end
-        on_enter      :yellow do |event| called << 'on_enter_yellow_2' end
-        on_transition :yellow do |event| called << 'on_transition_yellow_1' end
-        on_transition :yellow do |event| called << 'on_transition_yellow_2' end
-
-        # event callbacks
-        on_before :slow do |event| called << 'on_before_slow_1' end
-        on_before :slow do |event| called << 'on_before_slow_2' end
-        on_after  :slow do |event| called << 'on_after_slow_1' end
-        on_after  :slow do |event| called << 'on_after_slow_2' end
-      }
+      event :slow,  :green  => :yellow
+      event :stop,  :yellow => :red
+      event :ready, :red    => :yellow
+      event :go,    :yellow => :green
+
+      # generic state 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
+
+      # generic event callbacks
+      on_before do |event| called << 'on_before' end
+      on_after  do |event| called << 'on_after' end
+
+      # state callbacks
+      on_exit       :green  do |event| called << 'on_exit_green_1' end
+      on_exit       :green  do |event| called << 'on_exit_green_2' end
+      on_enter      :yellow do |event| called << 'on_enter_yellow_1' end
+      on_enter      :yellow do |event| called << 'on_enter_yellow_2' end
+      on_transition :yellow do |event| called << 'on_transition_yellow_1' end
+      on_transition :yellow do |event| called << 'on_transition_yellow_2' end
+
+      # event callbacks
+      on_before :slow do |event| called << 'on_before_slow_1' end
+      on_before :slow do |event| called << 'on_before_slow_2' end
+      on_after  :slow do |event| called << 'on_after_slow_1' end
+      on_after  :slow do |event| called << 'on_after_slow_2' end
     end
 
     expect(fsm.current).to eql(:green)
@@ -254,46 +238,42 @@ RSpec.describe FiniteMachine, 'callbacks' do
     fsm.slow
     expect(fsm.current).to eql(:yellow)
     expect(called).to eql([
+      'on_before',
       'on_before_slow_1',
       'on_before_slow_2',
-      'on_before',
+      'on_exit',
       'on_exit_green_1',
       'on_exit_green_2',
-      'on_exit',
+      'on_transition',
       'on_transition_yellow_1',
       'on_transition_yellow_2',
-      'on_transition',
+      'on_enter',
       'on_enter_yellow_1',
       'on_enter_yellow_2',
-      'on_enter',
+      'on_after',
       'on_after_slow_1',
-      'on_after_slow_2',
-      'on_after'
+      'on_after_slow_2'
     ])
   end
 
   it "allows for fluid callback definition" do
     called = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :slow,  :green  => :yellow
-        event :stop,  :yellow => :red
-        event :ready, :red    => :yellow
-        event :go,    :yellow => :green
-      }
-
-      callbacks {
-        # state callbacks
-        on_exit_green do |event| called << 'on_exit_green' end
-        on_enter_yellow do |event| called << 'on_enter_yellow' end
-        on_transition_yellow do |event| called << 'on_transition_yellow' end
-
-        # event callbacks
-        on_before_slow do |event| called << 'on_before_slow' end
-        on_after_slow do |event| called << 'on_after_slow' end
-      }
+      event :slow,  :green  => :yellow
+      event :stop,  :yellow => :red
+      event :ready, :red    => :yellow
+      event :go,    :yellow => :green
+
+      # state callbacks
+      on_exit_green do |event| called << 'on_exit_green' end
+      on_enter_yellow do |event| called << 'on_enter_yellow' end
+      on_transition_yellow do |event| called << 'on_transition_yellow' end
+
+      # event callbacks
+      on_before_slow do |event| called << 'on_before_slow' end
+      on_after_slow do |event| called << 'on_after_slow' end
     end
 
     called = []
@@ -310,16 +290,12 @@ RSpec.describe FiniteMachine, 'callbacks' do
 
   it "passes event object to callback" do
     evt = nil
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :slow, :green  => :yellow
-      }
+      event :slow, :green  => :yellow
 
-      callbacks {
-        on_enter(:yellow) { |e| evt = e }
-      }
+      on_enter(:yellow) { |e| evt = e }
     end
 
     expect(fsm.current).to eql(:green)
@@ -333,17 +309,13 @@ RSpec.describe FiniteMachine, 'callbacks' do
 
   it "identifies the from state for callback event parameter" do
     evt = nil
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :slow, [:red, :blue, :green]  => :yellow
-        event :fast, :red => :purple
-      }
+      event :slow, [:red, :blue, :green] => :yellow
+      event :fast, :red => :purple
 
-      callbacks {
-        on_enter(:yellow) { |e| evt = e }
-      }
+      on_enter(:yellow) { |e| evt = e }
     end
 
     expect(fsm.current).to eql(:green)
@@ -366,54 +338,47 @@ RSpec.describe FiniteMachine, 'callbacks' do
       target.expect(b).to target.eql(expected[:b])
       target.expect(c).to target.eql(expected[:c])
     }
-    context = self
 
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new(self) do
       initial :green
 
-      target context
-
-      events {
-        event :slow,  :green  => :yellow
-        event :stop,  :yellow => :red
-        event :ready, :red    => :yellow
-        event :go,    :yellow => :green
-      }
-
-      callbacks {
-        # generic state callbacks
-        on_enter(&callback)
-        on_transition(&callback)
-        on_exit(&callback)
-
-        # generic event callbacks
-        on_before(&callback)
-        on_after(&callback)
-
-        # state callbacks
-        on_enter :green,  &callback
-        on_enter :yellow, &callback
-        on_enter :red,    &callback
-
-        on_transition :green , &callback
-        on_transition :yellow, &callback
-        on_transition :red   , &callback
-
-        on_exit :green , &callback
-        on_exit :yellow, &callback
-        on_exit :red   , &callback
-
-        # event callbacks
-        on_before :slow , &callback
-        on_before :stop , &callback
-        on_before :ready, &callback
-        on_before :go   , &callback
-
-        on_after :slow , &callback
-        on_after :stop , &callback
-        on_after :ready, &callback
-        on_after :go   , &callback
-      }
+      event :slow,  :green  => :yellow
+      event :stop,  :yellow => :red
+      event :ready, :red    => :yellow
+      event :go,    :yellow => :green
+
+      # generic state callbacks
+      on_enter(&callback)
+      on_transition(&callback)
+      on_exit(&callback)
+
+      # generic event callbacks
+      on_before(&callback)
+      on_after(&callback)
+
+      # state callbacks
+      on_enter :green,  &callback
+      on_enter :yellow, &callback
+      on_enter :red,    &callback
+
+      on_transition :green , &callback
+      on_transition :yellow, &callback
+      on_transition :red   , &callback
+
+      on_exit :green , &callback
+      on_exit :yellow, &callback
+      on_exit :red   , &callback
+
+      # event callbacks
+      on_before :slow , &callback
+      on_before :stop , &callback
+      on_before :ready, &callback
+      on_before :go   , &callback
+
+      on_after :slow , &callback
+      on_after :stop , &callback
+      on_after :ready, &callback
+      on_after :go   , &callback
     end
 
     expected = {name: :slow, from: :green, to: :yellow, a: 1, b: 2, c: 3}
@@ -441,63 +406,55 @@ RSpec.describe FiniteMachine, 'callbacks' do
       target.expect(c).to target.eql(expected[:c])
     }
 
-    context = self
-
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new(self) do
       initial :red
 
-      target context
-
-      events {
-        event :power_on,  :off => :red
-        event :power_off, :any => :off
-        event :go,   :red    => :green
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
-
-      callbacks {
-        # generic state callbacks
-        on_enter(&callback)
-        on_transition(&callback)
-        on_exit(&callback)
-
-        # generic event callbacks
-        on_before(&callback)
-        on_after(&callback)
-
-        # state callbacks
-        on_enter :green,  &callback
-        on_enter :yellow, &callback
-        on_enter :red,    &callback
-        on_enter :off,    &callback
-        on_enter :off,    &callback
-
-        on_transition :green,  &callback
-        on_transition :yellow, &callback
-        on_transition :red,    &callback
-        on_transition :off,    &callback
-        on_transition :off,    &callback
-
-        on_exit :green,  &callback
-        on_exit :yellow, &callback
-        on_exit :red,    &callback
-        on_exit :off,    &callback
-        on_exit :off,    &callback
-
-        # event callbacks
-        on_before :power_on, &callback
-        on_before :power_off, &callback
-        on_before :go,       &callback
-        on_before :slow,     &callback
-        on_before :stop,     &callback
-
-        on_after :power_on, &callback
-        on_after :power_off, &callback
-        on_after :go,       &callback
-        on_after :slow,     &callback
-        on_after :stop,     &callback
-      }
+      event :power_on,  :off => :red
+      event :power_off, any_state => :off
+      event :go,   :red    => :green
+      event :slow, :green  => :yellow
+      event :stop, :yellow => :red
+
+      # generic state callbacks
+      on_enter(&callback)
+      on_transition(&callback)
+      on_exit(&callback)
+
+      # generic event callbacks
+      on_before(&callback)
+      on_after(&callback)
+
+      # state callbacks
+      on_enter :green,  &callback
+      on_enter :yellow, &callback
+      on_enter :red,    &callback
+      on_enter :off,    &callback
+      on_enter :off,    &callback
+
+      on_transition :green,  &callback
+      on_transition :yellow, &callback
+      on_transition :red,    &callback
+      on_transition :off,    &callback
+      on_transition :off,    &callback
+
+      on_exit :green,  &callback
+      on_exit :yellow, &callback
+      on_exit :red,    &callback
+      on_exit :off,    &callback
+      on_exit :off,    &callback
+
+      # event callbacks
+      on_before :power_on, &callback
+      on_before :power_off, &callback
+      on_before :go,       &callback
+      on_before :slow,     &callback
+      on_before :stop,     &callback
+
+      on_after :power_on, &callback
+      on_after :power_off, &callback
+      on_after :go,       &callback
+      on_after :slow,     &callback
+      on_after :stop,     &callback
     end
 
     expect(fsm.current).to eq(:red)
@@ -517,47 +474,43 @@ RSpec.describe FiniteMachine, 'callbacks' do
 
   it "raises an error with invalid callback name" do
     expect {
-      FiniteMachine.define do
+      FiniteMachine.new do
         initial :green
 
-        events {
-          event :slow, :green => :yellow
-        }
+        event :slow, :green => :yellow
 
-        callbacks {
-          on_enter(:magic) { |event| called << 'on_enter'}
-        }
+        on_enter(:magic) { |event| called << 'on_enter'}
       end
     }.to raise_error(FiniteMachine::InvalidCallbackNameError, /\"magic\" is not a valid callback name/)
   end
 
   it "doesn't allow to mix state callback with event name" do
     expect {
-      FiniteMachine.define do
-        events { event :slow,  :green  => :yellow }
+      FiniteMachine.new do
+        event :slow, :green  => :yellow
 
-        callbacks { on_enter_slow do |event| end }
+        on_enter_slow do |event| end
       end
     }.to raise_error(FiniteMachine::InvalidCallbackNameError, "\"on_enter\" callback is a state listener and cannot be used with \"slow\" event name. Please use on_before or on_after instead.")
   end
 
   it "doesn't allow to mix event callback with state name" do
     expect {
-      FiniteMachine.define do
-        events { event :slow, :green => :yellow }
+      FiniteMachine.new do
+        event :slow, :green => :yellow
 
-        callbacks { on_before_green do |event| end }
+        on_before_green do |event| end
       end
     }.to raise_error(FiniteMachine::InvalidCallbackNameError, '"on_before" callback is an event listener and cannot be used with "green" state name. Please use on_enter, on_transition or on_exit instead.')
   end
 
   it "propagates exceptions raised inside callback" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events { event :slow, :green => :yellow }
+      event :slow, :green => :yellow
 
-      callbacks { on_enter(:yellow) { raise RuntimeError } }
+      on_enter(:yellow) { raise RuntimeError }
     end
 
     expect(fsm.current).to eql(:green)
@@ -566,19 +519,15 @@ RSpec.describe FiniteMachine, 'callbacks' do
 
   it "executes callbacks with multiple 'from' transitions" do
     called = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :stop,  :green  => :yellow
-        event :stop,  :yellow => :red
-      }
+      event :stop,  :green  => :yellow
+      event :stop,  :yellow => :red
 
-      callbacks {
-        on_before_stop do |event|
-          called << 'on_before_stop'
-        end
-      }
+      on_before_stop do |event|
+        called << 'on_before_stop'
+      end
     end
     expect(fsm.current).to eql(:green)
     fsm.stop
@@ -593,15 +542,13 @@ RSpec.describe FiniteMachine, 'callbacks' do
 
   it "allows to define callbacks on machine instance" do
     called = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :slow,  :green  => :yellow
-        event :stop,  :yellow => :red
-        event :ready, :red    => :yellow
-        event :go,    :yellow => :green
-      }
+      event :slow,  :green  => :yellow
+      event :stop,  :yellow => :red
+      event :ready, :red    => :yellow
+      event :go,    :yellow => :green
     end
 
     fsm.on_enter_yellow do |event|
@@ -616,52 +563,46 @@ RSpec.describe FiniteMachine, 'callbacks' do
   end
 
   it "raises error for unknown callback" do
-    expect { FiniteMachine.define do
-      initial :green
+    expect { 
+      FiniteMachine.new do
+        initial :green
 
-      events {
         event :slow,  :green  => :yellow
         event :stop,  :yellow => :red
         event :ready, :red    => :yellow
         event :go,    :yellow => :green
-      }
 
-      callbacks {
         on_enter_unknown do |event| end
-      }
-    end }.to raise_error(NoMethodError)
+      end
+    }.to raise_error(NameError, /`on_enter_unknown'/)
   end
 
   it "triggers callbacks only once" do
     called = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green, silent: false
 
-      events {
-        event :slow, :green  => :yellow
-        event :go,   :yellow => :green
-      }
-
-      callbacks {
-        # state callbacks
-        once_on_enter_green  do |event| called << 'once_on_enter_green' end
-        once_on_enter_yellow do |event| called << 'once_on_enter_yellow' end
-
-        once_on_transition_green do |event| called << 'once_on_transition_green' end
-        once_on_transition_yellow do |event| called << 'once_on_transition_yellow' end
-        once_on_exit_none   do |event| called << 'once_on_exit_none' end
-        once_on_exit_green  do |event| called << 'once_on_exit_green' end
-        once_on_exit_yellow do |event| called << 'once_on_exit_yellow' end
-
-        # event callbacks
-        once_on_before_init do |event| called << 'once_on_before_init' end
-        once_on_before_slow do |event| called << 'once_on_before_slow' end
-        once_on_before_go   do |event| called << 'once_on_before_go' end
-
-        once_on_after_init do |event| called << 'once_on_after_init' end
-        once_on_after_slow do |event| called << 'once_on_after_slow' end
-        once_on_after_go   do |event| called << 'once_on_after_go' end
-      }
+      event :slow, :green  => :yellow
+      event :go,   :yellow => :green
+
+      # state callbacks
+      once_on_enter_green  do |event| called << 'once_on_enter_green' end
+      once_on_enter_yellow do |event| called << 'once_on_enter_yellow' end
+
+      once_on_transition_green do |event| called << 'once_on_transition_green' end
+      once_on_transition_yellow do |event| called << 'once_on_transition_yellow' end
+      once_on_exit_none   do |event| called << 'once_on_exit_none' end
+      once_on_exit_green  do |event| called << 'once_on_exit_green' end
+      once_on_exit_yellow do |event| called << 'once_on_exit_yellow' end
+
+      # event callbacks
+      once_on_before_init do |event| called << 'once_on_before_init' end
+      once_on_before_slow do |event| called << 'once_on_before_slow' end
+      once_on_before_go   do |event| called << 'once_on_before_go' end
+
+      once_on_after_init do |event| called << 'once_on_after_init' end
+      once_on_after_slow do |event| called << 'once_on_after_slow' end
+      once_on_after_go   do |event| called << 'once_on_after_go' end
     end
     expect(fsm.current).to eql(:green)
     fsm.slow
@@ -687,83 +628,31 @@ RSpec.describe FiniteMachine, 'callbacks' do
     ])
   end
 
-  it "cancels transition on event 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 "stops executing callbacks when cancelled" do
-    called = []
-
-    fsm = FiniteMachine.define do
-      initial :initial
-
-      events { event :bump, initial: :low }
-
-      callbacks {
-        on_before do |event|
-          called << "enter_#{event.name}_#{event.from}_#{event.to}"
-
-          FiniteMachine::CANCELLED
-        end
-
-        on_exit :initial do |event| called << "exit_initial" end
-        on_exit          do |event| called << "exit_any" end
-        on_enter :low    do |event| called << "enter_low" end
-        on_after :bump   do |event| called << "after_#{event.name}" end
-        on_after         do |event| called << "after_any" end
-      }
-    end
-
-    fsm.bump
-
-    expect(called).to eq(['enter_bump_initial_low'])
-  end
-
   xit "groups callbacks"
 
   it "groups states from separate events with the same name" do
     callbacks = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :initial, silent: false
 
-      events {
-        event :bump, :initial => :low
-        event :bump, :low     => :medium
-        event :bump, :medium  => :high
-      }
-
-      callbacks {
-        on_enter do |event|
-          callbacks << "enter_#{event.name}_#{event.from}_#{event.to}"
-        end
-        on_exit do |event|
-          callbacks << "exit_#{event.name}_#{event.from}_#{event.to}"
-        end
-        on_before do |event|
-          callbacks << "before_#{event.name}_#{event.from}_#{event.to}"
-        end
-        on_after do |event|
-          callbacks << "after_#{event.name}_#{event.from}_#{event.to}"
-        end
-      }
+      event :bump, :initial => :low
+      event :bump, :low     => :medium
+      event :bump, :medium  => :high
+
+      on_enter do |event|
+        callbacks << "enter_#{event.name}_#{event.from}_#{event.to}"
+      end
+      on_exit do |event|
+        callbacks << "exit_#{event.name}_#{event.from}_#{event.to}"
+      end
+      on_before do |event|
+        callbacks << "before_#{event.name}_#{event.from}_#{event.to}"
+      end
+      on_after do |event|
+        callbacks << "after_#{event.name}_#{event.from}_#{event.to}"
+      end
     end
+
     expect(fsm.current).to eq(:initial)
     fsm.bump
     expect(callbacks).to eq([
@@ -814,24 +703,21 @@ RSpec.describe FiniteMachine, 'callbacks' do
 
   it "groups states under event name" do
     callbacks = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :initial, silent: false
 
-      events {
-        event :bump, :initial => :low,
-                     :low     => :medium,
-                     :medium  => :high
-      }
-
-      callbacks {
-        on_enter do |event|
-          callbacks << "enter_#{event.name}_#{event.from}_#{event.to}"
-        end
-        on_before do |event|
-          callbacks << "before_#{event.name}_#{event.from}_#{event.to}"
-        end
-      }
+      event :bump, :initial => :low,
+                    :low     => :medium,
+                    :medium  => :high
+
+      on_enter do |event|
+        callbacks << "enter_#{event.name}_#{event.from}_#{event.to}"
+      end
+      on_before do |event|
+        callbacks << "before_#{event.name}_#{event.from}_#{event.to}"
+      end
     end
+
     expect(fsm.current).to eq(:initial)
     fsm.bump
     expect(callbacks).to eq([
@@ -864,18 +750,14 @@ RSpec.describe FiniteMachine, 'callbacks' do
 
   it "permits state and event with the same name" do
     called = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :on_hook, silent: false
 
-      events {
-        event :off_hook, :on_hook => :off_hook
-        event :on_hook,  :off_hook => :on_hook
-      }
+      event :off_hook, :on_hook => :off_hook
+      event :on_hook,  :off_hook => :on_hook
 
-      callbacks {
-        on_before(:on_hook) { |event| called << "on_before_#{event.name}"}
-        on_enter(:on_hook)  { |event| called << "on_enter_#{event.to}"}
-      }
+      on_before(:on_hook) { |event| called << "on_before_#{event.name}"}
+      on_enter(:on_hook)  { |event| called << "on_enter_#{event.to}"}
     end
     expect(fsm.current).to eq(:on_hook)
     expect(called).to eq([
@@ -893,18 +775,14 @@ RSpec.describe FiniteMachine, 'callbacks' do
 
   it "allows to selectively silence events" do
     called = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :yellow
 
-      events {
-        event :go,   :yellow => :green, silent: true
-        event :stop, :green  => :red
-      }
+      event :go,   :yellow => :green, silent: true
+      event :stop, :green  => :red
 
-      callbacks {
-        on_enter :green do |event| called << 'on_enter_yellow' end
-        on_enter :red   do |event| called << 'on_enter_red' end
-      }
+      on_enter :green do |event| called << 'on_enter_yellow' end
+      on_enter :red   do |event| called << 'on_enter_red' end
     end
     expect(fsm.current).to eq(:yellow)
     fsm.go
@@ -914,22 +792,18 @@ RSpec.describe FiniteMachine, 'callbacks' do
 
   it "executes event-based callbacks even when state does not change" do
     called = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :active
 
-      events {
-        event :advance, :active   => :inactive, if: -> { false }
-        event :advance, :inactive => :active,   if: -> { false }
-      }
-
-      callbacks {
-        on_before do |event|
-          called << "before_#{event.name}_#{event.from}_#{event.to}"
-        end
-        on_after do |event|
-          called << "after_#{event.name}_#{event.from}_#{event.to}"
-        end
-      }
+      event :advance, :active   => :inactive, if: -> { false }
+      event :advance, :inactive => :active,   if: -> { false }
+
+      on_before do |event|
+        called << "before_#{event.name}_#{event.from}_#{event.to}"
+      end
+      on_after do |event|
+        called << "after_#{event.name}_#{event.from}_#{event.to}"
+      end
     end
     expect(fsm.current).to eq(:active)
     fsm.advance
@@ -939,4 +813,39 @@ RSpec.describe FiniteMachine, 'callbacks' do
       'after_advance_active_inactive'
     ])
   end
+
+  it "doesn't transition if error raised in callback" do
+    fsm = FiniteMachine.new do
+      initial :green
+
+      event :slow, :green => :yellow
+
+      on_enter { raise RuntimeError }
+    end
+
+    expect {
+      fsm.slow
+    }.to raise_error(RuntimeError)
+    expect(fsm.current).to eq(:green)
+  end
+
+  xit "narrows down on_transition callback to state transition" do
+    called = []
+    fsm = FiniteMachine.new do
+      initial :red
+
+      event :ready, :red => :yellow
+      event :go, :yellow => :green
+      event :stop, :green => :red
+
+      on_transition :yellow => :green do
+        called << 'on_transition_yellow_green'
+      end
+    end
+
+    fsm.ready
+    fsm.go
+
+    expect(called).to eq(['on_transition_yellow_green'])
+  end
 end