finite_machine 0.1.0 → 0.2.0

data/lib/finite_machine/state_machine.rb

@@ -5,6 +5,7 @@ module FiniteMachine
   # Base class for state machine
   class StateMachine
     include Threadable
+    include Catchable
 
     # Initial state, defaults to :none
     attr_threadsafe :initial_state
@@ -18,6 +19,9 @@ module FiniteMachine
     # Events DSL
     attr_threadsafe :events
 
+    # Errors DSL
+    attr_threadsafe :errors
+
     # The prefix used to name events.
     attr_threadsafe :namespace
 
@@ -39,6 +43,7 @@ module FiniteMachine
     def initialize(*args, &block)
       @subscribers = Subscribers.new(self)
       @events      = EventsDSL.new(self)
+      @errors      = ErrorsDSL.new(self)
       @observer    = Observer.new(self)
       @transitions = Hash.new { |hash, name| hash[name] = Hash.new }
       @env         = Environment.new(target: self)
@@ -57,10 +62,12 @@ module FiniteMachine
     #
     # @api public
     def notify(event_type, _transition, *data)
-      event_class     = Event.const_get(event_type.capitalize.to_s)
-      state_or_action = event_class < Event::Anystate ? state : _transition.name
-      _event          = event_class.new(state_or_action, _transition, *data)
-      subscribers.visit(_event)
+      sync_shared do
+        event_class     = Event.const_get(event_type.capitalize.to_s)
+        state_or_action = event_class < Event::Anystate ? state : _transition.name
+        _event          = event_class.new(state_or_action, _transition, *data)
+        subscribers.visit(_event)
+      end
     end
 
     # Get current state
@@ -136,21 +143,18 @@ module FiniteMachine
       is?(final_state)
     end
 
-    #
-    #
-    # @api public
-    def errors
-    end
-
     private
 
     # Check if state is reachable
     #
     # @api private
-    def validate_state(_transition)
+    def valid_state?(_transition)
       current_states = transitions[_transition.name].keys
-      if !current_states.include?(state)  && !current_states.include?(ANY_STATE)
-        raise TransitionError, "inappropriate current state '#{state}'"
+      if !current_states.include?(state) && !current_states.include?(ANY_STATE)
+        exception = InvalidStateError
+        catch_error(exception) ||
+          raise(exception, "inappropriate current state '#{state}'")
+        true
       end
     end
 
@@ -158,9 +162,11 @@ module FiniteMachine
     #
     # @api private
     def transition(_transition, *args, &block)
-      validate_state(_transition)
+      return CANCELLED if valid_state?(_transition)
 
-      return CANCELLED unless _transition.conditions.all? { |c| c.call(env) }
+      return CANCELLED unless _transition.conditions.all? do |condition|
+                                condition.call(env.target)
+                              end
       return NOTRANSITION if state == _transition.to
 
       sync_exclusive do
@@ -172,9 +178,10 @@ module FiniteMachine
 
           notify :transitionstate, _transition, *args
           notify :transitionaction, _transition, *args
-        rescue StandardError => e
-          raise TransitionError, "#(#{e.class}): #{e.message}\n" +
-            "occured at #{e.backtrace.join("\n")}"
+        rescue Exception => e
+          catch_error(e) ||
+            raise(TransitionError, "#(#{e.class}): #{e.message}\n" +
+              "occured at #{e.backtrace.join("\n")}")
         end
 
         notify :enterstate, _transition, *args
@@ -184,5 +191,17 @@ module FiniteMachine
       SUCCEEDED
     end
 
+    def method_missing(method_name, *args, &block)
+      if env.target.respond_to?(method_name.to_sym)
+        env.target.send(method_name.to_sym, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      env.target.respond_to?(method_name.to_sym)
+    end
+
   end # StateMachine
 end # FiniteMachine

data/lib/finite_machine/subscribers.rb

@@ -29,7 +29,7 @@ module FiniteMachine
     end
 
     def visit(event)
-      each { |subscriber| @mutex.synchronize { event.notify subscriber } }
+      each { |subscriber| event.notify subscriber }
     end
 
     def reset

data/lib/finite_machine/threadable.rb

@@ -1,6 +1,8 @@
 # encoding: utf-8
 
 module FiniteMachine
+
+  # A mixin to allow instance methods to be synchronized
   module Threadable
     module InstanceMethods
       @@sync = Sync.new
@@ -27,8 +29,12 @@ module FiniteMachine
       def attr_threadsafe(*attrs)
         attrs.flatten.each do |attr|
           class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-            def #{attr}
-              sync_shared { @#{attr} }
+            def #{attr}(*args)
+              if args.empty?
+                sync_shared { @#{attr} }
+              else
+                self.#{attr} = args.shift
+              end
             end
             alias_method '#{attr}?', '#{attr}'
 

data/lib/finite_machine/transition.rb

@@ -20,6 +20,9 @@ module FiniteMachine
     # The current state machine
     attr_threadsafe :machine
 
+    # The original from state
+    attr_threadsafe :from_state
+
     # Initialize a Transition
     #
     # @api public
@@ -27,6 +30,7 @@ module FiniteMachine
       @machine    = machine
       @name       = attrs.fetch(:name, DEFAULT_STATE)
       @from, @to  = *parse_states(attrs)
+      @from_state = @from.first
       @if         = Array(attrs.fetch(:if, []))
       @unless     = Array(attrs.fetch(:unless, []))
       @conditions = make_conditions
@@ -43,6 +47,7 @@ module FiniteMachine
     def parse_states(attrs)
       _attrs = attrs.dup
       [:name, :if, :unless].each { |key| _attrs.delete(key) }
+      raise_not_enough_transitions(attrs) unless _attrs.any?
 
       if [:from, :to].any? { |key| attrs.keys.include?(key) }
         [Array(_attrs[:from] || ANY_STATE), _attrs[:to]]
@@ -51,18 +56,57 @@ module FiniteMachine
       end
     end
 
+    # Add transition to the machine
+    #
+    # @return [Transition]
+    #
+    # @api private
+    def define
+      from.each do |from|
+        machine.transitions[name][from] = to || from
+      end
+    end
+
+    # Define event on the machine
+    #
+    # @api private
+    def define_event
+      _transition = self
+      # TODO check if event is already defined and raise error
+      machine.class.__send__(:define_method, name) do |*args, &block|
+        transition(_transition, *args, &block)
+      end
+    end
+
     # Execute current transition
     #
     # @api private
     def call
       sync_exclusive do
         transitions = machine.transitions[name]
+        self.from_state = machine.state
         machine.state = transitions[machine.state] || transitions[ANY_STATE] || name
       end
     end
 
+    # Return transition name
+    #
+    # @api public
+    def to_s
+      @name
+    end
+
     def inspect
-      [@name, @from, @to, @conditions].inspect
+      "<#{self.class} name: #{@name}, transitions: #{@from} => #{@to}, when: #{@conditions}>"
+    end
+
+    private
+
+    # Raise error when not enough transitions are provided
+    #
+    # @api private
+    def raise_not_enough_transitions(attrs)
+      raise NotEnoughTransitionsError, "please provide state transitions for '#{attrs.inspect}'"
     end
 
   end # Transition

data/lib/finite_machine/version.rb

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

data/spec/spec_helper.rb

@@ -12,4 +12,13 @@ RSpec.configure do |config|
   # the seed, which is printed after each run.
   #     --seed 1234
   config.order = 'random'
+
+  # Remove defined constants
+  config.before :each do
+    [:Car, :Logger].each do |class_name|
+      if Object.const_defined?(class_name)
+        Object.send(:remove_const, class_name)
+      end
+    end
+  end
 end

data/spec/unit/callable/call_spec.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine::Callable, '#call' do
+
+  before(:each) {
+    Car = Class.new do
+      attr_reader :result
+
+      def turn_engine_on
+        @result = 'turn_engine_on'
+        @engine_on = true
+      end
+
+      def set_engine(value)
+        @result = "set_engine(#{value})"
+        @engine = value.to_sym == :on
+      end
+
+      def turn_engine_off
+        @result = 'turn_engine_off'
+        @engine_on = false
+      end
+
+      def engine_on?
+        @result = 'engine_on'
+        !!@engine_on
+      end
+    end
+  }
+
+  let(:called) { [] }
+
+  let(:target) { Car.new }
+
+  let(:instance) { described_class.new(object) }
+
+  context 'when string' do
+    let(:object) {  'engine_on?' }
+
+    it 'executes method on target' do
+      instance.call(target)
+      expect(target.result).to eql('engine_on')
+    end
+  end
+
+  context 'when string' do
+    let(:object) {  'set_engine(:on)' }
+
+    it 'executes method with arguments' do
+      instance.call(target)
+      expect(target.result).to eql('set_engine(on)')
+    end
+  end
+
+  context 'when symbol' do
+    let(:object) {  :engine_on? }
+
+    it 'executes method on target' do
+      instance.call(target)
+      expect(target.result).to eql('engine_on')
+    end
+  end
+
+  context 'when proc without args' do
+    let(:object) {  proc { |a| called << "block_with(#{a})" } }
+
+    it 'passes arguments' do
+      instance.call(target)
+      expect(called).to eql(["block_with(#{target})"])
+    end
+  end
+
+  context 'when proc with args' do
+    let(:object) {  proc { |a,b| called << "block_with(#{a},#{b})" } }
+
+    it 'passes arguments' do
+      instance.call(target, :red)
+      expect(called).to eql(["block_with(#{target},red)"])
+    end
+  end
+
+  context 'when unknown' do
+    let(:object) { Object.new }
+
+    it 'raises error' do
+      expect { instance.call(target) }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/unit/callbacks_spec.rb

@@ -18,9 +18,17 @@ describe FiniteMachine, 'callbacks' do
 
       callbacks {
         # generic callbacks
-        on_enter      do |event| called << 'on_enter' end
-        on_transition do |event| called << 'on_transition' end
+        on_enter       do |event| called << 'on_enter' end
+        on_enter_state do |event| called << 'on_enter_state' end
+        on_enter_event do |event| called << 'on_enter_event' end
+
+        on_transition       do |event| called << 'on_transition' end
+        on_transition_state do |event| called << 'on_transition_state' end
+        on_transition_event do |event| called << 'on_transition_event' end
+
         on_exit       do |event| called << 'on_exit' end
+        on_exit_state do |event| called << 'on_exit_state' end
+        on_exit_event do |event| called << 'on_exit_event' end
 
         # state callbacks
         on_enter :none  do |event| called << 'on_enter_none' end
@@ -42,16 +50,22 @@ describe FiniteMachine, 'callbacks' do
     expect(called).to eql([
       'on_exit_none',
       'on_exit',
+      'on_exit_state',
       'on_enter_init',
       'on_enter',
+      'on_enter_event',
       'on_transition_green',
       'on_transition',
+      'on_transition_state',
       'on_transition_init',
       'on_transition',
+      'on_transition_event',
       'on_enter_green',
       'on_enter',
+      'on_enter_state',
       'on_exit_init',
-      'on_exit'
+      'on_exit',
+      'on_exit_event'
     ])
   end
 
@@ -69,9 +83,17 @@ describe FiniteMachine, 'callbacks' do
 
       callbacks {
         # generic callbacks
-        on_enter      do |event| called << 'on_enter' end
-        on_transition do |event| called << 'on_transition' end
+        on_enter       do |event| called << 'on_enter' end
+        on_enter_state do |event| called << 'on_enter_state' end
+        on_enter_event do |event| called << 'on_enter_event' end
+
+        on_transition       do |event| called << 'on_transition' end
+        on_transition_state do |event| called << 'on_transition_state' end
+        on_transition_event do |event| called << 'on_transition_event' end
+
         on_exit       do |event| called << 'on_exit' end
+        on_exit_state do |event| called << 'on_exit_state' end
+        on_exit_event do |event| called << 'on_exit_event' end
 
         # state callbacks
         on_enter :green  do |event| called << 'on_enter_green' end
@@ -109,16 +131,22 @@ describe FiniteMachine, 'callbacks' do
     expect(called).to eql([
       'on_exit_green',
       'on_exit',
+      'on_exit_state',
       'on_enter_slow',
       'on_enter',
+      'on_enter_event',
       'on_transition_yellow',
       'on_transition',
+      'on_transition_state',
       'on_transition_slow',
       'on_transition',
+      'on_transition_event',
       'on_enter_yellow',
       'on_enter',
+      'on_enter_state',
       'on_exit_slow',
-      'on_exit'
+      'on_exit',
+      'on_exit_event'
     ])
 
     called = []
@@ -126,16 +154,22 @@ describe FiniteMachine, 'callbacks' do
     expect(called).to eql([
       'on_exit_yellow',
       'on_exit',
+      'on_exit_state',
       'on_enter_stop',
       'on_enter',
+      'on_enter_event',
       'on_transition_red',
       'on_transition',
+      'on_transition_state',
       'on_transition_stop',
       'on_transition',
+      'on_transition_event',
       'on_enter_red',
       'on_enter',
+      'on_enter_state',
       'on_exit_stop',
-      'on_exit'
+      'on_exit',
+      'on_exit_event'
     ])
 
     called = []
@@ -143,16 +177,22 @@ describe FiniteMachine, 'callbacks' do
     expect(called).to eql([
       'on_exit_red',
       'on_exit',
+      'on_exit_state',
       'on_enter_ready',
       'on_enter',
+      'on_enter_event',
       'on_transition_yellow',
       'on_transition',
+      'on_transition_state',
       'on_transition_ready',
       'on_transition',
+      'on_transition_event',
       'on_enter_yellow',
       'on_enter',
+      'on_enter_state',
       'on_exit_ready',
-      'on_exit'
+      'on_exit',
+      'on_exit_event'
     ])
 
     called = []
@@ -160,16 +200,22 @@ describe FiniteMachine, 'callbacks' do
     expect(called).to eql([
       'on_exit_yellow',
       'on_exit',
+      'on_exit_state',
       'on_enter_go',
       'on_enter',
+      'on_enter_event',
       'on_transition_green',
       'on_transition',
+      'on_transition_state',
       'on_transition_go',
       'on_transition',
+      'on_transition_event',
       'on_enter_green',
       'on_enter',
+      'on_enter_state',
       'on_exit_go',
-      'on_exit'
+      'on_exit',
+      'on_exit_event'
     ])
   end
 
@@ -279,7 +325,32 @@ describe FiniteMachine, 'callbacks' do
       initial :green
 
       events {
-        event :slow,  :green  => :yellow
+        event :slow, :green  => :yellow
+      }
+
+      callbacks {
+        on_enter(:yellow) { |e| evt = e }
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+    fsm.slow
+    expect(fsm.current).to eql(:yellow)
+
+    expect(evt.from).to eql(:green)
+    expect(evt.to).to eql(:yellow)
+    expect(evt.name).to eql(:slow)
+  end
+
+  it "identifies the from state for callback event parameter" do
+    evt = nil
+
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow, [:red, :blue, :green]  => :yellow
+        event :fast, :red => :purple
       }
 
       callbacks {
@@ -307,10 +378,13 @@ describe FiniteMachine, 'callbacks' do
       expect(b).to eql(expected[:b])
       expect(c).to eql(expected[:c])
     }
+    context = self
 
     fsm = FiniteMachine.define do
       initial :green
 
+      target context
+
       events {
         event :slow,  :green  => :yellow
         event :stop,  :yellow => :red
@@ -355,7 +429,6 @@ describe FiniteMachine, 'callbacks' do
       }
     end
 
-
     expected = {name: :slow, from: :green, to: :yellow, a: 1, b: 2, c: 3}
     fsm.slow(1, 2, 3)
 
@@ -385,7 +458,18 @@ describe FiniteMachine, 'callbacks' do
     }.to raise_error(FiniteMachine::InvalidCallbackNameError, /magic is not a valid callback name/)
   end
 
-  xit "propagates exceptions raised inside callback"
+  it "propagates exceptions raised inside callback" do
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events { event :slow,  :green  => :yellow }
+
+      callbacks { on_enter(:yellow) { raise RuntimeError } }
+    end
+
+    expect(fsm.current).to eql(:green)
+    expect { fsm.slow }.to raise_error(RuntimeError)
+  end
 
   xit "executes callbacks with multiple 'from' transitions"
 end