statemachine 0.3.0 → 0.4.0

data/CHANGES

@@ -1,5 +1,15 @@
 = Statemachine Changelog
 
+== Version 0.4.0
+
+Feature enhancements
+* enabled nested superstate history
+* TransitionMissingException's are raised when the statemachine can't respond to an event
+* Statmachine overrides respond_to? to respond to valid events.
+
+Behavior Fixes
+* fixed default transition so that superstate transitions have priority over default
+
 == Version 0.3.0
 
 Feature enhancements

data/TODO

@@ -1,4 +1,4 @@
-
+Specific Exceptions... so missing events can be identified.
 
 Maybe:
 Implement superstate endstate with automatic transition

data/lib/statemachine/state.rb

@@ -22,8 +22,8 @@ module Statemachine
     
     def transition_for(event)
       transition = @transitions[event]
+      transition = @superstate.transition_for(event) if @superstate and not transition      
       transition = @default_transition if not transition
-      transition = @superstate.transition_for(event) if @superstate and not transition
       return transition 
     end
     

data/lib/statemachine/statemachine.rb

@@ -3,6 +3,9 @@ module Statemachine
   class StatemachineException < Exception
   end
   
+  class TransitionMissingException < Exception 
+  end
+  
   # Used at runtime to execute the behavior of the statemachine.
   # Should be created by using the Statemachine.build method.
   # 
@@ -86,7 +89,7 @@ module Statemachine
         if transition
           transition.invoke(@state, self, args)
         else
-          raise StatemachineException.new("#{@state} does not respond to the '#{event}' event.")
+          raise TransitionMissingException.new("#{@state} does not respond to the '#{event}' event.")
         end
       else
         raise StatemachineException.new("The state machine isn't in any state while processing the '#{event}' event.")
@@ -104,8 +107,7 @@ module Statemachine
         superstate_id = base_id(id)
         superstate = @states[superstate_id]
         raise StatemachineException.new("No history exists for #{superstate} since it is not a super state.") if superstate.is_concrete?
-        raise StatemachineException.new("#{superstate} doesn't have any history yet.") if not superstate.history
-        return superstate.history
+        return load_history(superstate)
       else
         state = State.new(id, @root, self)
         @states[id] = state
@@ -125,13 +127,24 @@ module Statemachine
       end
     end
     
+    def respond_to?(message)
+      return true if super(message)
+      return true if @state.transition_for(message)
+      return false
+    end
+    
     def method_missing(message, *args) #:nodoc:
       if @state and @state.transition_for(message)
-        method = self.method(:process_event)
-        params = [message.to_sym].concat(args)
-        method.call(*params)
+        process_event(message.to_sym, *args)
+        # method = self.method(:process_event)
+        # params = [message.to_sym].concat(args)
+        # method.call(*params)
       else
-        super(message, args)
+        begin
+          super(message, args)
+        rescue NoMethodError
+          process_event(message.to_sym, *args)
+        end
       end
     end
     
@@ -145,6 +158,18 @@ module Statemachine
       return history_id.to_s[0...-2].to_sym
     end
     
+    def load_history(superstate)
+      100.times do
+        history = superstate.history
+        raise StatemachineException.new("#{superstate} doesn't have any history yet.") if not history
+        if history.is_concrete?
+          return history
+        else
+          superstate = history
+        end
+      end
+      raise StatemachineException.new("No history found within 100 levels of nested superstates.")
+    end
+    
   end
-
 end

data/lib/statemachine/version.rb

@@ -2,7 +2,7 @@ module Statemachine
   module VERSION #:nodoc:
     unless defined? MAJOR
       MAJOR  = 0
-      MINOR  = 3
+      MINOR  = 4
       TINY   = 0
 
       STRING = [MAJOR, MINOR, TINY].join('.')

data/spec/action_invokation_spec.rb

@@ -19,13 +19,13 @@ class Noodle
   
 end
 
-context "Action Invokation" do
+describe "Action Invokation" do
 
-  setup do
+  before(:each) do
     @noodle = Noodle.new
   end
   
-  specify "Proc actions" do
+  it "Proc actions" do
     sm = Statemachine.build do |smb|
       smb.trans :cold, :fire, :hot, Proc.new { @cooked = true } 
     end
@@ -33,10 +33,10 @@ context "Action Invokation" do
     sm.context = @noodle
     sm.fire
     
-    @noodle.cooked.should_be true
+    @noodle.cooked.should equal(true)
   end
   
-  specify "Symbol actions" do
+  it "Symbol actions" do
     sm = Statemachine.build do |smb|
       smb.trans :cold, :fire, :hot, :cook
       smb.trans :hot, :mold, :changed, :transform
@@ -45,22 +45,22 @@ context "Action Invokation" do
     sm.context = @noodle
     sm.fire
   
-    @noodle.cooked.should_be true
+    @noodle.cooked.should equal(true)
     
     sm.mold "capellini"
     
-    @noodle.shape.should_eql "capellini"
+    @noodle.shape.should eql("capellini")
   end
 
-  specify "String actions" do
+  it "String actions" do
     sm = Statemachine.build do |smb|
       smb.trans :cold, :fire, :hot, "@shape = 'fettucini'; @cooked = true"
     end
     sm.context = @noodle
     
     sm.fire
-    @noodle.shape.should_eql "fettucini"
-    @noodle.cooked.should_be true
+    @noodle.shape.should eql("fettucini")
+    @noodle.cooked.should equal(true)
   end
 
   

data/spec/builder_spec.rb

@@ -1,24 +1,24 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-context "Builder" do
+describe "Builder" do
 
-  setup do
+  before(:each) do
     @log = []
   end
 
   def check_switch(sm)
-    sm.state.should_be :off
+    sm.state.should equal(:off)
     
     sm.toggle
-    @log[0].should_eql "toggle on"
-    sm.state.should_be :on
+    @log[0].should eql("toggle on")
+    sm.state.should equal(:on)
     
     sm.toggle
-    @log[1].should_eql "toggle off"
-    sm.state.should_be :off
+    @log[1].should eql("toggle off")
+    sm.state.should equal(:off)
   end
 
-  specify "Building a the switch, relaxed" do
+  it "Building a the switch, relaxed" do
     sm = Statemachine.build do
       trans :off, :toggle, :on, Proc.new { @log << "toggle on" }
       trans :on, :toggle, :off, Proc.new { @log << "toggle off" }
@@ -28,7 +28,7 @@ context "Builder" do
     check_switch sm
   end
 
-  specify "Building a the switch, strict" do
+  it "Building a the switch, strict" do
     sm = Statemachine.build do
       state(:off) { |s| s.event :toggle, :on, Proc.new { @log << "toggle on" } }
       state(:on) { |s| s.event :toggle, :off, Proc.new { @log << "toggle off" } }
@@ -38,7 +38,7 @@ context "Builder" do
     check_switch sm
   end
 
-  specify "Adding a superstate to the switch" do
+  it "Adding a superstate to the switch" do
     the_context = self
     sm = Statemachine.build do
       superstate :operation do
@@ -52,16 +52,16 @@ context "Builder" do
       context the_context
     end
     
-    sm.state.should_be :off
+    sm.state.should equal(:off)
     sm.toggle
     sm.admin
-    sm.state.should_be :testing
+    sm.state.should equal(:testing)
     sm.resume
-    sm.state.should_be :on
-    @log.join(",").should_eql "toggle on,testing,resuming"
+    sm.state.should equal(:on)
+    @log.join(",").should eql("toggle on,testing,resuming")
   end
   
-  specify "entry exit actions" do
+  it "entry exit actions" do
     the_context = self
     sm = Statemachine.build do
       state :off do
@@ -74,14 +74,14 @@ context "Builder" do
     end
 
     sm.toggle
-    sm.state.should_be :on
+    sm.state.should equal(:on)
     sm.toggle
-    sm.state.should_be :off
+    sm.state.should equal(:off)
 
-    @log.join(",").should_eql "enter off,exit off,toggle on,toggle off,enter off"
+    @log.join(",").should eql("enter off,exit off,toggle on,toggle off,enter off")
   end
   
-  specify "History state" do
+  it "History state" do
     the_context = self
     sm = Statemachine.build do
       superstate :operation do
@@ -100,12 +100,12 @@ context "Builder" do
     
     sm.admin
     sm.resume
-    sm.state.should_be :off
+    sm.state.should equal(:off)
     
-    @log.join(",").should_eql "enter off,testing,resuming,enter off"
+    @log.join(",").should eql("enter off,testing,resuming,enter off")
   end
 
-  specify "entry and exit action created from superstate builder" do
+  it "entry and exit action created from superstate builder" do
     the_context = self
     sm = Statemachine.build do
       trans :off, :toggle, :on, Proc.new { @log << "toggle on" }
@@ -118,11 +118,11 @@ context "Builder" do
     sm.toggle
     sm.toggle
     
-    @log.join(",").should_eql "entering off,toggle on,exiting on,toggle off,entering off"
+    @log.join(",").should eql("entering off,toggle on,exiting on,toggle off,entering off")
     
   end
 
-  specify "superstate as startstate" do
+  it "superstate as startstate" do
     
     lambda do 
       sm = Statemachine.build do
@@ -131,11 +131,11 @@ context "Builder" do
         end
       end
       
-      sm.state.should_be :luigi
-    end.should_not_raise(Exception)
+      sm.state.should equal(:luigi)
+    end.should_not raise_error(Exception)
   end
   
-  specify "setting the start state before any other states declared" do
+  it "setting the start state before any other states declared" do
     
     sm = Statemachine.build do
       startstate :right
@@ -144,12 +144,12 @@ context "Builder" do
       trans :right, :pull, :middle
     end
     
-    sm.state.should_be :right
+    sm.state.should equal(:right)
     sm.pull
-    sm.state.should_be :middle
+    sm.state.should equal(:middle)
   end
   
-  specify "setting start state which is in a super state" do
+  it "setting start state which is in a super state" do
     sm = Statemachine.build do
       startstate :right
       superstate :table do
@@ -161,16 +161,16 @@ context "Builder" do
       state :floor
     end
     
-    sm.state.should_be :right
+    sm.state.should equal(:right)
     sm.pull
-    sm.state.should_be :middle
+    sm.state.should equal(:middle)
     sm.push
-    sm.state.should_be :right
+    sm.state.should equal(:right)
     sm.tilt
-    sm.state.should_be :floor
+    sm.state.should equal(:floor)
   end
   
-  specify "can set context" do
+  it "can set context" do
     widget = Object.new
     sm = Statemachine.build do
       context widget
@@ -179,7 +179,7 @@ context "Builder" do
     sm.context.should be(widget)
   end
 
-  specify "statemachine will be set on context if possible" do
+  it "statemachine will be set on context if possible" do
     class Widget
       attr_accessor :statemachine
     end

data/spec/default_transition_spec.rb

@@ -1,8 +1,8 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-context "Default Transition" do
+describe "Default Transition" do
 
-  setup do
+  before(:each) do
     @sm = Statemachine.build do
       trans :default_state, :start, :test_state
       
@@ -12,20 +12,20 @@ context "Default Transition" do
     end
   end
   
-  specify "the default transition is set" do
+  it "the default transition is set" do
     test_state = @sm.get_state(:test_state)
     test_state.default_transition.should_not be(nil)
     test_state.transition_for(:fake_event).should_not be(nil)
   end
   
-  specify "Should go to the default_state with any event" do
+  it "Should go to the default_state with any event" do
     @sm.start
     @sm.fake_event
     
     @sm.state.should eql(:default_state)
   end
   
-  specify "default transition can have actions" do
+  it "default transition can have actions" do
     me = self
     @sm = Statemachine.build do
       trans :default_state, :start, :test_state
@@ -47,7 +47,7 @@ context "Default Transition" do
     @hi = true
   end
   
-  specify "superstate supports the default" do
+  it "superstate supports the default" do
     @sm = Statemachine.build do
       superstate :test_superstate do
         default :default_state
@@ -62,4 +62,26 @@ context "Default Transition" do
     @sm.blah
     @sm.state.should eql(:default_state)
   end
+  
+  it "superstate transitions do not go to the default state" do
+    @sm = Statemachine.build do
+      superstate :test_superstate do
+        event :not_default, :not_default_state
+        
+        state :start_state do 
+          default :default_state
+        end
+        
+        state :default_state
+      end
+      
+      startstate :start_state
+    end
+    
+    @sm.state = :start_state
+    @sm.not_default
+    @sm.state.should eql(:not_default_state)
+  end
+
+  
 end

data/spec/history_spec.rb

@@ -1,8 +1,8 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-context "History States" do
+describe "History States" do
 
-  setup do
+  before(:each) do
     @sm = Statemachine.build do
       superstate :operate do
         trans :on, :toggle, :off
@@ -16,19 +16,19 @@ context "History States" do
     end
   end
   
-  specify "no history allowed for concrete states" do
+  it "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.")
+      }.should raise_error(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
+  it "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.")
+      }.should raise_error(Statemachine::StatemachineException, "'operate' superstate doesn't have any history yet.")
   end
   
-  specify "reseting the statemachine resets history" do
+  it "reseting the statemachine resets history" do
     @sm.faddle
     @sm.fiddle
     @sm.get_state(:operate).history.id.should eql(:on)
@@ -39,9 +39,9 @@ context "History States" do
   
 end
 
-context "History Default" do
+describe "History Default" do
   
-  setup do    
+  before(:each) do    
     @sm = Statemachine.build do
       superstate :operate do
         trans :on, :toggle, :off
@@ -55,12 +55,12 @@ context "History Default" do
     end
   end
   
-  specify "default history" do
+  it "default history" do
     @sm.fiddle
     @sm.state.should eql(:on)
   end
   
-  specify "reseting the statemachine resets history" do
+  it "reseting the statemachine resets history" do
     @sm.faddle
     @sm.toggle
     @sm.fiddle
@@ -72,3 +72,36 @@ context "History Default" do
 
 end
 
+describe "Nested Superstates" do
+
+  before(:each) do
+    @sm = Statemachine.build do
+      
+      superstate :grandpa do
+        trans :start, :go, :daughter
+        event :sister, :great_auntie
+        
+        superstate :papa do
+          state :son
+          state :daughter
+        end
+      end
+      
+      state :great_auntie do
+        event :foo, :grandpa_H
+      end
+    
+    end
+  end
+  
+  it "should use history of sub superstates when transitioning itto it's own history" do
+    @sm.go
+    @sm.sister
+    @sm.foo
+    
+    @sm.state.should eql(:daughter)
+  end
+
+end
+
+

data/spec/sm_action_parameterization_spec.rb

@@ -1,99 +1,99 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-context "State Machine Odds And Ends" do
+describe "State Machine Odds And Ends" do
   include SwitchStatemachine
 
-  setup do
+  before(:each) do
     create_switch
   end
   
-  specify "action with one parameter" do
+  it "action with one parameter" do
     Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |value| @status = value } }
     @sm.set "blue"
-    @status.should_eql "blue"
-    @sm.state.should_be :on
+    @status.should eql("blue")
+    @sm.state.should equal(:on)
   end
 
-  specify "action with two parameters" do
+  it "action with two parameters" do
     Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b| @status = [a, b].join(",") } }
     @sm.set "blue", "green"
-    @status.should_eql "blue,green"
-    @sm.state.should_be :on
+    @status.should eql("blue,green")
+    @sm.state.should equal(:on)
   end
 
-  specify "action with three parameters" do
+  it "action with three parameters" do
     Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c| @status = [a, b, c].join(",") } }
     @sm.set "blue", "green", "red"
-    @status.should_eql "blue,green,red"
-    @sm.state.should_be :on
+    @status.should eql("blue,green,red")
+    @sm.state.should equal(:on)
   end
 
-  specify "action with four parameters" do
+  it "action with four parameters" do
     Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c, d| @status = [a, b, c, d].join(",") } }
     @sm.set "blue", "green", "red", "orange"
-    @status.should_eql "blue,green,red,orange"
-    @sm.state.should_be :on
+    @status.should eql("blue,green,red,orange")
+    @sm.state.should equal(:on)
   end
 
-  specify "action with five parameters" do
+  it "action with five parameters" do
     Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c, d, e| @status = [a, b, c, d, e].join(",") } }
     @sm.set "blue", "green", "red", "orange", "yellow"
-    @status.should_eql "blue,green,red,orange,yellow"
-    @sm.state.should_be :on
+    @status.should eql("blue,green,red,orange,yellow")
+    @sm.state.should equal(:on)
   end
   
-  specify "action with six parameters" do
+  it "action with six parameters" do
     Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c, d, e, f| @status = [a, b, c, d, e, f].join(",") } }
     @sm.set "blue", "green", "red", "orange", "yellow", "indigo"
-    @status.should_eql "blue,green,red,orange,yellow,indigo"
-    @sm.state.should_be :on
+    @status.should eql("blue,green,red,orange,yellow,indigo")
+    @sm.state.should equal(:on)
   end
 
-  specify "action with seven parameters" do
+  it "action with seven parameters" do
     Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c, d, e, f, g| @status = [a, b, c, d, e, f, g].join(",") } }
     @sm.set "blue", "green", "red", "orange", "yellow", "indigo", "violet"
-    @status.should_eql "blue,green,red,orange,yellow,indigo,violet"
-    @sm.state.should_be :on
+    @status.should eql("blue,green,red,orange,yellow,indigo,violet")
+    @sm.state.should equal(:on)
   end
 
-  specify "action with eight parameters" do
+  it "action with eight parameters" do
     Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c, d, e, f, g, h| @status = [a, b, c, d, e, f, g, h].join(",") } }
     @sm.set "blue", "green", "red", "orange", "yellow", "indigo", "violet", "ultra-violet"
-    @status.should_eql "blue,green,red,orange,yellow,indigo,violet,ultra-violet"
-    @sm.state.should_be :on
+    @status.should eql("blue,green,red,orange,yellow,indigo,violet,ultra-violet")
+    @sm.state.should equal(:on)
   end
   
-  specify "calling process_event with parameters" do
+  it "calling process_event with parameters" do
     Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c| @status = [a, b, c].join(",") } }
     @sm.process_event(:set, "blue", "green", "red")
-    @status.should_eql "blue,green,red"
-    @sm.state.should_be :on
+    @status.should eql("blue,green,red")
+    @sm.state.should equal(:on)
   end
 
-  specify "Insufficient params" do
+  it "Insufficient params" do
     Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c| @status = [a, b, c].join(",") } }
-    lambda { @sm.set "blue", "green" }.should_raise(Statemachine::StatemachineException, 
+    lambda { @sm.set "blue", "green" }.should raise_error(Statemachine::StatemachineException, 
       "Insufficient parameters. (transition action from 'off' state invoked by 'set' event)")
   end
   
-  specify "infinate args" do
+  it "infinate args" do
    Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |*a| @status = a.join(",") } }
     @sm.set(1, 2, 3)
-    @status.should_eql "1,2,3"
+    @status.should eql("1,2,3")
     
     @sm.state = :off
     @sm.set(1, 2, 3, 4, 5, 6)
-    @status.should_eql "1,2,3,4,5,6"
+    @status.should eql("1,2,3,4,5,6")
   end
   
-  specify "Insufficient params when params are infinate" do
+  it "Insufficient params when params are infinate" do
     Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, *b| @status = a.to_s + ":" + b.join(",") } }
     @sm.set(1, 2, 3)
-    @status.should_eql "1:2,3"
+    @status.should eql("1:2,3")
     
     @sm.state = :off
    
-    lambda { @sm.set }.should_raise(Statemachine::StatemachineException, 
+    lambda { @sm.set }.should raise_error(Statemachine::StatemachineException, 
       "Insufficient parameters. (transition action from 'off' state invoked by 'set' event)")
   end
 end

data/spec/sm_entry_exit_actions_spec.rb

@@ -1,8 +1,8 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-context "State Machine Entry and Exit Actions" do
+describe "State Machine Entry and Exit Actions" do
 
-  setup do
+  before(:each) do
     @log = []
     @sm = Statemachine.build do
       trans :off, :toggle, :on, Proc.new { @log << "on" }
@@ -11,50 +11,50 @@ context "State Machine Entry and Exit Actions" do
     @sm.context = self
   end
 
-  specify "entry action" do
+  it "entry action" do
     @sm.get_state(:on).entry_action = Proc.new { @log << "entered_on" }
     
     @sm.toggle
     
-    @log.join(",").should_eql "on,entered_on"
+    @log.join(",").should eql("on,entered_on")
   end
   
-  specify "exit action" do
+  it "exit action" do
     @sm.get_state(:off).exit_action = Proc.new { @log << "exited_off" }
     
     @sm.toggle
     
-    @log.join(",").should_eql "exited_off,on"
+    @log.join(",").should eql("exited_off,on")
   end
 
-  specify "exit and entry" do
+  it "exit and entry" do
     @sm.get_state(:off).exit_action = Proc.new { @log << "exited_off" }
     @sm.get_state(:on).entry_action = Proc.new { @log << "entered_on" }
     
     @sm.toggle
     
-    @log.join(",").should_eql "exited_off,on,entered_on"
+    @log.join(",").should eql("exited_off,on,entered_on")
   end
   
-  specify "entry and exit actions may be parameterized" do
+  it "entry and exit actions may be parameterized" do
       @sm.get_state(:off).exit_action = Proc.new { |a| @log << "exited_off(#{a})" }
       @sm.get_state(:on).entry_action = Proc.new { |a, b| @log << "entered_on(#{a},#{b})" }
       
       @sm.toggle "one", "two"
       
-      @log.join(",").should_eql "exited_off(one),on,entered_on(one,two)"
+      @log.join(",").should eql("exited_off(one),on,entered_on(one,two)")
   end
 
-  specify "current state is set prior to exit and entry actions" do
+  it "current state is set prior to exit and entry actions" do
     @sm.get_state(:off).exit_action = Proc.new { @log << @sm.state }
     @sm.get_state(:on).entry_action =  Proc.new { @log << @sm.state }
     
     @sm.toggle
     
-    @log.join(",").should_eql "off,on,on"  
+    @log.join(",").should eql("off,on,on")
   end
 
-  specify "current state is set prior to exit and entry actions even with super states" do
+  it "current state is set prior to exit and entry actions even with super states" do
     @sm = Statemachine::Statemachine.new
     Statemachine.build(@sm) do
       superstate :off_super do
@@ -72,18 +72,18 @@ context "State Machine Entry and Exit Actions" do
     @sm.context = self
 
     @sm.toggle
-    @log.join(",").should_eql "off,super_on,on"  
+    @log.join(",").should eql("off,super_on,on")
   end
 
-  specify "entry actions invokes another event" do
+  it "entry actions invokes another event" do
     @sm.get_state(:on).entry_action = Proc.new { @sm.toggle }
     
     @sm.toggle
-    @log.join(",").should_eql "on,off"
-    @sm.state.should_be :off
+    @log.join(",").should eql("on,off")
+    @sm.state.should equal(:off)
   end
 
-  specify "startstate's entry action should be called when the statemachine starts" do
+  it "startstate's entry action should be called when the statemachine starts" do
     the_context = self
     @sm = Statemachine.build do
       trans :a, :b, :c

data/spec/sm_odds_n_ends_spec.rb

@@ -1,41 +1,58 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-context "State Machine Odds And Ends" do
+describe "State Machine Odds And Ends" do
   include SwitchStatemachine
 
-  setup do
+  before(:each) do
     create_switch
   end
   
-  specify "method missing delegates to super in case of no event" do
-    lambda { @sm.blah }.should_raise NoMethodError
+  it "method missing delegates to super in case of no event" do
+    $method_missing_called = false
+    module Blah 
+      def method_missing(message, *args)
+        $method_missing_called = true
+      end
+    end
+    @sm.extend(Blah)
+    @sm.blah
+    $method_missing_called.should eql(true)
+  end
+  
+  it "should raise TransistionMissingException when the state doesn't respond to the event" do
+    lambda { @sm.blah }.should raise_error(Statemachine::TransitionMissingException, "'off' state does not respond to the 'blah' event.")
+  end
+  
+  it "should respond to valid events" do
+    @sm.respond_to?(:toggle).should eql(true)
+    @sm.respond_to?(:blah).should eql(false)
   end
   
-  specify "set state with string" do
-    @sm.state.should_be :off
+  it "set state with string" do
+    @sm.state.should equal(:off)
     @sm.state = "on"
-    @sm.state.should_be :on
+    @sm.state.should equal(:on)
   end
   
-  specify "set state with symbol" do
-    @sm.state.should_be :off
+  it "set state with symbol" do
+    @sm.state.should equal(:off)
     @sm.state = :on
-    @sm.state.should_be :on
+    @sm.state.should equal(:on)
   end
   
-  specify "process event accepts strings" do
+  it "process event accepts strings" do
     @sm.process_event("toggle")
-    @sm.state.should_be :on
+    @sm.state.should equal(:on)
   end
 
-  specify "states without transitions are valid" do
+  it "states without transitions are valid" do
     @sm = Statemachine.build do
       trans :middle, :push, :stuck
       startstate :middle
     end
     
     @sm.push
-    @sm.state.should_be :stuck
+    @sm.state.should equal(:stuck)
   end
 
 end

data/spec/sm_simple_spec.rb

@@ -1,23 +1,23 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-context "simple cases:" do
-  setup do
+describe "simple cases:" do
+  before(:each) do
     @sm = Statemachine::Statemachine.new
     @sm.context = self
     @count = 0
     @proc = Proc.new {@count = @count + 1}
   end
   
-  specify "reset" do
+  it "reset" do
     Statemachine.build(@sm) { |s| s.trans :start, :blah, :end, @proc }
     @sm.process_event(:blah)
     
     @sm.reset
     
-    @sm.state.should_be :start
+    @sm.state.should equal(:start)
   end
 
-  specify "no proc in transition" do
+  it "no proc in transition" do
      Statemachine.build(@sm) { |s| s.trans :on, :flip, :off }
     
     @sm.flip

data/spec/sm_super_state_spec.rb

@@ -1,9 +1,9 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-context "Turn Stile" do
+describe "Turn Stile" do
   include TurnstileStatemachine
   
-  setup do
+  before(:each) do
     create_turnstile
     
     @out_out_order = false
@@ -22,19 +22,19 @@ context "Turn Stile" do
     @sm.context = self
   end
 
-  specify "substates respond to superstate transitions" do
+  it "substates respond to superstate transitions" do
     @sm.process_event(:maintain)
-    @sm.state.should_be :maintenance
-    @locked.should_be true
-    @out_of_order.should_be true
+    @sm.state.should equal(:maintenance)
+    @locked.should equal(true)
+    @out_of_order.should equal(true)
   end
 
-  specify "after transitions, substates respond to superstate transitions" do
+  it "after transitions, substates respond to superstate transitions" do
     @sm.coin
     @sm.maintain
-    @sm.state.should_be :maintenance
-    @locked.should_be false
-    @out_of_order.should_be true
+    @sm.state.should equal(:maintenance)
+    @locked.should equal(false)
+    @out_of_order.should equal(true)
   end
   
 end

data/spec/sm_turnstile_spec.rb

@@ -1,18 +1,18 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-context "Turn Stile" do
+describe "Turn Stile" do
   include TurnstileStatemachine
   
-  setup do
+  before(:each) do
     create_turnstile
   end
   
-  specify "connections" do
+  it "connections" do
     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
+    locked_state.transitions.length.should equal(2)
+    unlocked_state.transitions.length.should equal(2)
     
     check_transition(locked_state.transitions[:coin], :locked, :unlocked, :coin, @unlock)
     check_transition(locked_state.transitions[:pass], :locked, :locked, :pass, @alarm)
@@ -20,57 +20,57 @@ context "Turn Stile" do
     check_transition(unlocked_state.transitions[:coin], :unlocked, :locked, :coin, @thankyou)
   end
   
-  specify "start state" do
+  it "start state" do
     @sm.reset
-    @sm.startstate.should.be :locked
-    @sm.state.should.be :locked
+    @sm.startstate.should equal(:locked)
+    @sm.state.should equal(:locked)
   end
   
-  specify "bad event" do
+  it "bad event" do
     begin
       @sm.process_event(:blah)
       self.should.fail_with_message("Exception expected")
     rescue Exception => e
-      e.class.should.be Statemachine::StatemachineException
-      e.to_s.should_eql "'locked' state does not respond to the 'blah' event."
+      e.class.should equal(Statemachine::TransitionMissingException)
+      e.to_s.should eql("'locked' state does not respond to the 'blah' event.")
     end
   end
   
-  specify "locked state with a coin" do
+  it "locked state with a coin" do
     @sm.process_event(:coin)
     
-    @sm.state.should.be :unlocked
-    @locked.should.be false
+    @sm.state.should equal(:unlocked)
+    @locked.should equal(false)
   end
   
-  specify "locked state with pass event" do
+  it "locked state with pass event" do
     @sm.process_event(:pass)
     
-    @sm.state.should.be :locked
-    @locked.should.be true
-    @alarm_status.should.be true
+    @sm.state.should equal(:locked)
+    @locked.should equal(true)
+    @alarm_status.should equal(true)
   end
 
-  specify "unlocked state with coin" do
+  it "unlocked state with coin" do
     @sm.process_event(:coin)
     @sm.process_event(:coin)
     
-    @sm.state.should.be :locked
-    @thankyou_status.should.be true
+    @sm.state.should equal(:locked)
+    @thankyou_status.should equal(true)
   end
 
-  specify "unlocked state with pass event" do
+  it "unlocked state with pass event" do
     @sm.process_event(:coin)
     @sm.process_event(:pass)
     
-    @sm.state.should.be :locked
-    @locked.should.be true
+    @sm.state.should equal(:locked)
+    @locked.should equal(true)
   end
 
-  specify "events invoked via method_missing" do
+  it "events invoked via method_missing" do
     @sm.coin
-    @sm.state.should.be :unlocked
+    @sm.state.should equal(:unlocked)
     @sm.pass
-    @sm.state.should.be :locked
+    @sm.state.should equal(:locked)
   end
 end

data/spec/spec_helper.rb

@@ -4,11 +4,11 @@ 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.origin_id.should_be origin_id
-  transition.destination_id.should_be destination_id
-  transition.action.should_eql action
+  transition.should_not equal(nil)
+  transition.event.should equal(event)
+  transition.origin_id.should equal(origin_id)
+  transition.destination_id.should equal(destination_id)
+  transition.action.should eql(action)
 end
 
 module SwitchStatemachine

data/spec/transition_spec.rb

@@ -1,107 +1,107 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-context "Transition Calculating Exits and Entries" do
+describe "Transition Calculating Exits and Entries" do
 
-  setup do
+  before(:each) do
     @transition = Statemachine::Transition.new(nil, nil, nil, nil)
   end
   
-  specify "to nil" do
+  it "to nil" do
     @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
+    exits.to_s.should eql([@a].to_s)
+    entries.to_s.should eql([].to_s)
+    entries.length.should equal(0)
   end
   
-  specify "to itself" do
+  it "to itself" do
     @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
+    exits.to_s.should eql([@a].to_s)
+    entries.to_s.should eql([@a].to_s)
   end
 
-  specify "to friend" do
+  it "to friend" do
     @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
+    exits.to_s.should eql([@a].to_s)
+    entries.to_s.should eql([@b].to_s)
   end
 
-  specify "to parent" do
+  it "to parent" do
     @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
+    exits.to_s.should eql([@a, @b].to_s)
+    entries.to_s.should eql([@b].to_s)
   end
 
-  specify "to uncle" do
+  it "to uncle" do
     @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
+    exits.to_s.should eql([@a, @b].to_s)
+    entries.to_s.should eql([@c].to_s)
   end
 
-  specify "to cousin" do
+  it "to cousin" do
     @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
+    exits.to_s.should eql([@a, @b].to_s)
+    entries.to_s.should eql([@d, @c].to_s)
   end
   
-  specify "to nephew" do
+  it "to nephew" do
     @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
+    exits.to_s.should eql([@c].to_s)
+    entries.to_s.should eql([@b,@a].to_s)
   end
 
-  specify "to sister" do
+  it "to sister" do
     @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
+    exits.to_s.should eql([@a].to_s)
+    entries.to_s.should eql([@b].to_s)
   end
   
-  specify "to second cousin" do
+  it "to second cousin" do
     @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
+    exits.to_s.should eql([@a, @b].to_s)
+    entries.to_s.should eql([@e, @d].to_s)
   end
 
-  specify "to grandparent" do
+  it "to grandparent" do
     @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
+    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
+  it "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
+    exits.to_s.should eql([@d].to_s)
+    entries.to_s.should eql([@b, @a].to_s)
   end
   
 end

metadata

@@ -3,9 +3,9 @@ rubygems_version: 0.9.1
 specification_version: 1
 name: statemachine
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
-date: 2007-04-18 00:00:00 -05:00
-summary: Statemachine-0.3.0 - Statemachine Library for Ruby http://statemachine.rubyforge.org/
+  version: 0.4.0
+date: 2007-05-17 00:00:00 -05:00
+summary: Statemachine-0.4.0 - Statemachine Library for Ruby http://statemachine.rubyforge.org/
 require_paths: 
 - lib
 email: statemachine-devel@rubyforge.org