finite_machine 0.3.0 → 0.4.0

data/lib/finite_machine/async_call.rb

@@ -13,6 +13,13 @@ module FiniteMachine
 
     attr_threadsafe :block
 
+    # Create an AsynCall
+    #
+    # @api private
+    def initialize
+      @mutex = Mutex.new
+    end
+
     # Build asynchronous call instance
     #
     # @param [Object] context
@@ -41,7 +48,9 @@ module FiniteMachine
     #
     # @api private
     def dispatch
-      callable.call(context, *arguments, block)
+      @mutex.synchronize do
+        callable.call(context, *arguments, block)
+      end
     end
   end # AsyncCall
 end # FiniteMachine

data/lib/finite_machine/dsl.rb

@@ -1,7 +1,6 @@
 # encoding: utf-8
 
 module FiniteMachine
-
   # A generic DSL for describing the state machine
   class GenericDSL
     include Threadable
@@ -32,7 +31,6 @@ module FiniteMachine
   end # GenericDSL
 
   class DSL < GenericDSL
-
     attr_threadsafe :defer
 
     attr_threadsafe :initial_event
@@ -48,12 +46,20 @@ module FiniteMachine
 
     # Define initial state
     #
+    # @example
+    #   initial :green
+    #
+    # @example
+    #   initial state: green, defer: true
+    #
     # @param [String, Hash] value
     #
+    # @return [StateMachine]
+    #
     # @api public
     def initial(value)
       state, name, self.defer = parse(value)
-      self.initial_event = name
+      machine.state = state unless defer
       event = proc { event name, from: FiniteMachine::DEFAULT_STATE, to: state }
       machine.events.call(&event)
     end
@@ -70,6 +76,11 @@ module FiniteMachine
 
     # Define terminal state
     #
+    # @example
+    #   terminal :red
+    #
+    # @return [StateMachine]
+    #
     # @api public
     def terminal(value)
       machine.final_state = value
@@ -100,19 +111,28 @@ module FiniteMachine
 
     # Parse initial options
     #
-    # @param [String, Hash] value
+    # @param [Object] value
     #
     # @return [Array[Symbol,String]]
     #
     # @api private
     def parse(value)
-      if value.is_a?(String) || value.is_a?(Symbol)
+      unless value.is_a?(Hash)
         [value, FiniteMachine::DEFAULT_EVENT_NAME, false]
       else
-        [value[:state], value.fetch(:event, FiniteMachine::DEFAULT_EVENT_NAME),
-        !!value[:defer]]
+        [value.fetch(:state) { raise_missing_state },
+         value.fetch(:event) { FiniteMachine::DEFAULT_EVENT_NAME },
+         value.fetch(:defer) { false }]
       end
     end
+
+    # Raises missing state error
+    #
+    # @api private
+    def raise_missing_state
+      raise MissingInitialStateError,
+            'Provide state to transition :to for the initial event'
+    end
   end # DSL
 
   class EventsDSL < GenericDSL
@@ -151,6 +171,5 @@ module FiniteMachine
     def handle(*exceptions, &block)
       machine.handle(*exceptions, &block)
     end
-
   end # ErrorsDSL
 end # FiniteMachine

data/lib/finite_machine/event_queue.rb

@@ -16,7 +16,10 @@ module FiniteMachine
       @queue = Queue.new
       @mutex = Mutex.new
       @dead  = false
-      run
+
+      @thread = Thread.new do
+        process_events
+      end
     end
 
     # Retrieve the next event
@@ -104,20 +107,19 @@ module FiniteMachine
 
     private
 
-    # Run all the events
+    # Process all the events
     #
     # @return [Thread]
     #
     # @api private
-    def run
-      @thread = Thread.new do
-        Thread.current.abort_on_exception = true
-        until(@dead) do
-          event = next_event
-          Thread.exit unless event
-          event.dispatch
-        end
+    def process_events
+      until(@dead) do
+        event = next_event
+        event.dispatch
       end
+    rescue Exception => ex
+      Logger.error "Error while running event: #{ex}"
     end
+
   end # EventQueue
 end # FiniteMachine

data/lib/finite_machine/logger.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+module FiniteMachine
+  module Logger
+    module_function
+
+    def debug(message)
+      FiniteMachine.logger.debug(message)
+    end
+
+    def info(message)
+      FiniteMachine.logger.info(message)
+    end
+
+    def warn(message)
+      FiniteMachine.logger.warn(message)
+    end
+
+    def error(message)
+      FiniteMachine.logger.error(message)
+    end
+  end # Logger
+end # FiniteMachine

data/lib/finite_machine/observer.rb

@@ -1,5 +1,7 @@
 # encoding: utf-8
 
+require 'set'
+
 module FiniteMachine
 
   # A class responsible for observing state changes
@@ -98,14 +100,20 @@ module FiniteMachine
       end
     end
 
+    # Run callback
+    #
+    # @api private
     def run_callback(hook, event)
       trans_event = TransitionEvent.new
       trans_event.build(event.transition)
       data = event.data
-      deferred_hook = proc { |_trans_event, *_data|
+      transition = event.transition
+      deferred_hook = proc do |_trans_event, *_data|
         machine.instance_exec(_trans_event, *_data, &hook)
-      }
-      deferred_hook.call(trans_event, *data)
+      end
+      callable = Callable.new(deferred_hook)
+      result = callable.call(trans_event, *data)
+      transition.cancelled = (result == CANCELLED)
     end
 
     def trigger(event, *args, &block)

data/lib/finite_machine/state_machine.rb

@@ -48,11 +48,9 @@ module FiniteMachine
       @observer    = Observer.new(self)
       @transitions = Hash.new { |hash, name| hash[name] = Hash.new }
       @env         = Environment.new(target: self)
+      @dsl         = DSL.new(self)
 
-      @dsl = DSL.new self
       @dsl.call(&block) if block_given?
-      send(:"#{@dsl.initial_event}") unless @dsl.defer
-      self.event_queue = FiniteMachine::EventQueue.new
     end
 
     # @example
@@ -213,7 +211,7 @@ module FiniteMachine
       return CANCELLED if valid_state?(_transition)
 
       return CANCELLED unless _transition.conditions.all? do |condition|
-                                condition.call(env.target)
+                                condition.call(env.target, *args)
                               end
       return NOTRANSITION if state == _transition.to
 

data/lib/finite_machine/subscribers.rb

@@ -3,38 +3,72 @@
 require 'monitor'
 
 module FiniteMachine
-
   # A class responsibile for storage of event subscribers
   class Subscribers
     include Enumerable
     include MonitorMixin
 
+    # Initialize a subscribers collection
+    #
+    # @api public
     def initialize(machine)
       super()
       @machine     = machine
       @subscribers = []
     end
 
+    # Iterate over subscribers
+    #
+    # @api public
     def each(&block)
       @subscribers.each(&block)
     end
 
+    # Return index of the subscriber
+    #
+    # @api public
     def index(subscriber)
       @subscribers.index(subscriber)
     end
 
+    # Check if anyone is subscribed
+    #
+    # @return [Boolean]
+    #
+    # @api public
     def empty?
       @subscribers.empty?
     end
 
+    # Add listener to subscribers
+    #
+    # @param [Array[#trigger]] observers
+    #
+    # @return [undefined]
+    #
+    # @api public
     def subscribe(*observers)
-      observers.each { |observer| @subscribers << observer }
+      synchronize do
+        observers.each { |observer| @subscribers << observer }
+      end
     end
 
+    # Visit subscribers and notify
+    #
+    # @param [FiniteMachine::Event] event
+    #
+    # @return [undefined]
+    #
+    # @api public
     def visit(event)
       each { |subscriber| synchronize { event.notify subscriber } }
     end
 
+    # Reset subscribers
+    #
+    # @return [self]
+    #
+    # @api public
     def reset
       @subscribers.clear
       self

data/lib/finite_machine/thread_context.rb

@@ -5,10 +5,12 @@ module FiniteMachine
   # A mixin to allow sharing of thread context
   module ThreadContext
 
+    # @api public
     def event_queue
-      Thread.current[:finite_machine_event_queue]
+      Thread.current[:finite_machine_event_queue] ||= FiniteMachine::EventQueue.new
     end
 
+    # @api public
     def event_queue=(value)
       Thread.current[:finite_machine_event_queue] = value
     end

data/lib/finite_machine/transition.rb

@@ -22,6 +22,9 @@ module FiniteMachine
     # The original from state
     attr_threadsafe :from_state
 
+    # Check if transition should be cancelled
+    attr_threadsafe :cancelled
+
     # Initialize a Transition
     #
     # @param [StateMachine] machine
@@ -36,6 +39,7 @@ module FiniteMachine
       @if         = Array(attrs.fetch(:if, []))
       @unless     = Array(attrs.fetch(:unless, []))
       @conditions = make_conditions
+      @cancelled  = false
     end
 
     # Reduce conditions
@@ -97,17 +101,37 @@ module FiniteMachine
     #
     # @api private
     def define_event
-      _transition = self
       _name       = name
+      bang_name   = "#{_name}!"
 
       machine.singleton_class.class_eval do
-        undef_method(_name) if method_defined?(_name)
+        undef_method(_name)     if method_defined?(_name)
+        undef_method(bang_name) if method_defined?(bang_name)
       end
+      define_transition(name)
+      define_event_bang(name)
+    end
+
+    # Define transition event
+    #
+    # @api private
+    def define_transition(name)
+      _transition = self
       machine.send(:define_singleton_method, name) do |*args, &block|
         transition(_transition, *args, &block)
       end
     end
 
+    # Define event that skips validations
+    #
+    # @api private
+    def define_event_bang(name)
+      machine.send(:define_singleton_method, "#{name}!") do
+        transitions   = machine.transitions[name]
+        machine.state = transitions.values[0]
+      end
+    end
+
     # Execute current transition
     #
     # @return [nil]
@@ -115,9 +139,10 @@ module FiniteMachine
     # @api private
     def call
       sync_exclusive do
-        transitions = machine.transitions[name]
+        return if cancelled
+        transitions     = machine.transitions[name]
         self.from_state = machine.state
-        machine.state = transitions[machine.state] || transitions[ANY_STATE] || name
+        machine.state   = transitions[machine.state] || transitions[ANY_STATE] || name
       end
     end
 
@@ -125,7 +150,7 @@ module FiniteMachine
     #
     # @api public
     def to_s
-      @name
+      @name.to_s
     end
 
     # Return string representation
@@ -150,7 +175,8 @@ module FiniteMachine
     #
     # @api private
     def raise_not_enough_transitions(attrs)
-      raise NotEnoughTransitionsError, "please provide state transitions for '#{attrs.inspect}'"
+      fail NotEnoughTransitionsError, "please provide state transitions for" \
+           " '#{attrs.inspect}'"
     end
   end # Transition
 end # FiniteMachine

data/lib/finite_machine/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module FiniteMachine
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/spec/unit/async_events_spec.rb

@@ -56,10 +56,10 @@ describe FiniteMachine, 'async_events' do
         on_enter :yellow do |event, a| called << "(bar)on_enter_yellow_#{a}" end
       }
     end
-    fsmFoo.slow(:foo)
-    fsmBar.slow(:bar)
-    fsmFoo.event_queue.join 0.01
-    fsmBar.event_queue.join 0.01
+    foo_thread = Thread.new { fsmFoo.async.slow(:foo) }
+    bar_thread = Thread.new { fsmBar.async.slow(:bar) }
+    [foo_thread, bar_thread].each(&:join)
+    [fsmFoo, fsmBar].each { |fsm| fsm.event_queue.join 0.02 }
     expect(called).to include('(foo)on_enter_yellow_foo')
     expect(called).to include('(bar)on_enter_yellow_bar')
     expect(fsmFoo.current).to eql(:yellow)

data/spec/unit/callbacks_spec.rb

@@ -7,7 +7,7 @@ describe FiniteMachine, 'callbacks' do
   it "triggers default init event" do
     called = []
     fsm = FiniteMachine.define do
-      initial :green
+      initial state: :green, defer: true
 
       events {
         event :slow,  :green  => :yellow
@@ -47,8 +47,8 @@ describe FiniteMachine, 'callbacks' do
       }
     end
 
-    expect(fsm.current).to eql(:green)
-
+    expect(fsm.current).to eql(:none)
+    fsm.init
     expect(called).to eql([
       'on_exit_none',
       'on_exit',
@@ -570,12 +570,54 @@ describe FiniteMachine, 'callbacks' do
     fsm.slow
     expect(fsm.current).to eql(:yellow)
     expect(called).to eql([
-      'once_on_transition_green',
-      'once_on_enter_green',
       'once_on_exit_green',
       'once_on_transition_yellow',
       'once_on_enter_yellow',
-      'once_on_exit_yellow'
+      'once_on_exit_yellow',
+      'once_on_transition_green',
+      'once_on_enter_green'
     ])
   end
+
+  it "cancels transition on state callback" do
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow,  :green  => :yellow
+        event :go,    :yellow => :green
+      }
+
+      callbacks {
+        on_exit :green do |event| FiniteMachine::CANCELLED end
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+    fsm.slow
+    expect(fsm.current).to eql(:green)
+  end
+
+  it "cancels transition on event callback" do
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow,  :green  => :yellow
+        event :go,    :yellow => :green
+      }
+
+      callbacks {
+        on_enter :slow do |event|
+          FiniteMachine::CANCELLED
+        end
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+    fsm.slow
+    expect(fsm.current).to eql(:green)
+  end
+
+  xit "groups callbacks"
 end