finite_machine 0.7.1 → 0.8.0

data/spec/unit/can_spec.rb

@@ -3,6 +3,13 @@
 require 'spec_helper'
 
 describe FiniteMachine, 'can?' do
+  before(:each) {
+    Bug = Class.new do
+      def pending?
+        false
+      end
+    end
+  }
 
   it "allows to check if event can be fired" do
     fsm = FiniteMachine.define do
@@ -19,7 +26,7 @@ describe FiniteMachine, 'can?' do
     expect(fsm.current).to eql(:green)
 
     expect(fsm.can?(:slow)).to be_true
-    expect(fsm.can?(:stop)).to be_false
+    expect(fsm.cannot?(:stop)).to be_true
     expect(fsm.can?(:ready)).to be_false
     expect(fsm.can?(:go)).to be_false
 
@@ -47,4 +54,45 @@ describe FiniteMachine, 'can?' do
     expect(fsm.can?(:ready)).to be_false
     expect(fsm.can?(:go)).to be_true
   end
+
+  context 'with conditionl transition' do
+    it "evalutes condition with parameters" do
+      fsm = FiniteMachine.define do
+        initial :green
+
+        events {
+          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
+      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
+    end
+
+    it "checks against target and grouped events" do
+      bug = Bug.new
+      fsm = FiniteMachine.define do
+        initial :initial
+
+        target bug
+
+        events {
+          event :bump, :initial => :low
+          event :bump, :low     => :medium, if: :pending?
+          event :bump, :medium  => :high
+        }
+      end
+      expect(fsm.current).to eq(:initial)
+
+      expect(fsm.can?(:bump)).to be_true
+      fsm.bump
+      expect(fsm.can?(:bump)).to be_false
+    end
+  end
 end

data/spec/unit/choice_spec.rb

@@ -0,0 +1,137 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine, '#choice' do
+  before(:each) {
+    User = Class.new do
+      def promo?(token = false)
+        token == :yes
+      end
+    end
+  }
+
+  it "allows for static choice based on conditional branching" do
+    called = []
+    fsm = FiniteMachine.define 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
+      }
+    end
+    expect(fsm.current).to eq(:company_form)
+    fsm.next
+    expect(fsm.current).to eq(:official_form)
+    expect(called).to eq([
+      'on_exit_company_form',
+      'on_enter_official_form'
+    ])
+  end
+
+  it "allows for dynamic choice based on conditional branching" do
+    fsm = FiniteMachine.define 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
+      }
+    end
+    expect(fsm.current).to eq(:company_form)
+    fsm.next(0)
+    expect(fsm.current).to eq(:agreement_form)
+
+    fsm.restore!(:company_form)
+    fsm.next(1)
+    expect(fsm.current).to eq(:promo_form)
+
+    fsm.restore!(:company_form)
+    fsm.next(2)
+    expect(fsm.current).to eq(:official_form)
+  end
+
+  it "allows for dynamic choice based on conditional branching and target" do
+    user = User.new
+    fsm = FiniteMachine.define 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
+      }
+    end
+    expect(fsm.current).to eq(:company_form)
+    fsm.next(:no)
+    expect(fsm.current).to eq(:promo_form)
+    fsm.restore!(:company_form)
+    fsm.next(:yes)
+    expect(fsm.current).to eq(:agreement_form)
+  end
+
+  it "choses state when skipped if/unless" do
+    fsm = FiniteMachine.define 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
+      }
+    end
+    expect(fsm.current).to eq(:company_form)
+    fsm.next
+    expect(fsm.current).to eq(:promo_form)
+  end
+
+  it "choice default state when branching conditions don't match" do
+    fsm = FiniteMachine.define 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
+      }
+    end
+    expect(fsm.current).to eq(:company_form)
+    fsm.next
+    expect(fsm.current).to eq(:official_form)
+  end
+
+  it "fails to transition when no condition matches without default state" do
+    fsm = FiniteMachine.define do
+      initial :company_form
+
+      events {
+        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
+    expect(fsm.current).to eq(:company_form)
+  end
+end

data/spec/unit/if_unless_spec.rb

@@ -19,6 +19,12 @@ describe FiniteMachine, ':if, :unless' do
         !!@engine_on
       end
     end
+
+    class Bug
+      def pending?
+        false
+      end
+    end
   }
 
   it "allows to cancel event with :if option" do
@@ -225,12 +231,6 @@ describe FiniteMachine, ':if, :unless' do
   end
 
   context 'when same event name' do
-    class Bug
-      def pending?
-        false
-      end
-    end
-
     it "preservers conditions for the same named event" do
       bug = Bug.new
       fsm = FiniteMachine.define do
@@ -250,5 +250,46 @@ describe FiniteMachine, ':if, :unless' do
       fsm.bump
       expect(fsm.current).to eq(:low)
     end
+
+    it "allows for static choice based on branching condition" do
+      fsm = FiniteMachine.define 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 }
+        }
+      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
+        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 }
+        }
+      end
+      expect(fsm.current).to eq(:company_form)
+
+      fsm.next(0)
+      expect(fsm.current).to eq(:agreement_form)
+      fsm.restore!(:company_form)
+      expect(fsm.current).to eq(:company_form)
+
+      fsm.next(1)
+      expect(fsm.current).to eq(:promo_form)
+      fsm.restore!(:company_form)
+      expect(fsm.current).to eq(:company_form)
+
+      fsm.next(2)
+      expect(fsm.current).to eq(:official_form)
+    end
   end
 end

data/spec/unit/initialize_spec.rb

@@ -54,10 +54,7 @@ describe FiniteMachine, 'initialize' do
       }
     end
     expect(fsm.current).to eql(:green)
-    expect(called).to eq([
-      'on_exit_none',
-      'on_enter_green'
-    ])
+    expect(called).to be_empty
   end
 
   it "allows to specify initial state through parameter" do
@@ -189,4 +186,37 @@ describe FiniteMachine, 'initialize' do
     expect(fsm.current).to eq(:green)
     expect(fsm.initial_state).to eq(:green)
   end
+
+  it "allows to trigger callbacks on initial with :silent option" do
+    called = []
+    fsm = FiniteMachine.define do
+      initial state: :green, silent: false
+
+      events {
+        event :slow, :green => :yellow
+      }
+      callbacks {
+        on_enter :green do |event| called << 'on_enter_green' end
+      }
+    end
+    expect(fsm.current).to eq(:green)
+    expect(called).to eq(['on_enter_green'])
+  end
+
+  it "allows to trigger callbacks on deferred initial state" do
+    called = []
+    fsm = FiniteMachine.define do
+      initial state: :green, silent: false, defer: true
+
+      events {
+        event :slow, :green => :yellow
+      }
+      callbacks {
+        on_enter :green do |event| called << 'on_enter_green' end
+      }
+    end
+    expect(fsm.current).to eq(:none)
+    fsm.init
+    expect(called).to eq(['on_enter_green'])
+  end
 end

data/spec/unit/states_spec.rb

@@ -16,6 +16,20 @@ describe FiniteMachine, 'states' do
       }
     end
 
-    expect(fsm.states).to eql([:none, :green, :yellow, :red])
+    expect(fsm.states).to match_array([:none, :green, :yellow, :red])
+  end
+
+  it "retrieves all unique states for choice transition" do
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        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
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: finite_machine
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Piotr Murach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-08 00:00:00.000000000 Z
+date: 2014-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -51,6 +51,7 @@ files:
 - lib/finite_machine/async_proxy.rb
 - lib/finite_machine/callable.rb
 - lib/finite_machine/catchable.rb
+- lib/finite_machine/choice_merger.rb
 - lib/finite_machine/dsl.rb
 - lib/finite_machine/event.rb
 - lib/finite_machine/event_queue.rb
@@ -73,6 +74,7 @@ files:
 - spec/unit/callable/call_spec.rb
 - spec/unit/callbacks_spec.rb
 - spec/unit/can_spec.rb
+- spec/unit/choice_spec.rb
 - spec/unit/define_spec.rb
 - spec/unit/event/add_spec.rb
 - spec/unit/event/inspect_spec.rb
@@ -130,6 +132,7 @@ test_files:
 - spec/unit/callable/call_spec.rb
 - spec/unit/callbacks_spec.rb
 - spec/unit/can_spec.rb
+- spec/unit/choice_spec.rb
 - spec/unit/define_spec.rb
 - spec/unit/event/add_spec.rb
 - spec/unit/event/inspect_spec.rb