finite_machine 0.10.2 → 0.11.0

data/lib/finite_machine/subscribers.rb

@@ -11,9 +11,8 @@ module FiniteMachine
     # Initialize a subscribers collection
     #
     # @api public
-    def initialize(machine)
-      super()
-      @machine     = machine
+    def initialize
+      super
       @subscribers = []
     end
 
@@ -55,13 +54,25 @@ module FiniteMachine
 
     # Visit subscribers and notify
     #
-    # @param [FiniteMachine::Event] event
+    # @param [HookEvent] hook_event
+    #   the callback event to notify about
     #
     # @return [undefined]
     #
     # @api public
-    def visit(event)
-      each { |subscriber| synchronize { event.notify subscriber } }
+    def visit(hook_event, *data)
+      each { |subscriber|
+        synchronize { hook_event.notify(subscriber, *data) }
+      }
+    end
+
+    # Number of subscribed listeners
+    #
+    # @return [Integer]
+    #
+    # @api public
+    def size
+      synchronize { @subscribers.size }
     end
 
     # Reset subscribers

data/lib/finite_machine/thread_context.rb

@@ -6,7 +6,7 @@ module FiniteMachine
 
     # @api public
     def event_queue
-      Thread.current[:finite_machine_event_queue] ||= FiniteMachine::EventQueue.new
+      Thread.current[:finite_machine_event_queue]
     end
 
     # @api public

data/lib/finite_machine/transition.rb

@@ -5,94 +5,57 @@ module FiniteMachine
   class Transition
     include Threadable
 
+    # The event name
     attr_threadsafe :name
 
-    # State transitioning from
-    attr_threadsafe :from_states
-
-    # State transitioning to
-    attr_threadsafe :to_states
-
     # Predicates before transitioning
     attr_threadsafe :conditions
 
     # The current state machine
     attr_threadsafe :machine
 
-    # The original from state
-    attr_threadsafe :from_state
-
     # Check if transition should be cancelled
     attr_threadsafe :cancelled
 
     # All states for this transition event
     attr_threadsafe :states
 
-    # Silence callbacks
-    attr_threadsafe :silent
-
     # Initialize a Transition
     #
+    # @example
+    #   attributes = {parsed_states: {green: :yellow}}
+    #   Transition.new(machine, attributes)
+    #
     # @param [StateMachine] machine
+    #
     # @param [Hash] attrs
     #
+    # @return [Transition]
+    #
     # @api public
     def initialize(machine, attrs = {})
       @machine     = machine
-      @name        = attrs.fetch(:name, DEFAULT_STATE)
-      @states      = attrs.fetch(:parsed_states, {})
-      @silent      = attrs.fetch(:silent, false)
-      @from_states = @states.keys
-      @to_states   = @states.values
-      @from_state  = @from_states.first
+      @name        = attrs[:name]
+      @states      = attrs.fetch(:states, {})
       @if          = Array(attrs.fetch(:if, []))
       @unless      = Array(attrs.fetch(:unless, []))
       @conditions  = make_conditions
-      @cancelled   = false
+      @cancelled   = attrs.fetch(:cancelled, false)
     end
 
-    # Create transition with associated helper methods
+    # Check if this transition is cancelled or not
     #
-    # @param [FiniteMachine::StateMachine] machine
-    #
-    # @param [Hash] attrs
-    #
-    # @example
-    #   attributes = {parsed_states: {green: :yellow}, silent: true}
-    #   Transition.create(machine, attrbiutes)
-    #
-    # @return [Transition]
-    #
-    # @api public
-    def self.create(machine, attrs = {})
-      transition = new(machine, attrs)
-      transition.update_transitions
-      transition.define_state_query_methods
-      transition
-    end
-
-    # Decide :to state from available transitions for this event
-    #
-    # @return [Symbol]
+    # @return [Boolean]
     #
     # @api public
-    def to_state(*args)
-      if transition_choice?
-        found_trans = machine.select_choice_transition(name, from_state, *args)
-
-        if found_trans.nil? # no choice found
-          from_state
-        else
-          found_trans.states[from_state] || found_trans.states[ANY_STATE]
-        end
-      else
-        available_trans = machine.transitions[name]
-        available_trans[from_state] || available_trans[ANY_STATE]
-      end
+    def cancelled?
+      @cancelled
     end
 
     # Reduce conditions
     #
+    # @return [Array[Callable]]
+    #
     # @api private
     def make_conditions
       @if.map { |c| Callable.new(c) } +
@@ -101,153 +64,62 @@ module FiniteMachine
 
     # Verify conditions returning true if all match, false otherwise
     #
+    # @param [Array[Object]] args
+    #   the arguments for the condition
+    #
     # @return [Boolean]
     #
     # @api private
-    def check_conditions(*args, &block)
+    def check_conditions(*args)
       conditions.all? do |condition|
-        condition.call(machine.target, *args, &block)
+        condition.call(machine.target, *args)
       end
     end
 
-    # Check if moved to different state or not
+    # Check if this transition matches from state
     #
-    # @param [Symbol] state
-    #   the current state name
-    #
-    # @return [Boolean]
-    #
-    # @api public
-    def same?(state)
-      states[state] == state || (states[ANY_STATE] == state && from_state == state)
-    end
-
-    # Check if from matches current state
+    # @param [Symbol] from
+    #   the from state to match against
     #
     # @example
-    #   transition.current? # => true
+    #   transition = Transition.new(machine, states: {:green => :red})
+    #   transition.matches?(:green) # => true
     #
     # @return [Boolean]
     #   Return true if match is found, false otherwise.
     #
     # @api public
-    def current?
-      [machine.current, ANY_STATE].any? { |state| state == from_state }
-    end
-
-    # Check if this transition has branching choice or not
-    #
-    # @return [Boolean]
-    #
-    # @api public
-    def transition_choice?
-      matching = machine.transitions[name]
-      [matching[from_state], matching[ANY_STATE]].any? do |match|
-        match.is_a?(Array)
-      end
+    def matches?(from)
+      states.keys.any? { |state| [ANY_STATE, from].include?(state) }
     end
 
-    # Check if transition can be performed according to constraints
+    # Find to state for this transition given the from state
     #
-    # @param [Array] args
+    # @param [Symbol] from
+    #   the from state to check
     #
-    # @param [Proc] block
+    # @example
+    #   transition = Transition.new(machine, states: {:green => :red})
+    #   transition.to_state(:green) # => :red
     #
-    # @return [Boolean]
+    # @return [Symbol]
+    #   the to state
     #
     # @api public
-    def valid?(*args, &block)
-      if transition_choice?
-        machine.check_choice_conditions(name, *args, &block)
-      else
-        check_conditions(*args, &block)
-      end
-    end
-
-    # Add transition to the machine
-    #
-    # @return [Transition]
-    #
-    # @api private
-    def update_transitions
-      from_states.each do |from|
-        if (value = machine.transitions[name][from])
-          machine.transitions[name][from] = [value, states[from]].flatten
-        else
-          machine.transitions[name][from] = states[from] || ANY_STATE
-        end
-      end
-      self
-    end
-
-    # Define helper state mehods for the transition states
-    #
-    # @return [Transition]
-    #
-    # @api private
-    def define_state_query_methods
-      from_states.concat(to_states).each do |state|
-        define_state_query_method(state)
-      end
-      self
-    end
-
-    # Define state helper method
-    #
-    # @param [Symbol] state
-    #
-    # @api private
-    def define_state_query_method(state)
-      return if machine.respond_to?("#{state}?")
-      machine.send(:define_singleton_method, "#{state}?") do
-        machine.is?(state.to_sym)
-      end
-    end
-
-    # Set state on the machine
-    #
-    # @api private
-    def update_state(*args)
-      if transition_choice?
-        found_trans   = machine.select_transition(name, *args)
-        machine.state = found_trans.to_states.first
+    def to_state(from)
+      if cancelled?
+        from
       else
-        transitions   = machine.transitions[name]
-        machine.state = transitions[machine.state] || transitions[ANY_STATE] || name
-      end
-    end
-
-    # Find latest from state
-    #
-    # Note that for the exit hook the call hasn't happened yet so
-    # we need to find previous to state when the from is :any.
-    #
-    # @return [Object] from_state
-    #
-    # @api private
-    def latest_from_state
-      sync_shared do
-        from_state == ANY_STATE ? machine.previous_state : from_state
-      end
-    end
-
-    # Execute current transition
-    #
-    # @return [nil]
-    #
-    # @api private
-    def execute(*args)
-      sync_exclusive do
-        return if cancelled
-        self.from_state = machine.state
-        update_state(*args)
-        machine.previous_state = machine.state
-        machine.initial_state = machine.state if from_state == DEFAULT_STATE
+        states[from] || states[ANY_STATE]
       end
     end
 
     # Return transition name
     #
+    # @example
+    #   transition = Transition.new(machine, name: :go)
+    #   transition.to_s # => 'go'
+    #
     # @return [String]
     #
     # @api public

data/lib/finite_machine/transition_builder.rb

@@ -1,8 +1,14 @@
 # encoding: utf-8
 
+require 'finite_machine/state_parser'
+require 'finite_machine/event_definition'
+require 'finite_machine/state_definition'
+
 module FiniteMachine
   # A class reponsible for building transition out of parsed states
   #
+  # Used internally by {DSL} to
+  #
   # @api private
   class TransitionBuilder
     include Threadable
@@ -14,6 +20,8 @@ module FiniteMachine
 
     attr_threadsafe :event_definition
 
+    attr_threadsafe :state_definition
+
     # Initialize a TransitionBuilder
     #
     # @example
@@ -24,25 +32,35 @@ module FiniteMachine
       @machine = machine
       @attributes = attributes
       @event_definition = EventDefinition.new(machine)
+      @state_definition = StateDefinition.new(machine)
     end
 
     # Creates transitions for the states
     #
     # @example
-    #   transition_parser.call([:green, :yellow] => :red)
+    #   transition_builder.call([:green, :yellow] => :red)
     #
     # @param [Hash[Symbol]] states
     #   The states to extract
     #
-    # @return [nil]
+    # @return [self]
     #
     # @api public
     def call(states)
-      FiniteMachine::StateParser.new(states).parse do |from, to|
-        attributes.merge!(parsed_states: { from => to })
-        transition = Transition.create(machine, attributes)
-        event_definition.apply(transition)
+      StateParser.new(states).parse do |from, to|
+        attributes.merge!(states: { from => to })
+        transition = Transition.new(machine, attributes)
+        name = attributes[:name]
+        silent = attributes.fetch(:silent, false)
+
+        machine.events_chain.add(name, transition)
+
+        unless machine.respond_to?(name)
+          event_definition.apply(name, silent)
+        end
+        state_definition.apply({ from => to })
       end
+      self
     end
   end # TransitionBuilder
 end # FiniteMachine

data/lib/finite_machine/transition_event.rb

@@ -35,10 +35,11 @@ module FiniteMachine
     # @return [self]
     #
     # @api private
-    def initialize(transition, *data)
-      @name = transition.name
-      @from = transition.latest_from_state
-      @to   = transition.to_state(*data)
+    # def initialize(transition, *data)
+    def initialize(hook_event, to)
+      @name = hook_event.event_name
+      @from = hook_event.from
+      @to   = to
       freeze
     end
   end # TransitionEvent

data/lib/finite_machine/undefined_transition.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module FiniteMachine
+  # Stand in for lack of matching transition.
+  #
+  # Used internally by {EventsChain}
+  #
+  # @api private
+  class UndefinedTransition
+    include Threadable
+
+    # Initialize an undefined transition
+    #
+    # @api private
+    def initialize(name)
+      self.name = name
+    end
+
+    def to_state(from)
+      from
+    end
+
+    def ==(other)
+      other.is_a?(UndefinedTransition) && name == other.name
+    end
+
+    protected
+
+    attr_threadsafe :name
+
+  end # UndefinedTransition
+end # FiniteMachine