finite_machine 0.11.3 → 0.12.0

data/spec/unit/respond_to_spec.rb

@@ -1,6 +1,4 @@
-# encoding: utf-8
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe FiniteMachine, '#respond_to' do
 
@@ -14,9 +12,7 @@ RSpec.describe FiniteMachine, '#respond_to' do
     FiniteMachine.new target: Car.new do
       initial :green
 
-      events {
-        event :slow,  :green  => :yellow
-      }
+      event :slow,  :green  => :yellow
     end
   }
 

data/spec/unit/state_parser/parse_spec.rb

@@ -1,19 +1,16 @@
-# encoding: utf-8
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe FiniteMachine::StateParser, '#parse' do
   let(:object) { described_class }
 
-  subject(:parser) { object.new(attrs) }
-
   context 'when no attributes' do
     let(:attrs) { { } }
 
     it "raises error for no transitions" do
       expect {
-        parser.parse
-      }.to raise_error(FiniteMachine::NotEnoughTransitionsError)
+        object.parse(attrs)
+      }.to raise_error(FiniteMachine::NotEnoughTransitionsError,
+                       /please provide state transitions/)
     end
   end
 
@@ -21,7 +18,7 @@ RSpec.describe FiniteMachine::StateParser, '#parse' do
     let(:attrs) { { from: :green, to: :yellow }}
 
     it "removes :from and :to keys" do
-      expect(parser.parse).to eq({green: :yellow})
+      expect(object.parse(attrs)).to eq({green: :yellow})
     end
   end
 
@@ -29,7 +26,7 @@ RSpec.describe FiniteMachine::StateParser, '#parse' do
     let(:attrs) { { from: :green }}
 
     it "adds to state as copy of from" do
-      expect(parser.parse).to eq({green: :green})
+      expect(object.parse(attrs)).to eq({green: :green})
     end
   end
 
@@ -37,7 +34,7 @@ RSpec.describe FiniteMachine::StateParser, '#parse' do
     let(:attrs) { { to: :green }}
 
     it "inserts :any from state" do
-      expect(parser.parse).to eq({any: :green})
+      expect(object.parse(attrs)).to eq({FiniteMachine::ANY_STATE => :green})
     end
   end
 
@@ -45,7 +42,7 @@ RSpec.describe FiniteMachine::StateParser, '#parse' do
     let(:attrs) { { green: :yellow } }
 
     it "copies attributes over" do
-      expect(parser.parse).to eq({green: :yellow})
+      expect(object.parse(attrs)).to eq({green: :yellow})
     end
   end
 
@@ -53,7 +50,7 @@ RSpec.describe FiniteMachine::StateParser, '#parse' do
     let(:attrs) { { [:green, :red] => :yellow } }
 
     it "extracts states" do
-      expect(parser.parse).to include({red: :yellow, green: :yellow})
+      expect(object.parse(attrs)).to include({red: :yellow, green: :yellow})
     end
   end
 end

data/spec/unit/states_spec.rb

@@ -1,33 +1,27 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'spec_helper'
-
-RSpec.describe FiniteMachine, 'states' do
+RSpec.describe FiniteMachine, '#states' do
   it "retrieves all available states" 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.states).to match_array([:none, :green, :yellow, :red])
   end
 
   it "retrieves all unique states for choice transition" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :next, from: :green do
-          choice :yellow, if: -> { false }
-          choice :red,    if: -> { true }
-        end
-      }
+      event :next, from: :green do
+        choice :yellow, if: -> { false }
+        choice :red,    if: -> { true }
+      end
     end
     expect(fsm.states).to match_array([:none, :green, :yellow, :red])
   end

data/spec/unit/subscribers_spec.rb

@@ -1,6 +1,4 @@
-# encoding: utf-8
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe FiniteMachine::Subscribers do
   let(:listener) { double }

data/spec/unit/target_spec.rb

@@ -1,6 +1,4 @@
-# encoding: utf-8
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 RSpec.describe FiniteMachine, '#target' do
   it "allows to target external object" do
@@ -20,28 +18,21 @@ RSpec.describe FiniteMachine, '#target' do
       end
 
       def engine
-        context = self
-        @engine ||= FiniteMachine.define do
+        @engine ||= FiniteMachine.new(self) do
           initial :neutral
 
-          target context
-
-          events {
-            event :forward, [:reverse, :neutral] => :one
-            event :shift, :one => :two
-            event :shift, :two => :one
-            event :back,  [:neutral, :one] => :reverse
-          }
+          event :forward, [:reverse, :neutral] => :one
+          event :shift, :one => :two
+          event :shift, :two => :one
+          event :back,  [:neutral, :one] => :reverse
 
-          callbacks {
-            on_enter :reverse do |event|
-              target.turn_reverse_lights_on
-            end
+          on_enter :reverse do |event|
+            target.turn_reverse_lights_on
+          end
 
-            on_exit :reverse do |event|
-              target.turn_reverse_lights_off
-            end
-          }
+          on_exit :reverse do |event|
+            target.turn_reverse_lights_off
+          end
         end
       end
     end)
@@ -57,17 +48,14 @@ RSpec.describe FiniteMachine, '#target' do
   end
 
   it "propagates method call" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
-      events {
-        event :slow, :green => :yellow
-      }
 
-      callbacks {
-        on_enter_yellow do |event|
-          uknown_method
-        end
-      }
+      event :slow, :green => :yellow
+
+      on_enter_yellow do |event|
+        uknown_method
+      end
     end
     expect(fsm.current).to eql(:green)
     expect { fsm.slow }.to raise_error(StandardError)
@@ -75,25 +63,21 @@ RSpec.describe FiniteMachine, '#target' do
 
   it "references machine methods inside callback" do
     called = []
-    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
 
-      callbacks {
-        on_enter_yellow do |event|
-          stop(:now)
-        end
+      on_enter_yellow do |event|
+        stop(:now)
+      end
 
-        on_enter_red do |event, param|
-          called << "#{event.from} #{param}"
-        end
-      }
+      on_enter_red do |event, param|
+        called << "#{event.from} #{param}"
+      end
     end
 
     expect(fsm.current).to eql(:green)
@@ -121,29 +105,23 @@ RSpec.describe FiniteMachine, '#target' do
 
       def engine
         self.called ||= []
-        context ||= self
-        @engine ||= FiniteMachine.define do
+
+        @engine ||= FiniteMachine.new(self) do
           initial :neutral
 
-          target context
-
-          events {
-            event :forward, [:reverse, :neutral] => :one
-            event :shift, :one => :two
-            event :shift, :two => :one
-            event :back,  [:neutral, :one] => :reverse
-          }
-
-          callbacks {
-            on_enter :reverse do |event|
-              target.called << 'on_enter_reverse'
-              target.turn_reverse_lights_on
-              forward('Piotr!')
-            end
-            on_before :forward do |event, name|
-              target.called << "on_enter_forward with #{name}"
-            end
-          }
+          event :forward, [:reverse, :neutral] => :one
+          event :shift, :one => :two
+          event :shift, :two => :one
+          event :back,  [:neutral, :one] => :reverse
+
+          on_enter :reverse do |event|
+            target.called << 'on_enter_reverse'
+            target.turn_reverse_lights_on
+            forward('Piotr!')
+          end
+          on_before :forward do |event, name|
+            target.called << "on_enter_forward with #{name}"
+          end
         end
       end
     end)
@@ -162,20 +140,15 @@ RSpec.describe FiniteMachine, '#target' do
   it "allows to access target inside the callback" do
     context = double(:context)
     called = nil
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new(context) do
       initial :green
 
-      target context
+      event :slow, :green  => :yellow
+      event :stop, :yellow => :red
 
-      events {
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
-      callbacks {
-        on_enter_yellow do |event|
-          called = target
-        end
-      }
+      on_enter_yellow do |event|
+        called = target
+      end
     end
     expect(fsm.current).to eql(:green)
     fsm.slow
@@ -194,25 +167,19 @@ RSpec.describe FiniteMachine, '#target' do
     end)
 
     car = Car.new(called)
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new(car) do
       initial :unsaved
 
-      target car
-
-      events {
-        event :validate, :unsaved => :valid
-        event :save, :valid => :saved
-      }
+      event :validate, :unsaved => :valid
+      event :save, :valid => :saved
 
-      callbacks {
-        on_enter :valid do |event|
-          target.save
-          save
-        end
-        on_after :save do |event|
-          called << 'event save called'
-        end
-      }
+      on_enter :valid do |event|
+        target.save
+        save
+      end
+      on_after :save do |event|
+        called << 'event save called'
+      end
     end
     expect(fsm.current).to eql(:unsaved)
     fsm.validate

data/spec/unit/terminated_spec.rb

@@ -1,18 +1,14 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'spec_helper'
-
-RSpec.describe FiniteMachine, 'terminated?' do
+RSpec.describe FiniteMachine, '#terminated?' do
 
   it "allows to specify terminal state" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :green
       terminal :red
 
-      events {
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
+      event :slow, :green  => :yellow
+      event :stop, :yellow => :red
     end
 
     expect(fsm.current).to eql(:green)
@@ -28,13 +24,11 @@ RSpec.describe FiniteMachine, 'terminated?' do
   end
 
   it "allows to specify terminal state as parameter" do
-    fsm = FiniteMachine.define terminal: :red do
+    fsm = FiniteMachine.new terminal: :red do
       initial :green
 
-      events {
-        event :slow, :green  => :yellow
-        event :stop, :yellow => :red
-      }
+      event :slow, :green  => :yellow
+      event :stop, :yellow => :red
     end
     fsm.slow
     fsm.stop
@@ -42,13 +36,11 @@ RSpec.describe FiniteMachine, 'terminated?' do
   end
 
   it "checks without terminal state" 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)
@@ -64,16 +56,14 @@ RSpec.describe FiniteMachine, 'terminated?' do
   end
 
   it "allows for multiple terminal states" do
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new do
       initial :open
 
       terminal :close, :canceled, :faulty
 
-      events {
-        event :resolve, :open => :close
-        event :decline, :open => :canceled
-        event :error,   :open => :faulty
-      }
+      event :resolve, :open => :close
+      event :decline, :open => :canceled
+      event :error,   :open => :faulty
     end
     expect(fsm.current).to eql(:open)
     expect(fsm.terminated?).to be(false)

data/spec/unit/transition/check_conditions_spec.rb

@@ -1,37 +1,39 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::Transition, '.check_conditions' do
+RSpec.describe FiniteMachine::Transition, '#check_conditions' do
   it "verifies all conditions pass" do
+    context = double(:context)
     exec_conditions = 0
     ok_condition = -> { exec_conditions += 1; return true }
     fail_condition = -> { exec_conditions += 1; return false }
-    machine = double(:machine, target: Object.new)
 
-    transition = described_class.new(machine, if: [ok_condition, fail_condition])
+    transition = described_class.new(context, :event_name,
+                                     if: [ok_condition, fail_condition])
 
     expect(transition.check_conditions).to eql(false)
     expect(exec_conditions).to eq(2)
   end
 
   it "verifies 'if' and 'unless' conditions" do
-    machine = double(:machine, target: Object.new)
+    context = double(:context)
     exec_conditions = 0
     ok_condition = -> { exec_conditions += 1; return true }
     fail_condition = -> { exec_conditions += 1; return false }
 
-    transition = described_class.new(machine, if: [ok_condition], unless: [fail_condition])
+    transition = described_class.new(context, :event_name,
+                                     if: [ok_condition],
+                                     unless: [fail_condition])
 
     expect(transition.check_conditions).to eql(true)
     expect(exec_conditions).to eq(2)
   end
 
   it "verifies condition with arguments" do
-    machine = double(:machine, target: Object.new)
-    condition = lambda { |target, arg| arg == 1 }
+    context = double(:context)
+    condition = -> (_, arg) { arg == 1 }
 
-    transition = described_class.new(machine, if: [condition])
+    transition = described_class.new(context, :event_name,
+                                     if: [condition])
 
     expect(transition.check_conditions(2)).to eql(false)
     expect(transition.check_conditions(1)).to eql(true)
@@ -43,11 +45,10 @@ RSpec.describe FiniteMachine::Transition, '.check_conditions' do
         true
       end
     end)
-    target = Car.new
-    machine = double(:machine, target: target)
-    condition = lambda { |car| car.engine_on? }
+    context = Car.new
+    condition = -> (car) { car.engine_on? }
 
-    transition = described_class.new(machine, if: condition)
+    transition = described_class.new(context, :event_name, if: condition)
 
     expect(transition.check_conditions).to eql(true)
   end