finite_machine 0.11.3 → 0.12.0

data/spec/unit/can_spec.rb

@@ -1,6 +1,4 @@
-# encoding: utf-8
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe FiniteMachine, 'can?' do
   before(:each) {
@@ -12,15 +10,13 @@ RSpec.describe FiniteMachine, 'can?' do
   }
 
   it "allows to check if event can be fired" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :slow,  :green  => :yellow
-        event :stop,  :yellow => :red
-        event :ready, :red    => :yellow
-        event :go,    :yellow => :green
-      }
+      event :slow,  :green  => :yellow
+      event :stop,  :yellow => :red
+      event :ready, :red    => :yellow
+      event :go,    :yellow => :green
     end
 
     expect(fsm.current).to eql(:green)
@@ -57,13 +53,11 @@ RSpec.describe FiniteMachine, 'can?' do
 
   context 'with conditionl transition' do
     it "evalutes condition with parameters" do
-      fsm = FiniteMachine.define do
+      fsm = FiniteMachine.new do
         initial :green
 
-        events {
-          event :slow,  :green  => :yellow
-          event :stop,  :yellow => :red, if: proc { |_, state| state }
-        }
+        event :slow,  :green  => :yellow
+        event :stop,  :yellow => :red, if: proc { |_, state| state }
       end
       expect(fsm.current).to eq(:green)
       expect(fsm.can?(:slow)).to be(true)
@@ -77,16 +71,12 @@ RSpec.describe FiniteMachine, 'can?' do
 
     it "checks against target and grouped events" 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)
 

data/spec/unit/cancel_callbacks_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+RSpec.describe FiniteMachine, '#cancel_event' do
+  it "cancels transition on event callback" do
+    fsm = FiniteMachine.new do
+      initial :green
+
+      event :slow, :green  => :yellow
+      event :go,   :yellow => :green
+
+      on_exit :green do |event|
+        cancel_event(event)
+      end
+    end
+
+    expect(fsm.current).to eql(:green)
+    fsm.slow
+    expect(fsm.current).to eql(:green)
+  end
+
+  it "stops executing callbacks when cancelled" do
+    called = []
+
+    fsm = FiniteMachine.new do
+      initial :initial
+
+      event :bump, initial: :low
+
+      on_before do |event|
+        called << "enter_#{event.name}_#{event.from}_#{event.to}"
+
+        cancel_event(event)
+      end
+
+      on_exit :initial do |event| called << "exit_initial" end
+      on_exit          do |event| called << "exit_any" end
+      on_enter :low    do |event| called << "enter_low" end
+      on_after :bump   do |event| called << "after_#{event.name}" end
+      on_after         do |event| called << "after_any" end
+    end
+
+    fsm.bump
+
+    expect(called).to eq(['enter_bump_initial_low'])
+  end
+end

data/spec/unit/choice_spec.rb

@@ -1,6 +1,4 @@
-# encoding: utf-8
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe FiniteMachine, '#choice' do
   before(:each) {
@@ -13,21 +11,17 @@ RSpec.describe FiniteMachine, '#choice' do
 
   it "allows for static choice based on conditional branching" do
     called = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :company_form
 
-      events {
-        event :next, from: :company_form do
-          choice :agreement_form, if: -> { false }
-          choice :promo_form,     if: -> { false }
-          choice :official_form,  if: -> { true }
-        end
-      }
-
-      callbacks {
-        on_exit  do |event| called << "on_exit_#{event.from}" end
-        on_enter do |event| called << "on_enter_#{event.to}"  end
-      }
+      event :next, from: :company_form do
+        choice :agreement_form, if: -> { false }
+        choice :promo_form,     if: -> { false }
+        choice :official_form,  if: -> { true }
+      end
+
+      on_exit  do |event| called << "on_exit_#{event.from}" end
+      on_enter do |event| called << "on_enter_#{event.to}"  end
     end
     expect(fsm.current).to eq(:company_form)
     fsm.next
@@ -39,16 +33,14 @@ RSpec.describe FiniteMachine, '#choice' do
   end
 
   it "allows for dynamic choice based on conditional branching" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :company_form
 
-      events {
-        event :next, from: :company_form do
-          choice :agreement_form, if: proc { |_, a| a < 1 }
-          choice :promo_form,     if: proc { |_, a| a == 1 }
-          choice :official_form,  if: proc { |_, a| a > 1 }
-        end
-      }
+      event :next, from: :company_form do
+        choice :agreement_form, if: proc { |_, a| a < 1 }
+        choice :promo_form,     if: proc { |_, a| a == 1 }
+        choice :official_form,  if: proc { |_, a| a > 1 }
+      end
     end
     expect(fsm.current).to eq(:company_form)
     fsm.next(0)
@@ -65,17 +57,13 @@ RSpec.describe FiniteMachine, '#choice' do
 
   it "allows for dynamic choice based on conditional branching and target" do
     user = User.new
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new(user) do
       initial :company_form
 
-      target user
-
-      events {
-        event :next, from: :company_form do
-          choice :agreement_form, if: proc { |_user, token| _user.promo?(token) }
-          choice :promo_form, unless: proc { |_user, token| _user.promo?(token) }
-        end
-      }
+      event :next, from: :company_form do
+        choice :agreement_form, if: proc { |_user, token| _user.promo?(token) }
+        choice :promo_form, unless: proc { |_user, token| _user.promo?(token) }
+      end
     end
     expect(fsm.current).to eq(:company_form)
     fsm.next(:no)
@@ -86,16 +74,14 @@ RSpec.describe FiniteMachine, '#choice' do
   end
 
   it "chooses state when skipped if/unless" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :company_form
 
-      events {
-        event :next, from: :company_form do
-          choice :agreement_form, if: -> { false }
-          choice :promo_form
-          choice :official_form,  if: -> { true }
-        end
-      }
+      event :next, from: :company_form do
+        choice :agreement_form, if: -> { false }
+        choice :promo_form
+        choice :official_form,  if: -> { true }
+      end
     end
     expect(fsm.current).to eq(:company_form)
     fsm.next
@@ -103,16 +89,14 @@ RSpec.describe FiniteMachine, '#choice' do
   end
 
   it "chooses default state when branching conditions don't match" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :company_form
 
-      events {
-        event :next, from: :company_form do
-          choice :agreement_form, if: -> { false }
-          choice :promo_form,     if: -> { false }
-          default :official_form
-        end
-      }
+      event :next, from: :company_form do
+        choice :agreement_form, if: -> { false }
+        choice :promo_form,     if: -> { false }
+        default :official_form
+      end
     end
     expect(fsm.current).to eq(:company_form)
     fsm.next
@@ -120,15 +104,13 @@ RSpec.describe FiniteMachine, '#choice' do
   end
 
   it "fails to transition when no condition matches without default state" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :company_form
 
-      events {
-        event :next, from: :company_form do
-          choice :agreement_form, if: -> { false }
-          choice :promo_form,     if: -> { false }
-        end
-      }
+      event :next, from: :company_form do
+        choice :agreement_form, if: -> { false }
+        choice :promo_form,     if: -> { false }
+      end
     end
     expect(fsm.current).to eq(:company_form)
     fsm.next
@@ -136,7 +118,7 @@ RSpec.describe FiniteMachine, '#choice' do
   end
 
   it "allows to transition from multiple states to choice pseudostate" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :red
 
       event :go, from: [:yellow, :red] do
@@ -154,10 +136,10 @@ RSpec.describe FiniteMachine, '#choice' do
   end
 
   it "allows to transition from any state to choice pseudo state" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :red
 
-      event :go, from: :any do
+      event :go, from: any_state do
         choice :pink, if: -> { false }
         choice :green
       end
@@ -168,7 +150,7 @@ RSpec.describe FiniteMachine, '#choice' do
   end
 
   it "groups correctly events under the same name" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :red
 
       event :next, from: :yellow, to: :green
@@ -187,24 +169,20 @@ RSpec.describe FiniteMachine, '#choice' do
 
   it "performs matching transitions for multiple event definitions with the same name" do
     ticket = double(:ticket, :pending? => true, :finished? => true)
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new(ticket) do
       initial :inactive
 
-      target ticket
-
-      events {
-        event :advance, from: [:inactive, :paused, :fulfilled] do
-          choice :active, if: proc { |_ticket| !_ticket.pending? }
-        end
+      event :advance, from: [:inactive, :paused, :fulfilled] do
+        choice :active, if: proc { |_ticket| !_ticket.pending? }
+      end
 
-        event :advance, from: [:inactive, :active, :fulfilled] do
-          choice :paused, if: proc { |_ticket| _ticket.pending? }
-        end
+      event :advance, from: [:inactive, :active, :fulfilled] do
+        choice :paused, if: proc { |_ticket| _ticket.pending? }
+      end
 
-        event :advance, from: [:inactive, :active, :paused] do
-          choice :fulfilled, if: proc { |_ticket| _ticket.finished? }
-        end
-      }
+      event :advance, from: [:inactive, :active, :paused] do
+        choice :fulfilled, if: proc { |_ticket| _ticket.finished? }
+      end
     end
     expect(fsm.current).to eq(:inactive)
     fsm.advance
@@ -216,29 +194,23 @@ RSpec.describe FiniteMachine, '#choice' do
   it "does not transition when no matching choice for multiple event definitions" do
     ticket = double(:ticket, :pending? => true, :finished? => false)
     called = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new(ticket) do
       initial :inactive
 
-      target ticket
-
-      events {
-        event :advance, from: [:inactive, :paused, :fulfilled] do
-          choice :active, if: proc { |_ticket| !_ticket.pending? }
-        end
+      event :advance, from: [:inactive, :paused, :fulfilled] do
+        choice :active, if: proc { |_ticket| !_ticket.pending? }
+      end
 
-        event :advance, from: [:inactive, :active, :fulfilled] do
-          choice :paused, if: proc { |_ticket| _ticket.pending? }
-        end
+      event :advance, from: [:inactive, :active, :fulfilled] do
+        choice :paused, if: proc { |_ticket| _ticket.pending? }
+      end
 
-        event :advance, from: [:inactive, :active, :paused] do
-          choice :fulfilled, if: proc { |_ticket| _ticket.finished? }
-        end
-      }
+      event :advance, from: [:inactive, :active, :paused] do
+        choice :fulfilled, if: proc { |_ticket| _ticket.finished? }
+      end
 
-      callbacks {
-        on_before(:advance) { called << 'on_before_advance' }
-        on_after(:advance)  { called << 'on_after_advance' }
-      }
+      on_before(:advance) { called << 'on_before_advance' }
+      on_after(:advance)  { called << 'on_after_advance' }
     end
     expect(fsm.current).to eq(:inactive)
     fsm.advance
@@ -265,57 +237,49 @@ RSpec.describe FiniteMachine, '#choice' do
       target.expect(c).to target.eql(expected[:c])
     }
 
-    context = self
-
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new(self) do
       initial :red
 
-      target context
-
-      events {
-        event :next, from: :red do
-          choice :green, if: -> { false }
-          choice :yellow
-        end
-
-        event :next, from: :yellow do
-          choice :green, if: -> { true }
-          choice :yellow
-        end
-
-        event :finish, from: :any do
-          choice :green, if: -> { false }
-          choice :red
-        end
-      }
-
-      callbacks {
-        # generic state callbacks
-        on_enter(&callback)
-        on_transition(&callback)
-        on_exit(&callback)
-
-        # generic event callbacks
-        on_before(&callback)
-        on_after(&callback)
-
-        # state callbacks
-        on_enter :green,  &callback
-        on_enter :yellow, &callback
-        on_enter :red,    &callback
-
-        on_transition :green,  &callback
-        on_transition :yellow, &callback
-        on_transition :red,    &callback
-
-        on_exit :green,  &callback
-        on_exit :yellow, &callback
-        on_exit :red,    &callback
-
-        # event callbacks
-        on_before :next, &callback
-        on_after  :next, &callback
-      }
+      event :next, from: :red do
+        choice :green, if: -> { false }
+        choice :yellow
+      end
+
+      event :next, from: :yellow do
+        choice :green, if: -> { true }
+        choice :yellow
+      end
+
+      event :finish, from: any_state do
+        choice :green, if: -> { false }
+        choice :red
+      end
+
+      # generic state callbacks
+      on_enter(&callback)
+      on_transition(&callback)
+      on_exit(&callback)
+
+      # generic event callbacks
+      on_before(&callback)
+      on_after(&callback)
+
+      # state callbacks
+      on_enter :green,  &callback
+      on_enter :yellow, &callback
+      on_enter :red,    &callback
+
+      on_transition :green,  &callback
+      on_transition :yellow, &callback
+      on_transition :red,    &callback
+
+      on_exit :green,  &callback
+      on_exit :yellow, &callback
+      on_exit :red,    &callback
+
+      # event callbacks
+      on_before :next, &callback
+      on_after  :next, &callback
     end
     expect(fsm.current).to eq(:red)