finite_machine 0.3.0 → 0.4.0

data/spec/unit/events_spec.rb

@@ -150,6 +150,21 @@ describe FiniteMachine, 'events' do
     expect { fsm.stop }.to raise_error(FiniteMachine::InvalidStateError, /state 'green'/)
   end
 
+  it "allows to transition to any state" do
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow,  from: :green,  to: :yellow
+        event :stop,  from: :yellow, to: :red
+      }
+    end
+    expect(fsm.current).to eql(:green)
+    expect(fsm.can?(:stop)).to be_false
+    fsm.stop!
+    expect(fsm.current).to eql(:red)
+  end
+
   context 'when multiple from states' do
     it "allows for array from key" do
       fsm = FiniteMachine.define do

data/spec/unit/if_unless_spec.rb

@@ -5,6 +5,8 @@ require 'spec_helper'
 describe FiniteMachine, ':if, :unless' do
   before(:each) {
     Car = Class.new do
+      attr_accessor :engine_on
+
       def turn_engine_on
         @engine_on = true
       end
@@ -116,81 +118,109 @@ describe FiniteMachine, ':if, :unless' do
     ])
   end
 
-  it "specifies :if and :unless with proc" do
-    car = Car.new
+  context 'when proc' do
+    it "specifies :if and :unless" do
+      car = Car.new
 
-    fsm = FiniteMachine.define do
-      initial :neutral
+      fsm = FiniteMachine.define do
+        initial :neutral
 
-      target car
+        target car
 
-      events {
-        event :start, :neutral => :one, if: proc {|_car| _car.engine_on? }
-        event :shift, :one => :two
-      }
+        events {
+          event :start, :neutral => :one, if: proc {|_car| _car.engine_on? }
+          event :shift, :one => :two
+        }
+      end
+      car.turn_engine_off
+      expect(car.engine_on?).to be_false
+      expect(fsm.current).to eql(:neutral)
+      fsm.start
+      expect(fsm.current).to eql(:neutral)
+
+      car.turn_engine_on
+      expect(car.engine_on?).to be_true
+      expect(fsm.current).to eql(:neutral)
+      fsm.start
+      expect(fsm.current).to eql(:one)
+    end
+
+    it "passes arguments to the scope" do
+      car = Car.new
+
+      fsm = FiniteMachine.define do
+        initial :neutral
+
+        target car
+
+        events {
+          event :start, :neutral => :one, if: proc { |_car, state|
+            _car.engine_on = state
+            _car.engine_on?
+          }
+          event :shift, :one => :two
+        }
+      end
+      fsm.start(false)
+      expect(fsm.current).to eql(:neutral)
+      fsm.start(true)
+      expect(fsm.current).to eql(:one)
     end
-    car.turn_engine_off
-    expect(car.engine_on?).to be_false
-    expect(fsm.current).to eql(:neutral)
-    fsm.start
-    expect(fsm.current).to eql(:neutral)
-
-    car.turn_engine_on
-    expect(car.engine_on?).to be_true
-    expect(fsm.current).to eql(:neutral)
-    fsm.start
-    expect(fsm.current).to eql(:one)
   end
 
-  it "specifies :if and :unless with symbol" do
-    car = Car.new
+  context 'when symbol' do
+    it "specifies :if and :unless" do
+      car = Car.new
 
-    fsm = FiniteMachine.define do
-      initial :neutral
+      fsm = FiniteMachine.define do
+        initial :neutral
 
-      target car
+        target car
 
-      events {
-        event :start, :neutral => :one, if: :engine_on?
-        event :shift, :one => :two
-      }
+        events {
+          event :start, :neutral => :one, if: :engine_on?
+          event :shift, :one => :two
+        }
+      end
+      car.turn_engine_off
+      expect(car.engine_on?).to be_false
+      expect(fsm.current).to eql(:neutral)
+      fsm.start
+      expect(fsm.current).to eql(:neutral)
+
+      car.turn_engine_on
+      expect(car.engine_on?).to be_true
+      expect(fsm.current).to eql(:neutral)
+      fsm.start
+      expect(fsm.current).to eql(:one)
     end
-    car.turn_engine_off
-    expect(car.engine_on?).to be_false
-    expect(fsm.current).to eql(:neutral)
-    fsm.start
-    expect(fsm.current).to eql(:neutral)
-
-    car.turn_engine_on
-    expect(car.engine_on?).to be_true
-    expect(fsm.current).to eql(:neutral)
-    fsm.start
-    expect(fsm.current).to eql(:one)
   end
 
-  it "specifies :if and :unless with string" do
-    car = Car.new
+  context 'when string' do
+    it "specifies :if and :unless" do
+      car = Car.new
 
-    fsm = FiniteMachine.define do
-      initial :neutral
+      fsm = FiniteMachine.define do
+        initial :neutral
 
-      target car
+        target car
 
-      events {
-        event :start, :neutral => :one, if: "engine_on?"
-        event :shift, :one => :two
-      }
+        events {
+          event :start, :neutral => :one, if: "engine_on?"
+          event :shift, :one => :two
+        }
+      end
+      car.turn_engine_off
+      expect(car.engine_on?).to be_false
+      expect(fsm.current).to eql(:neutral)
+      fsm.start
+      expect(fsm.current).to eql(:neutral)
+
+      car.turn_engine_on
+      expect(car.engine_on?).to be_true
+      expect(fsm.current).to eql(:neutral)
+      fsm.start
+      expect(fsm.current).to eql(:one)
     end
-    car.turn_engine_off
-    expect(car.engine_on?).to be_false
-    expect(fsm.current).to eql(:neutral)
-    fsm.start
-    expect(fsm.current).to eql(:neutral)
-
-    car.turn_engine_on
-    expect(car.engine_on?).to be_true
-    expect(fsm.current).to eql(:neutral)
-    fsm.start
-    expect(fsm.current).to eql(:one)
   end
 end

data/spec/unit/initialize_spec.rb

@@ -25,7 +25,22 @@ describe FiniteMachine, 'initialize' do
     expect(fsm.current).to eql(:none)
   end
 
+  it "requires initial state transition from :none" do
+    fsm = FiniteMachine.define do
+      events {
+        event :init, :none   => :green
+        event :slow, :green  => :yellow
+        event :stop, :yellow => :red
+      }
+    end
+
+    expect(fsm.current).to eql(:none)
+    fsm.init
+    expect(fsm.current).to eql(:green)
+  end
+
   it "allows to specify inital state" do
+    called = []
     fsm = FiniteMachine.define do
       initial :green
 
@@ -33,9 +48,12 @@ describe FiniteMachine, 'initialize' do
         event :slow, :green  => :yellow
         event :stop, :yellow => :red
       }
+      callbacks {
+        on_enter :green do |event| called << 'on_enter_green' end
+      }
     end
-
     expect(fsm.current).to eql(:green)
+    expect(called).to be_empty
   end
 
   it "allows to specify deferred inital state" do
@@ -48,10 +66,24 @@ describe FiniteMachine, 'initialize' do
       }
     end
 
+    expect(fsm.current).to eql(:none)
     fsm.init
     expect(fsm.current).to eql(:green)
   end
 
+  it "raises error when specyfying initial without state name" do
+    expect {
+      FiniteMachine.define do
+        initial defer: true
+
+        events {
+          event :slow, :green  => :yellow
+          event :stop, :yellow => :red
+        }
+      end
+    }.to raise_error(FiniteMachine::MissingInitialStateError)
+  end
+
   it "allows to specify inital start event" do
     fsm = FiniteMachine.define do
       initial state: :green, event: :start
@@ -96,4 +128,19 @@ describe FiniteMachine, 'initialize' do
     end
     expect(fsm.current).to eql(:pending)
   end
+
+  it "doesn't care about state type" do
+    fsm = FiniteMachine.define do
+      initial 1
+      events {
+        event :a, 1 => 2
+        event :b, 2 => 3
+      }
+    end
+    expect(fsm.current).to eql(1)
+    fsm.a
+    expect(fsm.current).to eql(2)
+    fsm.b
+    expect(fsm.current).to eql(3)
+  end
 end

data/spec/unit/inspect_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine::Transition, 'inspect' do
+  let(:machine) { double }
+
+  subject(:transition) { described_class.new(machine, attrs) }
+
+  context 'when inspecting' do
+    let(:attrs) { {name: :start, :foo => :bar } }
+
+    it "displays name and transitions" do
+      expect(transition.inspect).to eql("<FiniteMachine::Transition name: start, transitions: [:foo] => bar, when: []>")
+    end
+  end
+
+  context 'when converting to string' do
+    let(:attrs) { {name: :start, :foo => :bar } }
+
+    it "displays name and transitions" do
+      expect(transition.to_s).to eql("start")
+    end
+  end
+end

data/spec/unit/logger_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'logger'
+
+describe FiniteMachine::Logger do
+  let(:message) { 'error' }
+  let(:log) { double }
+
+  subject(:logger) { described_class }
+
+  before { FiniteMachine.stub(:logger) { log } }
+
+  it "debugs message call" do
+    expect(log).to receive(:debug).with(message)
+    logger.debug(message)
+  end
+
+  it "informs message call" do
+    expect(log).to receive(:info).with(message)
+    logger.info(message)
+  end
+
+  it "warns message call" do
+    expect(log).to receive(:warn).with(message)
+    logger.warn(message)
+  end
+
+  it "errors message call" do
+    expect(log).to receive(:error).with(message)
+    logger.error(message)
+  end
+end

data/spec/unit/subscribers_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine::Subscribers do
+  let(:machine)  { double }
+  let(:event)    { double }
+  let(:listener) { double }
+
+  subject(:subscribers) { described_class.new(machine) }
+
+  before { subscribers.subscribe(listener) }
+
+  it "checks if any subscribers exist" do
+    expect(subscribers.empty?).to be_false
+  end
+
+  it "returns index for the subscriber" do
+    expect(subscribers.index(listener)).to eql(0)
+  end
+
+  it "visits all subscribed listeners for the event" do
+    expect(event).to receive(:notify).with(listener)
+    subscribers.visit(event)
+  end
+
+  it "resets the subscribers" do
+    subscribers.reset
+    expect(subscribers.empty?).to be_true
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: finite_machine
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Piotr Murach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-30 00:00:00.000000000 Z
+date: 2014-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -43,6 +43,8 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- examples/atm.rb
+- examples/bug_system.rb
 - finite_machine.gemspec
 - lib/finite_machine.rb
 - lib/finite_machine/async_call.rb
@@ -53,6 +55,7 @@ files:
 - lib/finite_machine/event.rb
 - lib/finite_machine/event_queue.rb
 - lib/finite_machine/hooks.rb
+- lib/finite_machine/logger.rb
 - lib/finite_machine/observer.rb
 - lib/finite_machine/state_machine.rb
 - lib/finite_machine/subscribers.rb
@@ -71,8 +74,11 @@ files:
 - spec/unit/handlers_spec.rb
 - spec/unit/if_unless_spec.rb
 - spec/unit/initialize_spec.rb
+- spec/unit/inspect_spec.rb
 - spec/unit/is_spec.rb
+- spec/unit/logger_spec.rb
 - spec/unit/states_spec.rb
+- spec/unit/subscribers_spec.rb
 - spec/unit/target_spec.rb
 - spec/unit/transition/parse_states_spec.rb
 - tasks/console.rake
@@ -114,8 +120,11 @@ test_files:
 - spec/unit/handlers_spec.rb
 - spec/unit/if_unless_spec.rb
 - spec/unit/initialize_spec.rb
+- spec/unit/inspect_spec.rb
 - spec/unit/is_spec.rb
+- spec/unit/logger_spec.rb
 - spec/unit/states_spec.rb
+- spec/unit/subscribers_spec.rb
 - spec/unit/target_spec.rb
 - spec/unit/transition/parse_states_spec.rb
 has_rdoc: