MINT-statemachine 1.2.3 → 1.3.0

data/lib/statemachine/state.rb

@@ -10,23 +10,46 @@ module Statemachine
       @id = id
       @superstate = superstate
       @statemachine = state_machine
-      @transitions = {}
+      @transitions = []
+      @spontaneous_transitions = []
+    end
+
+    # TODO hack to support SCXML parser parallel state creation
+    def modify_statemachine(state_machine)
+      @statemachine = state_machine
     end
 
     def add(transition)
-      @transitions[transition.event] = transition
+      if transition.event == nil
+        @spontaneous_transitions.push(transition)
+      else
+        @transitions.push(transition)
+      end
     end
 
     def transitions
-      return @superstate ? @transitions.merge(@superstate.transitions) : @transitions
+      return @superstate ? @transitions | @superstate.transitions : @transitions
+    end
+
+    def get_transitions(event)
+      transitions = []
+      @transitions.each do |t|
+        if t.event == event
+          transitions << t
+        end
+      end
+      if transitions.empty?
+        return nil
+      end
+      transitions
     end
 
     def non_default_transition_for(event,check_superstates = true)
-      transition = @transitions[event]
+      transition = get_transitions(event)
       if check_superstates and @superstate
         transition = @superstate.non_default_transition_for(event) if @superstate and @superstate.is_parallel == false and not transition
       end
-      return transition
+      transition
     end
 
     def default_transition
@@ -35,10 +58,28 @@ module Statemachine
       return nil
     end
 
+    def spontaneous_transition
+      transition = []
+      @spontaneous_transitions.each do |s|
+        if s.cond == true
+          transition << [s,self]
+        else
+          if s.cond
+            transition << [s,self] if @statemachine.invoke_action(s.cond, [], "condition from #{@state} invoked by '#{nil}' event", nil, nil)
+          end
+        end
+      end
+
+      if transition.empty?
+        return nil
+      end
+      return transition
+    end
+
     def transition_for(event,check_superstate=true)
       transition = non_default_transition_for(event,check_superstate)
       transition = default_transition if not transition
-      return transition
+      transition
     end
 
     def exit(args)
@@ -58,11 +99,11 @@ module Statemachine
 
     def activate
       @statemachine.state = self
-     # if (@statemachine.is_parallel)
+      # if (@statemachine.is_parallel)
       # @statemachine.activation.call(self.id,@statemachine.is_parallel.abstract_states,@statemachine.is_parallel.statemachine.states_id) if @statemachine.activation
       #else
-      @statemachine.activation.call(self.id,@statemachine.abstract_states,@statemachine.states_id) if @statemachine.activation
-    # end
+      #@statemachine.activation.call(self.id,self.abstract_states,@statemachine.states_id) if @statemachine.activation # and  not @statemachine.is_parallel
+      # end
     end
 
     def concrete?
@@ -83,13 +124,13 @@ module Statemachine
 
     def has_superstate(id)
       return false if not @superstate
-      return true if @superstate.id == id 
+      return true if @superstate.id == id
       return @superstate.has_superstate(id)
     end
 
     def abstract_states
-      return [] if not superstate
-      return @superstate.abstract_states if not @superstate.is_parallel
+      return [] if not @superstate
+      return @superstate.abstract_states #if not @superstate.is_parallel
       []
     end
 
@@ -97,5 +138,5 @@ module Statemachine
       false
     end
   end
-  
+
 end

data/lib/statemachine/statemachine.rb

@@ -37,6 +37,15 @@ module Statemachine
     attr_accessor :messenger, :message_queue, :is_parallel #:nodoc:
     attr_accessor :activation
 
+    # workaround that activation is not automatically set for parallel state machines
+    def activation
+      if is_parallel
+        is_parallel.statemachine.activation
+      else
+        @activation
+      end
+    end
+
     # Should not be called directly.  Instances of Statemachine::Statemachine are created
     # through the Statemachine.build method.
     def initialize(root = Superstate.new(:root, nil, self))
@@ -46,11 +55,11 @@ module Statemachine
 
     # Returns the id of the startstate of the statemachine.
     def startstate
-      return @root.startstate_id
+      @root.startstate_id
     end
 
     # Resets the statemachine back to its starting state.
-    def reset(startstate_id=nil)
+    def reset(startstate_id=nil, use_activation_callback = true)
 
       if (startstate_id and @root.is_parallel) # called when enterin a parallel state or dierctly entering a child of a parallel state from outside the parallel state
         @state = get_state(startstate_id)
@@ -62,9 +71,11 @@ module Statemachine
       end
       raise StatemachineException.new("The state machine doesn't know where to start. Try setting the startstate.") if @state == nil
       @state.enter
+      @state.activate
       @states.values.each { |state|
         state.reset if not state.is_a? Parallelstate
       }
+      activation.call([@state.id],abstract_states,states_id) if  use_activation_callback and activation  and  not is_parallel
     end
 
     def context= c
@@ -94,7 +105,11 @@ module Statemachine
 
     # returns an array with all currently active super states
     def abstract_states
-      @state.abstract_states
+      belongs, parallel = belongs_to_parallel(@state.id)
+      if belongs
+        return parallel.abstract_states
+      end
+      return @state.abstract_states
     end
 
     # You may change the state of the statemachine by using this method.  The parameter should be
@@ -136,22 +151,32 @@ module Statemachine
       event = event.to_sym
       trace "Event: #{event}"
       if @state
-        belongs, parallel = belongs_to_parallel(@state.id)
-        if belongs
-          r = parallel.process_event(event, *args)
-          return true if r
-        end
+
         transition = @state.transition_for(event)
         if transition
-          cond = true
-          if transition.cond!=true
-             cond = @state.statemachine.invoke_action(transition.cond, [], "condition from #{@state} invoked by '#{event}' event", nil, nil)
+          if not transition.is_a? Array
+            transition = [transition]
           end
-          if cond
-            transition.invoke(@state, self, args)
+          transition.each do |t|
+            cond = true
+            if t.cond != true
+              cond = @state.statemachine.invoke_action(t.cond, [], "condition from #{@state} invoked by '#{event}' event", nil, nil)
+            end
+            if cond
+              t.invoke(@state, self, args)
+            end
           end
         else
+
+          belongs, parallel = belongs_to_parallel(@state.id)
+          if belongs
+            r = parallel.process_event(event, *args)
+            if r
+              return true
+            end
+          end
           raise TransitionMissingException.new("#{@state} does not respond to the '#{event}' event.")
+
         end
 
       else
@@ -205,6 +230,9 @@ module Statemachine
       elsif p = get_parallel and s = p.get_state(id)
         return s
       else
+        if @root.is_a? Parallelstate
+          return false
+        end
         state = State.new(id, @root, self)
         @states[id] = state
         return state
@@ -233,6 +261,12 @@ module Statemachine
       return false
     end
 
+    def which_state_respond_to?(message)
+      #return super if super(message)
+      return @state if  @state and @state.transition_for(message)
+      nil
+    end
+
     def method_missing(message, *args) #:nodoc:
       if @state and @state.transition_for(message)
         process_event(message.to_sym, *args)
@@ -240,8 +274,9 @@ module Statemachine
         # params = [message.to_sym].concat(args)
         # method.call(*params)
       else
-        begin
-          super(message, args)
+        begin        return super if super(message)
+
+        super(message, args)
         rescue NoMethodError
           process_event(message.to_sym, *args)
         end
@@ -258,18 +293,18 @@ module Statemachine
       # check if it is one of the running parallel states
       belongs, parallel = belongs_to_parallel(@state.id)
       if belongs
-        return parallel.In(id)
+        parallel.In(id)
       end
     end
 
     private
 
     def is_history_state_id?(id)
-      return id.to_s[-2..-1] == "_H"
+      id.to_s[-2..-1] == "_H"
     end
 
     def base_id(history_id)
-      return history_id.to_s[0...-2].to_sym
+      history_id.to_s[0...-2].to_sym
     end
 
     def load_history(superstate)

data/lib/statemachine/superstate.rb

@@ -47,7 +47,11 @@ module Statemachine
       return [@id] if not @superstate or @superstate.is_parallel
       ([@id] + @superstate.abstract_states).uniq
     end
-  
+
+    def spontaneous_transition
+      startstate.spontaneous_transition
+    end
+
   end
 
 end

data/lib/statemachine/transition.rb

@@ -13,14 +13,21 @@ module Statemachine
       @cond = cond
     end
 
+    def is_self_transition?
+      @origin_id == @destination_id
+    end
+
     def invoke(origin, statemachine, args)
+      old_abstract_states = statemachine.abstract_states
+      old_atomic_states =   statemachine.states_id
+
       destination = statemachine.get_state(@destination_id)
       exits, entries = exits_and_entries(origin, destination)
       exits.each { |exited_state| exited_state.exit(args) }
       messenger = origin.statemachine.messenger
       message_queue = origin.statemachine.message_queue
 
-       if @action # changed this if statement to return if action fails
+      if @action # changed this if statement to return if action fails
         if not origin.statemachine.invoke_action(@action, args, "transition action from #{origin} invoked by '#{@event}' event", messenger, message_queue)
           raise StatemachineException.new("Transition to state #{destination.id} failed because action for event #{@event} return false.")
         end
@@ -30,16 +37,50 @@ module Statemachine
 
       terminal_state = entries.last
 
-      terminal_state.activate if terminal_state and not terminal_state.is_parallel
 
+      terminal_state.activate if terminal_state and not terminal_state.is_parallel
       entries.each { |entered_state| entered_state.enter(args) }
-      entries.each { |entered_state| entered_state.activate(terminal_state.id)  if entered_state.is_parallel }
+#entries.each { |entered_state| entered_state.activate(terminal_state.id)  if entered_state.is_parallel }
       statemachine.state = terminal_state if statemachine.has_state(terminal_state.id) and statemachine.is_parallel
 
+      if is_self_transition? # handle special case of self transition
+        new_states = [@destination_id]
+      else
+        new_states = statemachine.states_id - (old_atomic_states & statemachine.states_id)
+        new_states = (statemachine.abstract_states - old_abstract_states) + new_states
+      end
+
+      if statemachine.activation
+        sm = statemachine
+        while (sm.is_parallel)
+          sm = sm.is_parallel.statemachine
+        end
+        sm.activation.call(new_states,sm.abstract_states,sm.states_id) if sm.activation # and  not @statemachine.is_parallel
+      end
+
+      # Take any valid spontaneous transitions
+      transition = destination.spontaneous_transition
+
+      if transition
+        if destination.is_parallel
+          transition.each do |trans,statem|
+            trans.each do |t|
+              t[0].invoke(t[1], statem, args) if t[0].is_a? Transition
+            end
+          end
+        else
+
+          if transition.is_a? Array
+            transition.each do |t|
+              t[0].invoke(t[1], statemachine, args) if t[0].is_a? Transition
+            end
+          end
+        end
+      end
     end
 
     def exits_and_entries(origin, destination)
-     # return [], [] if origin == destination
+      # return [], [] if origin == destination
       exits = []
       entries = exits_and_entries_helper(exits, origin, destination)
       return exits, entries.reverse

data/lib/statemachine/version.rb

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

data/spec/action_invokation_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require 'spec_helper'
 #require 'statemachine'
 #require 'lib/statemachine/action_invokation.rb'
 require "noodle"

data/spec/builder_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require 'spec_helper'
 
 describe "Builder" do
 

data/spec/default_transition_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require 'spec_helper'
 
 describe "Default Transition" do
 

data/spec/generate/dot_graph/dot_graph_stagemachine_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
+require "./"+File.dirname(__FILE__) + '/../../spec_helper'
 require 'statemachine/generate/dot_graph/dot_graph_statemachine'
 
 describe Statemachine::Statemachine, "(Turn Stile)" do

data/spec/history_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require 'spec_helper'
 
 describe "History States" do
 

data/spec/sm_action_parameterization_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require 'spec_helper'
 
 describe "State Machine Odds And Ends" do
   include SwitchStatemachine

data/spec/sm_activation_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require 'spec_helper'
 
 describe "State Activation Callback" do
   include SwitchStatemachine
@@ -7,46 +7,54 @@ describe "State Activation Callback" do
   before(:each) do
     class ActivationCallback
       attr_reader :called
-      attr_reader :state
+      attr_reader :new_states
       attr_reader :abstract_states
       attr_reader :atomic_states
 
       def initialize
         @called = []
-        @state = []
+        @new_states = []
         @abstract_states = []
         @atomic_states =[]
 
       end
-      def activate(state,abstract_states, atomic_states)
+      def activate(new_states,abstract_states, atomic_states)
         @called << true
-        @state <<  state
+        @new_states<<  new_states
         @abstract_states << abstract_states
         @atomic_states <<  atomic_states
-        puts "activate #{@state.last} #{@abstract_states.last} #{@atomic_states.last}"
+        puts "activate #{@new_states.last} #{@abstract_states.last} #{@atomic_states.last}"
       end
     end
 
     @callback = ActivationCallback.new
   end
-  
+
   it "should fire on successful state change" do
     create_switch
     @sm.activation=@callback.method(:activate)
-    @callback.called.length.should == 0
+
     @sm.toggle
     @callback.called.length.should == 1
   end
 
+  it "should call activation callback after rest" do
+    create_switch
+    @sm.activation=@callback.method(:activate)
+    @callback.called.length.should == 0
+    @sm.reset
+    @callback.called.length.should == 1
+  end
+
   it "should deliver new active state on state change" do
     create_switch
     @sm.activation=@callback.method(:activate)
     @sm.toggle
-    @callback.state.last.should == :on
+    @callback.new_states.last.should == [:on]
     @callback.atomic_states.last.should == [:on]
     @callback.abstract_states.last.should == [:root]
     @sm.toggle
-    @callback.state.last.should == :off
+    @callback.new_states.last.should == [:off]
   end
 
   it "should deliver new active state on state change of parallel state machine" do
@@ -54,24 +62,25 @@ describe "State Activation Callback" do
 
     @sm.activation=@callback.method(:activate)
     @sm.go
-    @callback.called.length.should == 2
-    @callback.state.last.should == :on
-    @callback.abstract_states.last.should.eql? [:operative, :root, :onoff]
-    @callback.atomic_states.last.should == [:locked, :on]
+    @callback.called.length.should == 1
+    @callback.new_states.last.should == [:p, :operative, :onoff, :locked, :on]
+    @callback.abstract_states.last.should == [:root,:p, :operative,  :onoff]
+    @callback.atomic_states.last.should == [:locked,:on]
     @sm.toggle
-    @callback.state.last.should == :off
-    @callback.abstract_states.last.should.eql? [:onoff,:operative,:root]
-    @callback.atomic_states.last.should.eql? [:off,:locked]
+    @callback.new_states.last.should == [:off]
+    @callback.abstract_states.last.should == [:root, :p, :operative, :onoff]
+    @callback.atomic_states.last.should == [:locked,:off]
 
   end
 
   it "activation works for on_entry ticks as well" do
+    pending "throwing an event inside on entry is substituted by event-less transitions"
     create_tick
     @sm.activation=@callback.method(:activate)
     @sm.toggle
     @callback.called.length.should == 2
-    @callback.state.last.should == :off
-    @callback.state.first.should == :on
+    @callback.new_states.last.should == :off
+    @callback.new_states.first.should == :on
     @callback.atomic_states.last.should == [:off]
     @callback.atomic_states.first.should == [:on]
     @callback.abstract_states.last.should == [:root]
@@ -82,7 +91,7 @@ describe "State Activation Callback" do
     @sm.activation=@callback.method(:activate)
     @sm.toggle
     @callback.called.length.should == 1
-    @callback.state.last.should == :me
+    @callback.new_states.last.should == [:me]
     @callback.atomic_states.last.should == [:me]
     @callback.abstract_states.last.should == [:root]
   end
@@ -108,8 +117,8 @@ describe "State Activation Callback" do
 
     @sm.activation=@callback.method(:activate)
     @sm.go
-    @callback.state.should.eql? [:unlocked,:on]
-    @callback.called.length.should == 2
+    @callback.new_states.last.should == [:p, :operative, :onoff, :unlocked, :on]
+    @callback.called.length.should == 1
   end