finite_machine 0.11.2 → 0.14.0

data/lib/finite_machine/hooks.rb

@@ -1,92 +1,93 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
+require "concurrent/map"
+
+require_relative "hook_event"
 
 module FiniteMachine
   # A class reponsible for registering callbacks
   class Hooks
-    include Threadable
-
-    attr_threadsafe :collection
+    attr_reader :hooks_map
 
-    # Initialize a collection of hoooks
+    # Initialize a hooks_map of hooks
     #
     # @example
     #   Hoosk.new(machine)
     #
     # @api public
     def initialize
-      @collection = Hash.new do |events_hash, event_type|
-        events_hash[event_type] = Hash.new do |state_hash, name|
+      @hooks_map = Concurrent::Map.new do |events_hash, hook_event|
+        events_hash[hook_event] = Concurrent::Map.new do |state_hash, name|
           state_hash[name] = []
         end
       end
     end
 
-    # Register callback
+    # Finds all hooks for the event type
     #
-    # @param [String] event_type
-    # @param [String] name
-    # @param [Proc]   callback
+    # @param [Symbol] name
     #
     # @example
-    #   hooks.register HookEvent::Enter, :green do ... end
+    #   hooks[HookEvent::Enter][:go] # => [-> { }]
     #
-    # @example
-    #   hooks.register HookEvent::Before, :any do ... end
-    #
-    # @return [Hash]
+    # @return [Array[Transition]]
+    #   the transitions matching event name
     #
     # @api public
-    def register(event_type, name, callback)
-      collection[event_type][name] << callback
+    def find(name)
+      @hooks_map[name]
     end
+    alias [] find
 
-    # Unregister callback
+    # Register callback
     #
-    # @param [String] event_type
+    # @param [String] hook_event
     # @param [String] name
     # @param [Proc]   callback
     #
     # @example
-    #   hooks.unregister HookEvent::Enter, :green do ... end
+    #   hooks.register HookEvent::Enter, :green do ... end
+    #
+    # @example
+    #   hooks.register HookEvent::Before, any_state do ... end
     #
     # @return [Hash]
     #
     # @api public
-    def unregister(event_type, name, callback)
-      callbacks = collection[event_type][name]
-      callbacks.delete(callback)
+    def register(hook_event, name, callback)
+      @hooks_map[hook_event][name] << callback
     end
 
-    # Return all hooks matching event and state
+    # Unregister callback
     #
-    # @param [String] event_type
-    # @param [String] event_state
-    # @param [Event] event
+    # @param [String] hook_event
+    # @param [String] name
+    # @param [Proc]   callback
     #
     # @example
-    #   hooks.call(HookEvent::Enter, :green, Event.new)
+    #   hooks.unregister HookEvent::Enter, :green do ... end
     #
     # @return [Hash]
     #
     # @api public
-    def call(event_type, event_state, &block)
-      collection[event_type][event_state].each(&block)
+    def unregister(hook_event, name, callback)
+      @hooks_map[hook_event][name].delete(callback)
     end
 
-    # Check if collection has any elements
+    # Check if hooks_map has any elements
     #
     # @return [Boolean]
     #
     # @api public
     def empty?
-      collection.empty?
+      @hooks_map.empty?
     end
 
     # Remove all callbacks
     #
     # @api public
     def clear
-      collection.clear
+      @hooks_map.clear
     end
 
     # String representation
@@ -95,7 +96,14 @@ module FiniteMachine
     #
     # @api public
     def to_s
-      self.inspect
+      hash = {}
+      @hooks_map.each_pair do |hook_event, nested_hash|
+        hash[hook_event] = {}
+        nested_hash.each_pair do |name, callbacks|
+          hash[hook_event][name] = callbacks
+        end
+      end
+      hash.to_s
     end
 
     # String representation
@@ -104,7 +112,7 @@ module FiniteMachine
     #
     # @api public
     def inspect
-      "<##{self.class}:0x#{object_id.to_s(16)} @collection=#{collection.inspect}>"
+      "<##{self.class}:0x#{object_id.to_s(16)} @hooks_map=#{self}>"
     end
   end # Hooks
 end # FiniteMachine

data/lib/finite_machine/listener.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module FiniteMachine
   # A generic listener interface
@@ -24,6 +24,6 @@ module FiniteMachine
     def call(*args)
       @on_delivery.call(*args) if @on_delivery
     end
-    alias_method :handle_delivery, :call
+    alias handle_delivery call
   end # Listener
 end # FiniteMachine

data/lib/finite_machine/logger.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module FiniteMachine
   module Logger
@@ -21,21 +21,22 @@ module FiniteMachine
     end
 
     def format_error(error)
-      message = "#{error.class}: #{error.message}\n\t"
+      message = ["#{error.class}: #{error.message}\n\t"]
       if error.backtrace
         message << "occured at #{error.backtrace.join("\n\t")}"
       else
         message << "EMPTY BACKTRACE\n\t"
       end
+      message.join
     end
 
     def report_transition(name, from, to, *args)
-      message = "Transition: @event=#{name} "
+      message = ["Transition: @event=#{name} "]
       unless args.empty?
         message << "@with=[#{args.join(',')}] "
       end
       message << "#{from} -> #{to}"
-      info(message)
+      info(message.join)
     end
   end # Logger
 end # FiniteMachine

data/lib/finite_machine/{event_queue.rb → message_queue.rb}

@@ -1,36 +1,55 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-module FiniteMachine
-  # A class responsible for running asynchronous events
-  class EventQueue
-    include Threadable
+require_relative "listener"
+require "thread"
 
-    # Initialize an event queue
+module FiniteMachine
+  # Allows for storage of asynchronous messages such as events
+  # and callbacks.
+  #
+  # Used internally by {Observer} and {StateMachine}
+  #
+  # @api private
+  class MessageQueue
+    # Initialize an event queue in separate thread
     #
     # @example
-    #  EventQueue.new
+    #   MessageQueue.new
     #
     # @api public
     def initialize
+      @not_empty = ConditionVariable.new
+      @mutex     = Mutex.new
       @queue     = Queue.new
       @dead      = false
       @listeners = []
+      @thread    = nil
+    end
 
+    # Start a new thread with a queue of callback events to run
+    #
+    # @api private
+    def start
+      return if running?
+
+      @mutex.synchronize { spawn_thread }
+    end
+
+    # Spawn new background thread
+    #
+    # @api private
+    def spawn_thread
       @thread = Thread.new do
+        Thread.current.abort_on_exception = true
         process_events
       end
     end
 
-    # Retrieve the next event
-    #
-    # @return [AsyncCall]
-    #
-    # @api private
-    def next_event
-      sync_shared { @queue.pop }
+    def running?
+      !@thread.nil? && alive?
     end
 
-    # Add asynchronous event to the event queue
+    # Add asynchronous event to the event queue to process
     #
     # @example
     #   event_queue << AsyncCall.build(...)
@@ -41,15 +60,21 @@ module FiniteMachine
     #
     # @api public
     def <<(event)
-      sync_exclusive { @queue << event }
-      self
+      @mutex.synchronize do
+        if @dead
+          discard_message(event)
+        else
+          @queue << event
+          @not_empty.signal
+        end
+      end
     end
 
     # Add listener to the queue to receive messages
     #
     # @api public
     def subscribe(*args, &block)
-      sync_exclusive do
+      @mutex.synchronize do
         listener = Listener.new(*args)
         listener.on_delivery(&block)
         @listeners << listener
@@ -63,7 +88,7 @@ module FiniteMachine
     #
     # @api public
     def empty?
-      sync_shared { @queue.empty? }
+      @mutex.synchronize { @queue.empty? }
     end
 
     # Check if the event queue is alive
@@ -75,7 +100,7 @@ module FiniteMachine
     #
     # @api public
     def alive?
-      sync_shared { !@dead }
+      @mutex.synchronize { !@dead }
     end
 
     # Join the event queue from current thread
@@ -89,6 +114,8 @@ module FiniteMachine
     #
     # @api public
     def join(timeout = nil)
+      return unless @thread
+
       timeout.nil? ? @thread.join : @thread.join(timeout)
     end
 
@@ -101,16 +128,18 @@ module FiniteMachine
     #
     # @api public
     def shutdown
-      fail EventQueueDeadError, 'event queue already dead' if @dead
+      raise EventQueueDeadError, "event queue already dead" if @dead
 
       queue = []
-      sync_exclusive do
+      @mutex.synchronize do
+        @dead = true
+        @not_empty.broadcast
+
         queue = @queue
         @queue.clear
-        @dead = true
       end
       while !queue.empty?
-        Logger.debug "Discarded message: #{queue.pop}"
+        discard_message(queue.pop)
       end
       true
     end
@@ -124,20 +153,24 @@ module FiniteMachine
     #
     # @api public
     def size
-      sync_shared { @queue.size }
+      @mutex.synchronize { @queue.size }
+    end
+
+    def inspect
+      @mutex.synchronize do
+        "#<#{self.class}:#{object_id.to_s(16)} @size=#{size}, @dead=#{@dead}>"
+      end
     end
 
     private
 
     # Notify consumers about process event
     #
-    # @param [FiniteMachine::AsyncCall] event
+    # @param [AsyncCall] event
     #
     # @api private
     def notify_listeners(event)
-      sync_shared do
-        @listeners.each { |listener| listener.handle_delivery(event) }
-      end
+      @listeners.each { |listener| listener.handle_delivery(event) }
     end
 
     # Process all the events
@@ -147,12 +180,23 @@ module FiniteMachine
     # @api private
     def process_events
       until @dead
-        event = next_event
-        notify_listeners(event)
-        event.dispatch
+        @mutex.synchronize do
+          while @queue.empty?
+            @not_empty.wait(@mutex)
+          end
+          event = @queue.pop
+          break unless event
+
+          notify_listeners(event)
+          event.dispatch
+        end
       end
     rescue Exception => ex
       Logger.error "Error while running event: #{Logger.format_error(ex)}"
     end
+
+    def discard_message(message)
+      Logger.debug "Discarded message: #{message}" if $DEBUG
+    end
   end # EventQueue
 end # FiniteMachine

data/lib/finite_machine/observer.rb

@@ -1,26 +1,54 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'finite_machine/hooks'
+require_relative "async_call"
+require_relative "callable"
+require_relative "hook_event"
+require_relative "hooks"
+require_relative "message_queue"
+require_relative "safety"
+require_relative "transition_event"
 
 module FiniteMachine
   # A class responsible for observing state changes
-  class Observer
-    include Threadable
+  class Observer < GenericDSL
     include Safety
 
+    # Clean up callback queue
+    #
+    # @api private
+    def self.cleanup_callback_queue
+      proc do
+        begin
+          if callback_queue.alive?
+            callback_queue.shutdown
+          end
+        rescue MessageQueueDeadError
+        end
+      end
+    end
+
     # The current state machine
-    attr_threadsafe :machine
+    attr_reader :machine
 
     # The hooks to trigger around the transition lifecycle.
-    attr_threadsafe :hooks
+    attr_reader :hooks
 
     # Initialize an Observer
     #
+    # @param [StateMachine] machine
+    #   reference to the current machine
+    #
     # @api public
     def initialize(machine)
       @machine = machine
+      @hooks   = Hooks.new
+
       @machine.subscribe(self)
-      @hooks = FiniteMachine::Hooks.new
+      ObjectSpace.define_finalizer(self, self.class.cleanup_callback_queue)
+    end
+
+    def callback_queue
+      @callback_queue ||= MessageQueue.new
     end
 
     # Evaluate in current context
@@ -43,7 +71,7 @@ module FiniteMachine
     def on(hook_type, state_or_event_name = nil, async = nil, &callback)
       sync_exclusive do
         if state_or_event_name.nil?
-          state_or_event_name = HookEvent.infer_default_name(hook_type)
+          state_or_event_name = HookEvent.any_state_or_event(hook_type)
         end
         async = false if async.nil?
         ensure_valid_callback_name!(hook_type, state_or_event_name)
@@ -118,8 +146,9 @@ module FiniteMachine
     def emit(event, *data)
       sync_exclusive do
         [event.type].each do |hook_type|
-          [event.name, ANY_STATE, ANY_EVENT].each do |event_name|
-            hooks.call(hook_type, event_name) do |hook|
+          any_state_or_event = HookEvent.any_state_or_event(hook_type)
+          [any_state_or_event, event.name].each do |event_name|
+            hooks[hook_type][event_name].each do |hook|
               handle_callback(hook, event, *data)
               off(hook_type, event_name, &hook) if hook.is_a?(Once)
             end
@@ -128,26 +157,21 @@ module FiniteMachine
       end
     end
 
-    private
-
-    # Defer callback execution
+    # Cancel the current event
     #
-    # @api private
-    def defer(callable, trans_event, *data)
-      async_call = AsyncCall.new(machine, callable, trans_event, *data)
-      machine.event_queue << async_call
-    end
-
-    # Create callable instance
+    # This should be called inside a on_before or on_exit callbacks
+    # to prevent event transition.
     #
-    # @api private
-    def create_callable(hook)
-      callback = proc do |trans_event, *data|
-        machine.instance_exec(trans_event, *data, &hook)
-      end
-      Callable.new(callback)
+    # @param [String] msg
+    #   the message used for failure
+    #
+    # @api public
+    def cancel_event(msg = nil)
+      raise CallbackError.new(msg)
     end
 
+    private
+
     # Handle callback and decide if run synchronously or asynchronously
     #
     # @param [Proc] :hook
@@ -160,21 +184,34 @@ module FiniteMachine
     #
     # @api private
     def handle_callback(hook, event, *data)
-      to = machine.events_chain.move_to(event.event_name, event.from, *data)
-      trans_event = TransitionEvent.new(event, to)
+      to = machine.events_map.move_to(event.event_name, event.from, *data)
+      trans_event = TransitionEvent.new(event.event_name, event.from, to)
       callable    = create_callable(hook)
 
       if hook.is_a?(Async)
         defer(callable, trans_event, *data)
-        result = nil
       else
-        result = callable.call(trans_event, *data)
+        callable.(trans_event, *data)
       end
+    end
+
+    # Defer callback execution
+    #
+    # @api private
+    def defer(callable, trans_event, *data)
+      async_call = AsyncCall.new(machine, callable, trans_event, *data)
+      callback_queue.start unless callback_queue.running?
+      callback_queue << async_call
+    end
 
-      if result == CANCELLED
-        hooks.clear
-        machine.events_chain.cancel_transitions(event.event_name)
+    # Create callable instance
+    #
+    # @api private
+    def create_callable(hook)
+      callback = proc do |trans_event, *data|
+        machine.instance_exec(trans_event, *data, &hook)
       end
+      Callable.new(callback)
     end
 
     # Callback names including all states and events
@@ -184,7 +221,7 @@ module FiniteMachine
     #
     # @api private
     def callback_names
-      machine.states + machine.event_names + [ANY_EVENT, ANY_STATE]
+      machine.states + machine.events + [ANY_EVENT, ANY_STATE]
     end
 
     # Forward the message to observer