finite_machine 0.6.1 → 0.7.0

data/lib/finite_machine/state_parser.rb

@@ -21,18 +21,21 @@ module FiniteMachine
 
     # Extract states from attributes
     #
+    # @param [Proc] block
+    #
     # @example
     #   StateParpser.new(attr).parase_states
     #
     # @return [Hash[Symbol]] states
     #
     # @api public
-    def parse_states
-      if contains_from_to_keys?
+    def parse_states(&block)
+      transitions = if contains_from_to_keys?
         convert_from_to_attributes_to_states_hash
       else
         convert_attributes_to_states_hash
       end
+      block ? transitions.each(&block) : transitions
     end
 
     # Check if attributes contain :from or :to key

data/lib/finite_machine/transition.rb

@@ -4,6 +4,7 @@ module FiniteMachine
   # Class describing a transition associated with a given event
   class Transition
     include Threadable
+    include Safety
 
     attr_threadsafe :name
 
@@ -37,7 +38,7 @@ module FiniteMachine
     def initialize(machine, attrs = {})
       @machine     = machine
       @name        = attrs.fetch(:name, DEFAULT_STATE)
-      @map         = FiniteMachine::StateParser.new(attrs).parse_states
+      @map         = attrs.fetch(:parsed_states, {})
       @from_states = @map.keys
       @to_states   = @map.values
       @from_state  = @from_states.first
@@ -47,6 +48,25 @@ module FiniteMachine
       @cancelled   = false
     end
 
+    # Create transition with associated helper methods
+    #
+    # @param [FiniteMachine::StateMachine] machine
+    # @param [Hash] attrs
+    #
+    # @example
+    #   Transition.create(machine, {})
+    #
+    # @return [FiniteMachine::Transition]
+    #
+    # @api public
+    def self.create(machine, attrs = {})
+      _transition = self.new(machine, attrs)
+      _transition.update_transitions
+      _transition.define_state_methods
+      _transition.define_event
+      _transition
+    end
+
     # Decide :to state from available transitions for this event
     #
     # @return [Symbol]
@@ -64,7 +84,7 @@ module FiniteMachine
         @unless.map { |c| Callable.new(c).invert }
     end
 
-    # Check if moved to different state
+    # Check if moved to different state or not
     #
     # @param [Symbol] state
     #   the current state name
@@ -72,8 +92,23 @@ module FiniteMachine
     # @return [Boolean]
     #
     # @api public
-    def different?(state)
-      map[state] == state || map[ANY_STATE] == state
+    def same?(state)
+      map[state] == state || (map[ANY_STATE] == state && from_state == state)
+    end
+
+    # Check if transition can be performed according to constraints
+    #
+    # @param [Array] args
+    #
+    # @param [Proc] block
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def valid?(*args, &block)
+      conditions.all? do |condition|
+        condition.call(machine.target, *args, &block)
+      end
     end
 
     # Add transition to the machine
@@ -81,7 +116,7 @@ module FiniteMachine
     # @return [Transition]
     #
     # @api private
-    def define
+    def update_transitions
       from_states.each do |from|
         machine.transitions[name][from] = map[from] || ANY_STATE
       end
@@ -110,24 +145,25 @@ module FiniteMachine
     #
     # @api private
     def define_event
-      _name       = name
-      bang_name   = "#{_name}!"
-
-      machine.singleton_class.class_eval do
-        undef_method(_name)     if method_defined?(_name)
-        undef_method(bang_name) if method_defined?(bang_name)
+      detect_event_conflict!(name)
+      if machine.singleton_class.send(:method_defined?, name)
+        machine.events_chain[name] << self
+      else
+        define_event_transition(name)
+        define_event_bang(name)
       end
-      define_transition(name)
-      define_event_bang(name)
     end
 
     # Define transition event
     #
     # @api private
-    def define_transition(name)
-      _transition = self
+    def define_event_transition(name)
+      _event = FiniteMachine::Event.new(machine, name: name)
+      _event << self
+      machine.events_chain[name] = _event
+
       machine.send(:define_singleton_method, name) do |*args, &block|
-        transition(_transition, *args, &block)
+        _event.call(*args, &block)
       end
     end
 
@@ -158,6 +194,8 @@ module FiniteMachine
 
     # Return transition name
     #
+    # @return [String]
+    #
     # @api public
     def to_s
       @name.to_s

data/lib/finite_machine/version.rb

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

data/spec/unit/async_events_spec.rb

@@ -79,10 +79,10 @@ describe FiniteMachine, 'async_events' do
       }
 
       callbacks {
-        on_enter :green,  :async  do |event| called << 'on_enter_green' end
-        on_enter :slow,   :async  do |event| called << 'on_enter_slow'  end
-        on_exit  :yellow, :async  do |event| called << 'on_exit_yellow' end
-        on_exit  :go,     :async  do |event| called << 'on_exit_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
@@ -90,8 +90,8 @@ describe FiniteMachine, 'async_events' do
     sleep 0.1
     expect(called).to match_array([
       'on_enter_green',
-      'on_enter_slow',
-      'on_exit_go',
+      'on_before_slow',
+      'on_after_go',
       'on_exit_yellow'
     ])
   end

data/spec/unit/callbacks_spec.rb

@@ -9,26 +9,15 @@ describe FiniteMachine, 'callbacks' do
     fsm = FiniteMachine.define do
       initial state: :green, defer: true
 
-      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_enter_state do |event| called << 'on_enter_state' end
-        on_enter_event do |event| called << 'on_enter_event' end
-
-        on_transition       do |event| called << 'on_transition' end
-        on_transition_state do |event| called << 'on_transition_state' end
-        on_transition_event do |event| called << 'on_transition_event' 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
-        on_exit_state do |event| called << 'on_exit_state' end
-        on_exit_event do |event| called << 'on_exit_event' end
+
+        # generic event callbacks
+        on_before 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
@@ -41,33 +30,24 @@ describe FiniteMachine, 'callbacks' do
         on_exit :green do |event| called << 'on_exit_green' end
 
         # event callbacks
-        on_enter      :init do |event| called << 'on_enter_init' end
-        on_transition :init do |event| called << 'on_transition_init' end
-        on_exit       :init do |event| called << 'on_exit_init' end
+        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_exit',
-      'on_exit_state',
-      'on_enter_init',
-      'on_enter',
-      'on_enter_event',
       'on_transition_green',
       'on_transition',
-      'on_transition_state',
-      'on_transition_init',
-      'on_transition',
-      'on_transition_event',
       'on_enter_green',
       'on_enter',
-      'on_enter_state',
-      'on_exit_init',
-      'on_exit',
-      'on_exit_event'
+      'on_after_init',
+      'on_after'
     ])
   end
 
@@ -85,17 +65,12 @@ describe FiniteMachine, 'callbacks' do
 
       callbacks {
         # generic callbacks
-        on_enter       do |event| called << 'on_enter' end
-        on_enter_state do |event| called << 'on_enter_state' end
-        on_enter_event do |event| called << 'on_enter_event' end
-
-        on_transition       do |event| called << 'on_transition' end
-        on_transition_state do |event| called << 'on_transition_state' end
-        on_transition_event do |event| called << 'on_transition_event' end
-
+        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_exit_state do |event| called << 'on_exit_state' end
-        on_exit_event do |event| called << 'on_exit_event' 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
@@ -111,113 +86,105 @@ describe FiniteMachine, 'callbacks' do
         on_exit :red    do |event| called << "on_exit_red" end
 
         # event callbacks
-        on_enter :slow  do |event| called << 'on_enter_slow' end
-        on_enter :stop  do |event| called << "on_enter_stop" end
-        on_enter :ready do |event| called << "on_enter_ready" end
-        on_enter :go    do |event| called << "on_enter_go" end
-
-        on_transition :slow  do |event| called << 'on_transition_slow' end
-        on_transition :stop  do |event| called << "on_transition_stop" end
-        on_transition :ready do |event| called << "on_transition_ready" end
-        on_transition :go    do |event| called << "on_transition_go" end
-
-        on_exit :slow  do |event| called << 'on_exit_slow' end
-        on_exit :stop  do |event| called << "on_exit_stop" end
-        on_exit :ready do |event| called << "on_exit_ready" end
-        on_exit :go    do |event| called << "on_exit_go" end
+        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
 
     called = []
     fsm.slow
     expect(called).to eql([
+      'on_before_slow',
+      'on_before',
       'on_exit_green',
       'on_exit',
-      'on_exit_state',
-      'on_enter_slow',
-      'on_enter',
-      'on_enter_event',
       'on_transition_yellow',
       'on_transition',
-      'on_transition_state',
-      'on_transition_slow',
-      'on_transition',
-      'on_transition_event',
       'on_enter_yellow',
       'on_enter',
-      'on_enter_state',
-      'on_exit_slow',
-      'on_exit',
-      'on_exit_event'
+      'on_after_slow',
+      'on_after'
     ])
 
     called = []
     fsm.stop
     expect(called).to eql([
+      'on_before_stop',
+      'on_before',
       'on_exit_yellow',
       'on_exit',
-      'on_exit_state',
-      'on_enter_stop',
-      'on_enter',
-      'on_enter_event',
       'on_transition_red',
       'on_transition',
-      'on_transition_state',
-      'on_transition_stop',
-      'on_transition',
-      'on_transition_event',
       'on_enter_red',
       'on_enter',
-      'on_enter_state',
-      'on_exit_stop',
-      'on_exit',
-      'on_exit_event'
+      'on_after_stop',
+      'on_after'
     ])
 
     called = []
     fsm.ready
     expect(called).to eql([
+      'on_before_ready',
+      'on_before',
       'on_exit_red',
       'on_exit',
-      'on_exit_state',
-      'on_enter_ready',
-      'on_enter',
-      'on_enter_event',
       'on_transition_yellow',
       'on_transition',
-      'on_transition_state',
-      'on_transition_ready',
-      'on_transition',
-      'on_transition_event',
       'on_enter_yellow',
       'on_enter',
-      'on_enter_state',
-      'on_exit_ready',
-      'on_exit',
-      'on_exit_event'
+      'on_after_ready',
+      'on_after'
     ])
 
     called = []
     fsm.go
     expect(called).to eql([
+      'on_before_go',
+      'on_before',
       'on_exit_yellow',
       'on_exit',
-      'on_exit_state',
-      'on_enter_go',
-      'on_enter',
-      'on_enter_event',
       'on_transition_green',
       'on_transition',
-      'on_transition_state',
-      'on_transition_go',
-      'on_transition',
-      'on_transition_event',
       'on_enter_green',
       'on_enter',
-      'on_enter_state',
-      'on_exit_go',
-      'on_exit',
-      'on_exit_event'
+      'on_after_go',
+      'on_after'
+    ])
+  end
+
+  it "maintains transition execution sequence from UML statechart" do
+    called = []
+    fsm = FiniteMachine.define do
+      initial :previous
+
+      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}" }
+      }
+    end
+    expect(fsm.current).to eq(:previous)
+    fsm.go
+    expect(called).to eq([
+      'before_go',
+      'guard',
+      'exit_previous',
+      'transition_previous_next',
+      'enter_next',
+      'after_go'
     ])
   end
 
@@ -234,26 +201,28 @@ describe FiniteMachine, 'callbacks' do
       }
 
       callbacks {
-        # generic 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_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_enter      :slow do |event| called << 'on_enter_slow_1' end
-        on_enter      :slow do |event| called << 'on_enter_slow_2' end
-        on_transition :slow do |event| called << 'on_transition_slow_1' end
-        on_transition :slow do |event| called << 'on_transition_slow_2' end
-        on_exit       :slow do |event| called << 'on_exit_slow_1' end
-        on_exit       :slow do |event| called << 'on_exit_slow_2' end
+        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
 
@@ -261,24 +230,21 @@ describe FiniteMachine, 'callbacks' do
     fsm.slow
     expect(fsm.current).to eql(:yellow)
     expect(called).to eql([
+      'on_before_slow_1',
+      'on_before_slow_2',
+      'on_before',
       'on_exit_green_1',
       'on_exit_green_2',
       'on_exit',
-      'on_enter_slow_1',
-      'on_enter_slow_2',
-      'on_enter',
       'on_transition_yellow_1',
       'on_transition_yellow_2',
       'on_transition',
-      'on_transition_slow_1',
-      'on_transition_slow_2',
-      'on_transition',
       'on_enter_yellow_1',
       'on_enter_yellow_2',
       'on_enter',
-      'on_exit_slow_1',
-      'on_exit_slow_2',
-      'on_exit'
+      'on_after_slow_1',
+      'on_after_slow_2',
+      'on_after'
     ])
   end
 
@@ -301,9 +267,8 @@ describe FiniteMachine, 'callbacks' do
         on_transition_yellow do |event| called << 'on_transition_yellow' end
 
         # event callbacks
-        on_enter_slow do |event| called << 'on_enter_slow' end
-        on_transition_slow do |event| called << 'on_transition_slow' end
-        on_exit_slow do |event| called << 'on_exit_slow' end
+        on_before_slow do |event| called << 'on_before_slow' end
+        on_after_slow do |event| called << 'on_after_slow' end
       }
     end
 
@@ -311,18 +276,16 @@ describe FiniteMachine, 'callbacks' do
     fsm.slow
     expect(fsm.current).to eql(:yellow)
     expect(called).to eql([
+      'on_before_slow',
       'on_exit_green',
-      'on_enter_slow',
       'on_transition_yellow',
-      'on_transition_slow',
       'on_enter_yellow',
-      'on_exit_slow'
+      'on_after_slow'
     ])
   end
 
   it "passes event object to callback" do
     evt = nil
-
     fsm = FiniteMachine.define do
       initial :green
 
@@ -346,7 +309,6 @@ describe FiniteMachine, 'callbacks' do
 
   it "identifies the from state for callback event parameter" do
     evt = nil
-
     fsm = FiniteMachine.define do
       initial :green
 
@@ -395,11 +357,15 @@ describe FiniteMachine, 'callbacks' do
       }
 
       callbacks {
-        # generic 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
@@ -414,20 +380,15 @@ describe FiniteMachine, 'callbacks' do
         on_exit :red   , &callback
 
         # event callbacks
-        on_enter :slow , &callback
-        on_enter :stop , &callback
-        on_enter :ready, &callback
-        on_enter :go   , &callback
-
-        on_transition :slow , &callback
-        on_transition :stop , &callback
-        on_transition :ready, &callback
-        on_transition :go   , &callback
-
-        on_exit :slow , &callback
-        on_exit :stop , &callback
-        on_exit :ready, &callback
-        on_exit :go   , &callback
+        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
 
@@ -457,7 +418,27 @@ describe FiniteMachine, 'callbacks' do
           on_enter(:magic) { |event| called << 'on_enter'}
         }
       end
-    }.to raise_error(FiniteMachine::InvalidCallbackNameError, /magic is not a valid callback name/)
+    }.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 }
+
+        callbacks { 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 }
+
+        callbacks { 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
@@ -484,8 +465,8 @@ describe FiniteMachine, 'callbacks' do
       }
 
       callbacks {
-        on_enter_stop do |event|
-          called << 'on_enter_stop'
+        on_before_stop do |event|
+          called << 'on_before_stop'
         end
       }
     end
@@ -495,8 +476,8 @@ describe FiniteMachine, 'callbacks' do
     fsm.stop
     expect(fsm.current).to eql(:red)
     expect(called).to eql([
-      'on_enter_stop',
-      'on_enter_stop'
+      'on_before_stop',
+      'on_before_stop'
     ])
   end
 
@@ -552,6 +533,7 @@ describe FiniteMachine, 'callbacks' do
       }
 
       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
 
@@ -560,6 +542,13 @@ describe FiniteMachine, 'callbacks' do
 
         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_slow do |event| called << 'once_on_before_slow' end
+        once_on_before_go   do |event| called << 'once_on_before_go' 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)
@@ -570,12 +559,16 @@ describe FiniteMachine, 'callbacks' do
     fsm.slow
     expect(fsm.current).to eql(:yellow)
     expect(called).to eql([
+      'once_on_before_slow',
       'once_on_exit_green',
       'once_on_transition_yellow',
       'once_on_enter_yellow',
+      'once_on_after_slow',
+      'once_on_before_go',
       'once_on_exit_yellow',
       'once_on_transition_green',
-      'once_on_enter_green'
+      'once_on_enter_green',
+      'once_on_after_go'
     ])
   end
 
@@ -633,35 +626,53 @@ describe FiniteMachine, 'callbacks' do
       }
 
       callbacks {
-        on_enter_state do |event|
-          callbacks << "enter_state_#{event.name}_#{event.from}_#{event.to}"
+        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_enter_event do |event|
-          callbacks << "enter_event_#{event.name}_#{event.from}_#{event.to}"
+        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([
-      'enter_event_bump_initial_low',
-      'enter_state_bump_initial_low'
+      'before_bump_initial_low',
+      'exit_bump_initial_low',
+      'enter_bump_initial_low',
+      'after_bump_initial_low'
     ])
     fsm.bump
     expect(callbacks).to eq([
-      'enter_event_bump_initial_low',
-      'enter_state_bump_initial_low',
-      'enter_event_bump_low_medium',
-      'enter_state_bump_low_medium'
+      'before_bump_initial_low',
+      'exit_bump_initial_low',
+      'enter_bump_initial_low',
+      'after_bump_initial_low',
+      'before_bump_low_medium',
+      'exit_bump_low_medium',
+      'enter_bump_low_medium',
+      'after_bump_low_medium'
     ])
     fsm.bump
     expect(callbacks).to eq([
-      'enter_event_bump_initial_low',
-      'enter_state_bump_initial_low',
-      'enter_event_bump_low_medium',
-      'enter_state_bump_low_medium',
-      'enter_event_bump_medium_high',
-      'enter_state_bump_medium_high'
+      'before_bump_initial_low',
+      'exit_bump_initial_low',
+      'enter_bump_initial_low',
+      'after_bump_initial_low',
+      'before_bump_low_medium',
+      'exit_bump_low_medium',
+      'enter_bump_low_medium',
+      'after_bump_low_medium',
+      'before_bump_medium_high',
+      'exit_bump_medium_high',
+      'enter_bump_medium_high',
+      'after_bump_medium_high'
     ])
   end
 
@@ -677,35 +688,35 @@ describe FiniteMachine, 'callbacks' do
       }
 
       callbacks {
-        on_enter_state do |event|
-          callbacks << "enter_state_#{event.name}_#{event.from}_#{event.to}"
+        on_enter do |event|
+          callbacks << "enter_#{event.name}_#{event.from}_#{event.to}"
         end
-        on_enter_event do |event|
-          callbacks << "enter_event_#{event.name}_#{event.from}_#{event.to}"
+        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([
-      'enter_event_bump_initial_low',
-      'enter_state_bump_initial_low'
+      'before_bump_initial_low',
+      'enter_bump_initial_low'
     ])
     fsm.bump
     expect(callbacks).to eq([
-      'enter_event_bump_initial_low',
-      'enter_state_bump_initial_low',
-      'enter_event_bump_low_medium',
-      'enter_state_bump_low_medium'
+      'before_bump_initial_low',
+      'enter_bump_initial_low',
+      'before_bump_low_medium',
+      'enter_bump_low_medium'
     ])
     fsm.bump
     expect(callbacks).to eq([
-      'enter_event_bump_initial_low',
-      'enter_state_bump_initial_low',
-      'enter_event_bump_low_medium',
-      'enter_state_bump_low_medium',
-      'enter_event_bump_medium_high',
-      'enter_state_bump_medium_high'
+      'before_bump_initial_low',
+      'enter_bump_initial_low',
+      'before_bump_low_medium',
+      'enter_bump_low_medium',
+      'before_bump_medium_high',
+      'enter_bump_medium_high'
     ])
   end
 end