finite_machine 0.8.1 → 0.9.0

data/spec/unit/can_spec.rb

@@ -25,34 +25,34 @@ describe FiniteMachine, 'can?' do
 
     expect(fsm.current).to eql(:green)
 
-    expect(fsm.can?(:slow)).to be_true
-    expect(fsm.cannot?(:stop)).to be_true
-    expect(fsm.can?(:ready)).to be_false
-    expect(fsm.can?(:go)).to be_false
+    expect(fsm.can?(:slow)).to be(true)
+    expect(fsm.cannot?(:stop)).to be(true)
+    expect(fsm.can?(:ready)).to be(false)
+    expect(fsm.can?(:go)).to be(false)
 
     fsm.slow
     expect(fsm.current).to eql(:yellow)
 
-    expect(fsm.can?(:slow)).to be_false
-    expect(fsm.can?(:stop)).to be_true
-    expect(fsm.can?(:ready)).to be_false
-    expect(fsm.can?(:go)).to be_true
+    expect(fsm.can?(:slow)).to be(false)
+    expect(fsm.can?(:stop)).to be(true)
+    expect(fsm.can?(:ready)).to be(false)
+    expect(fsm.can?(:go)).to be(true)
 
     fsm.stop
     expect(fsm.current).to eql(:red)
 
-    expect(fsm.can?(:slow)).to be_false
-    expect(fsm.can?(:stop)).to be_false
-    expect(fsm.can?(:ready)).to be_true
-    expect(fsm.can?(:go)).to be_false
+    expect(fsm.can?(:slow)).to be(false)
+    expect(fsm.can?(:stop)).to be(false)
+    expect(fsm.can?(:ready)).to be(true)
+    expect(fsm.can?(:go)).to be(false)
 
     fsm.ready
     expect(fsm.current).to eql(:yellow)
 
-    expect(fsm.can?(:slow)).to be_false
-    expect(fsm.can?(:stop)).to be_true
-    expect(fsm.can?(:ready)).to be_false
-    expect(fsm.can?(:go)).to be_true
+    expect(fsm.can?(:slow)).to be(false)
+    expect(fsm.can?(:stop)).to be(true)
+    expect(fsm.can?(:ready)).to be(false)
+    expect(fsm.can?(:go)).to be(true)
   end
 
   context 'with conditionl transition' do
@@ -66,13 +66,13 @@ describe FiniteMachine, 'can?' do
         }
       end
       expect(fsm.current).to eq(:green)
-      expect(fsm.can?(:slow)).to be_true
-      expect(fsm.can?(:stop)).to be_false
+      expect(fsm.can?(:slow)).to be(true)
+      expect(fsm.can?(:stop)).to be(false)
 
       fsm.slow
       expect(fsm.current).to eq(:yellow)
-      expect(fsm.can?(:stop, false)).to be_false
-      expect(fsm.can?(:stop, true)).to be_true
+      expect(fsm.can?(:stop, false)).to be(false)
+      expect(fsm.can?(:stop, true)).to be(true)
     end
 
     it "checks against target and grouped events" do
@@ -90,9 +90,9 @@ describe FiniteMachine, 'can?' do
       end
       expect(fsm.current).to eq(:initial)
 
-      expect(fsm.can?(:bump)).to be_true
+      expect(fsm.can?(:bump)).to be(true)
       fsm.bump
-      expect(fsm.can?(:bump)).to be_false
+      expect(fsm.can?(:bump)).to be(false)
     end
   end
 end

data/spec/unit/event/eql_spec.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine::Event, 'eql?' do
+  let(:machine) { double(:machine) }
+  let(:name)    { :green }
+  let(:options) { {} }
+  let(:object)  { described_class }
+
+  subject(:event) { object.new(machine, options) }
+
+  context 'with the same object' do
+   let(:other) { event }
+
+    it "equals" do
+      expect(event).to eql(other)
+    end
+  end
+
+  context 'with an equivalent object' do
+    let(:other) { event.dup }
+
+    it "equals" do
+      expect(event).to eql(other)
+    end
+  end
+
+  context "with an object having different name" do
+    let(:other_name) { :red }
+    let(:other) { object.new(machine, {name: other_name}) }
+
+    it "doesn't equal" do
+      expect(event).to_not eql(other)
+    end
+  end
+end

data/spec/unit/event/initialize_spec.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine::Event, 'new' do
+  let(:machine) { double(:machine) }
+  let(:name)    { :green }
+  let(:options) { {} }
+  let(:object)  { described_class }
+
+  subject(:event) { object.new(machine, options) }
+
+  context "by default" do
+    it "sets name to :none" do
+      expect(event.name).to eql(:none)
+    end
+
+    it "sets silent to false"do
+      expect(event.silent).to eql(false)
+    end
+  end
+
+  context "with custom data" do
+    let(:options) { {silent: true, name: name} }
+
+    it "sets name to :green" do
+      expect(event.name).to eql(name)
+    end
+
+    it "sets silent to true"do
+      expect(event.silent).to eql(true)
+    end
+  end
+
+  it "freezes object" do
+    expect { event.name = :red }.to raise_error(RuntimeError)
+  end
+end

data/spec/unit/event/inspect_spec.rb

@@ -12,7 +12,7 @@ describe FiniteMachine::Event, '#inspect' do
   it "adds multiple transitions" do
     transition = double(:transition)
     event << transition
-    expect(event.inspect).to eq("<#FiniteMachine::Event @name=test, @transitions=[#{transition.inspect}]>")
+    expect(event.inspect).to eq("<#FiniteMachine::Event @name=test, @silent=false, @transitions=[#{transition.inspect}]>")
   end
 
   it "prints event name" do

data/spec/unit/event_queue_spec.rb

@@ -40,12 +40,12 @@ describe FiniteMachine::EventQueue do
     event1 = double(:event1, dispatch: true)
     event2 = double(:event2, dispatch: true)
     event3 = double(:event3, dispatch: true)
-    expect(event_queue.alive?).to be_true
+    expect(event_queue.alive?).to be(true)
     event_queue << event1
     event_queue << event2
     event_queue.shutdown
     event_queue << event3
     sleep 0.001
-    expect(event_queue.alive?).to be_false
+    expect(event_queue.alive?).to be(false)
   end
 end

data/spec/unit/events_chain/check_choice_conditions_spec.rb

@@ -12,9 +12,9 @@ describe FiniteMachine::EventsChain, '#clear' do
   it "clears chain events" do
     event = double(:event)
     chain.add(:validated, event)
-    expect(chain.empty?).to be_false
+    expect(chain.empty?).to be(false)
 
     chain.clear
-    expect(chain.empty?).to be_true
+    expect(chain.empty?).to be(true)
   end
 end

data/spec/unit/events_chain/clear_spec.rb

@@ -21,6 +21,6 @@ describe FiniteMachine::EventsChain, '#insert' do
   end
 
   it "fails to insert transition" do
-    expect(chain.insert(:validated, transition)).to be_false
+    expect(chain.insert(:validated, transition)).to be(false)
   end
 end

data/spec/unit/events_chain/insert_spec.rb

@@ -21,6 +21,6 @@ describe FiniteMachine::EventsChain, '#insert' do
   end
 
   it "fails to insert transition" do
-    expect(chain.insert(:validated, transition)).to be_false
+    expect(chain.insert(:validated, transition)).to be false
   end
 end

data/spec/unit/events_spec.rb

@@ -64,16 +64,16 @@ describe FiniteMachine, 'events' do
 
     expect(fsm.current).to eql(:green)
 
-    expect(fsm.can?(:noop)).to be_true
-    expect(fsm.can?(:slow)).to be_true
+    expect(fsm.can?(:noop)).to be true
+    expect(fsm.can?(:slow)).to be true
 
     fsm.noop
     expect(fsm.current).to eql(:green)
     fsm.slow
     expect(fsm.current).to eql(:yellow)
 
-    expect(fsm.cannot?(:noop)).to be_true
-    expect(fsm.cannot?(:slow)).to be_true
+    expect(fsm.cannot?(:noop)).to be true
+    expect(fsm.cannot?(:slow)).to be true
   end
 
   it "permits event from any state with :any 'from'" do
@@ -171,7 +171,7 @@ describe FiniteMachine, 'events' do
       }
     end
     expect(fsm.current).to eql(:green)
-    expect(fsm.can?(:stop)).to be_false
+    expect(fsm.can?(:stop)).to be false
     fsm.stop!
     expect(fsm.current).to eql(:red)
   end
@@ -191,10 +191,10 @@ describe FiniteMachine, 'events' do
 
       expect(fsm.current).to eql(:green)
 
-      expect(fsm.can?(:slow)).to be_true
-      expect(fsm.can?(:stop)).to be_true
-      expect(fsm.cannot?(:ready)).to be_true
-      expect(fsm.cannot?(:go)).to be_true
+      expect(fsm.can?(:slow)).to be true
+      expect(fsm.can?(:stop)).to be true
+      expect(fsm.cannot?(:ready)).to be true
+      expect(fsm.cannot?(:go)).to be true
 
       fsm.slow;  expect(fsm.current).to eql(:yellow)
       fsm.stop;  expect(fsm.current).to eql(:red)
@@ -219,10 +219,10 @@ describe FiniteMachine, 'events' do
 
       expect(fsm.current).to eql(:green)
 
-      expect(fsm.can?(:slow)).to be_true
-      expect(fsm.can?(:stop)).to be_true
-      expect(fsm.cannot?(:ready)).to be_true
-      expect(fsm.cannot?(:go)).to be_true
+      expect(fsm.can?(:slow)).to be true
+      expect(fsm.can?(:stop)).to be true
+      expect(fsm.cannot?(:ready)).to be true
+      expect(fsm.cannot?(:go)).to be true
 
       fsm.slow;  expect(fsm.current).to eql(:yellow)
       fsm.stop;  expect(fsm.current).to eql(:red)
@@ -247,7 +247,7 @@ describe FiniteMachine, 'events' do
     end
 
     expect(fsm.current).to eql(:green)
-    expect(fsm.can?(:stop)).to be_true
+    expect(fsm.can?(:stop)).to be true
     fsm.stop
     expect(fsm.current).to eql(:yellow)
     fsm.stop
@@ -272,12 +272,9 @@ describe FiniteMachine, 'events' do
     end
 
     expect(fsm.current).to eq(:initial)
-    fsm.bump
-    expect(fsm.current).to eq(:low)
-    fsm.bump
-    expect(fsm.current).to eq(:medium)
-    fsm.bump
-    expect(fsm.current).to eq(:high)
+    fsm.bump; expect(fsm.current).to eq(:low)
+    fsm.bump; expect(fsm.current).to eq(:medium)
+    fsm.bump; expect(fsm.current).to eq(:high)
   end
 
   it "returns values for events" do

data/spec/unit/hook_event/eql_spec.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine::HookEvent, 'eql?' do
+  let(:name)       { :green }
+  let(:transition) { double(:transition) }
+  let(:data)       { [:foo, :bar] }
+  let(:object)     { described_class }
+
+  subject(:hook) { object.new(name, transition, *data) }
+
+  context 'with the same object' do
+   let(:other) { hook }
+
+    it "equals" do
+      expect(hook).to eql(other)
+    end
+  end
+
+  context 'with an equivalent object' do
+    let(:other) { hook.dup }
+
+    it "equals" do
+      expect(hook).to eql(other)
+    end
+  end
+
+  context "with an object having different name" do
+    let(:other_name) { :red }
+    let(:other) { object.new(other_name, transition, *data) }
+
+    it "doesn't equal" do
+      expect(hook).not_to eql(other)
+    end
+  end
+end

data/spec/unit/hook_event/initialize_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine::HookEvent, 'new' do
+  let(:name)       { :green }
+  let(:transition) { double(:transition) }
+  let(:data)       { [:foo, :bar] }
+  let(:object)     { described_class }
+
+  subject(:hook) { object.new(name, transition, *data) }
+
+  it "exposes readers" do
+    expect(hook.name).to eql(name)
+    expect(hook.data).to eql(data)
+    expect(hook.type).to eql(object)
+  end
+
+  it "freezes object" do
+    expect { hook.name = :red }.to raise_error(RuntimeError)
+  end
+end

data/spec/unit/if_unless_spec.rb

@@ -139,13 +139,13 @@ describe FiniteMachine, ':if, :unless' do
         }
       end
       car.turn_engine_off
-      expect(car.engine_on?).to be_false
+      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(car.engine_on?).to be true
       expect(fsm.current).to eql(:neutral)
       fsm.start
       expect(fsm.current).to eql(:one)
@@ -189,13 +189,13 @@ describe FiniteMachine, ':if, :unless' do
         }
       end
       car.turn_engine_off
-      expect(car.engine_on?).to be_false
+      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(car.engine_on?).to be true
       expect(fsm.current).to eql(:neutral)
       fsm.start
       expect(fsm.current).to eql(:one)
@@ -217,13 +217,13 @@ describe FiniteMachine, ':if, :unless' do
         }
       end
       car.turn_engine_off
-      expect(car.engine_on?).to be_false
+      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(car.engine_on?).to be true
       expect(fsm.current).to eql(:neutral)
       fsm.start
       expect(fsm.current).to eql(:one)

data/spec/unit/initialize_spec.rb

@@ -69,7 +69,7 @@ describe FiniteMachine, 'initialize' do
 
   it "allows to specify deferred inital state" do
     fsm = FiniteMachine.define do
-      initial state: :green, defer: true
+      initial :green, defer: true
 
       events {
         event :slow, :green  => :yellow
@@ -97,7 +97,7 @@ describe FiniteMachine, 'initialize' do
 
   it "allows to specify inital start event" do
     fsm = FiniteMachine.define do
-      initial state: :green, event: :start
+      initial :green, event: :start
 
       events {
         event :slow, :green  => :none
@@ -114,7 +114,7 @@ describe FiniteMachine, 'initialize' do
 
   it "allows to specify deferred inital start event" do
     fsm = FiniteMachine.define do
-      initial state: :green, event: :start, defer: true
+      initial :green, event: :start, defer: true
 
       events {
         event :slow, :green  => :yellow
@@ -173,7 +173,7 @@ describe FiniteMachine, 'initialize' do
 
   it "allows to retrieve initial state for deferred" do
     fsm = FiniteMachine.define do
-      initial state: :green, defer: true
+      initial :green, defer: true
 
       events {
         event :slow, :green  => :yellow
@@ -190,7 +190,7 @@ describe FiniteMachine, 'initialize' do
   it "allows to trigger callbacks on initial with :silent option" do
     called = []
     fsm = FiniteMachine.define do
-      initial state: :green, silent: false
+      initial :green, silent: false
 
       events {
         event :slow, :green => :yellow
@@ -206,7 +206,7 @@ describe FiniteMachine, 'initialize' do
   it "allows to trigger callbacks on deferred initial state" do
     called = []
     fsm = FiniteMachine.define do
-      initial state: :green, silent: false, defer: true
+      initial :green, silent: false, defer: true
 
       events {
         event :slow, :green => :yellow