finite_machine 0.1.0 → 0.2.0

data/spec/unit/events_spec.rb

@@ -147,7 +147,7 @@ describe FiniteMachine, 'events' do
 
     expect(fsm.current).to eql(:green)
 
-    expect { fsm.stop }.to raise_error(FiniteMachine::TransitionError, /state 'green'/)
+    expect { fsm.stop }.to raise_error(FiniteMachine::InvalidStateError, /state 'green'/)
   end
 
   context 'when multiple from states' do

data/spec/unit/handlers_spec.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine, 'handlers' do
+
+  before(:each) {
+    Logger = Class.new do
+      attr_reader :result
+
+      def log_error(exception)
+        @result = "log_error(#{exception})"
+      end
+
+      def raise_error
+        raise FiniteMachine::TransitionError
+      end
+    end
+  }
+
+  it "allows to customise error handling" do
+    called = []
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow, :green  => :yellow
+        event :stop, :yellow => :red
+      }
+
+      handlers {
+        handle FiniteMachine::InvalidStateError do |exception|
+          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 'allows for :with to be symbol' do
+    logger = Logger.new
+    fsm = FiniteMachine.define do
+      initial :green
+
+      target logger
+
+      events {
+        event :slow, :green  => :yellow
+        event :stop, :yellow => :red
+      }
+
+      handlers {
+        handle FiniteMachine::InvalidStateError, with: :log_error
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+    fsm.stop
+    expect(fsm.current).to eql(:green)
+    expect(logger.result).to eql('log_error(FiniteMachine::InvalidStateError)')
+  end
+
+  it 'allows for error type as string' do
+    logger = Logger.new
+    called = []
+    fsm = FiniteMachine.define do
+      initial :green
+
+      target logger
+
+      events {
+        event :slow, :green  => :yellow
+        event :stop, :yellow => :red
+      }
+
+      callbacks {
+        on_enter_yellow do |event|
+          raise_error
+        end
+      }
+      handlers {
+        handle 'InvalidStateError' do |exception|
+          called << 'invalid_state_error'
+        end
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+    fsm.stop
+    expect(fsm.current).to eql(:green)
+    expect(called).to eql(['invalid_state_error'])
+  end
+end

data/spec/unit/if_unless_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 describe FiniteMachine, ':if, :unless' do
-  before(:all) {
+  before(:each) {
     Car = Class.new do
       def turn_engine_on
         @engine_on = true
@@ -62,7 +62,7 @@ describe FiniteMachine, ':if, :unless' do
       initial :green
 
       events {
-        event :slow, :green => :yellow, unless: -> { return true }
+        event :slow, :green => :yellow, unless: -> { true }
         event :stop, :yellow => :red
       }
 
@@ -125,7 +125,7 @@ describe FiniteMachine, ':if, :unless' do
       target car
 
       events {
-        event :start, :neutral => :one, if: -> (car) { car.engine_on? }
+        event :start, :neutral => :one, if: proc {|car| car.engine_on? }
         event :shift, :one => :two
       }
     end

data/spec/unit/initialize_spec.rb

@@ -4,6 +4,16 @@ require 'spec_helper'
 
 describe FiniteMachine, 'initialize' do
 
+  before(:each) {
+    Logger = Class.new do
+      attr_accessor :level
+
+      def initialize
+        @level = :pending
+      end
+    end
+  }
+
   it "defaults initial state to :none" do
     fsm = FiniteMachine.define do
       events {
@@ -46,6 +56,23 @@ describe FiniteMachine, 'initialize' do
     fsm = FiniteMachine.define do
       initial state: :green, event: :start
 
+      events {
+        event :slow, :green  => :none
+        event :stop, :yellow => :red
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+    fsm.slow
+    expect(fsm.current).to eql(:none)
+    fsm.start
+    expect(fsm.current).to eql(:green)
+  end
+
+  it "allows to specify deferred inital start event" do
+    fsm = FiniteMachine.define do
+      initial state: :green, event: :start, defer: true
+
       events {
         event :slow, :green  => :yellow
         event :stop, :yellow => :red
@@ -56,4 +83,17 @@ describe FiniteMachine, 'initialize' do
     fsm.start
     expect(fsm.current).to eql(:green)
   end
+
+  it "evaluates initial state" do
+    logger = Logger.new
+    fsm = FiniteMachine.define do
+      initial logger.level
+
+      events {
+        event :slow, :green  => :none
+        event :stop, :yellow => :red
+      }
+    end
+    expect(fsm.current).to eql(:pending)
+  end
 end

data/spec/unit/target_spec.rb

@@ -0,0 +1,137 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine, '#target' do
+
+  it "allows to target external object" do
+    Car = Class.new do
+      attr_accessor :reverse_lights
+
+      def turn_reverse_lights_off
+        @reverse_lights = false
+      end
+
+      def turn_reverse_lights_on
+        @reverse_lights = true
+      end
+
+      def engine
+        context = self
+        @engine ||= FiniteMachine.define do
+          initial :neutral
+
+          target context
+
+          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|
+              turn_reverse_lights_on
+            end
+
+            on_exit :reverse do |event|
+              turn_reverse_lights_off
+            end
+          }
+        end
+      end
+    end
+    car = Car.new
+    expect(car.reverse_lights).to be_false
+    expect(car.engine.current).to eql(:neutral)
+    car.engine.back
+    expect(car.engine.current).to eql(:reverse)
+    expect(car.reverse_lights).to be_true
+    car.engine.forward
+    expect(car.engine.current).to eql(:one)
+    expect(car.reverse_lights).to be_false
+  end
+
+  it "references machine methods inside callback" 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
+      }
+
+      callbacks {
+        on_enter_yellow do |event|
+          stop(:now)
+        end
+
+        on_enter_red do |event, param|
+          called << "#{event.from} #{param}"
+        end
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+    fsm.slow
+    expect(fsm.current).to eql(:red)
+    expect(called).to eql(['yellow now'])
+  end
+
+  it "allows context methods take precedence over machine ones" do
+    Car = Class.new do
+      attr_accessor :reverse_lights
+      attr_accessor :called
+
+      def turn_reverse_lights_off
+        @reverse_lights = false
+      end
+
+      def turn_reverse_lights_on
+        @reverse_lights = true
+      end
+
+      def engine
+        self.called ||= []
+        context ||= self
+        @engine ||= FiniteMachine.define do
+          initial :neutral
+
+          target context
+
+          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|
+              called << 'on_enter_reverse'
+              turn_reverse_lights_on
+              forward('Piotr!')
+            end
+            on_enter :forward do |event, name|
+              called << "on_enter_forward with #{name}"
+            end
+          }
+        end
+      end
+    end
+
+    car = Car.new
+    expect(car.reverse_lights).to be_false
+    expect(car.engine.current).to eql(:neutral)
+    car.engine.back
+    expect(car.engine.current).to eql(:one)
+    expect(car.called).to eql([
+      'on_enter_reverse',
+      'on_enter_forward with Piotr!'
+    ])
+  end
+end

data/spec/unit/transition/parse_states_spec.rb

@@ -4,15 +4,24 @@ require 'spec_helper'
 
 describe FiniteMachine::Transition, 'parse_states' do
 
-  let(:object) { described_class.new(attrs) }
+  let(:machine) { double }
 
-  subject(:transition) { object.parse_states(attrs) }
+  subject(:transition) { described_class.new(machine, attrs) }
+
+  context 'without transitions' do
+    let(:attrs) { { } }
+
+    it "raises exception" do
+      expect { transition }.to raise_error(FiniteMachine::NotEnoughTransitionsError)
+    end
+  end
 
   context 'with :from, :to keys' do
     let(:attrs) { {from: [:green, :yellow], to: :red} }
 
     it "groups states" do
-      expect(transition).to eql([[:green, :yellow], :red])
+      expect(transition.from).to eql(attrs[:from])
+      expect(transition.to).to eql(attrs[:to])
     end
   end
 
@@ -20,7 +29,8 @@ describe FiniteMachine::Transition, 'parse_states' do
     let(:attrs) { {[:green, :yellow] => :red} }
 
     it "groups states" do
-      expect(transition).to eql([[:green, :yellow], :red])
+      expect(transition.from).to eql([:green, :yellow])
+      expect(transition.to).to eql(:red)
     end
   end
 
@@ -28,7 +38,8 @@ describe FiniteMachine::Transition, 'parse_states' do
     let(:attrs) { { :green => :red, :yellow => :red} }
 
     it "groups states" do
-      expect(transition).to eql([[:green, :yellow], :red])
+      expect(transition.from).to eql([:green, :yellow])
+      expect(transition.to).to eql(:red)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: finite_machine
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Piotr Murach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-09 00:00:00.000000000 Z
+date: 2014-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,7 +52,9 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: A minimal finite state machine with a straightforward syntax.
+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.
 email:
 - ''
 executables: []
@@ -62,6 +64,7 @@ files:
 - .gitignore
 - .rspec
 - .travis.yml
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -69,8 +72,10 @@ files:
 - finite_machine.gemspec
 - lib/finite_machine.rb
 - lib/finite_machine/callable.rb
+- lib/finite_machine/catchable.rb
 - lib/finite_machine/dsl.rb
 - lib/finite_machine/event.rb
+- lib/finite_machine/hooks.rb
 - lib/finite_machine/observer.rb
 - lib/finite_machine/state_machine.rb
 - lib/finite_machine/subscribers.rb
@@ -78,17 +83,20 @@ files:
 - lib/finite_machine/transition.rb
 - lib/finite_machine/version.rb
 - spec/spec_helper.rb
+- spec/unit/callable/call_spec.rb
 - spec/unit/callbacks_spec.rb
 - spec/unit/can_spec.rb
 - spec/unit/define_spec.rb
 - spec/unit/events_spec.rb
 - spec/unit/finished_spec.rb
+- spec/unit/handlers_spec.rb
 - spec/unit/if_unless_spec.rb
 - spec/unit/initialize_spec.rb
 - spec/unit/is_spec.rb
 - spec/unit/states_spec.rb
+- spec/unit/target_spec.rb
 - spec/unit/transition/parse_states_spec.rb
-homepage: ''
+homepage: https://github.com/peter-murach/finite_machine
 licenses:
 - MIT
 metadata: {}
@@ -114,13 +122,16 @@ specification_version: 4
 summary: A minimal finite state machine with a straightforward syntax.
 test_files:
 - spec/spec_helper.rb
+- spec/unit/callable/call_spec.rb
 - spec/unit/callbacks_spec.rb
 - spec/unit/can_spec.rb
 - spec/unit/define_spec.rb
 - spec/unit/events_spec.rb
 - spec/unit/finished_spec.rb
+- spec/unit/handlers_spec.rb
 - spec/unit/if_unless_spec.rb
 - spec/unit/initialize_spec.rb
 - spec/unit/is_spec.rb
 - spec/unit/states_spec.rb
+- spec/unit/target_spec.rb
 - spec/unit/transition/parse_states_spec.rb