statemachine 0.0.3 → 0.1.0

data/lib/statemachine/transition.rb

@@ -6,56 +6,58 @@ module StateMachine
     
     include ProcCalling
     
-    attr_reader :origin, :event, :action
-    attr_accessor :destination
+    attr_reader :origin_id, :event, :action
+    attr_accessor :destination_id
 
-    def initialize(origin, destination, event, action)
-      @origin = origin
-      @destination = destination
+    def initialize(origin_id, destination_id, event, action)
+      @origin_id = origin_id
+      @destination_id = destination_id
       @event = event
       @action = action
     end
     
-    def invoke(origin, args)
-      exits, entries = exits_and_entries(origin)
+    def invoke(origin, statemachine, args)
+      destination = statemachine.get_state(@destination_id)
+      exits, entries = exits_and_entries(origin, destination)
       exits.each { |exited_state| exited_state.exit(args) }
       
-      call_proc(@action, args, "transition action from #{origin} invoked by '#{event}' event") if @action
-
-      entries.each { |entered_state| entered_state.enter(args) }
+      call_proc(@action, args, "transition action from #{origin} invoked by '#{@event}' event") if @action
       
-      terminal_state = @destination
-      while terminal_state and terminal_state.is_superstate?
+      terminal_state = destination
+      while terminal_state and not terminal_state.is_concrete?
         terminal_state = terminal_state.start_state
-        terminal_state.enter(args)
+        entries << terminal_state
       end
+      terminal_state.activate if terminal_state
+
+      entries.each { |entered_state| entered_state.enter(args) }
     end
     
-    def exits_and_entries(origin)
+    def exits_and_entries(origin, destination)
       exits = []
-      entries = exits_and_entries_helper(exits, origin)
+      entries = exits_and_entries_helper(exits, origin, destination)
       
       return exits, entries.reverse
     end
   
     def to_s
-      return "#{origin.id} ---#{event}---> #{destination.id} : #{action}"
+      return "#{@origin_id} ---#{@event}---> #{@destination_id} : #{action}"
     end
     
     private
     
-    def exits_and_entries_helper(exits, exit_state)
-      entries = entries_to_destination(exit_state)
+    def exits_and_entries_helper(exits, exit_state, destination)
+      entries = entries_to_destination(exit_state, destination)
       return entries if entries
       return [] if exit_state == nil
       
       exits << exit_state
-      exits_and_entries_helper(exits, exit_state.superstate)
+      exits_and_entries_helper(exits, exit_state.superstate, destination)
     end
     
-    def entries_to_destination(exit_state)
+    def entries_to_destination(exit_state, destination)
       entries = []
-      state = @destination
+      state = destination
       while state    
         entries << state
         return entries if exit_state == state.superstate

data/lib/statemachine/version.rb

@@ -2,8 +2,8 @@ module StateMachine
   module VERSION
     unless defined? MAJOR
       MAJOR  = 0
-      MINOR  = 0
-      TINY   = 3
+      MINOR  = 1
+      TINY   = 0
 
       STRING = [MAJOR, MINOR, TINY].join('.')
       TAG    = "REL_" + [MAJOR, MINOR, TINY].join('_')

data/spec/builder_spec.rb

@@ -0,0 +1,131 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+context "Builder" do
+
+  setup do
+    @log = []
+  end
+
+  def check_switch(sm)
+    sm.state.should_be :off
+    
+    sm.toggle
+    @log[0].should_eql "toggle on"
+    sm.state.should_be :on
+    
+    sm.toggle
+    @log[1].should_eql "toggle off"
+    sm.state.should_be :off
+  end
+
+  specify "Building a the switch, relaxed" do
+    sm = StateMachine.build do |b|
+      b.trans :off, :toggle, :on, Proc.new { @log << "toggle on" }
+      b.trans :on, :toggle, :off, Proc.new { @log << "toggle off" }
+    end
+    
+    check_switch sm
+  end
+
+  specify "Building a the switch, strict" do
+    sm = StateMachine.build do |b|
+      b.state(:off) { |s| s.event :toggle, :on, Proc.new { @log << "toggle on" } }
+      b.state(:on) { |s| s.event :toggle, :off, Proc.new { @log << "toggle off" } }
+    end
+
+    check_switch sm
+  end
+
+  specify "Adding a superstate to the switch" do
+    sm = StateMachine.build do |b|
+      b.superstate :operation do |o|
+        o.event :admin, :testing, lambda { @log << "testing" }
+        o.trans :off, :toggle, :on, lambda { @log << "toggle on" }
+        o.trans :on, :toggle, :off, lambda { @log << "toggle off" }
+        o.start_state :on
+      end
+      b.trans :testing, :resume, :operation, lambda { @log << "resuming" }
+      b.start_state :off
+    end
+    
+    sm.state.should_be :off
+    sm.toggle
+    sm.admin
+    sm.state.should_be :testing
+    sm.resume
+    sm.state.should_be :on
+    @log.join(",").should_eql "toggle on,testing,resuming"
+  end
+  
+  specify "entry exit actions" do
+    sm = StateMachine.build do |sm|
+      sm.state :off do |off|
+        off.on_entry { @log << "enter off" }
+        off.event :toggle, :on, lambda { @log << "toggle on" }
+        off.on_exit { @log << "exit off" }
+      end
+      sm.trans :on, :toggle, :off, lambda { @log << "toggle off" } 
+    end
+
+    sm.toggle
+    sm.state.should_be :on
+    sm.toggle
+    sm.state.should_be :off
+
+    @log.join(",").should_eql "exit off,toggle on,toggle off,enter off"
+  end
+  
+  specify "History state" do
+    sm = StateMachine.build do |b|
+      b.superstate :operation do |o|
+        o.event :admin, :testing, lambda { @log << "testing" }
+        o.state :off do |off|
+          off.on_entry { @log << "enter off" }
+          off.event :toggle, :on, lambda { @log << "toggle on" }
+        end
+        o.trans :on, :toggle, :off, lambda { @log << "toggle off" }
+        o.start_state :on
+      end
+      b.trans :testing, :resume, :operation_H, lambda { @log << "resuming" }
+      b.start_state :off
+    end
+    
+    sm.admin
+    sm.resume
+    sm.state.should_be :off
+    
+    @log.join(",").should_eql "testing,resuming,enter off"
+  end
+
+  specify "entry and exit action created from superstate builder" do
+    sm = StateMachine.build do |b|
+      b.trans :off, :toggle, :on, Proc.new { @log << "toggle on" }
+      b.on_entry_of(:off) { @log << "entering off" }
+      b.trans :on, :toggle, :off, Proc.new { @log << "toggle off" }
+      b.on_exit_of(:on) { @log << "exiting on" }
+    end
+    
+    sm.toggle
+    sm.toggle
+    
+    @log.join(",").should_eql "toggle on,exiting on,toggle off,entering off"
+    
+  end
+
+  specify "superstate as startstate" do
+    
+    lambda do 
+      sm = StateMachine.build do |b|
+        b.superstate :mario_bros do |m|
+          m.trans :luigi, :bother, :mario
+        end
+      end
+      
+      sm.state.should_be :luigi
+    end.should_not_raise(Exception)
+  end
+
+  
+  
+end
+

data/spec/sm_action_parameterization_spec.rb

@@ -5,110 +5,95 @@ context "State Machine Odds And Ends" do
 
   setup do
     create_switch
-    @sm.run
   end
   
   specify "action with one parameter" do
-    @sm.add(:off, :set, :on, Proc.new { |value| @status = value } )
+    StateMachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |value| @status = value } }
     @sm.set "blue"
-    @status.should_equal "blue"
-    @sm.state.id.should_be :on
+    @status.should_eql "blue"
+    @sm.state.should_be :on
   end
 
   specify "action with two parameters" do
-    @sm.add(:off, :set, :on, Proc.new { |a, b| @status = [a, b].join(",") } )
+    StateMachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b| @status = [a, b].join(",") } }
     @sm.set "blue", "green"
-    @status.should_equal "blue,green"
-    @sm.state.id.should_be :on
+    @status.should_eql "blue,green"
+    @sm.state.should_be :on
   end
 
   specify "action with three parameters" do
-    @sm.add(:off, :set, :on, Proc.new { |a, b, c| @status = [a, b, c].join(",") } )
+    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_equal "blue,green,red"
-    @sm.state.id.should_be :on
+    @status.should_eql "blue,green,red"
+    @sm.state.should_be :on
   end
 
   specify "action with four parameters" do
-    @sm.add(:off, :set, :on, Proc.new { |a, b, c, d| @status = [a, b, c, d].join(",") } )
+    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_equal "blue,green,red,orange"
-    @sm.state.id.should_be :on
+    @status.should_eql "blue,green,red,orange"
+    @sm.state.should_be :on
   end
 
   specify "action with five parameters" do
-    @sm.add(:off, :set, :on, Proc.new { |a, b, c, d, e| @status = [a, b, c, d, e].join(",") } )
+    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_equal "blue,green,red,orange,yellow"
-    @sm.state.id.should_be :on
+    @status.should_eql "blue,green,red,orange,yellow"
+    @sm.state.should_be :on
   end
   
   specify "action with six parameters" do
-    @sm.add(:off, :set, :on, Proc.new { |a, b, c, d, e, f| @status = [a, b, c, d, e, f].join(",") } )
+    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_equal "blue,green,red,orange,yellow,indigo"
-    @sm.state.id.should_be :on
+    @status.should_eql "blue,green,red,orange,yellow,indigo"
+    @sm.state.should_be :on
   end
 
   specify "action with seven parameters" do
-    @sm.add(:off, :set, :on, Proc.new { |a, b, c, d, e, f, g| @status = [a, b, c, d, e, f, g].join(",") } )
+    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_equal "blue,green,red,orange,yellow,indigo,violet"
-    @sm.state.id.should_be :on
+    @status.should_eql "blue,green,red,orange,yellow,indigo,violet"
+    @sm.state.should_be :on
   end
 
   specify "action with eight parameters" do
-    @sm.add(:off, :set, :on, Proc.new { |a, b, c, d, e, f, g, h| @status = [a, b, c, d, e, f, g, h].join(",") } )
+    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_equal "blue,green,red,orange,yellow,indigo,violet,ultra-violet"
-    @sm.state.id.should_be :on
-  end
-  
-  specify "To many parameters" do
-    @sm.add(:off, :set, :on, Proc.new { |a, b, c, d, e, f, g, h, i| @status = [a, b, c, d, e, f, g, h, i].join(",") } )
-    begin
-      @sm.process_event(:set, "blue", "green", "red", "orange", "yellow", "indigo", "violet", "ultra-violet", "Yikes!")
-    rescue StateMachine::StateMachineException => e
-      e.message.should_equal "Too many arguments(9). (transition action from 'off' state invoked by 'set' event)"
-    end
+    @status.should_eql "blue,green,red,orange,yellow,indigo,violet,ultra-violet"
+    @sm.state.should_be :on
   end
   
   specify "calling process_event with parameters" do
-    @sm.add(:off, :set, :on, Proc.new { |a, b, c| @status = [a, b, c].join(",") } )
+    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_equal "blue,green,red"
-    @sm.state.id.should_be :on
+    @status.should_eql "blue,green,red"
+    @sm.state.should_be :on
   end
 
   specify "Insufficient params" do
-    @sm.add(:off, :set, :on, Proc.new { |a, b, c| @status = [a, b, c].join(",") } )
-    begin
-      @sm.set "blue", "green"
-    rescue StateMachine::StateMachineException => e
-      e.message.should_equal "Insufficient parameters. (transition action from 'off' state invoked by 'set' event)"
-    end
+    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, 
+      "Insufficient parameters. (transition action from 'off' state invoked by 'set' event)")
   end
   
   specify "infinate args" do
-    @sm.add(:off, :set, :on, Proc.new { |*a| @status = a.join(",") } )
+   StateMachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |*a| @status = a.join(",") } }
     @sm.set(1, 2, 3)
-    @status.should_equal "1,2,3"
+    @status.should_eql "1,2,3"
     
     @sm.state = :off
     @sm.set(1, 2, 3, 4, 5, 6)
-    @status.should_equal "1,2,3,4,5,6"
+    @status.should_eql "1,2,3,4,5,6"
   end
   
   specify "Insufficient params when params are infinate" do
-    @sm.add(:off, :set, :on, Proc.new { |a, *b| @status = a.to_s + ":" + b.join(",") } )
+    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_equal "1:2,3"
+    @status.should_eql "1:2,3"
     
     @sm.state = :off
-    begin
-      @sm.set
-    rescue StateMachine::StateMachineException => e
-      e.message.should_equal "Insufficient parameters. (transition action from 'off' state invoked by 'set' event)"
-    end
+   
+    lambda { @sm.set }.should_raise(StateMachine::StateMachineException, 
+      "Insufficient parameters. (transition action from 'off' state invoked by 'set' event)")
   end
 end

data/spec/sm_entry_exit_actions_spec.rb

@@ -4,73 +4,81 @@ context "State Machine Entry and Exit Actions" do
 
   setup do
     @log = []
-    @sm = StateMachine::StateMachine.new
-    @sm.add(:off, :toggle, :on, Proc.new { @log << "on" } )
-    @sm.add(:on, :toggle, :off, Proc.new { @log << "off" } )
-    @sm.run
+    @sm = StateMachine.build do |s|
+      s.trans :off, :toggle, :on, Proc.new { @log << "on" }
+      s.trans :on, :toggle, :off, Proc.new { @log << "off" }
+    end
   end
 
   specify "entry action" do
-    @sm[:on].on_entry Proc.new { @log << "entered_on" }
+    @sm.get_state(:on).entry_action = Proc.new { @log << "entered_on" }
     
     @sm.toggle
     
-    @log.join(",").should_equal "on,entered_on"
+    @log.join(",").should_eql "on,entered_on"
   end
   
   specify "exit action" do
-    @sm[:off].on_exit Proc.new { @log << "exited_off" }
+    @sm.get_state(:off).exit_action = Proc.new { @log << "exited_off" }
     
     @sm.toggle
     
-    @log.join(",").should_equal "exited_off,on"
+    @log.join(",").should_eql "exited_off,on"
   end
 
   specify "exit and entry" do
-    @sm[:off].on_exit Proc.new { @log << "exited_off" }
-    @sm[:on].on_entry Proc.new { @log << "entered_on" }
+    @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_equal "exited_off,on,entered_on"
+    @log.join(",").should_eql "exited_off,on,entered_on"
   end
   
   specify "entry and exit actions may be parameterized" do
-      @sm[:off].on_exit Proc.new { |a| @log << "exited_off(#{a})" }
-      @sm[:on].on_entry Proc.new { |a, b| @log << "entered_on(#{a},#{b})" }
+      @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_equal "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
-    @sm[:off].on_exit Proc.new { @log << @sm.state.id }
-    @sm[:on].on_entry Proc.new { @log << @sm.state.id }
+    @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_equal "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
-    @sm.add(:off_super, :toggle, :on, Proc.new { @log << "super_on" } )
-    @sm.add(:on_super, :toggle, :off, Proc.new { @log << "super_off" } )
-    @sm[:off_super].add_substates(:off)
-    @sm[:on_super].add_substates(:on)
-    @sm[:off_super].on_exit Proc.new { @log << @sm.state.id }
-    @sm[:on_super].on_entry Proc.new { @log << @sm.state.id }
+    @sm = StateMachine::StateMachine.new
+    StateMachine.build(@sm) do |s|
+      s.superstate :off_super do |off_s|
+        off_s.on_exit {@log << @sm.state}
+        off_s.trans :off, :toggle, :on, Proc.new { @log << "on" }
+        off_s.event :toggle, :on, Proc.new { @log << "super_on" }
+      end
+      s.superstate :on_super do |on_s|
+        on_s.on_entry { @log << @sm.state }
+        on_s.trans :on, :toggle, :off, Proc.new { @log << "off" }
+        on_s.event :toggle, :off, Proc.new { @log << "super_off" }
+      end
+      s.start_state :off
+    end
 
     @sm.toggle
-    @log.join(",").should_equal "off_super,super_on,on_super"  
+    @log.join(",").should_eql "off,super_on,on"  
   end
 
   specify "entry actions invokes another event" do
-    @sm[:on].on_entry Proc.new { @sm.toggle }
+    @sm.get_state(:on).entry_action = Proc.new { @sm.toggle }
     
     @sm.toggle
-    @log.join(",").should_equal "on,off"
-    @sm.state.id.should_be :off
+    @log.join(",").should_eql "on,off"
+    @sm.state.should_be :off
   end