finite_machine 0.11.2 → 0.14.0

data/lib/finite_machine/env.rb

@@ -1,4 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
+require_relative "threadable"
 
 module FiniteMachine
   # Holds references to targets and aliases
@@ -11,7 +13,7 @@ module FiniteMachine
 
     attr_threadsafe :aliases
 
-    def initialize(target, aliases)
+    def initialize(target, aliases = [])
       @target = target
       @aliases = aliases
     end

data/lib/finite_machine/event_definition.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module FiniteMachine
   # A class responsible for defining event methods on state machine
@@ -8,10 +8,8 @@ module FiniteMachine
   #
   # @api private
   class EventDefinition
-    include Threadable
-
     # The current state machine
-    attr_threadsafe :machine
+    attr_reader :machine
 
     # Initialize an EventDefinition
     #
@@ -19,7 +17,7 @@ module FiniteMachine
     #
     # @api private
     def initialize(machine)
-      self.machine = machine
+      @machine = machine
     end
 
     # Define transition event names as state machine events
@@ -50,11 +48,8 @@ module FiniteMachine
     # @api private
     def define_event_transition(event_name, silent)
       machine.send(:define_singleton_method, event_name) do |*data, &block|
-        if silent
-          machine.transition(event_name, *data, &block)
-        else
-          machine.trigger(event_name, *data, &block)
-        end
+        method = silent ? :transition : :trigger
+        machine.public_send(method, event_name, *data, &block)
       end
     end
 
@@ -71,11 +66,8 @@ module FiniteMachine
     # @api private
     def define_event_bang(event_name, silent)
       machine.send(:define_singleton_method, "#{event_name}!") do |*data, &block|
-        if silent
-          machine.transition!(event_name, *data, &block)
-        else
-          machine.trigger!(event_name, *data, &block)
-        end
+        method = silent ? :transition! : :trigger!
+        machine.public_send(method, event_name, *data, &block)
       end
     end
   end # EventBuilder

data/lib/finite_machine/{events_chain.rb → events_map.rb}

@@ -1,35 +1,34 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'finite_machine/undefined_transition'
+require "concurrent/map"
+require "forwardable"
+
+require_relative "threadable"
+require_relative "undefined_transition"
 
 module FiniteMachine
-  # A class responsible for storing chain of events.
+  # A class responsible for storing mappings between event namess and
+  # their transition objects.
   #
   # Used internally by {StateMachine}.
   #
   # @api private
-  class EventsChain
-    include Threadable
+  class EventsMap
     extend Forwardable
 
-    # The chain of events
-    #
-    # @api private
-    attr_threadsafe :chain
-
-    def_delegators :@chain, :empty?, :size
+    def_delegators :@events_map, :empty?, :size
 
-    # Initialize a EventsChain
+    # Initialize a EventsMap
     #
     # @api private
     def initialize
-      @chain = {}
+      @events_map = Concurrent::Map.new
     end
 
     # Check if event is present
     #
     # @example
-    #   events_chain.exists?(:go) # => true
+    #   events_map.exists?(:go) # => true
     #
     # @param [Symbol] name
     #   the event name
@@ -39,7 +38,7 @@ module FiniteMachine
     #
     # @api public
     def exists?(name)
-      !chain[name].nil?
+      @events_map.key?(name)
     end
 
     # Add transition under name
@@ -54,9 +53,9 @@ module FiniteMachine
     # @api public
     def add(name, transition)
       if exists?(name)
-        chain[name] << transition
+        @events_map[name] << transition
       else
-        chain[name] = [transition]
+        @events_map[name] = [transition]
       end
       self
     end
@@ -66,41 +65,41 @@ module FiniteMachine
     # @param [Symbol] name
     #
     # @example
-    #   events_chain[:start] # => []
+    #   events_map[:start] # => []
     #
     # @return [Array[Transition]]
     #   the transitions matching event name
     #
     # @api public
     def find(name)
-      chain.fetch(name) { [] }
+      @events_map.fetch(name) { [] }
     end
-    alias_method :[], :find
+    alias [] find
 
     # Retrieve all event names
     #
     # @example
-    #   events_chain.events # => [:init, :start, :stop]
+    #   events_map.events # => [:init, :start, :stop]
     #
     # @return [Array[Symbol]]
     #   All event names
     #
     # @api public
     def events
-      chain.keys
+      @events_map.keys
     end
 
     # Retreive all unique states
     #
     # @example
-    #   events_chain.states # => [:yellow, :green, :red]
+    #   events_map.states # => [:yellow, :green, :red]
     #
     # @return [Array[Symbol]]
     #   the array of all unique states
     #
     # @api public
     def states
-      chain.values.flatten.map(&:states).map(&:to_a).flatten.uniq
+      @events_map.values.flatten.map(&:states).map(&:to_a).flatten.uniq
     end
 
     # Retrieves all state transitions
@@ -109,7 +108,7 @@ module FiniteMachine
     #
     # @api public
     def state_transitions
-      chain.values.flatten.map(&:states)
+      @events_map.values.flatten.map(&:states)
     end
 
     # Retrieve from states for the event name
@@ -117,7 +116,7 @@ module FiniteMachine
     # @param [Symbol] event_name
     #
     # @example
-    #   events_chain.states_for(:start) # => [:yellow, :green]
+    #   events_map.states_for(:start) # => [:yellow, :green]
     #
     # @api public
     def states_for(name)
@@ -136,7 +135,7 @@ module FiniteMachine
     # Check if event has branching choice transitions or not
     #
     # @example
-    #   events_chain.choice_transition?(:go, :green) # => true
+    #   events_map.choice_transition?(:go, :green) # => true
     #
     # @param [Symbol] name
     #   the event name
@@ -183,8 +182,7 @@ module FiniteMachine
     # @api public
     def match_transition_with(name, from_state, *conditions)
       find(name).find do |trans|
-        trans.matches?(from_state) &&
-        trans.check_conditions(*conditions)
+        trans.matches?(from_state) && trans.check_conditions(*conditions)
       end
     end
 
@@ -211,7 +209,7 @@ module FiniteMachine
     # Find state that this machine can move to
     #
     # @example
-    #   evenst_chain.move_to(:go, :green) # => :red
+    #   evenst_map.move_to(:go, :green) # => :red
     #
     # @param [Symbol] name
     #   the event name
@@ -229,53 +227,42 @@ module FiniteMachine
     def move_to(name, from_state, *conditions)
       transition = select_transition(name, from_state, *conditions)
       transition ||= UndefinedTransition.new(name)
-
       transition.to_state(from_state)
     end
 
-    # Set status to cancelled for all transitions matching event name
-    #
-    # @param [Symbol] name
-    #   the event name
-    #
-    # @return [nil]
-    #
-    # @api public
-    def cancel_transitions(name)
-      chain[name].each do |trans|
-        trans.cancelled = true
-      end
-    end
-
-    # Reset chain
+    # Reset map
     #
     # @return [self]
     #
     # @api public
     def clear
-      @chain.clear
+      @events_map.clear
       self
     end
 
-    # Return string representation of this chain
+    # Return string representation of this map
     #
     # @return [String]
     #
     # @api public
     def to_s
-      chain.to_s
+      hash = {}
+      @events_map.each_pair do |name, trans|
+        hash[name] = trans
+      end
+      hash.to_s
     end
 
-    # Inspect chain content
+    # Inspect map content
     #
     # @example
-    #   events_chain.inspect
+    #   events_map.inspect
     #
     # @return [String]
     #
     # @api public
     def inspect
-      "<##{self.class} @chain=#{chain.inspect}>"
+      "<##{self.class} @events_map=#{self}>"
     end
-  end # EventsChain
+  end # EventsMap
 end # FiniteMachine

data/lib/finite_machine/hook_event.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module FiniteMachine
   # A class responsible for event notification
   class HookEvent
-    include Threadable
     include Comparable
 
     class Anystate < HookEvent; end
@@ -24,38 +23,34 @@ module FiniteMachine
 
     MESSAGE = :emit
 
-    # HookEvent state or action
-    attr_threadsafe :name
-
-    # HookEvent type
-    attr_threadsafe :type
-
-    # The from state this hook has been fired
-    attr_threadsafe :from
-
-    # The event name triggering this hook event
-    attr_threadsafe :event_name
+    # Extract event name
+    #
+    # @return [String] the event name
+    #
+    # @api public
+    def self.event_name
+      name.split("::").last.downcase.to_sym
+    end
 
-    # Instantiate a new HookEvent object
+    # String representation
     #
-    # @param [Symbol] name
-    #   The action or state name
+    # @return [String] the event name
     #
-    # @param [Symbol] event_name
-    #   The event name associated with this hook event.
+    # @api public
+    def self.to_s
+      event_name.to_s
+    end
+
+    # Choose any state or event name based on even type
     #
-    # @example
-    #   HookEvent.new(:green, :move, :green)
+    # @param [HookEvent] event_type
     #
-    # @return [self]
+    # @return [Symbol]
+    #   out of :any or :any_event
     #
     # @api public
-    def initialize(name, event_name, from)
-      @name       = name
-      @type       = self.class
-      @event_name = event_name
-      @from       = from
-      freeze
+    def self.any_state_or_event(event_type)
+      event_type < Anyaction ? ANY_EVENT : ANY_STATE
     end
 
     # Build event hook
@@ -74,16 +69,44 @@ module FiniteMachine
       new(state_or_action, event_name, from)
     end
 
-    # Deduce default name based on even type
+    EVENTS.each do |event|
+      (class << self; self; end).class_eval do
+        define_method(event.event_name) { event }
+      end
+    end
+
+    # HookEvent state or action name
+    attr_reader :name
+
+    # HookEvent type
+    attr_reader :type
+
+    # The from state this hook has been fired
+    attr_reader :from
+
+    # The event name triggering this hook event
+    attr_reader :event_name
+
+    # Instantiate a new HookEvent object
     #
-    # @param [HookEvent] event_type
+    # @param [Symbol] name
+    #   The action or state name
     #
-    # @return [Symbol]
-    #   out of :any or :any_event
+    # @param [Symbol] event_name
+    #   The event name associated with this hook event.
+    #
+    # @example
+    #   HookEvent.new(:green, :move, :green)
+    #
+    # @return [self]
     #
     # @api public
-    def self.infer_default_name(event_type)
-      event_type < Anyaction ? ANY_EVENT : ANY_STATE
+    def initialize(name, event_name, from)
+      @name       = name
+      @type       = self.class
+      @event_name = event_name
+      @from       = from
+      freeze
     end
 
     # Notify subscriber about this event
@@ -98,27 +121,9 @@ module FiniteMachine
     #
     # @api public
     def notify(subscriber, *data)
-      if subscriber.respond_to?(MESSAGE)
-        subscriber.public_send(MESSAGE, self, *data)
-      end
-    end
+      return unless subscriber.respond_to?(MESSAGE)
 
-    # Extract event name
-    #
-    # @return [String] the event name
-    #
-    # @api public
-    def self.event_name
-      name.split('::').last.downcase.to_sym
-    end
-
-    # String representation
-    #
-    # @return [String] the event name
-    #
-    # @api public
-    def self.to_s
-      event_name.to_s
+      subscriber.public_send(MESSAGE, self, *data)
     end
 
     # Compare whether the instance is greater, less then or equal to other
@@ -128,14 +133,8 @@ module FiniteMachine
     # @api public
     def <=>(other)
       other.is_a?(type) &&
-      [name, from, event_name] <=> [other.name, other.from, other.event_name]
-    end
-    alias_method :eql?, :==
-
-    EVENTS.each do |event|
-      (class << self; self; end).class_eval do
-        define_method(event.event_name) { event }
-      end
+        [name, from, event_name] <=> [other.name, other.from, other.event_name]
     end
+    alias eql? ==
   end # HookEvent
 end # FiniteMachine