statemachine 0.0.3 → 0.1.0

data/spec/sm_odds_n_ends_spec.rb

@@ -5,7 +5,6 @@ context "State Machine Odds And Ends" do
 
   setup do
     create_switch
-    @sm.run
   end
   
   specify "method missing delegates to super in case of no event" do
@@ -13,15 +12,58 @@ context "State Machine Odds And Ends" do
   end
   
   specify "set state with string" do
-    @sm.state.id.should_be :off
+    @sm.state.should_be :off
     @sm.state = "on"
-    @sm.state.id.should_be :on
+    @sm.state.should_be :on
   end
   
   specify "set state with symbol" do
-    @sm.state.id.should_be :off
+    @sm.state.should_be :off
     @sm.state = :on
-    @sm.state.id.should_be :on
+    @sm.state.should_be :on
+  end
+  
+  specify "process event accepts strings" do
+    @sm.process_event("toggle")
+    @sm.state.should_be :on
   end
 
 end
+
+context "Special States" do
+
+  setup do
+    @sm = StateMachine.build do |s|
+      s.superstate :operate do |o|
+        o.trans :on, :toggle, :off
+        o.trans :off, :toggle, :on
+        o.event :fiddle, :middle
+      end
+      s.trans :middle, :fiddle, :operate_H
+      s.trans :middle, :push, :stuck
+      s.trans :middle, :dream, :on_H
+      s.start_state :middle
+    end
+  end
+  
+  specify "states without transitions are valid" do
+    @sm.push
+    @sm.state.should_be :stuck
+  end
+  
+  specify "no history allowed for concrete states" do
+    lambda {
+        @sm.dream
+      }.should_raise(StateMachine::StateMachineException, "No history exists for 'on' state since it is not a super state.")
+  end
+
+  specify "error when trying to use history that doesn't exist yet" do
+    lambda {
+      @sm.fiddle
+      }.should_raise(StateMachine::StateMachineException, "'operate' superstate doesn't have any history yet.")
+  end
+
+end
+
+
+

data/spec/sm_simple_spec.rb

@@ -7,52 +7,19 @@ context "simple cases:" do
     @proc = Proc.new {@count = @count + 1}
   end
   
-  specify "one transition has states" do
-    @sm.add(:on, :flip, :off, @proc)
-    
-    @sm.states.length.should_be 2
-    @sm[:on].should_not_be nil
-    @sm[:off].should_not_be nil
-  end
-    
-  specify "one trasition create connects states with transition" do
-    @sm.add(:on, :flip, :off, @proc)
-    origin = @sm[:on]
-    destination = @sm[:off]
-    
-    origin.transitions.length.should_be 1
-    destination.transitions.length.should_be 0
-    transition = origin[:flip]
-    check_transition(transition, :on, :off, :flip, @proc)
-  end
-
   specify "reset" do
-    @sm.add(:start, :blah, nil, @proc)
-    @sm.run
+    StateMachine.build(@sm) { |s| s.trans :start, :blah, :end, @proc }
     @sm.process_event(:blah)
     
     @sm.reset
     
-    @sm.state.should.be @sm[:start]
-  end
-  
-  specify "exception when state machine is not running" do
-    @sm.add(:on, :flip, :off)
-    
-    begin
-      @sm.process_event(:flip)
-    rescue StateMachine::StateMachineException => e
-      e.message.should_equal "The state machine isn't in any state.  Did you forget to call run?"
-    end
+    @sm.state.should_be :start
   end
 
   specify "no proc in transition" do
-    @sm.add(:on, :flip, :off)
-    @sm.run
+     StateMachine.build(@sm) { |s| s.trans :on, :flip, :off }
     
     @sm.flip
   end
-
-  
   
 end

data/spec/sm_super_state_spec.rb

@@ -7,16 +7,23 @@ context "Turn Stile" do
     create_turnstile
     
     @out_out_order = false
-    @sm.add(:operative, :maintain, :maintenance, Proc.new { @out_of_order = true } )
-    @sm.add(:maintenance, :operate, :operative, Proc.new { @out_of_order = false } )
-    @sm[:operative].add_substates(:locked, :unlocked)
     
-    @sm.run
+    @sm = StateMachine.build do |s|
+      s.superstate :operative do |o|
+        o.trans :locked, :coin, :unlocked, @unlock
+        o.trans :unlocked, :pass, :locked, @lock
+        o.trans :locked, :pass, :locked, @alarm
+        o.trans :unlocked, :coin, :locked, @thankyou
+        o.event :maintain, :maintenance, Proc.new { @out_of_order = true }
+      end
+      s.trans :maintenance, :operate, :operative, Proc.new { @out_of_order = false } 
+      s.start_state :locked
+    end
   end
 
   specify "substates respond to superstate transitions" do
     @sm.process_event(:maintain)
-    @sm.state.id.should_be :maintenance
+    @sm.state.should_be :maintenance
     @locked.should_be true
     @out_of_order.should_be true
   end
@@ -24,57 +31,9 @@ context "Turn Stile" do
   specify "after transitions, substates respond to superstate transitions" do
     @sm.coin
     @sm.maintain
-    @sm.state.id.should_be :maintenance
+    @sm.state.should_be :maintenance
     @locked.should_be false
     @out_of_order.should_be true
   end
   
-  specify "transitions back to superstate go to history state" do
-    @sm[:operative].use_history
-    @sm.maintain
-    @sm.operate
-    @sm.state.id.should_be :locked
-    @out_of_order.should_be false
-    
-    @sm.coin
-    @sm.maintain
-    @sm.operate
-    @sm.state.id.should_be :unlocked
-  end
-  
-  specify "missing substates are added" do
-    @sm[:operative].add_substates(:blah)
-    @sm[:blah].should_not_be nil
-    @sm[:blah].superstate.id.should_be :operative
-  end
-
-  specify "recursive superstates not allowed" do
-    begin
-      @sm[:operative].add_substates(:operative)
-      self.should_fail_with_message("exception expected")
-    rescue StateMachine::StateMachineException => e
-      e.message.should_equal "Cyclic substates not allowed. (operative)"
-    end
-  end
-
-  specify "recursive superstates (2 levels) not allowed" do
-    begin
-      @sm[:operative].add_substates(:blah)
-      @sm[:blah].add_substates(:operative)
-      self.should_fail_with_message("exception expected")
-    rescue StateMachine::StateMachineException => e
-      e.message.should_equal "Cyclic substates not allowed. (blah)"
-    end
-  end
-  
-  specify "exception when add_substates called without args" do
-    begin
-      @sm[:locked].add_substates()
-      self.should_fail_with_message("exception expected")
-    rescue StateMachine::StateMachineException => e
-      e.message.should_equal "At least one parameter is required for add_substates."
-    end
-  end
-  
-  
 end

data/spec/sm_turnstile_spec.rb

@@ -5,27 +5,25 @@ context "Turn Stile" do
   
   setup do
     create_turnstile
-    @sm.run
   end
   
   specify "connections" do
-    @sm.states.length.should_be 2
-    locked_state = @sm[:locked]
-    unlocked_state = @sm[:unlocked]
+    locked_state = @sm.get_state(:locked)
+    unlocked_state = @sm.get_state(:unlocked)
     
     locked_state.transitions.length.should_be 2
     unlocked_state.transitions.length.should_be 2
     
-    check_transition(locked_state[:coin], :locked, :unlocked, :coin, @unlock)
-    check_transition(locked_state[:pass], :locked, :locked, :pass, @alarm)
-    check_transition(unlocked_state[:pass], :unlocked, :locked, :pass, @lock)
-    check_transition(unlocked_state[:coin], :unlocked, :locked, :coin, @thankyou)
+    check_transition(locked_state.transitions[:coin], :locked, :unlocked, :coin, @unlock)
+    check_transition(locked_state.transitions[:pass], :locked, :locked, :pass, @alarm)
+    check_transition(unlocked_state.transitions[:pass], :unlocked, :locked, :pass, @lock)
+    check_transition(unlocked_state.transitions[:coin], :unlocked, :locked, :coin, @thankyou)
   end
   
   specify "start state" do
-    @sm.run
-    @sm.start_state.should.be @sm[:locked]
-    @sm.state.should.be @sm[:locked]
+    @sm.reset
+    @sm.start_state.should.be :locked
+    @sm.state.should.be :locked
   end
   
   specify "bad event" do
@@ -33,31 +31,31 @@ context "Turn Stile" do
       @sm.process_event(:blah)
       self.should.fail_with_message("Exception expected")
     rescue Exception => e
-      e.class.should.be StateMachine::MissingTransitionException
-      e.to_s.should_equal "'locked' state does not respond to the 'blah' event."
+      e.class.should.be StateMachine::StateMachineException
+      e.to_s.should_eql "'locked' state does not respond to the 'blah' event."
     end
   end
   
   specify "locked state with a coin" do
     @sm.process_event(:coin)
     
-    @sm.state.should.be @sm[:unlocked]
+    @sm.state.should.be :unlocked
     @locked.should.be false
   end
   
   specify "locked state with pass event" do
     @sm.process_event(:pass)
     
-    @sm.state.should.be @sm[:locked]
+    @sm.state.should.be :locked
     @locked.should.be true
-    @alarm.should.be true
+    @alarm_status.should.be true
   end
 
   specify "unlocked state with coin" do
     @sm.process_event(:coin)
     @sm.process_event(:coin)
     
-    @sm.state.should.be @sm[:locked]
+    @sm.state.should.be :locked
     @thankyou_status.should.be true
   end
 
@@ -65,14 +63,14 @@ context "Turn Stile" do
     @sm.process_event(:coin)
     @sm.process_event(:pass)
     
-    @sm.state.should.be @sm[:locked]
+    @sm.state.should.be :locked
     @locked.should.be true
   end
 
   specify "events invoked via method_missing" do
     @sm.coin
-    @sm.state.should.be @sm[:unlocked]
+    @sm.state.should.be :unlocked
     @sm.pass
-    @sm.state.should.be @sm[:locked]
+    @sm.state.should.be :locked
   end
 end

data/spec/spec_helper.rb

@@ -1,21 +1,24 @@
-$:.unshift('lib')
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'rubygems'
+require 'spec'
 require 'statemachine'
 
 def check_transition(transition, origin_id, destination_id, event, action)
   transition.should_not_be nil
   transition.event.should_be event
   transition.action.should_be action
-  transition.origin.id.should_be origin_id
-  transition.destination.id.should_be destination_id
+  transition.origin_id.should_be origin_id
+  transition.destination_id.should_be destination_id
 end
 
 module SwitchStateMachine
   
   def create_switch
     @status = "off"
-    @sm = StateMachine::StateMachine.new
-    @sm.add(:off, :toggle, :on, Proc.new { @status = "on" } )
-    @sm.add(:on, :toggle, :off, Proc.new { @status = "off" } )
+    @sm = StateMachine.build do |s|
+      s.trans :off, :toggle, :on, Proc.new { @status = "on" } 
+      s.trans :on, :toggle, :off, Proc.new { @status = "off" }
+    end
   end
   
 end
@@ -31,11 +34,12 @@ module TurnstileStateMachine
     @alarm = Proc.new { @alarm_status = true }
     @thankyou = Proc.new { @thankyou_status = true }
   
-    @sm = StateMachine::StateMachine.new
-    @sm.add(:locked, :coin, :unlocked, @unlock)
-    @sm.add(:unlocked, :pass, :locked, @lock)
-    @sm.add(:locked, :pass, :locked, @alarm)
-    @sm.add(:unlocked, :coin, :locked, @thankyou)
+    @sm = StateMachine.build do |s|
+      s.trans :locked, :coin, :unlocked, @unlock
+      s.trans :unlocked, :pass, :locked, @lock
+      s.trans :locked, :pass, :locked, @alarm
+      s.trans :unlocked, :coin, :locked, @thankyou
+    end
   end
   
 end

data/spec/transition_spec.rb

@@ -3,95 +3,105 @@ require File.dirname(__FILE__) + '/spec_helper'
 context "Transition Calculating Exits and Entries" do
 
   setup do
-    @a = StateMachine::State.new("a", nil)
-    @b = StateMachine::State.new("b", nil)
-    @c = StateMachine::State.new("c", nil)
-    @d = StateMachine::State.new("d", nil)
-    @e = StateMachine::State.new("e", nil)
+    @transition = StateMachine::Transition.new(nil, nil, nil, nil)
   end
   
   specify "to nil" do
-    transition = StateMachine::Transition.new(@a, nil, nil, nil)
-    exits, entries = transition.exits_and_entries(@a)
-    exits.to_s.should_equal [@a].to_s
-    entries.to_s.should_equal [].to_s
+    @a = StateMachine::State.new("a", nil, nil)
+    exits, entries = @transition.exits_and_entries(@a, nil)
+    exits.to_s.should_eql [@a].to_s
+    entries.to_s.should_eql [].to_s
     entries.length.should_be 0
   end
   
   specify "to itself" do
-    transition = StateMachine::Transition.new(@a, @a, nil, nil)
-    exits, entries = transition.exits_and_entries(@a)
-    exits.to_s.should_equal [@a].to_s
-    entries.to_s.should_equal [@a].to_s
+    @a = StateMachine::State.new("a", nil, nil)
+    exits, entries = @transition.exits_and_entries(@a, @a)
+    exits.to_s.should_eql [@a].to_s
+    entries.to_s.should_eql [@a].to_s
   end
 
   specify "to friend" do
-    transition = StateMachine::Transition.new(@a, @b, nil, nil)
-    exits, entries = transition.exits_and_entries(@a)
-    exits.to_s.should_equal [@a].to_s
-    entries.to_s.should_equal [@b].to_s
+    @a = StateMachine::State.new("a", nil, nil)
+    @b = StateMachine::State.new("b", nil, nil)
+    exits, entries = @transition.exits_and_entries(@a, @b)
+    exits.to_s.should_eql [@a].to_s
+    entries.to_s.should_eql [@b].to_s
   end
 
   specify "to parent" do
-    @a.superstate = @b
-    transition = StateMachine::Transition.new(@a, @b, nil, nil)
-    exits, entries = transition.exits_and_entries(@a)
-    exits.to_s.should_equal [@a, @b].to_s
-    entries.to_s.should_equal [@b].to_s
+    @b = StateMachine::State.new("b", nil, nil)
+    @a = StateMachine::State.new("a", @b, nil)
+    exits, entries = @transition.exits_and_entries(@a, @b)
+    exits.to_s.should_eql [@a, @b].to_s
+    entries.to_s.should_eql [@b].to_s
   end
 
   specify "to uncle" do
-    @a.superstate = @b
-    transition = StateMachine::Transition.new(@a, @c, nil, nil)
-    exits, entries = transition.exits_and_entries(@a)
-    exits.to_s.should_equal [@a, @b].to_s
-    entries.to_s.should_equal [@c].to_s
+    @b = StateMachine::State.new("b", nil, nil)
+    @a = StateMachine::State.new("a", @b, nil)
+    @c = StateMachine::State.new("c", nil, nil)
+    exits, entries = @transition.exits_and_entries(@a, @c)
+    exits.to_s.should_eql [@a, @b].to_s
+    entries.to_s.should_eql [@c].to_s
   end
 
   specify "to cousin" do
-    @a.superstate = @b
-    @c.superstate = @d
-    transition = StateMachine::Transition.new(@a, @c, nil, nil)
-    exits, entries = transition.exits_and_entries(@a)
-    exits.to_s.should_equal [@a, @b].to_s
-    entries.to_s.should_equal [@d, @c].to_s
+    @b = StateMachine::State.new("b", nil, nil)
+    @d = StateMachine::State.new("d", nil, nil)
+    @a = StateMachine::State.new("a", @b, nil)
+    @c = StateMachine::State.new("c", @d, nil)
+    exits, entries = @transition.exits_and_entries(@a, @c)
+    exits.to_s.should_eql [@a, @b].to_s
+    entries.to_s.should_eql [@d, @c].to_s
   end
   
   specify "to nephew" do
-    @a.superstate = @b
-    transition = StateMachine::Transition.new(@c, @a, nil, nil)
-    exits, entries = transition.exits_and_entries(@c)
-    exits.to_s.should_equal [@c].to_s
-    entries.to_s.should_equal [@b,@a].to_s
+    @b = StateMachine::State.new("b", nil, nil)
+    @c = StateMachine::State.new("c", nil, nil)
+    @a = StateMachine::State.new("a", @b, nil)
+    exits, entries = @transition.exits_and_entries(@c, @a)
+    exits.to_s.should_eql [@c].to_s
+    entries.to_s.should_eql [@b,@a].to_s
   end
 
   specify "to sister" do
-    @a.superstate = @c
-    @b.superstate = @c
-    transition = StateMachine::Transition.new(@a, @b, nil, nil)
-    exits, entries = transition.exits_and_entries(@a)
-    exits.to_s.should_equal [@a].to_s
-    entries.to_s.should_equal [@b].to_s
+    @c = StateMachine::State.new("c", nil, nil)
+    @a = StateMachine::State.new("a", @c, nil)
+    @b = StateMachine::State.new("b", @c, nil)
+    exits, entries = @transition.exits_and_entries(@a, @b)
+    exits.to_s.should_eql [@a].to_s
+    entries.to_s.should_eql [@b].to_s
   end
   
   specify "to second cousin" do
-    @a.superstate = @b
-    @b.superstate = @c
-    @d.superstate = @e
-    @e.superstate = @c
-    transition = StateMachine::Transition.new(@a, @d, nil, nil)
-    exits, entries = transition.exits_and_entries(@a)
-    exits.to_s.should_equal [@a, @b].to_s
-    entries.to_s.should_equal [@e, @d].to_s
+    @c = StateMachine::State.new("c", nil, nil)
+    @b = StateMachine::State.new("b", @c, nil)
+    @a = StateMachine::State.new("a", @b, nil)
+    @e = StateMachine::State.new("e", @c, nil)
+    @d = StateMachine::State.new("d", @e, nil)
+    exits, entries = @transition.exits_and_entries(@a, @d)
+    exits.to_s.should_eql [@a, @b].to_s
+    entries.to_s.should_eql [@e, @d].to_s
   end
 
   specify "to grandparent" do
-    @a.superstate = @b
-    @b.superstate = @c
-    transition = StateMachine::Transition.new(@a, @c, nil, nil)
-    exits, entries = transition.exits_and_entries(@a)
-    exits.to_s.should_equal [@a, @b, @c].to_s
-    entries.to_s.should_equal [@c].to_s
+    @c = StateMachine::State.new("c", nil, nil)
+    @b = StateMachine::State.new("b", @c, nil)
+    @a = StateMachine::State.new("a", @b, nil)
+    exits, entries = @transition.exits_and_entries(@a, @c)
+    exits.to_s.should_eql [@a, @b, @c].to_s
+    entries.to_s.should_eql [@c].to_s
+  end
+
+  specify "to parent's grandchild" do
+    @c = StateMachine::State.new("c", nil, nil)
+    @b = StateMachine::State.new("b", @c, nil)
+    @a = StateMachine::State.new("a", @b, nil) 
+    @d = StateMachine::State.new("d", @c, nil)
+    exits, entries = @transition.exits_and_entries(@d, @a)
+    exits.to_s.should_eql [@d].to_s
+    entries.to_s.should_eql [@b, @a].to_s
   end
   
 end