finite_machine 0.2.0 → 0.3.0

data/spec/unit/callable/call_spec.rb

@@ -8,12 +8,16 @@ describe FiniteMachine::Callable, '#call' do
     Car = Class.new do
       attr_reader :result
 
+      def initialize
+        @engine_on = false
+      end
+
       def turn_engine_on
         @result = 'turn_engine_on'
         @engine_on = true
       end
 
-      def set_engine(value)
+      def set_engine(value = :on)
         @result = "set_engine(#{value})"
         @engine = value.to_sym == :on
       end
@@ -54,12 +58,30 @@ describe FiniteMachine::Callable, '#call' do
     end
   end
 
+  context 'when string with arguments' do
+    let(:object) {  'set_engine' }
+
+    it 'executes method with arguments' do
+      instance.call(target, :off)
+      expect(target.result).to eql('set_engine(off)')
+    end
+  end
+
   context 'when symbol' do
-    let(:object) {  :engine_on? }
+    let(:object) {  :set_engine }
 
     it 'executes method on target' do
       instance.call(target)
-      expect(target.result).to eql('engine_on')
+      expect(target.result).to eql('set_engine(on)')
+    end
+  end
+
+  context 'when symbol with arguments' do
+    let(:object) {  :set_engine }
+
+    it 'executes method on target' do
+      instance.call(target, :off)
+      expect(target.result).to eql('set_engine(off)')
     end
   end
 

data/spec/unit/callbacks_spec.rb

@@ -47,6 +47,8 @@ describe FiniteMachine, 'callbacks' do
       }
     end
 
+    expect(fsm.current).to eql(:green)
+
     expect(called).to eql([
       'on_exit_none',
       'on_exit',
@@ -394,9 +396,9 @@ describe FiniteMachine, 'callbacks' do
 
       callbacks {
         # generic callbacks
-        on_enter      &callback
-        on_transition &callback
-        on_exit       &callback
+        on_enter(&callback)
+        on_transition(&callback)
+        on_exit(&callback)
 
         # state callbacks
         on_enter :green,  &callback
@@ -471,5 +473,109 @@ describe FiniteMachine, 'callbacks' do
     expect { fsm.slow }.to raise_error(RuntimeError)
   end
 
-  xit "executes callbacks with multiple 'from' transitions"
+  it "executes callbacks with multiple 'from' transitions" do
+    called = []
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :stop,  :green  => :yellow
+        event :stop,  :yellow => :red
+      }
+
+      callbacks {
+        on_enter_stop do |event|
+          called << 'on_enter_stop'
+        end
+      }
+    end
+    expect(fsm.current).to eql(:green)
+    fsm.stop
+    expect(fsm.current).to eql(:yellow)
+    fsm.stop
+    expect(fsm.current).to eql(:red)
+    expect(called).to eql([
+      'on_enter_stop',
+      'on_enter_stop'
+    ])
+  end
+
+  it "allows to define callbacks on machine instance" do
+    called = []
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow,  :green  => :yellow
+        event :stop,  :yellow => :red
+        event :ready, :red    => :yellow
+        event :go,    :yellow => :green
+      }
+    end
+
+    fsm.on_enter_yellow do |event|
+      called << 'on_enter_yellow'
+    end
+
+    expect(fsm.current).to eql(:green)
+    fsm.slow
+    expect(called).to eql([
+      'on_enter_yellow'
+    ])
+  end
+
+  it "raises error for unknown callback" do
+    expect { FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow,  :green  => :yellow
+        event :stop,  :yellow => :red
+        event :ready, :red    => :yellow
+        event :go,    :yellow => :green
+      }
+
+      callbacks {
+        on_enter_unknown do |event| end
+      }
+    end }.to raise_error(NoMethodError)
+  end
+
+  it "triggers callbacks only once" do
+    called = []
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow,  :green  => :yellow
+        event :go,    :yellow => :green
+      }
+
+      callbacks {
+        once_on_enter_green  do |event| called << 'once_on_enter_green' end
+        once_on_enter_yellow do |event| called << 'once_on_enter_yellow' end
+
+        once_on_transition_green do |event| called << 'once_on_transition_green' end
+        once_on_transition_yellow do |event| called << 'once_on_transition_yellow' end
+
+        once_on_exit_green  do |event| called << 'once_on_exit_green' end
+        once_on_exit_yellow do |event| called << 'once_on_exit_yellow' end
+      }
+    end
+    expect(fsm.current).to eql(:green)
+    fsm.slow
+    expect(fsm.current).to eql(:yellow)
+    fsm.go
+    expect(fsm.current).to eql(:green)
+    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'
+    ])
+  end
 end

data/spec/unit/events_spec.rb

@@ -216,6 +216,7 @@ describe FiniteMachine, 'events' do
         event :stop,  :green  => :yellow
         event :stop,  :yellow => :red
         event :stop,  :red    => :pink
+        event :cycle, [:yellow, :red, :pink] => :green
       }
     end
 
@@ -229,6 +230,10 @@ describe FiniteMachine, 'events' do
     expect(fsm.current).to eql(:red)
     fsm.stop
     expect(fsm.current).to eql(:pink)
+    fsm.cycle
+    expect(fsm.current).to eql(:green)
+    fsm.stop
+    expect(fsm.current).to eql(:yellow)
   end
 
   it "returns values for events" do

data/spec/unit/handlers_spec.rb

@@ -96,4 +96,57 @@ describe FiniteMachine, 'handlers' do
     expect(fsm.current).to eql(:green)
     expect(called).to eql(['invalid_state_error'])
   end
+
+  it 'allows for empty block handler' do
+    called = []
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow, :green  => :yellow
+        event :stop, :yellow => :red
+      }
+
+      handlers {
+        handle FiniteMachine::InvalidStateError do
+          called << 'invalidstate'
+        end
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+    fsm.stop
+    expect(fsm.current).to eql(:green)
+    expect(called).to eql([
+      'invalidstate'
+    ])
+  end
+
+  it 'requires error handler' do
+    expect { FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow, :green => :yellow
+      }
+
+      handlers {
+        handle 'UnknownErrorType'
+      }
+    end }.to raise_error(ArgumentError, /error handler/)
+  end
+
+  it 'checks handler class to be Exception' do
+    expect { FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow, :green => :yellow
+      }
+
+      handlers {
+        handle Object do end
+      }
+    end }.to raise_error(ArgumentError, /Object isn't an Exception/)
+  end
 end

data/spec/unit/if_unless_spec.rb

@@ -125,7 +125,7 @@ describe FiniteMachine, ':if, :unless' do
       target car
 
       events {
-        event :start, :neutral => :one, if: proc {|car| car.engine_on? }
+        event :start, :neutral => :one, if: proc {|_car| _car.engine_on? }
         event :shift, :one => :two
       }
     end

data/spec/unit/is_spec.rb

@@ -30,4 +30,26 @@ describe FiniteMachine, 'is?' do
     expect(fsm.is?([:green, :red])).to be_false
     expect(fsm.is?([:yellow, :red])).to be_true
   end
+
+  it "defines helper methods to check current state" do
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow,  :green  => :yellow
+        event :stop,  :yellow => :red
+        event :ready, :red    => :yellow
+        event :go,    :yellow => :green
+      }
+    end
+    expect(fsm.current).to eql(:green)
+
+    expect(fsm.green?).to be_true
+    expect(fsm.yellow?).to be_false
+
+    fsm.slow
+
+    expect(fsm.green?).to be_false
+    expect(fsm.yellow?).to be_true
+  end
 end

data/spec/unit/target_spec.rb

@@ -53,6 +53,23 @@ describe FiniteMachine, '#target' do
     expect(car.reverse_lights).to be_false
   end
 
+  it "propagates method call" do
+    fsm = FiniteMachine.define do
+      initial :green
+      events {
+        event :slow, :green => :yellow
+      }
+
+      callbacks {
+        on_enter_yellow do |event|
+          uknown_method
+        end
+      }
+    end
+    expect(fsm.current).to eql(:green)
+    expect { fsm.slow }.to raise_error(StandardError)
+  end
+
   it "references machine methods inside callback" do
     called = []
     fsm = FiniteMachine.define do

data/tasks/console.rake

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+desc 'Load gem inside irb console'
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require File.join(__FILE__, '../lib/finite_machine')
+  ARGV.clear
+  IRB.start
+end

data/tasks/coverage.rake

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+desc 'Measure code coverage'
+task :coverage do
+  begin
+    original, ENV['COVERAGE'] = ENV['COVERAGE'], 'true'
+    Rake::Task['spec'].invoke
+  ensure
+    ENV['COVERAGE'] = original
+  end
+end

data/tasks/spec.rake

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+begin
+  require 'rspec/core/rake_task'
+
+  desc 'Run all specs'
+  RSpec::Core::RakeTask.new(:spec) do |task|
+    task.pattern = 'spec/{unit,integration}{,/*/**}/*_spec.rb'
+  end
+
+  namespace :spec do
+    desc 'Run unit specs'
+    RSpec::Core::RakeTask.new(:unit) do |task|
+      task.pattern = 'spec/unit{,/*/**}/*_spec.rb'
+    end
+
+    desc 'Run integration specs'
+    RSpec::Core::RakeTask.new(:integration) do |task|
+      task.pattern = 'spec/integration{,/*/**}/*_spec.rb'
+    end
+  end
+
+rescue LoadError
+  %w[spec spec:unit spec:integration].each do |name|
+    task name do
+      $stderr.puts "In order to run #{name}, do `gem install rspec`"
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: finite_machine
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Piotr Murach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-01 00:00:00.000000000 Z
+date: 2014-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,42 +16,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.3'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.5'
 description: A minimal finite state machine with a straightforward syntax. You can
   quickly model states, add callbacks and use object-oriented techniques to integrate
   with ORMs.
@@ -63,6 +35,8 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- .ruby-gemset
+- .ruby-version
 - .travis.yml
 - CHANGELOG.md
 - Gemfile
@@ -71,18 +45,23 @@ files:
 - Rakefile
 - finite_machine.gemspec
 - lib/finite_machine.rb
+- lib/finite_machine/async_call.rb
+- lib/finite_machine/async_proxy.rb
 - lib/finite_machine/callable.rb
 - lib/finite_machine/catchable.rb
 - lib/finite_machine/dsl.rb
 - lib/finite_machine/event.rb
+- lib/finite_machine/event_queue.rb
 - lib/finite_machine/hooks.rb
 - lib/finite_machine/observer.rb
 - lib/finite_machine/state_machine.rb
 - lib/finite_machine/subscribers.rb
+- lib/finite_machine/thread_context.rb
 - lib/finite_machine/threadable.rb
 - lib/finite_machine/transition.rb
 - lib/finite_machine/version.rb
 - spec/spec_helper.rb
+- spec/unit/async_events_spec.rb
 - spec/unit/callable/call_spec.rb
 - spec/unit/callbacks_spec.rb
 - spec/unit/can_spec.rb
@@ -96,6 +75,9 @@ files:
 - spec/unit/states_spec.rb
 - spec/unit/target_spec.rb
 - spec/unit/transition/parse_states_spec.rb
+- tasks/console.rake
+- tasks/coverage.rake
+- tasks/spec.rake
 homepage: https://github.com/peter-murach/finite_machine
 licenses:
 - MIT
@@ -122,6 +104,7 @@ specification_version: 4
 summary: A minimal finite state machine with a straightforward syntax.
 test_files:
 - spec/spec_helper.rb
+- spec/unit/async_events_spec.rb
 - spec/unit/callable/call_spec.rb
 - spec/unit/callbacks_spec.rb
 - spec/unit/can_spec.rb
@@ -135,3 +118,4 @@ test_files:
 - spec/unit/states_spec.rb
 - spec/unit/target_spec.rb
 - spec/unit/transition/parse_states_spec.rb
+has_rdoc: