MINT-statemachine 1.2.3 → 1.3.0

data/CHANGES

@@ -1,5 +1,27 @@
 = Statemachine Changelog
 
+== Version 1.3.0
+
+* (Sebastian) fixed bug that prevented exit call on parallel state exit
+* (Sebastian) refactorings to support existing parallel states without calling events twice
+* (Sebastian) if entering a parallel state, spontaneous initial transitions were not executed
+* (Sebastian) introduced workaround to retrieve correct activation callback within parallel state machines
+* (Jessica) fixed bug that prevented spontaneous transitions from initial state within superstate
+* (Jessica) added test using transition to self to recheck spontaneous transition's condition.
+* (Jessica) transitions now stored as array
+* (Jessica) correct abstract states handling working. All tests working
+* (Jessica) fixed bug that prevented in parallel state machine setups the correct publishing of all new atomic and abstract states
+* (Sebastian) added option to temporarily disable activation callback for reset
+* (Sebastian) several minor bug fixes
+* (Sebastian) changed activation callback processing so it can be used fo publishing state updates with redis
+* (Jessica) Added tests for on_entry, on_exit and transitions for parallel states.
+* (Sebastian) fixed optional parameter handling
+* (Sebastian) allow dynamic parameter size
+* (Jessica) No more In() hack. Use is_in? instead
+* (Jessica) Support for spontaneous transitions
+* (Sebastian) abstract_states now also includes parallel state name
+* (Jessica) added treatment for ifs
+
 == Version 1.2.3
 
 * Added Gemfile for bundler

data/LICENSE

@@ -1,5 +1,5 @@
-Copyright (C) 2010,2011 Sebastian Feuerstack, Jessica Colnago
-Copyright (C) 2006-2010  Micah Martin
+Copyright (C) 2010-2012 Sebastian Feuerstack, Jessica Colnago
+Copyright (C) 2006-2010 Micah Martin
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public

data/MINT-statemachine.gemspec

@@ -1,20 +1,20 @@
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name = %q{MINT-statemachine}
-  s.version = "1.2.3"
+  s.name = "MINT-statemachine"
+  s.version = "1.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = [%q{Sebastian Feuerstack}]
-  s.date = %q{2011-06-30}
-  s.description = %q{The MINT Statemachine is a ruby library for building Finite State Machines, based on the Statemachine gem by Micah Martin.}
-  s.email = %q{Sebastian@Feuerstack.org}
-  s.files = [%q{Rakefile}, %q{README.rdoc}, %q{CHANGES}, %q{TODO}, %q{LICENSE}, %q{lib/statemachine/generate/java/java_statemachine.rb}, %q{lib/statemachine/generate/src_builder.rb}, %q{lib/statemachine/generate/java.rb}, %q{lib/statemachine/generate/dot_graph.rb}, %q{lib/statemachine/generate/util.rb}, %q{lib/statemachine/generate/dot_graph/dot_graph_statemachine.rb}, %q{lib/statemachine/transition.rb}, %q{lib/statemachine/superstate.rb}, %q{lib/statemachine/version.rb}, %q{lib/statemachine/statemachine.rb}, %q{lib/statemachine/stub_context.rb}, %q{lib/statemachine/state.rb}, %q{lib/statemachine/parallelstate.rb}, %q{lib/statemachine/action_invokation.rb}, %q{lib/statemachine/builder.rb}, %q{lib/statemachine.rb}, %q{spec/sm_turnstile_spec.rb}, %q{spec/generate/java/java_statemachine_spec.rb}, %q{spec/generate/dot_graph/dot_graph_stagemachine_spec.rb}, %q{spec/sm_odds_n_ends_spec.rb}, %q{spec/noodle.rb}, %q{spec/sm_entry_exit_actions_spec.rb}, %q{spec/default_transition_spec.rb}, %q{spec/action_invokation_spec.rb}, %q{spec/sm_parallel_state_spec.rb}, %q{spec/builder_spec.rb}, %q{spec/sm_activation_spec.rb}, %q{spec/sm_super_state_spec.rb}, %q{spec/transition_spec.rb}, %q{spec/spec_helper.rb}, %q{spec/sm_simple_spec.rb}, %q{spec/sm_action_parameterization_spec.rb}, %q{spec/history_spec.rb}]
-  s.homepage = %q{http://www.multi-access.de}
-  s.require_paths = [%q{lib}]
-  s.rubygems_version = %q{1.8.5}
-  s.summary = %q{MINT-Statemachine-1.2.3 - Statemachine Library for Ruby based on statemachine from http://slagyr.github.com/statemachine http://www.multi-access.de/open-source-software/third-party-software-extensions/}
-  s.test_files = [%q{spec/sm_turnstile_spec.rb}, %q{spec/sm_odds_n_ends_spec.rb}, %q{spec/sm_entry_exit_actions_spec.rb}, %q{spec/default_transition_spec.rb}, %q{spec/action_invokation_spec.rb}, %q{spec/sm_parallel_state_spec.rb}, %q{spec/builder_spec.rb}, %q{spec/sm_activation_spec.rb}, %q{spec/sm_super_state_spec.rb}, %q{spec/transition_spec.rb}, %q{spec/sm_simple_spec.rb}, %q{spec/sm_action_parameterization_spec.rb}, %q{spec/history_spec.rb}]
+  s.authors = ["Sebastian Feuerstack"]
+  s.date = "2012-11-20"
+  s.description = "The MINT Statemachine is a ruby library for building Finite State Machines, based on the Statemachine gem by Micah Martin."
+  s.email = "Sebastian@Feuerstack.org"
+  s.files = ["TODO", "Gemfile.lock", "LICENSE", "CHANGES", "Rakefile", "Gemfile", "README.rdoc", "MINT-statemachine.gemspec", "lib/statemachine.rb", "lib/statemachine/builder.rb", "lib/statemachine/statemachine.rb", "lib/statemachine/generate/util.rb", "lib/statemachine/generate/dot_graph/dot_graph_statemachine.rb", "lib/statemachine/generate/java/java_statemachine.rb", "lib/statemachine/generate/dot_graph.rb", "lib/statemachine/generate/src_builder.rb", "lib/statemachine/generate/java.rb", "lib/statemachine/transition.rb", "lib/statemachine/version.rb", "lib/statemachine/parallelstate.rb", "lib/statemachine/action_invokation.rb", "lib/statemachine/superstate.rb", "lib/statemachine/state.rb", "lib/statemachine/stub_context.rb", "spec/default_transition_spec.rb", "spec/spec_helper.rb", "spec/sm_super_state_spec.rb", "spec/sm_action_parameterization_spec.rb", "spec/generate/dot_graph/dot_graph_stagemachine_spec.rb", "spec/generate/java/java_statemachine_spec.rb", "spec/sm_entry_exit_actions_spec.rb", "spec/sm_simple_spec.rb", "spec/sm_parallel_state_spec.rb", "spec/transition_spec.rb", "spec/noodle.rb", "spec/sm_activation_spec.rb", "spec/builder_spec.rb", "spec/action_invokation_spec.rb", "spec/sm_turnstile_spec.rb", "spec/history_spec.rb", "spec/sm_odds_n_ends_spec.rb"]
+  s.homepage = "http://www.multi-access.de"
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.15"
+  s.summary = "MINT-Statemachine-1.3.0 - Statemachine Library for Ruby based on statemachine from http://slagyr.github.com/statemachine http://www.multi-access.de/open-source-software/third-party-software-extensions/"
+  s.test_files = ["spec/default_transition_spec.rb", "spec/sm_super_state_spec.rb", "spec/sm_action_parameterization_spec.rb", "spec/sm_entry_exit_actions_spec.rb", "spec/sm_simple_spec.rb", "spec/sm_parallel_state_spec.rb", "spec/transition_spec.rb", "spec/sm_activation_spec.rb", "spec/builder_spec.rb", "spec/action_invokation_spec.rb", "spec/sm_turnstile_spec.rb", "spec/history_spec.rb", "spec/sm_odds_n_ends_spec.rb"]
 
   if s.respond_to? :specification_version then
     s.specification_version = 3

data/README.rdoc

@@ -51,7 +51,7 @@ http://www.multi-access.de
 	
 == License
 
-Copyright (C) 2010,2011 Sebastian Feuerstack, Jessica Colnago
+Copyright (C) 2010-2012 Sebastian Feuerstack, Jessica Colnago
 Copyright (C) 2006-2010  Micah Martin
 
 This library is free software; you can redistribute it and/or

data/lib/statemachine/action_invokation.rb

@@ -20,13 +20,40 @@ module Statemachine
             result = send(a[1],a[2])
           elsif a[0] == 'invoke'
             result = invoke_method(a[1],args, message)
+          elsif a[0] == 'script'
+            result = invoke_string(a[1])
+            result = true if result == nil
+          elsif a[0] == "if"
+            result = invoke_string(a[1])
+            if result
+              result = invoke_action(a[2], [], message, messenger, message_queue)
+              return result
+            else
+              result = true
+            end
+          elsif a[0] == "elseif"
+            result = invoke_string(a[1])
+            if result
+              result = invoke_action(a[2], [], message, messenger, message_queue)
+              return result
+            else
+              result = true
+            end
+          elsif a[0] == "else"
+            result = a[1]
+            if result
+              result = invoke_action(a[2], [], message, messenger, message_queue)
+              return result
+            else
+              result = true
+            end
           end
         else
           log("#{a}")
           result = invoke_string(a) if not messenger
         end
         return false if result == false
-       }
+      }
       result
     end
 
@@ -66,13 +93,33 @@ module Statemachine
       end
     end
 
+    #def params_for_block(block, args, message)
+    #      arity = block.arity
+    #      required_params = arity < 0 ? arity.abs - 1 : arity
+    #
+    #      raise StatemachineException.new("Insufficient parameters. (#{message})") if required_params > args.length
+    #
+    #      arity < 0 ? args : args[0...arity]
+    #end
+
+    # extended parameter handling that allows to define procs with variable parameter size and also
+    # supports cutting the arguments to match a fixed set of parameters
+
     def params_for_block(block, args, message)
-      arity = block.arity
-      required_params = arity < 0 ? arity.abs - 1 : arity
+      i = block.parameters
+
+      required_params = block.parameters.select {|x|  x[0].eql? :req or x[0].eql? :opt}.length
+
+      includes_optional =  block.parameters.select {|x|  x[0].eql? :rest}.length > 0
 
       raise StatemachineException.new("Insufficient parameters. (#{message})") if required_params > args.length
 
-      arity < 0 ? args : args[0...arity]
+      # in case we have no optional parameters but more args than parameters, vut the args to match the parameters
+      if args.length>required_params and includes_optional == false
+        args[0...required_params]
+      else
+        args
+      end
     end
 
   end

data/lib/statemachine/builder.rb

@@ -265,7 +265,7 @@ module Statemachine
       s = statemachine.get_state(id)
       if (s)
         statemachine.remove_state(@subject)
-        s.transitions.each {|k,v|
+        s.transitions.each {|v|
           @subject.add(v)
         }
       end
@@ -344,6 +344,23 @@ module Statemachine
       statemachine.add_state(@subject)
       #puts "added #{@subject.inspect}"
     end
+
+    def on_entry(entry_action)
+      @subject.entry_action = entry_action
+    end
+
+    def on_exit(exit_action)
+      @subject.exit_action = exit_action
+    end
+
+    def event(event, destination_id, action = nil, cond = true)
+      @subject.add(Transition.new(@subject.id, destination_id, event, action, cond))
+    end
+
+    def trans(origin_id, event, destination_id, action = nil, cond = true)
+      origin = acquire_state_in(origin_id, @subject)
+      origin.add(Transition.new(origin_id, destination_id, event, action, cond))
+    end
   end
 
   # Created by Statemachine.build as the root context for building the statemachine.

data/lib/statemachine/generate/dot_graph/dot_graph_statemachine.rb

@@ -41,7 +41,7 @@ module Statemachine
           @nodes = []
           @transitions = []
           @sm.states.values.each { |state|
-            state.transitions.values.each { |transition|
+            state.transitions.each { |transition|
               @nodes << transition.origin_id
               @nodes << transition.destination_id
               @transitions << transition
@@ -72,7 +72,7 @@ module Statemachine
 
           add_graph_header(builder, state.id)
 
-          state.transitions.values.each do |transition|
+          state.transitions.each do |transition|
             add_transition(builder, transition)
           end
 

data/lib/statemachine/generate/java/java_statemachine.rb

@@ -46,7 +46,7 @@ module Statemachine
           events = []
           actions = []
           @sm.states.values.each do |state|
-            state.transitions.values.each do |transition|
+            state.transitions.each do |transition|
               events << transition.event
               add_action(actions, transition.action)
             end
@@ -175,9 +175,9 @@ module Statemachine
           src << "{" << endl
           src.indent!
           add_one_liner(src, nil, "#{state_name}State", "#{@classname} statemachine", "super(statemachine)")
-          state.transitions.keys.sort.each do |event_id|
-            transition = state.transitions[event_id]
-            add_state_event_handler(transition, src)
+          trans_aux =  state.transitions
+          trans_aux.sort_by!{|t| t.event}.each do |t|
+            add_state_event_handler(t, src)
           end
           src.undent!
           src << "}" << endl

data/lib/statemachine/parallelstate.rb

@@ -1,39 +1,36 @@
 module Statemachine
 
-  class Parallelstate< Superstate 
-  
-    attr_accessor :parallel_statemachines, :id
+  class Parallelstate < Superstate
+
+    attr_accessor :parallel_statemachines, :id, :entry_action, :exit_action
     attr_reader :startstate_ids
 
     def initialize(id, superstate, statemachine)
       super(id, superstate, statemachine)
       @parallel_statemachines=[]
       @startstate_ids=[]
+      @transitions = []
+      @spontaneous_transitions = []
     end
 
-#    def startstate_id= id
-#      if @parallel_statemachines.size>0
-#        @startstate_ids[@parallel_statemachines.size-1]= id
-#      end
-#    end
-#
-#    def startstate_id
-#      if (@parallel_statemachines.size>0 and @parallel_statemachines.size==@startstate_ids.size)
-#        return true
-#      end
-#      nil
-#    end
+    def add(transition)
+      if transition.event == nil
+        @spontaneous_transitions.push(transition)
+      else
+        @transitions.push(transition)
+      end
+    end
 
     def context= c
       @parallel_statemachines.each do |s|
-         s.context=c
+        s.context=c
       end
     end
 
     def activate(terminal_state = nil)
       @parallel_statemachines.each do |s|
-       # next if terminal_state and s.has_state(terminal_state)
-        @statemachine.activation.call(s.state,self.abstract_states,self.states) if @statemachine.activation
+        next if terminal_state and s.has_state(terminal_state)
+        #     @statemachine.activation.call(s.state,self.abstract_states+s.abstract_states,s.state) if @statemachine.activation
       end
 
     end
@@ -48,18 +45,21 @@ module Statemachine
 
     def get_statemachine_with(id)
       @parallel_statemachines.each do |s|
-         return s if s.has_state(id)
+        return s if s.has_state(id)
       end
     end
 
-    def non_default_transition_for(event,check_superstates=true)
-      transition = @transitions[event]
-      return transition if transition
-      
-      transition = transition_for(event,check_superstates)
-      
-      transition = @superstate.non_default_transition_for(event) if check_superstates and @superstate and not transition
-      return transition
+    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 In(id)
@@ -70,12 +70,12 @@ module Statemachine
     end
 
     def state= id
-     @parallel_statemachines.each do |s|
+      @parallel_statemachines.each do |s|
         if s.has_state(id)
           s.state=id
           return true
         end
-     end
+      end
       return false
     end
 
@@ -89,9 +89,6 @@ module Statemachine
     end
 
     def get_state(id)
-#      if state = @statemachine.get_state(id)
-#        return state
-#      end
       @parallel_statemachines.each do |s|
         if state = s.get_state(id)
           return state
@@ -103,17 +100,24 @@ module Statemachine
     def process_event(event, *args)
       exceptions = []
       result = false
-      #  TODO fix needed: respond_to checks superstates lying out of the parallel state as well, in case an event is
-      # defined outside the parallel statemachine it gets processed twice!
 
-      @parallel_statemachines.each_with_index do |s,i|
+      # first check if the statemachine that currenlty executes the parallel state has a suitable transition
+      if (@statemachine.which_state_respond_to? event)
+        @statemachine.process_event(event,*args)
+        result = true
+      else  # otherwise check for local transitions inside parallel state
+
+        @parallel_statemachines.each_with_index do |s,i|
+          t = s.which_state_respond_to? event
           if s.respond_to? event
             s.process_event(event,*args)
             result = true
           end
+        end
       end
+
       result
-     end
+    end
 
     # Resets all of the statemachines back to theirs starting state.
     def reset
@@ -137,11 +141,11 @@ module Statemachine
     def substate_exiting(substate)
       @history_id = substate.id
     end
-  
+
     def add_substates(*substate_ids)
       do_substate_adding(substate_ids)
     end
-    
+
     def default_history=(state_id)
       @history_id = @default_history_id = state_id
     end
@@ -161,20 +165,28 @@ module Statemachine
     end
 
     def transition_for(event,check_superstates=true)
-      @parallel_statemachines.each do |s|
-        transition = s.get_state(s.state).non_default_transition_for(event,false)
-        transition = s.get_state(s.state).default_transition if not transition
-        return transition if transition
+      transition = super(event)
+      if not transition
+        @parallel_statemachines.each do |s|
+          transition = s.get_state(s.state).non_default_transition_for(event,false)
+          transition = s.get_state(s.state).default_transition if not transition
+          return transition if transition
+        end
+        @superstate.transition_for(event,check_superstates) if (@superstate and check_superstates and @superstate!=self)
+      else
+        transition
       end
-      return @superstate.transition_for(event,check_superstates) if (@superstate and check_superstates and @superstate!=self)
-
-      #super.transition_for(event)
     end
 
     def enter(args=[])
-     # reset
-      #super(args)
-        @statemachine.state = self
+      @statemachine.state = self
+      @statemachine.trace("\tentering #{self}")
+
+      if @entry_action != nil
+        messenger = self.statemachine.messenger
+        message_queue = self.statemachine.message_queue
+        @statemachine.invoke_action(@entry_action, args, "entry action for #{self}", messenger, message_queue)
+      end
 
       @parallel_statemachines.each_with_index do |s,i|
         s.activation = @statemachine.activation
@@ -183,6 +195,39 @@ module Statemachine
       end
     end
 
+    def spontaneous_transition
+      transition = []
+      @parallel_statemachines.each do |s|
+        t = s.get_state(s.state).spontaneous_transition
+        transition << [t,s] if t # we need to store the state machine relevant for the transition
+      end
+      if transition.empty?
+        return nil
+      end
+      transition
+    end
+
+
+    def exit(args)
+      @statemachine.trace("\texiting #{self}")
+
+      if @exit_action != nil
+        messenger = self.statemachine.messenger
+        message_queue = self.statemachine.message_queue
+        @statemachine.invoke_action(@exit_action, args, "exit action for #{self}", messenger, message_queue)
+        @superstate.substate_exiting(self) if @superstate
+      end
+
+      @parallel_statemachines.each_with_index do |s,i|
+        as = s.get_state(s.state)
+        while as and as != self do
+         as.exit(args)
+         as = as.superstate
+         end
+
+      end
+    end
+
     def to_s
       return "'#{id}' parallel"
     end
@@ -193,8 +238,11 @@ module Statemachine
       if (@superstate)
         abstract_states=@superstate.abstract_states
       end
+
+      abstract_states += [@id]
+
       @parallel_statemachines.each do |s|
-        abstract_states += s.abstract_states
+        abstract_states += s.abstract_states + []
       end
       abstract_states.uniq
     end