finite_machine 0.11.3 → 0.12.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/message_queue.rb

@@ -1,4 +1,7 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
+require_relative 'listener'
+require 'thread'
 
 module FiniteMachine
   # Allows for storage of asynchronous messages such as events
@@ -8,15 +11,15 @@ module FiniteMachine
   #
   # @api private
   class MessageQueue
-    include Threadable
-
-    # Initialize an event queue
+    # Initialize an event queue in separate thread
     #
     # @example
     #   MessageQueue.new
     #
     # @api public
     def initialize
+      @not_empty = ConditionVariable.new
+      @mutex     = Mutex.new
       @queue     = Queue.new
       @dead      = false
       @listeners = []
@@ -28,7 +31,13 @@ module FiniteMachine
     # @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
@@ -39,16 +48,7 @@ module FiniteMachine
       !@thread.nil? && alive?
     end
 
-    # Retrieve the next event
-    #
-    # @return [AsyncCall]
-    #
-    # @api private
-    def next_event
-      sync_shared { @queue.pop }
-    end
-
-    # Add asynchronous event to the event queue
+    # Add asynchronous event to the event queue to process
     #
     # @example
     #   event_queue << AsyncCall.build(...)
@@ -59,21 +59,21 @@ module FiniteMachine
     #
     # @api public
     def <<(event)
-      sync_exclusive do
+      @mutex.synchronize do
         if @dead
           discard_message(event)
         else
           @queue << event
+          @not_empty.signal
         end
       end
-      self
     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
@@ -87,7 +87,7 @@ module FiniteMachine
     #
     # @api public
     def empty?
-      sync_shared { @queue.empty? }
+      @mutex.synchronize { @queue.empty? }
     end
 
     # Check if the event queue is alive
@@ -99,7 +99,7 @@ module FiniteMachine
     #
     # @api public
     def alive?
-      sync_shared { !@dead }
+      @mutex.synchronize { !@dead }
     end
 
     # Join the event queue from current thread
@@ -129,10 +129,12 @@ module FiniteMachine
       fail 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?
         discard_message(queue.pop)
@@ -149,24 +151,24 @@ module FiniteMachine
     #
     # @api public
     def size
-      sync_shared { @queue.size }
+      @mutex.synchronize { @queue.size }
     end
 
     def inspect
-      "#<#{self.class}:#{object_id.to_s(16)} @size=#{size}, @dead=#{@dead}>"
+      @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
@@ -176,9 +178,16 @@ module FiniteMachine
     # @api private
     def process_events
       until @dead
-        event = next_event
-        notify_listeners(event)
-        event.dispatch
+        @mutex.synchronize do
+          while @queue.empty?
+            break if @dead
+            @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)}"

data/lib/finite_machine/observer.rb

@@ -1,18 +1,37 @@
-# 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
     #
@@ -21,12 +40,15 @@ module FiniteMachine
     #
     # @api public
     def initialize(machine)
-      @machine        = machine
-      @hooks          = FiniteMachine::Hooks.new
-      @callback_queue = MessageQueue.new
+      @machine = machine
+      @hooks   = Hooks.new
 
       @machine.subscribe(self)
-      ObjectSpace.define_finalizer(self, self.class.cleanup(@callback_queue))
+      ObjectSpace.define_finalizer(self, self.class.cleanup_callback_queue)
+    end
+
+    def callback_queue
+      @callback_queue ||= MessageQueue.new
     end
 
     # Evaluate in current context
@@ -49,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)
@@ -124,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
@@ -134,6 +157,19 @@ module FiniteMachine
       end
     end
 
+    # Cancel the current event
+    #
+    # This should be called inside a on_before or on_exit callbacks
+    # to prevent event transition.
+    #
+    # @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
@@ -148,20 +184,14 @@ 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)
-      end
-
-      if result == CANCELLED
-        hooks.clear
-        machine.events_chain.cancel_transitions(event.event_name)
+        callable.(trans_event, *data)
       end
     end
 
@@ -170,8 +200,8 @@ module FiniteMachine
     # @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
+      callback_queue.start unless callback_queue.running?
+      callback_queue << async_call
     end
 
     # Create callable instance
@@ -191,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
@@ -225,17 +255,5 @@ module FiniteMachine
       *_, callback_name = *method_name.to_s.match(/^(\w*?on_\w+?)_(\w+)$/)
       callback_name && callback_names.include?(:"#{callback_name}")
     end
-
-    # Clean up callback queue
-    #
-    # @api private
-    def self.cleanup(queue)
-      proc do
-        begin
-          queue && queue.shutdown
-        rescue MessageQueueDeadError
-        end
-      end
-    end
   end # Observer
 end # FiniteMachine