finite_machine 0.11.3 → 0.12.0

data/spec/unit/events_spec.rb

@@ -1,17 +1,12 @@
-# encoding: utf-8
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe FiniteMachine, 'events' do
-
   it "allows for hash rocket syntax to describe transition" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
+      event :slow, :green  => :yellow
+      event :stop, :yellow => :red
     end
 
     expect(fsm.current).to eql(:green)
@@ -21,25 +16,12 @@ RSpec.describe FiniteMachine, 'events' do
     expect(fsm.current).to eql(:red)
   end
 
-  it "allows to add event without events scope" do
-    fsm = FiniteMachine.define do
-      initial :green
-
-      event :slow, :green  => :yellow
-      event :stop, :yellow => :red
-    end
-
-    expect(fsm.current).to eql(:green)
-  end
-
   it "allows for (:from | :to) key pairs to describe transition" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :slow, from: :green, to: :yellow
-        event :stop, from: :yellow, to: :red
-      }
+      event :slow, from: :green, to: :yellow
+      event :stop, from: :yellow, to: :red
     end
 
     expect(fsm.current).to eql(:green)
@@ -50,16 +32,14 @@ RSpec.describe FiniteMachine, 'events' do
   end
 
   it "permits no-op event without 'to' transition" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :noop,  from: :green
-        event :slow,  from: :green,  to: :yellow
-        event :stop,  from: :yellow, to: :red
-        event :ready, from: :red,    to: :yellow
-        event :go,    from: :yellow, to: :green
-      }
+      event :noop,  from: :green
+      event :slow,  from: :green,  to: :yellow
+      event :stop,  from: :yellow, to: :red
+      event :ready, from: :red,    to: :yellow
+      event :go,    from: :yellow, to: :green
     end
 
     expect(fsm.current).to eql(:green)
@@ -76,17 +56,15 @@ RSpec.describe FiniteMachine, 'events' do
     expect(fsm.cannot?(:slow)).to be true
   end
 
-  it "permits event from any state with :any 'from'" do
-    fsm = FiniteMachine.define do
+  it "permits event from any state using :from" do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :slow,  from: :green,  to: :yellow
-        event :stop,  from: :yellow, to: :red
-        event :ready, from: :red,    to: :yellow
-        event :go,    from: :yellow, to: :green
-        event :run,   from: :any,    to: :green
-      }
+      event :slow,  from: :green,  to: :yellow
+      event :stop,  from: :yellow, to: :red
+      event :ready, from: :red,    to: :yellow
+      event :go,    from: :yellow, to: :green
+      event :run,   from: any_state, to: :green
     end
 
     expect(fsm.current).to eql(:green)
@@ -112,15 +90,13 @@ RSpec.describe FiniteMachine, 'events' do
   end
 
   it "permits event from any state for hash syntax" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :red
 
-      events {
-        event :start, :red    => :yellow
-        event :run,   :yellow => :green
-        event :stop,  :green  => :red
-        event :go,    :any    => :green
-      }
+      event :start, :red    => :yellow
+      event :run,   :yellow => :green
+      event :stop,  :green  => :red
+      event :go,    any_state => :green
     end
 
     expect(fsm.current).to eql(:red)
@@ -135,16 +111,14 @@ RSpec.describe FiniteMachine, 'events' do
   end
 
   it "permits event from any state without 'from'" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :slow,  from: :green,  to: :yellow
-        event :stop,  from: :yellow, to: :red
-        event :ready, from: :red,    to: :yellow
-        event :go,    from: :yellow, to: :green
-        event :run,                  to: :green
-      }
+      event :slow,  from: :green,  to: :yellow
+      event :stop,  from: :yellow, to: :red
+      event :ready, from: :red,    to: :yellow
+      event :go,    from: :yellow, to: :green
+      event :run,                  to: :green
     end
 
     expect(fsm.current).to eql(:green)
@@ -171,16 +145,13 @@ RSpec.describe FiniteMachine, 'events' do
 
   it "doesn't raise error on invalid transition for non-dangerous version" do
     called = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :stop, from: :yellow, to: :red
-      }
-      callbacks {
-        on_before :stop do |event| called << 'on_before_stop' end
-        on_after  :stop do |event| called << 'on_before_stop' end
-      }
+      event :stop, from: :yellow, to: :red
+
+      on_before :stop do |event| called << 'on_before_stop' end
+      on_after  :stop do |event| called << 'on_before_stop' end
     end
 
     expect(fsm.current).to eq(:green)
@@ -192,16 +163,13 @@ RSpec.describe FiniteMachine, 'events' do
   context 'for non-dangerous version' do
     it "doesn't raise error on invalid transition and fires callbacks" do
       called = []
-      fsm = FiniteMachine.define do
+      fsm = FiniteMachine.new do
         initial :green
 
-        events {
-          event :stop, from: :yellow, to: :red
-        }
-        callbacks {
-          on_before :stop do |event| called << 'on_before_stop' end
-          on_after  :stop do |event| called << 'on_before_stop' end
-        }
+        event :stop, from: :yellow, to: :red
+
+        on_before :stop do |event| called << 'on_before_stop' end
+        on_after  :stop do |event| called << 'on_before_stop' end
       end
 
       expect(fsm.current).to eq(:green)
@@ -212,17 +180,14 @@ RSpec.describe FiniteMachine, 'events' do
 
     it "raises error on invalid transition for dangerous version" do
       called = []
-      fsm = FiniteMachine.define do
+      fsm = FiniteMachine.new do
         initial :green
 
-        events {
-          event :slow,  from: :green,  to: :yellow
-          event :stop,  from: :yellow, to: :red, silent: true
-        }
-        callbacks {
-          on_before :stop do |event| called << 'on_before_stop' end
-          on_after  :stop do |event| called << 'on_before_stop' end
-        }
+        event :slow,  from: :green,  to: :yellow
+        event :stop,  from: :yellow, to: :red, silent: true
+
+        on_before :stop do |event| called << 'on_before_stop' end
+        on_after  :stop do |event| called << 'on_before_stop' end
       end
 
       expect(fsm.current).to eql(:green)
@@ -234,16 +199,13 @@ RSpec.describe FiniteMachine, 'events' do
   context 'for dangerous version' do
     it "raises error on invalid transition without callbacks" do
       called = []
-      fsm = FiniteMachine.define do
+      fsm = FiniteMachine.new do
         initial :green
 
-        events {
-          event :start, :red => :yellow, silent: true
-        }
-        callbacks {
-          on_before :start do |event| called << 'on_before_start' end
-          on_after  :start do |event| called << 'on_after_start' end
-        }
+        event :start, :red => :yellow, silent: true
+
+        on_before :start do |event| called << 'on_before_start' end
+        on_after  :start do |event| called << 'on_after_start' end
       end
 
       expect(fsm.current).to eq(:green)
@@ -254,16 +216,13 @@ RSpec.describe FiniteMachine, 'events' do
 
     it "raises error on invalid transition with callbacks fired" do
       called = []
-      fsm = FiniteMachine.define do
+      fsm = FiniteMachine.new do
         initial :green
 
-        events {
-          event :start, :red => :yellow
-        }
-        callbacks {
-          on_before :start do |event| called << 'on_before_start' end
-          on_after  :start do |event| called << 'on_after_start' end
-        }
+        event :start, :red => :yellow
+
+        on_before :start do |event| called << 'on_before_start' end
+        on_after  :start do |event| called << 'on_after_start' end
       end
 
       expect(fsm.current).to eq(:green)
@@ -276,15 +235,13 @@ RSpec.describe FiniteMachine, 'events' do
 
   context 'when multiple from states' do
     it "allows for array from key" do
-      fsm = FiniteMachine.define do
+      fsm = FiniteMachine.new do
         initial :green
 
-        events {
-          event :slow,  :green            => :yellow
-          event :stop,  [:green, :yellow] => :red
-          event :ready, :red              => :yellow
-          event :go,    [:yellow, :red]   => :green
-        }
+        event :slow,  :green            => :yellow
+        event :stop,  [:green, :yellow] => :red
+        event :ready, :red              => :yellow
+        event :go,    [:yellow, :red]   => :green
       end
 
       expect(fsm.current).to eql(:green)
@@ -304,15 +261,13 @@ RSpec.describe FiniteMachine, 'events' do
     end
 
     it "allows for hash of states" do
-      fsm = FiniteMachine.define do
+      fsm = FiniteMachine.new do
         initial :green
 
-        events {
-          event :slow,  :green  => :yellow
-          event :stop,  :green  => :red,   :yellow => :red
-          event :ready, :red    => :yellow
-          event :go,    :yellow => :green, :red    => :green
-        }
+        event :slow,  :green  => :yellow
+        event :stop,  :green  => :red,   :yellow => :red
+        event :ready, :red    => :yellow
+        event :go,    :yellow => :green, :red    => :green
       end
 
       expect(fsm.current).to eql(:green)
@@ -333,15 +288,13 @@ RSpec.describe FiniteMachine, 'events' do
   end
 
   it "groups events with the same name" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :stop,  :green  => :yellow
-        event :stop,  :yellow => :red
-        event :stop,  :red    => :pink
-        event :cycle, [:yellow, :red, :pink] => :green
-      }
+      event :stop,  :green  => :yellow
+      event :stop,  :yellow => :red
+      event :stop,  :red    => :pink
+      event :cycle, [:yellow, :red, :pink] => :green
     end
 
     expect(fsm.current).to eql(:green)
@@ -359,14 +312,12 @@ RSpec.describe FiniteMachine, 'events' do
   end
 
   it "groups transitions under one event name" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :initial
 
-      events {
-        event :bump, :initial => :low,
-                     :low     => :medium,
-                     :medium  => :high
-      }
+      event :bump, :initial => :low,
+                    :low     => :medium,
+                    :medium  => :high
     end
 
     expect(fsm.current).to eq(:initial)
@@ -376,19 +327,15 @@ RSpec.describe FiniteMachine, 'events' do
   end
 
   it "returns values for events" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :neutral
 
-      events {
-        event :start,  :neutral   => :engine_on
-        event :drive,  :engine_on => :running, if: -> { return false }
-        event :stop,   :any       => :neutral
-      }
+      event :start,  :neutral   => :engine_on
+      event :drive,  :engine_on => :running, if: -> { return false }
+      event :stop,   any_state  => :neutral
 
-      callbacks {
-        on_before(:drive) { FiniteMachine::CANCELLED }
-        on_after(:stop)   { }
-      }
+      on_before(:drive) { cancel_event }
+      on_after(:stop)   { }
     end
 
     expect(fsm.current).to eql(:neutral)
@@ -401,19 +348,15 @@ RSpec.describe FiniteMachine, 'events' do
   it "allows for self transition events" do
     digits = []
     callbacks = []
-    phone = FiniteMachine.define do
+    phone = FiniteMachine.new do
       initial :on_hook
 
-      events {
-        event :digit,    :on_hook => :dialing
-        event :digit,    :dialing => :dialing
-        event :off_hook, :dialing => :alerting
-      }
+      event :digit,    :on_hook => :dialing
+      event :digit,    :dialing => :dialing
+      event :off_hook, :dialing => :alerting
 
-      callbacks {
-        on_before_digit { |event, digit| digits << digit}
-        on_before_off_hook { |event| callbacks << "dialing #{digits.join}" }
-      }
+      on_before_digit { |event, digit| digits << digit}
+      on_before_off_hook { |event| callbacks << "dialing #{digits.join}" }
     end
 
     expect(phone.current).to eq(:on_hook)
@@ -429,24 +372,12 @@ RSpec.describe FiniteMachine, 'events' do
     expect(callbacks).to match_array(["dialing 911"])
   end
 
-  it "detects dangerous event names" do
-    expect {
-      FiniteMachine.define do
-        events {
-          event :trigger, :a => :b
-        }
-      end
-    }.to raise_error(FiniteMachine::AlreadyDefinedError)
-  end
-
   it "executes event block" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :red
 
-      events {
-        event :start, :red => :green
-        event :stop,  :green => :red
-      }
+      event :start, :red => :green
+      event :stop,  :green => :red
     end
 
     expect(fsm.current).to eq(:red)

data/spec/unit/handlers_spec.rb

@@ -1,9 +1,6 @@
-# encoding: utf-8
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe FiniteMachine, 'handlers' do
-
   before(:each) {
     stub_const("DummyLogger", Class.new do
       attr_reader :result
@@ -20,19 +17,15 @@ RSpec.describe FiniteMachine, 'handlers' do
 
   it "allows to customise error handling" do
     called = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
+      event :slow, :green  => :yellow
+      event :stop, :yellow => :red
 
-      handlers {
-        handle FiniteMachine::InvalidStateError do |exception|
-          called << 'invalidstate'
-        end
-      }
+      handle FiniteMachine::InvalidStateError do |exception|
+        called << 'invalidstate'
+      end
     end
 
     expect(fsm.current).to eql(:green)
@@ -45,19 +38,13 @@ RSpec.describe FiniteMachine, 'handlers' do
 
   it 'allows for :with to be symbol' do
     logger = DummyLogger.new
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new(logger) do
       initial :green
 
-      target logger
+      event :slow, :green  => :yellow
+      event :stop, :yellow => :red
 
-      events {
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
-
-      handlers {
-        handle FiniteMachine::InvalidStateError, with: :log_error
-      }
+      handle FiniteMachine::InvalidStateError, with: :log_error
     end
 
     expect(fsm.current).to eql(:green)
@@ -69,26 +56,19 @@ RSpec.describe FiniteMachine, 'handlers' do
   it 'allows for error type as string' do
     logger = DummyLogger.new
     called = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new(target: logger) 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
-      }
+      event :slow, :green  => :yellow
+      event :stop, :yellow => :red
+
+      on_enter_yellow do |event|
+        raise_error
+      end
+
+      handle 'InvalidStateError' do |exception|
+        called << 'invalid_state_error'
+      end
     end
 
     expect(fsm.current).to eql(:green)
@@ -99,19 +79,15 @@ RSpec.describe FiniteMachine, 'handlers' do
 
   it 'allows for empty block handler' do
     called = []
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
+      event :slow, :green  => :yellow
+      event :stop, :yellow => :red
 
-      handlers {
-        handle FiniteMachine::InvalidStateError do
-          called << 'invalidstate'
-        end
-      }
+      handle FiniteMachine::InvalidStateError do
+        called << 'invalidstate'
+      end
     end
 
     expect(fsm.current).to eql(:green)
@@ -123,30 +99,22 @@ RSpec.describe FiniteMachine, 'handlers' do
   end
 
   it 'requires error handler' do
-    expect { FiniteMachine.define do
+    expect { FiniteMachine.new do
       initial :green
 
-      events {
-        event :slow, :green => :yellow
-      }
+      event :slow, :green => :yellow
 
-      handlers {
-        handle 'UnknownErrorType'
-      }
+      handle 'UnknownErrorType'
     end }.to raise_error(ArgumentError, /error handler/)
   end
 
   it 'checks handler class to be Exception' do
-    expect { FiniteMachine.define do
+    expect { FiniteMachine.new do
       initial :green
 
-      events {
-        event :slow, :green => :yellow
-      }
+      event :slow, :green => :yellow
 
-      handlers {
-        handle Object do end
-      }
+      handle Object do end
     end }.to raise_error(ArgumentError, /Object isn't an Exception/)
   end
 end