observer.rb in finite_machine-0.11.0

- old
+ new

@@ -1,8 +1,8 @@
 # encoding: utf-8
 
-require 'set'
+require 'finite_machine/hooks'
 
 module FiniteMachine
   # A class responsible for observing state changes
   class Observer
     include Threadable
@@ -102,19 +102,26 @@
 
     def once_on_after(*args, &callback)
       on HookEvent::After, *args, &callback.extend(Once)
     end
 
-    # Trigger all listeners
+    # Execute each of the hooks in order with supplied data
     #
+    # @param [HookEvent] event
+    #   the hook event
+    #
+    # @param [Array[Object]] data
+    #
+    # @return [nil]
+    #
     # @api public
-    def trigger(event, *args, &block)
+    def emit(event, *data)
       sync_exclusive do
         [event.type].each do |event_type|
           [event.name, ANY_STATE, ANY_EVENT].each do |event_name|
             hooks.call(event_type, event_name) do |hook|
-              handle_callback(hook, event)
+              handle_callback(hook, event, *data)
               off(event_type, event_name, &hook) if hook.is_a?(Once)
             end
           end
         end
       end
@@ -132,31 +139,40 @@
 
     # Create callable instance
     #
     # @api private
     def create_callable(hook)
-      deferred_hook = proc do |_trans_event, *_data|
-        machine.instance_exec(_trans_event, *_data, &hook)
+      callback = proc do |trans_event, *data|
+        machine.instance_exec(trans_event, *data, &hook)
       end
-      Callable.new(deferred_hook)
+      Callable.new(callback)
     end
 
     # Handle callback and decide if run synchronously or asynchronously
     #
+    # @param [Proc] :hook
+    #   The hook to evaluate
+    #
+    # @param [HookEvent] :event
+    #   The event for which the hook is called
+    #
+    # @param [Array[Object]] :data
+    #
     # @api private
-    def handle_callback(hook, event)
-      data        = event.data
-      trans_event = TransitionEvent.new(event.transition, *data)
+    def handle_callback(hook, event, *data)
+      to = machine.events_chain.move_to(event.event_name, event.from, *data)
+      trans_event = TransitionEvent.new(event, to)
       callable    = create_callable(hook)
 
       if hook.is_a?(Async)
         defer(callable, trans_event, *data)
         result = nil
       else
         result = callable.call(trans_event, *data)
       end
 
-      event.transition.cancelled = (result == CANCELLED)
+      machine.events_chain.cancel_transitions(event.event_name,
+                                              (result == CANCELLED))
     end
 
     # Callback names including all states and events
     #
     # @return [Array[Symbol]]