finite_machine 0.9.2 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 64cf549e74a02a5036aec535a7be9784a10224bf
-  data.tar.gz: e7733f5805b8989033e229109200b7f69feebe3a
+  metadata.gz: f3f7827c0cdd099708b2dd384b7d7acfe82449d8
+  data.tar.gz: 1aa5b2f9964b04c5ff1c7d642acd6eb67b985411
 SHA512:
-  metadata.gz: db31c094295a9ed657daca0960b3299d00ee131a3149ce99750d14b44555e0e5375e5f0e3b5c0d70ecf955a895cd4addafc1b9e99576dd03a21df9ca2b271547
-  data.tar.gz: bff4f5c620276cf7cc664662d0c3aa66e555d1e09fd242e9d22ab5577f0425ee94c4db7bf804e4102a2e99d759eb1180fc04988ccff3fca2368879d4cc02ab1d
+  metadata.gz: 2146d17c6edc868af3e1dc7e0a772893e2b7c4b1954a2a259dd3a9bca6a750083ac06a78ce1bc10fbc3c04902a98ce7ae659a42948d558a3a3fd25ccc942ae4b
+  data.tar.gz: 4ac655d7e523e6c2d872844b65de8fa0b29449b7d33b4c6cf8834e8586b5b68503cda2653f266e4a4f9cf07291d47031513caf97d04fe2e33f88e6e154f917ad

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+0.10.0 (November 16, 2014)
+
+* Add #alias_target to allow renaming of target object by @reggieb
+* Fix issue with async calls passing wrong arguments to conditionals
+* Change TransitionEvent, AsyncCall to be immutable
+* Add :log_transitions option for easy transition debugging
+* Increase test coverage to 99%
+
 0.9.2 (September 27, 2014)
 
 * Removes use of class variable to share Sync by @reggieb

data/README.md

@@ -4,12 +4,14 @@
 [![Code Climate](https://codeclimate.com/github/peter-murach/finite_machine.png)][codeclimate]
 [![Coverage Status](https://coveralls.io/repos/peter-murach/finite_machine/badge.png)][coverage]
 [![Inline docs](http://inch-ci.org/github/peter-murach/finite_machine.png)][inchpages]
+[![Gitter](https://badges.gitter.im/Join Chat.svg)][gitter]
 
 [gem]: http://badge.fury.io/rb/finite_machine
 [travis]: http://travis-ci.org/peter-murach/finite_machine
 [codeclimate]: https://codeclimate.com/github/peter-murach/finite_machine
 [coverage]: https://coveralls.io/r/peter-murach/finite_machine
 [inchpages]: http://inch-ci.org/github/peter-murach/finite_machine
+[gitter]: https://gitter.im/peter-murach/finite_machine?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
 
 A minimal finite state machine with a straightforward and intuitive syntax. You can quickly model states and add callbacks that can be triggered synchronously or asynchronously. The machine is event driven with a focus on passing synchronous and asynchronous messages to trigger state transitions.
 
@@ -50,7 +52,8 @@ Or install it yourself as:
     * [1.5 can? and cannot?](#15-can-and-cannot)
     * [1.6 states](#16-states)
     * [1.7 target](#17-target)
-    * [1.8 restore!](#18-restore)
+    * [1.8 Alias target](#18-alias-target)
+    * [1.9 restore!](#19-restore)
 * [2. Transitions](#2-transitions)
     * [2.1 Performing transitions](#21-performing-transitions)
     * [2.2 Forcing transitions](#22-forcing-transitions)
@@ -59,6 +62,7 @@ Or install it yourself as:
     * [2.5 From :any state](#25-from-any-state)
     * [2.6 Grouping states under single event](#26-grouping-states-under-single-event)
     * [2.7 Silent transitions](#27-silent-transitions)
+    * [2.8 Log transitions](#28-log-transitions)
 * [3. Conditional transitions](#3-conditional-transitions)
     * [3.1 Using a Proc](#31-using-a-proc)
     * [3.2 Using a Symbol](#32-using-a-symbol)
@@ -371,7 +375,32 @@ fm = FiniteMachine.define do
 end
 ```
 
-### 1.8 restore!
+### 1.8 Alias target
+
+If you need to better express the intention behind the target name, in particular when calling actions in callbacks, you can use the `alias_target` helper:
+
+```ruby
+car = Car.new
+
+fm = FiniteMachine.define do
+  initial :neutral
+
+  target car
+
+  alias_target :car
+
+  events {
+    event :start, :neutral => :one, if: "engine_on?"
+  }
+
+  callbacks {
+    on_enter_start do |event| car.turn_engine_on end
+    on_exit_start  do |event| car.turn_engine_off end
+  }
+end
+```
+
+### 1.9 restore!
 
 In order to set the machine to a given state and thus skip triggering callbacks use the `restore!` method:
 
@@ -436,7 +465,13 @@ fm.current     # => :yellow
 In order to fire the event transition asynchronously use the `async` scope like so
 
 ```ruby
-fm.async.ready  # => executes in separate Thread
+fm.async.ready('Piotr')  # => executes in separate Thread
+```
+
+The `async` call allows for alternative syntax whereby the method name is passed as one of the parameters like so:
+
+```ruby
+fm.async(:ready, 'Piotr')
 ```
 
 ### 2.4 Multiple from states
@@ -526,6 +561,16 @@ fsm.go   # no callbacks
 fms.stop # callbacks are fired
 ```
 
+### 2.8 Log transitions
+
+To help debug your state machine, **FiniteMachine** provides `:log_transitions` option.
+
+```ruby
+FiniteMachine.define log_transitions: true do
+  ...
+end
+```
+
 ## 3 Conditional transitions
 
 Each event takes an optional `:if` and `:unless` options which act as a predicate for the transition. The `:if` and `:unless` can take a symbol, a string, a Proc or an array. Use `:if` option when you want to specify when the transition **should** happen. If you want to specify when the transition **should not** happen then use `:unless` option.
@@ -546,6 +591,27 @@ fm.slow    # doesn't transition to :yellow state
 fm.current # => :green
 ```
 
+Condition by default receives the current context, which is the current state machine instance, followed by extra arguments.
+
+```ruby
+fsm = FiniteMachine.define do
+  initial :red
+
+  events {
+    event :go, :red => :green,
+          if: -> (context, a) { context.current == a }
+  }
+end
+fm.go(:yellow) # doesn't transition
+fm.go          # raises ArgumentError
+```
+
+**Note** If you specify condition with a given arguments then you need to call an event with the exact number of arguments, otherwise you will get `ArgumentError`. Thus in above scenario to prevent errors specify condition like so:
+
+```ruby
+if: -> (context, *args) { ... }
+```
+
 Provided your **FiniteMachine** is associated with another object through `target` helper. Then the target object together with event arguments will be passed to the `:if` or `:unless` condition scope.
 
 ```ruby
@@ -1231,8 +1297,10 @@ class Account < ActiveRecord::Base
     self.state = manage.current
   end
 
-  def initialize(attrs = {})
-    super
+  after_find :restore_state
+  after_initialize :restore_state
+
+  def restore_state
     manage.restore!(state.to_sym) if state.present?
   end
 
@@ -1251,7 +1319,6 @@ class Account < ActiveRecord::Base
       callbacks {
         on_enter do |event|
           target.state = event.to
-          target.save
         end
       }
     end

data/lib/finite_machine/async_call.rb

@@ -2,25 +2,14 @@
 
 module FiniteMachine
   # An asynchronouse call representation
+  #
+  # Used internally by {EventQueue} to schedule events
+  #
+  # @api private
   class AsyncCall
     include Threadable
 
-    attr_threadsafe :context
-
-    attr_threadsafe :callable
-
-    attr_threadsafe :arguments
-
-    attr_threadsafe :block
-
-    # Create an AsynCall
-    #
-    # @api private
-    def initialize
-      @mutex = Mutex.new
-    end
-
-    # Build asynchronous call instance
+    # Create asynchronous call instance
     #
     # @param [Object] context
     # @param [Callable] callable
@@ -28,18 +17,18 @@ module FiniteMachine
     # @param [#call] block
     #
     # @example
-    #   AsyncCall.build(self, Callable.new(:method), :a, :b)
+    #   AsyncCall.new(context, Callable.new(:method), :a, :b)
     #
     # @return [self]
     #
     # @api public
-    def self.build(context, callable, *args, &block)
-      instance = new
-      instance.context = context
-      instance.callable = callable
-      instance.arguments = *args
-      instance.block = block
-      instance
+    def initialize(context, callable, *args, &block)
+      @context   = context
+      @callable  = callable
+      @arguments = args.dup
+      @block     = block
+      @mutex     = Mutex.new
+      freeze
     end
 
     # Dispatch the event to the context
@@ -49,8 +38,18 @@ module FiniteMachine
     # @api private
     def dispatch
       @mutex.synchronize do
-        callable.call(context, *arguments, block)
+        callable.call(context, *arguments, &block)
       end
     end
+
+    protected
+
+    attr_threadsafe :context
+
+    attr_threadsafe :callable
+
+    attr_threadsafe :arguments
+
+    attr_threadsafe :block
   end # AsyncCall
 end # FiniteMachine

data/lib/finite_machine/async_proxy.rb

@@ -22,7 +22,10 @@ module FiniteMachine
     #
     # @api private
     def method_missing(method_name, *args, &block)
-      event_queue << AsyncCall.build(context, Callable.new(method_name), *args, &block)
+      callable   = Callable.new(method_name)
+      async_call = AsyncCall.new(context, callable, *args, &block)
+
+      event_queue << async_call
     end
   end # AsyncProxy
 end # FiniteMachine

data/lib/finite_machine/dsl.rb

@@ -123,6 +123,27 @@ module FiniteMachine
       end
     end
 
+    # Use alternative name for target
+    #
+    # @example
+    #   target_alias: :car
+    #
+    #   callbacks {
+    #     on_transition do |event|
+    #       car.state = event.to
+    #     end
+    #   }
+    #
+    # @param [Symbol] alias_name
+    #   the name to alias target to
+    #
+    # @return [FiniteMachine::StateMachine]
+    #
+    # @api public
+    def alias_target(alias_name)
+      machine.env.aliases << alias_name.to_sym
+    end
+
     # Define terminal state
     #
     # @example
@@ -170,6 +191,13 @@ module FiniteMachine
       machine.errors.call(&block)
     end
 
+    # Decide whether to log transitions
+    #
+    # @api public
+    def log_transitions(value)
+      machine.log_transitions = value
+    end
+
     private
 
     # Initialize state machine properties based off attributes
@@ -179,6 +207,7 @@ module FiniteMachine
       attrs[:initial]  and initial(attrs[:initial])
       attrs[:target]   and target(attrs[:target])
       attrs[:terminal] and terminal(attrs[:terminal])
+      log_transitions(attrs.fetch(:log_transitions, false))
     end
 
     # Parse initial options

data/lib/finite_machine/event_queue.rb

@@ -40,12 +40,7 @@ module FiniteMachine
     #
     # @api public
     def <<(event)
-      @mutex.lock
-      begin
-        @queue << event
-      ensure
-        @mutex.unlock rescue nil
-      end
+      @mutex.synchronize { @queue << event }
       self
     end
 
@@ -53,7 +48,7 @@ module FiniteMachine
     #
     # @api public
     def subscribe(*args, &block)
-      listener = Listener.new
+      listener = Listener.new(*args)
       listener.on_delivery(&block)
       @listeners << listener
     end
@@ -103,7 +98,7 @@ module FiniteMachine
     #
     # @api public
     def shutdown
-      raise EventQueueDeadError, "event queue already dead" if @dead
+      fail EventQueueDeadError, 'event queue already dead' if @dead
 
       @mutex.lock
       begin
@@ -154,7 +149,7 @@ module FiniteMachine
         event.dispatch
       end
     rescue Exception => ex
-      Logger.error "Error while running event: #{ex}"
+      Logger.error "Error while running event: #{Logger.format_error(ex)}"
     end
   end # EventQueue
 end # FiniteMachine

data/lib/finite_machine/listener.rb

@@ -3,6 +3,13 @@
 module FiniteMachine
   # A generic listener interface
   class Listener
+    # Initialize a listener
+    #
+    # @api private
+    def initialize(*args)
+      @name = args.unshift
+    end
+
     # Define event delivery handler
     #
     # @api public

data/lib/finite_machine/logger.rb

@@ -19,5 +19,24 @@ module FiniteMachine
     def error(message)
       FiniteMachine.logger.error(message)
     end
+
+    def format_error(error)
+      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
+    end
+
+    def report_transition(event_transition, *args)
+      message = "Transition: @event=#{event_transition.name} "
+      unless args.empty?
+        message << "@with=[#{args.join(',')}] "
+      end
+      message << "#{event_transition.from_state} -> "
+      message << "#{event_transition.machine.current}"
+      info(message)
+    end
   end # Logger
 end # FiniteMachine

data/lib/finite_machine/observer.rb

@@ -126,7 +126,7 @@ module FiniteMachine
     #
     # @api private
     def defer(callable, trans_event, *data)
-      async_call = AsyncCall.build(machine, callable, trans_event, *data)
+      async_call = AsyncCall.new(machine, callable, trans_event, *data)
       machine.event_queue << async_call
     end
 
@@ -145,7 +145,7 @@ module FiniteMachine
     # @api private
     def handle_callback(hook, event)
       data        = event.data
-      trans_event = TransitionEvent.build(event.transition, *data)
+      trans_event = TransitionEvent.new(event.transition, *data)
       callable    = create_callable(hook)
 
       if hook.is_a?(Async)

data/lib/finite_machine/state_machine.rb

@@ -44,7 +44,11 @@ module FiniteMachine
     # The state machine event definitions
     attr_threadsafe :events_chain
 
-    def_delegators :@dsl, :initial, :terminal, :target, :trigger_init
+    # Allow or not logging of transitions
+    attr_threadsafe :log_transitions
+
+    def_delegators :@dsl, :initial, :terminal, :target, :trigger_init,
+                   :alias_target
 
     def_delegator :@events_dsl, :event
 
@@ -63,7 +67,7 @@ module FiniteMachine
       @observer      = Observer.new(self)
       @transitions   = Hash.new { |hash, name| hash[name] = Hash.new }
       @events_chain  = EventsChain.new(self)
-      @env           = Environment.new(target: self)
+      @env           = Environment.new(self, [])
       @dsl           = DSL.new(self, attributes)
 
       @dsl.call(&block) if block_given?
@@ -277,6 +281,7 @@ module FiniteMachine
 
         begin
           event_transition.call(*args)
+          Logger.report_transition(event_transition, *args) if log_transitions
 
           notify HookEvent::Transition, event_transition, *args
         rescue Exception => e
@@ -299,8 +304,7 @@ module FiniteMachine
     #
     # @api private
     def raise_transition_error(error)
-      fail(TransitionError, "#(#{error.class}): #{error.message}\n" \
-        "occured at #{error.backtrace.join("\n")}")
+      fail TransitionError, Logger.format_error(error)
     end
 
     # Forward the message to observer or self
@@ -315,6 +319,8 @@ module FiniteMachine
     def method_missing(method_name, *args, &block)
       if observer.respond_to?(method_name.to_sym)
         observer.public_send(method_name.to_sym, *args, &block)
+      elsif env.aliases.include?(method_name.to_sym)
+        env.send(:target, *args, &block)
       else
         super
       end
@@ -330,7 +336,8 @@ module FiniteMachine
     #
     # @api private
     def respond_to_missing?(method_name, include_private = false)
-      observer.respond_to?(method_name.to_sym) || super
+      observer.respond_to?(method_name.to_sym) ||
+        env.aliases.include?(method_name.to_sym) || super
     end
   end # StateMachine
 end # FiniteMachine

data/lib/finite_machine/transition_event.rb

@@ -7,24 +7,26 @@ module FiniteMachine
   #
   # @api private
   class TransitionEvent
+    include Threadable
+
     # This event from state name
     #
     # @return [Object]
     #
     # @api public
-    attr_accessor :from
+    attr_threadsafe :from
 
     # This event to state name
     #
     # @return [Object]
     #
     # @api public
-    attr_accessor :to
+    attr_threadsafe :to
 
     # This event name
     #
     # @api public
-    attr_accessor :name
+    attr_threadsafe :name
 
     # Build a transition event
     #
@@ -33,12 +35,11 @@ module FiniteMachine
     # @return [self]
     #
     # @api private
-    def self.build(transition, *data)
-      instance = new
-      instance.name = transition.name
-      instance.from = transition.latest_from_state
-      instance.to   = transition.to_state(*data)
-      instance
+    def initialize(transition, *data)
+      @name = transition.name
+      @from = transition.latest_from_state
+      @to   = transition.to_state(*data)
+      freeze
     end
   end # TransitionEvent
 end # FiniteMachine

data/lib/finite_machine/version.rb

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

data/lib/finite_machine.rb

@@ -78,7 +78,7 @@ module FiniteMachine
   # Raised when argument is already defined
   AlreadyDefinedError = Class.new(::ArgumentError)
 
-  Environment = Struct.new(:target)
+  Environment = Struct.new(:target, :aliases)
 
   class << self
     attr_accessor :logger

data/spec/spec_helper.rb

@@ -30,7 +30,7 @@ RSpec.configure do |config|
 
   # Remove defined constants
   config.before :each do
-    [:Car, :Logger, :Bug, :User, :Engine].each do |class_name|
+    [:Car, :DummyLogger, :Bug, :User, :Engine].each do |class_name|
       if Object.const_defined?(class_name)
         Object.send(:remove_const, class_name)
       end

data/spec/unit/alias_target_spec.rb

@@ -0,0 +1,108 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine::Definition, '#alias_target' do
+
+  before do
+    Car = Class.new do
+      def turn_reverse_lights_off
+        @reverse_lights = false
+      end
+
+      def turn_reverse_lights_on
+        @reverse_lights = true
+      end
+
+      def reverse_lights?
+        @reverse_lights ||= false
+      end
+    end
+  end
+
+  it "aliases target" do
+    car = Car.new
+    fsm = FiniteMachine.new
+    fsm.target(car)
+
+    expect(fsm.target).to eq(car)
+    expect { fsm.car }.to raise_error(NoMethodError)
+
+    fsm.alias_target(:delorean)
+    expect(fsm.delorean).to eq(car)
+  end
+
+  it "scopes the target alias to a state machine instance" do
+    delorean = Car.new
+    batmobile = Car.new
+    fsm_a = FiniteMachine.new
+    fsm_a.target(delorean)
+    fsm_b = FiniteMachine.new
+    fsm_b.target(batmobile)
+
+    fsm_a.alias_target(:delorean)
+    fsm_b.alias_target(:batmobile)
+
+    expect(fsm_a.delorean).to eq(delorean)
+    expect { fsm_a.batmobile }.to raise_error(NoMethodError)
+
+    expect(fsm_b.batmobile).to eq(batmobile)
+    expect { fsm_b.delorean }.to raise_error(NoMethodError)
+  end
+
+  context 'when inside definition' do
+    before do
+      class Engine < FiniteMachine::Definition
+        initial :neutral
+
+        alias_target :car
+
+        events {
+          event :forward, [:reverse, :neutral] => :one
+          event :shift, :one => :two
+          event :shift, :two => :one
+          event :back,  [:neutral, :one] => :reverse
+        }
+
+        callbacks {
+          on_enter :reverse do |event|
+            car.turn_reverse_lights_on
+          end
+
+          on_exit :reverse do |event|
+            car.turn_reverse_lights_off
+          end
+        }
+
+        handlers {
+          handle FiniteMachine::InvalidStateError do |exception| end
+        }
+      end
+    end
+
+    it "creates unique instances" do
+      engine_a = Engine.new
+      engine_b = Engine.new
+      expect(engine_a).not_to be(engine_b)
+
+      engine_a.forward
+      expect(engine_a.current).to eq(:one)
+      expect(engine_b.current).to eq(:neutral)
+    end
+
+    it "allows to create standalone machine" do
+      car = Car.new
+      engine = Engine.new
+      engine.target car
+      expect(engine.current).to eq(:neutral)
+
+      engine.forward
+      expect(engine.current).to eq(:one)
+      expect(car.reverse_lights?).to be false
+
+      engine.back
+      expect(engine.current).to eq(:reverse)
+      expect(car.reverse_lights?).to be true
+    end
+  end
+end

data/spec/unit/async_events_spec.rb

@@ -10,8 +10,8 @@ describe FiniteMachine, 'async_events' do
       initial :green
 
       events {
-        event :slow, :green => :yellow
-        event :stop, :yellow => :red
+        event :slow,  :green  => :yellow
+        event :stop,  :yellow => :red
         event :ready, :red    => :yellow
         event :go,    :yellow => :green
       }
@@ -38,6 +38,38 @@ describe FiniteMachine, 'async_events' do
     ])
   end
 
+  it 'correctly passes parameters to conditionals' do
+    called = []
+    fsm = FiniteMachine.define do
+      events {
+        event :go, :none => :green,
+              if: proc { |context, arg|
+                called << "cond_none_green(#{context},#{arg})"; true
+              }
+
+        event :stop, from: :any do
+          choice :red, if: proc { |context, arg|
+                         called << "cond_any_red(#{context},#{arg})"; true
+                       }
+        end
+      }
+    end
+    expect(fsm.current).to eql(:none)
+    fsm.async.go(:foo)
+    fsm.event_queue.join 0.01
+    expect(fsm.current).to eql(:green)
+    expect(called).to eql(["cond_none_green(#{fsm},foo)"])
+
+    expect(fsm.current).to eql(:green)
+    fsm.async.stop(:bar)
+    fsm.event_queue.join 0.01
+    expect(fsm.current).to eql(:red)
+    expect(called).to match_array([
+      "cond_none_green(#{fsm},foo)",
+      "cond_any_red(#{fsm},bar)"
+    ])
+  end
+
   it "ensure queue per thread" do
     called = []
     fsmFoo = FiniteMachine.define do

data/spec/unit/handlers_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe FiniteMachine, 'handlers' do
 
   before(:each) {
-    Logger = Class.new do
+    DummyLogger = Class.new do
       attr_reader :result
 
       def log_error(exception)
@@ -44,7 +44,7 @@ describe FiniteMachine, 'handlers' do
   end
 
   it 'allows for :with to be symbol' do
-    logger = Logger.new
+    logger = DummyLogger.new
     fsm = FiniteMachine.define do
       initial :green
 
@@ -67,7 +67,7 @@ describe FiniteMachine, 'handlers' do
   end
 
   it 'allows for error type as string' do
-    logger = Logger.new
+    logger = DummyLogger.new
     called = []
     fsm = FiniteMachine.define do
       initial :green

data/spec/unit/if_unless_spec.rb

@@ -27,6 +27,64 @@ describe FiniteMachine, ':if, :unless' do
     end
   }
 
+  it "passes context to conditionals" do
+    called = []
+    fsm = FiniteMachine.define do
+      initial :red
+
+      events {
+        event :go, :red => :green,
+              if: proc { |context| called << "cond_red_green(#{context})"; true}
+        event :stop, from: :any do
+          choice :red,
+                 if: proc { |context| called << "cond_any_red(#{context})"; true }
+        end
+      }
+    end
+
+    expect(fsm.current).to eq(:red)
+
+    fsm.go
+    expect(fsm.current).to eq(:green)
+    expect(called).to eq(["cond_red_green(#{fsm})"])
+
+    fsm.stop
+    expect(fsm.current).to eq(:red)
+    expect(called).to match_array([
+      "cond_red_green(#{fsm})",
+      "cond_any_red(#{fsm})"
+    ])
+  end
+
+  it "passes context & arguments to conditionals" do
+    called = []
+    fsm = FiniteMachine.define do
+      initial :red
+
+      events {
+        event :go,  :red => :green,
+              if: proc { |_, a| called << "cond_red_green(#{a})"; true }
+        event :stop, from: :any do
+          choice :red,
+                 if: proc { |_, b| called << "cond_any_red(#{b})"; true }
+        end
+      }
+    end
+
+    expect(fsm.current).to eq(:red)
+
+    fsm.go(:foo)
+    expect(fsm.current).to eq(:green)
+    expect(called).to eq(["cond_red_green(foo)"])
+
+    fsm.stop(:bar)
+    expect(fsm.current).to eq(:red)
+    expect(called).to match_array([
+      "cond_red_green(foo)",
+      "cond_any_red(bar)"
+    ])
+  end
+
   it "allows to cancel event with :if option" do
     called = []
 

data/spec/unit/initialize_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe FiniteMachine, 'initialize' do
 
   before(:each) {
-    Logger = Class.new do
+    DummyLogger = Class.new do
       attr_accessor :level
 
       def initialize
@@ -128,7 +128,7 @@ describe FiniteMachine, 'initialize' do
   end
 
   it "evaluates initial state" do
-    logger = Logger.new
+    logger = DummyLogger.new
     fsm = FiniteMachine.define do
       initial logger.level
 

data/spec/unit/log_transitions_spec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine, 'log_transitions' do
+  let(:output) { StringIO.new('', 'w+')}
+
+  before { FiniteMachine.logger = ::Logger.new(output) }
+
+  after  { FiniteMachine.logger = ::Logger.new($stderr) }
+
+  it "logs transitions" do
+    fsm = FiniteMachine.define log_transitions: true do
+      initial :green
+
+      events {
+        event :slow, :green  => :yellow
+        event :stop, :yellow => :red
+      }
+    end
+
+    fsm.slow
+    output.rewind
+    expect(output.read).to match(/Transition: @event=slow green -> yellow/)
+
+    fsm.stop(1, 2)
+    output.rewind
+    expect(output.read).to match(/Transition: @event=stop @with=\[1,2\] yellow -> red/)
+  end
+end

data/spec/unit/logger_spec.rb

@@ -30,4 +30,11 @@ describe FiniteMachine::Logger do
     expect(log).to receive(:error).with(message)
     logger.error(message)
   end
+
+  it "reports transition" do
+    expect(log).to receive(:info).with("Transition: @event=go red -> green")
+    machine = double(:machine, current: :green)
+    transition = double(:transition, name: "go", from_state: :red, machine: machine)
+    logger.report_transition(transition)
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: finite_machine
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.10.0
 platform: ruby
 authors:
 - Piotr Murach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-27 00:00:00.000000000 Z
+date: 2014-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -75,12 +75,14 @@ files:
 - lib/finite_machine/two_phase_lock.rb
 - lib/finite_machine/version.rb
 - spec/spec_helper.rb
+- spec/unit/alias_target_spec.rb
 - spec/unit/async_events_spec.rb
 - spec/unit/callable/call_spec.rb
 - spec/unit/callbacks_spec.rb
 - spec/unit/can_spec.rb
 - spec/unit/choice_spec.rb
 - spec/unit/define_spec.rb
+- spec/unit/definition_spec.rb
 - spec/unit/event/add_spec.rb
 - spec/unit/event/eql_spec.rb
 - spec/unit/event/initialize_spec.rb
@@ -103,9 +105,9 @@ files:
 - spec/unit/initialize_spec.rb
 - spec/unit/inspect_spec.rb
 - spec/unit/is_spec.rb
+- spec/unit/log_transitions_spec.rb
 - spec/unit/logger_spec.rb
 - spec/unit/respond_to_spec.rb
-- spec/unit/standalone_spec.rb
 - spec/unit/state_parser/inspect_spec.rb
 - spec/unit/state_parser/parse_states_spec.rb
 - spec/unit/states_spec.rb
@@ -143,12 +145,14 @@ specification_version: 4
 summary: A minimal finite state machine with a straightforward syntax.
 test_files:
 - spec/spec_helper.rb
+- spec/unit/alias_target_spec.rb
 - spec/unit/async_events_spec.rb
 - spec/unit/callable/call_spec.rb
 - spec/unit/callbacks_spec.rb
 - spec/unit/can_spec.rb
 - spec/unit/choice_spec.rb
 - spec/unit/define_spec.rb
+- spec/unit/definition_spec.rb
 - spec/unit/event/add_spec.rb
 - spec/unit/event/eql_spec.rb
 - spec/unit/event/initialize_spec.rb
@@ -171,9 +175,9 @@ test_files:
 - spec/unit/initialize_spec.rb
 - spec/unit/inspect_spec.rb
 - spec/unit/is_spec.rb
+- spec/unit/log_transitions_spec.rb
 - spec/unit/logger_spec.rb
 - spec/unit/respond_to_spec.rb
-- spec/unit/standalone_spec.rb
 - spec/unit/state_parser/inspect_spec.rb
 - spec/unit/state_parser/parse_states_spec.rb
 - spec/unit/states_spec.rb