finite_machine 0.11.3 → 0.12.0

data/spec/unit/hook_event/any_state_or_event_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+RSpec.describe FiniteMachine::HookEvent, '#any_state_or_event' do
+  it "infers default name for state" do
+    hook_event = described_class::Enter
+    expect(described_class.any_state_or_event(hook_event)).to eq(FiniteMachine::ANY_STATE)
+  end
+
+  it "infers default name for event" do
+    hook_event = described_class::Before
+    expect(described_class.any_state_or_event(hook_event)).to eq(FiniteMachine::ANY_EVENT)
+  end
+end

data/spec/unit/hook_event/build_spec.rb

@@ -1,6 +1,4 @@
-# encoding: utf-8
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe FiniteMachine::HookEvent, '#build' do
   it "builds action event" do

data/spec/unit/hook_event/eql_spec.rb

@@ -1,6 +1,4 @@
-# encoding: utf-8
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe FiniteMachine::HookEvent, 'eql?' do
   let(:name)       { :green }

data/spec/unit/hook_event/initialize_spec.rb

@@ -1,6 +1,4 @@
-# encoding: utf-8
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe FiniteMachine::HookEvent, '#new' do
   it "reads event name" do
@@ -20,6 +18,6 @@ RSpec.describe FiniteMachine::HookEvent, '#new' do
 
   it "freezes object" do
     hook_event = described_class.new(:green, :go, :green)
-    expect { hook_event.name = :red }.to raise_error(RuntimeError)
+    expect(hook_event.frozen?).to eq(true)
   end
 end

data/spec/unit/hook_event/notify_spec.rb

@@ -1,8 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::HookEvent, '.notify' do
+RSpec.describe FiniteMachine::HookEvent, '#notify' do
   it "emits event on the subscriber" do
     subscriber = spy(:subscriber)
     hook_event = described_class.new(:green, :go, :red)

data/spec/unit/hooks/clear_spec.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 RSpec.describe FiniteMachine::Hooks, '#clear' do
   it "clears all registered hooks" do

data/spec/unit/hooks/{call_spec.rb → find_spec.rb}

@@ -1,13 +1,8 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::Hooks, '#call' do
-  let(:object) { described_class }
-
-  subject(:hooks) { object.new }
+# frozen_string_literal: true
 
+RSpec.describe FiniteMachine::Hooks, '#[]' do
   it "adds and removes a single hook" do
+    hooks = FiniteMachine::Hooks.new
     expect(hooks).to be_empty
 
     yielded = []
@@ -15,7 +10,7 @@ RSpec.describe FiniteMachine::Hooks, '#call' do
     hook = -> { }
     hooks.register(event_type, :foo, hook)
 
-    hooks.call(event_type, :foo) do |callback|
+    hooks[event_type][:foo].each do |callback|
       yielded << callback
     end
 

data/spec/unit/hooks/inspect_spec.rb

@@ -1,17 +1,25 @@
-# encoding: utf-8
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe FiniteMachine::Hooks, '#inspect' do
-  subject(:hooks) { described_class.new }
-
   it "displays name and transitions" do
+    hooks = FiniteMachine::Hooks.new
+    hook = -> { }
+    event = FiniteMachine::HookEvent::Enter
+    hooks_map = {event => {yellow: [hook]}}
+
+    hooks.register(event, :yellow, hook)
+
+    expect(hooks.inspect).to eql("<#FiniteMachine::Hooks:0x#{hooks.object_id.to_s(16)} @hooks_map=#{hooks_map}>")
+  end
+
+  it "displays hooks content" do
+    hooks = FiniteMachine::Hooks.new
     hook = -> { }
     event = FiniteMachine::HookEvent::Enter
-    collection = {event => {yellow: [hook]}}
+    hooks_map = {event => {yellow: [hook]}}
+
     hooks.register(event, :yellow, hook)
 
-    expect(hooks.inspect).to eql("<#FiniteMachine::Hooks:0x#{hooks.object_id.to_s(16)} @collection=#{collection}>")
-    expect(hooks.to_s).to eql(hooks.inspect)
+    expect(hooks.to_s).to eql(hooks_map.to_s)
   end
 end

data/spec/unit/hooks/register_spec.rb

@@ -1,22 +1,17 @@
-# encoding: utf-8
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe FiniteMachine::Hooks, '#register' do
-  let(:object) { described_class }
-
-  subject(:hooks) { object.new }
-
   it "adds and removes a single hook" do
+    hooks = FiniteMachine::Hooks.new
     expect(hooks).to be_empty
 
     event_type = FiniteMachine::HookEvent::Before
     hook = -> { }
 
     hooks.register(event_type, :foo, hook)
-    expect(hooks.collection).to eq({event_type => {foo: [hook]}})
+    expect(hooks[event_type][:foo]).to eq([hook])
 
     hooks.unregister(event_type, :foo, hook)
-    expect(hooks.collection).to eq({event_type => {foo: []}})
+    expect(hooks[event_type][:foo]).to eq([])
   end
 end

data/spec/unit/if_unless_spec.rb

@@ -1,6 +1,4 @@
-# encoding: utf-8
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe FiniteMachine, ':if, :unless' do
   before(:each) {
@@ -29,17 +27,15 @@ RSpec.describe FiniteMachine, ':if, :unless' do
 
   it "passes context to conditionals" do
     called = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new 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
-      }
+      event :go, :red => :green,
+            if: proc { |context| called << "cond_red_green(#{context})"; true}
+      event :stop, from: any_state do
+        choice :red,
+               if: proc { |context| called << "cond_any_red(#{context})"; true }
+      end
     end
 
     expect(fsm.current).to eq(:red)
@@ -58,17 +54,15 @@ RSpec.describe FiniteMachine, ':if, :unless' do
 
   it "passes context & arguments to conditionals" do
     called = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new 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
-      }
+      event :go,  :red => :green,
+            if: proc { |_, a| called << "cond_red_green(#{a})"; true }
+      event :stop, from: any_state do
+        choice :red,
+                if: proc { |_, b| called << "cond_any_red(#{b})"; true }
+      end
     end
 
     expect(fsm.current).to eq(:red)
@@ -88,30 +82,26 @@ RSpec.describe FiniteMachine, ':if, :unless' do
   it "allows to cancel event with :if option" do
     called = []
 
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :slow, :green => :yellow, if: -> { return false }
-        event :stop, :yellow => :red
-      }
+      event :slow, :green => :yellow, if: -> { return false }
+      event :stop, :yellow => :red
 
-      callbacks {
-        # generic callbacks
-        on_enter      do |event| called << 'on_enter' end
-        on_transition do |event| called << 'on_transition' end
-        on_exit       do |event| called << 'on_exit' end
+      # generic callbacks
+      on_enter      do |event| called << 'on_enter' end
+      on_transition do |event| called << 'on_transition' end
+      on_exit       do |event| called << 'on_exit' end
 
-        # state callbacks
-        on_enter :green do |event| called << 'on_enter_green' end
-        on_enter :yellow do |event| called << "on_enter_yellow" end
+      # state callbacks
+      on_enter :green do |event| called << 'on_enter_green' end
+      on_enter :yellow do |event| called << "on_enter_yellow" end
 
-        on_transition :green  do |event| called << 'on_transition_green' end
-        on_transition :yellow do |event| called << "on_transition_yellow" end
+      on_transition :green  do |event| called << 'on_transition_green' end
+      on_transition :yellow do |event| called << "on_transition_yellow" end
 
-        on_exit :green  do |event| called << 'on_exit_green' end
-        on_exit :yellow do |event| called << "on_exit_yellow" end
-      }
+      on_exit :green  do |event| called << 'on_exit_green' end
+      on_exit :yellow do |event| called << "on_exit_yellow" end
     end
 
     expect(fsm.current).to eql(:green)
@@ -124,30 +114,26 @@ RSpec.describe FiniteMachine, ':if, :unless' do
   it "allows to cancel event with :unless option" do
     called = []
 
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :slow, :green => :yellow, unless: -> { true }
-        event :stop, :yellow => :red
-      }
+      event :slow, :green => :yellow, unless: -> { true }
+      event :stop, :yellow => :red
 
-      callbacks {
-        # generic callbacks
-        on_enter      do |event| called << 'on_enter' end
-        on_transition do |event| called << 'on_transition' end
-        on_exit       do |event| called << 'on_exit' end
+      # generic callbacks
+      on_enter      do |event| called << 'on_enter' end
+      on_transition do |event| called << 'on_transition' end
+      on_exit       do |event| called << 'on_exit' end
 
-        # state callbacks
-        on_enter :green do |event| called << 'on_enter_green' end
-        on_enter :yellow do |event| called << "on_enter_yellow" end
+      # state callbacks
+      on_enter :green do |event| called << 'on_enter_green' end
+      on_enter :yellow do |event| called << "on_enter_yellow" end
 
-        on_transition :green  do |event| called << 'on_transition_green' end
-        on_transition :yellow do |event| called << "on_transition_yellow" end
+      on_transition :green  do |event| called << 'on_transition_green' end
+      on_transition :yellow do |event| called << "on_transition_yellow" end
 
-        on_exit :green  do |event| called << 'on_exit_green' end
-        on_exit :yellow do |event| called << "on_exit_yellow" end
-      }
+      on_exit :green  do |event| called << 'on_exit_green' end
+      on_exit :yellow do |event| called << "on_exit_yellow" end
     end
 
     expect(fsm.current).to eql(:green)
@@ -160,16 +146,14 @@ RSpec.describe FiniteMachine, ':if, :unless' do
   it "allows to combine conditionals" do
     conditions = []
 
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :slow, :green => :yellow,
-          if: [ -> { conditions << 'first_if'; return true },
-                -> { conditions << 'second_if'; return true}],
-          unless: -> { conditions << 'first_unless'; return true }
-        event :stop, :yellow => :red
-      }
+      event :slow, :green => :yellow,
+        if: [ -> { conditions << 'first_if'; return true },
+              -> { conditions << 'second_if'; return true}],
+        unless: -> { conditions << 'first_unless'; return true }
+      event :stop, :yellow => :red
     end
 
     expect(fsm.current).to eql(:green)
@@ -186,15 +170,11 @@ RSpec.describe FiniteMachine, ':if, :unless' do
     it "specifies :if and :unless" do
       car = Car.new
 
-      fsm = FiniteMachine.define do
+      fsm = FiniteMachine.new(car) do
         initial :neutral
 
-        target car
-
-        events {
-          event :start, :neutral => :one, if: proc {|_car| _car.engine_on? }
-          event :shift, :one => :two
-        }
+        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
@@ -212,18 +192,14 @@ RSpec.describe FiniteMachine, ':if, :unless' do
     it "passes arguments to the scope" do
       car = Car.new
 
-      fsm = FiniteMachine.define do
+      fsm = FiniteMachine.new(car) 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
+        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)
@@ -236,15 +212,11 @@ RSpec.describe FiniteMachine, ':if, :unless' do
     it "specifies :if and :unless" do
       car = Car.new
 
-      fsm = FiniteMachine.define do
+      fsm = FiniteMachine.new(car) do
         initial :neutral
 
-        target car
-
-        events {
-          event :start, :neutral => :one, if: :engine_on?
-          event :shift, :one => :two
-        }
+        event :start, :neutral => :one, if: :engine_on?
+        event :shift, :one => :two
       end
       car.turn_engine_off
       expect(car.engine_on?).to be false
@@ -264,15 +236,11 @@ RSpec.describe FiniteMachine, ':if, :unless' do
     it "specifies :if and :unless" do
       car = Car.new
 
-      fsm = FiniteMachine.define do
+      fsm = FiniteMachine.new(car) do
         initial :neutral
 
-        target car
-
-        events {
-          event :start, :neutral => :one, if: "engine_on?"
-          event :shift, :one => :two
-        }
+        event :start, :neutral => :one, if: "engine_on?"
+        event :shift, :one => :two
       end
       car.turn_engine_off
       expect(car.engine_on?).to be false
@@ -291,16 +259,12 @@ RSpec.describe FiniteMachine, ':if, :unless' do
   context 'when same event name' do
     it "preservers conditions for the same named event" do
       bug = Bug.new
-      fsm = FiniteMachine.define do
+      fsm = FiniteMachine.new(bug) do
         initial :initial
 
-        target bug
-
-        events {
-          event :bump, :initial => :low
-          event :bump, :low     => :medium, if: :pending?
-          event :bump, :medium  => :high
-        }
+        event :bump, :initial => :low
+        event :bump, :low     => :medium, if: :pending?
+        event :bump, :medium  => :high
       end
       expect(fsm.current).to eq(:initial)
       fsm.bump
@@ -310,29 +274,26 @@ RSpec.describe FiniteMachine, ':if, :unless' do
     end
 
     it "allows for static choice based on branching condition" do
-      fsm = FiniteMachine.define do
+      fsm = FiniteMachine.new do
         initial :company_form
 
-        events {
-          event :next, :company_form => :agreement_form, if: -> { false }
-          event :next, :company_form => :promo_form,     if: -> { false }
-          event :next, :company_form => :official_form,  if: -> { true }
-        }
+        event :next, :company_form => :agreement_form, if: -> { false }
+        event :next, :company_form => :promo_form,     if: -> { false }
+        event :next, :company_form => :official_form,  if: -> { true }
       end
+
       expect(fsm.current).to eq(:company_form)
       fsm.next
       expect(fsm.current).to eq(:official_form)
     end
 
     it "allows for dynamic choice based on branching condition" do
-      fsm = FiniteMachine.define do
+      fsm = FiniteMachine.new do
         initial :company_form
 
-        events {
-          event :next, :company_form => :agreement_form, if: proc { |_, a| a < 1 }
-          event :next, :company_form => :promo_form,     if: proc { |_, a| a == 1 }
-          event :next, :company_form => :official_form,  if: proc { |_, a| a > 1 }
-        }
+        event :next, :company_form => :agreement_form, if: proc { |_, a| a < 1 }
+        event :next, :company_form => :promo_form,     if: proc { |_, a| a == 1 }
+        event :next, :company_form => :official_form,  if: proc { |_, a| a > 1 }
       end
       expect(fsm.current).to eq(:company_form)