ruote 2.1.11 → 2.2.0

data/lib/ruote/exp/fe_reserve.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -59,14 +59,14 @@ module Ruote::Exp
       set_mutex
     end
 
-    def reply (workitem)
+    def reply(workitem)
 
       release_mutex
 
       reply_to_parent(workitem)
     end
 
-    def cancel (flavour)
+    def cancel(flavour)
 
       super
 

data/lib/ruote/exp/fe_restore.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -93,7 +93,7 @@ module Ruote::Exp
       reply_to_parent(h.applied_workitem)
     end
 
-    def reply (workitem)
+    def reply(workitem)
 
       # empty, never called
     end

data/lib/ruote/exp/fe_save.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -70,7 +70,7 @@ module Ruote::Exp
       reply_to_parent(h.applied_workitem)
     end
 
-    def reply (workitem)
+    def reply(workitem)
 
       # empty, never called
     end

data/lib/ruote/exp/fe_sequence.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -43,11 +43,10 @@ module Ruote::Exp
       reply(h.applied_workitem)
     end
 
-    def reply (workitem)
+    def reply(workitem)
 
       position = workitem['fei'] == h.fei ?
-        0 :
-        Ruote::FlowExpressionId.new(workitem['fei']).child_id + 1
+        0 : Ruote::FlowExpressionId.new(workitem['fei']).child_id + 1
 
       if position < tree_children.size
         apply_child(position, workitem)

data/lib/ruote/exp/fe_set.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -85,9 +85,18 @@ module Ruote::Exp
   #     set 'f_${v:v}' => 'val2'
   #   end
   #
+  # == set and rset
+  #
+  # Some gems (Sinatra) for example may provide a set method that hides calls
+  # to set when building process definitions (see http://groups.google.com/group/openwferu-users/browse_thread/thread/9ac606e30ada686e)
+  #
+  # A workaround is to write 'rset' instead of 'set'.
+  #
+  #   rset 'customer' => 'Jeff'
+  #
   class SetExpression < FlowExpression
 
-    names :set, :unset
+    names :rset, :set, :unset
 
     def apply
 
@@ -117,14 +126,14 @@ module Ruote::Exp
       reply_to_parent(h.applied_workitem)
     end
 
-    def reply (workitem)
+    def reply(workitem)
 
       # never called
     end
 
     protected
 
-    def set_v (key, value)
+    def set_v(key, value)
 
       if name == 'unset'
         unset_variable(key)
@@ -133,7 +142,7 @@ module Ruote::Exp
       end
     end
 
-    def set_f (key, value)
+    def set_f(key, value)
 
       if name == 'unset'
         h.applied_workitem['fields'].delete(key)
@@ -142,9 +151,9 @@ module Ruote::Exp
       end
     end
 
-    PREFIX_REGEX = /^([^:]+):(.+)$/ unless defined?(PREFIX_REGEX)
+    PREFIX_REGEX = /^([^:]+):(.+)$/ #unless defined?(PREFIX_REGEX)
 
-    def set_vf (key, value)
+    def set_vf(key, value)
 
       field = true
 

data/lib/ruote/exp/fe_subprocess.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -147,6 +147,28 @@ module Ruote::Exp
   # The latter may make process definitions quite readable (but blur the
   # distinction between expressions, call to participants or to subprocesses).
   #
+  #
+  # == subprocess trees bound at engine level
+  #
+  # It's OK to place a process tree directly in an engine variable :
+  #
+  #   engine.variables['inventory_check'] = Ruote.process_definition do
+  #     cursor do
+  #       manager :task => 'hire inventory team'
+  #       floor_manager :task => 'lead inventory'
+  #       manager :task => 'check results'
+  #       rewind :unless => '${inventory_successful}'
+  #     end
+  #   end
+  #
+  # Then, from the main process :
+  #
+  #   sequence do
+  #     # ...
+  #     inventory_check
+  #     # ...
+  #   end
+  #
   class SubprocessExpression < FlowExpression
 
     names :subprocess

data/lib/ruote/exp/fe_that.rb

@@ -0,0 +1,92 @@
+#--
+# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+require 'ruote/exp/fe_sequence'
+
+
+module Ruote::Exp
+
+  #
+  # The 'that' and the 'of' expressions are used in conjuction with
+  # the 'given' expression (GivenExpression).
+  #
+  # In can be used 'standalone', it thus becomes then merely an 'if'.
+  #
+  # The children of the that/of are executed if the condition evaluates to
+  # true. The children are executed one by one, as if the that/of were
+  # a sequence.
+  #
+  #   given '${status}' do
+  #     that '${location} == CH' do
+  #       set 'f:bank' => 'UBS'
+  #       subprocess 'buy_chocolate'
+  #     end
+  #     of 'ready' do
+  #       participant 'saleshead', :msg => 'customer ready'
+  #       participant 'salesman', :task => 'visiter customer'
+  #     end
+  #     of 'over' do
+  #       participant 'manager', :msg => 'process over'
+  #     end
+  #   end
+  #
+  # (Yes, I know, it's a poor example).
+  #
+  class ThatExpression < SequenceExpression
+
+    names :that, :of
+
+    def reply(workitem)
+
+      if workitem['fei'] == h.fei # apply --> reply
+
+        cond = attribute(:t) || attribute(:test) || attribute_text
+
+        if name == 'of'
+          comparator = cond.match(/^\s*\/.*\/\s*$/) ? '=~' : '=='
+          cond = "#{workitem['fields']['__given__']} #{comparator} #{cond}"
+        end
+
+        h.result = Condition.true?(cond)
+
+        if h.result
+          apply_child(0, workitem)
+        else
+          reply_to_parent(workitem)
+        end
+
+      else # reply from child
+
+        super
+      end
+    end
+
+    def reply_to_parent(workitem)
+
+      workitem['fields']['__result__'] = h.result
+      super
+    end
+  end
+end
+

data/lib/ruote/exp/fe_undo.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -53,12 +53,12 @@ module Ruote::Exp
       ref = attribute(:ref) || attribute_text
       tag = ref ? lookup_variable(ref) : nil
 
-      @context.storage.put_msg('cancel', 'fei' => tag)
+      @context.storage.put_msg('cancel', 'fei' => tag) if Ruote.is_a_fei?(tag)
 
       reply_to_parent(h.applied_workitem)
     end
 
-    def reply (workitem)
+    def reply(workitem)
 
       # never called
     end

data/lib/ruote/exp/fe_unregisterp.rb

@@ -0,0 +1,71 @@
+#--
+# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+require 'ruote/exp/fe_registerp'
+
+
+module Ruote::Exp
+
+  #
+  # (Since ruote 2.1.12)
+  #
+  # Unregisters a participant.
+  #
+  #   Ruote.process_definition do
+  #     unregisterp 'alfred'
+  #     unregisterp :name => 'bob'
+  #   end
+  #
+  # Shows the same behaviour as
+  #
+  #   engine.unregister_participant 'alfred'
+  #   engine.unregister_participant 'bob'
+  #
+  # The expression 'registerp' can be used to register participants from
+  # a process definition.
+  #
+  class UnregisterpExpression < RegisterpExpression
+
+    names :unregisterp
+
+    def apply
+
+      registerp_allowed?
+
+      name = attribute(:name) || attribute_text
+
+      result = begin
+        context.engine.unregister_participant(name)
+        true
+      rescue
+        false
+      end
+
+      h.applied_workitem['fields']['__result__'] = result
+
+      reply_to_parent(h.applied_workitem)
+    end
+  end
+end
+

data/lib/ruote/exp/fe_wait.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -85,7 +85,7 @@ module Ruote::Exp
     #end
     #++
 
-    def cancel (flavour)
+    def cancel(flavour)
 
       @context.storage.delete_schedule(h.schedule_id)
       reply_to_parent(h.applied_workitem)

data/lib/ruote/exp/flowexpression.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -60,6 +60,7 @@ module Ruote::Exp
     require 'ruote/exp/ro_persist'
     require 'ruote/exp/ro_attributes'
     require 'ruote/exp/ro_variables'
+    require 'ruote/exp/ro_filters'
 
     COMMON_ATT_KEYS = %w[
       if unless forget timeout on_error on_cancel on_timeout ]
@@ -79,11 +80,12 @@ module Ruote::Exp
     h_reader :on_cancel
     h_reader :on_timeout
 
-    def initialize (context, h)
+    def initialize(context, h)
 
       @context = context
 
       @msg = nil
+        # contains generally the msg the expression got instantiated for
 
       self.h = h
 
@@ -99,22 +101,33 @@ module Ruote::Exp
       h.on_timeout ||= attribute(:on_timeout)
     end
 
-    def h= (hash)
+    def h=(hash)
       @h = hash
       class << h
         include Ruote::HashDot
       end
     end
 
+    # Returns the Ruote::FlowExpressionId for this expression.
+    #
     def fei
+
       Ruote::FlowExpressionId.new(h.fei)
     end
 
+    # Returns the Ruote::FlowExpressionIf of the parent expression, or nil
+    # if there is no parent expression.
+    #
     def parent_id
+
       h.parent_id ? Ruote::FlowExpressionId.new(h.parent_id) : nil
     end
 
+    # Fetches the parent expression, or returns nil if there is no parent
+    # expression.
+    #
     def parent
+
       Ruote::Exp::FlowExpression.fetch(@context, h.parent_id)
     end
 
@@ -128,7 +141,7 @@ module Ruote::Exp
 
     # Instantiates expression back from hash.
     #
-    def self.from_h (context, h)
+    def self.from_h(context, h)
 
       exp_class = context.expmap.expression_class(h['name'])
 
@@ -137,7 +150,7 @@ module Ruote::Exp
 
     # Fetches an expression from the storage and readies it for service.
     #
-    def self.fetch (context, fei)
+    def self.fetch(context, fei)
 
       return nil if fei.nil?
 
@@ -152,7 +165,7 @@ module Ruote::Exp
 
     # Keeping track of names and aliases for the expression
     #
-    def self.names (*exp_names)
+    def self.names(*exp_names)
 
       exp_names = exp_names.collect { |n| n.to_s }
       meta_def(:expression_names) { exp_names }
@@ -162,11 +175,15 @@ module Ruote::Exp
     # apply/reply
     #++
 
-    def self.do_action (context, msg)
+    # Called by the worker when it has something to do for a FlowExpression.
+    #
+    def self.do_action(context, msg)
 
       fei = msg['fei']
       action = msg['action']
 
+      p msg unless fei
+
       if action == 'reply' && fei['engine_id'] != context.engine_id
         #
         # the reply has to go to another engine, let's locate the
@@ -199,7 +216,12 @@ module Ruote::Exp
       fexp.send("do_#{action}", msg) if fexp
     end
 
-    def do_apply
+    # Called by the worker when it has just created this FlowExpression and
+    # wants to apply it.
+    #
+    def do_apply(msg)
+
+      @msg = Ruote.fulldup(msg)
 
       if not Condition.apply?(attribute(:if), attribute(:unless))
 
@@ -208,30 +230,48 @@ module Ruote::Exp
 
       if attribute(:forget).to_s == 'true'
 
-        i = h.parent_id
+        pi = h.parent_id
         wi = Ruote.fulldup(h.applied_workitem)
 
         h.variables = compile_variables
         h.parent_id = nil
         h.forgotten = true
 
-        @context.storage.put_msg('reply', 'fei' => i, 'workitem' => wi)
+        @context.storage.put_msg('reply', 'fei' => pi, 'workitem' => wi) if pi
+          # reply to parent immediately (if there is a parent)
+
+      elsif attribute(:lose).to_s == 'true'
+
+        h.lost = true
       end
 
+      filter
+
       consider_tag
       consider_timeout
 
       apply
     end
 
-    def reply_to_parent (workitem, delete=true)
+    # FlowExpression call this method when they're done and they want their
+    # parent expression to take over (it will end up calling the #reply of
+    # the parent expression).
+    #
+    def reply_to_parent(workitem, delete=true)
+
+      filter(workitem)
 
       if h.tagname
 
         unset_variable(h.tagname)
 
+        Ruote::Workitem.remove_tag(workitem, h.tagname)
+
         @context.storage.put_msg(
-          'left_tag', 'tag' => h.tagname, 'fei' => h.fei)
+          'left_tag',
+          'tag' => h.tagname,
+          'fei' => h.fei,
+          'workitem' => workitem)
       end
 
       if h.timeout_schedule_id && h.state != 'timing_out'
@@ -243,25 +283,26 @@ module Ruote::Exp
 
         trigger('on_error', workitem)
 
-      elsif (h.state == 'cancelling') and h.on_cancel
+      elsif h.state == 'cancelling' and h.on_cancel
 
         trigger('on_cancel', workitem)
 
-      elsif (h.state == 'cancelling') and h.on_re_apply
+      elsif h.state == 'cancelling' and h.on_re_apply
 
         trigger('on_re_apply', workitem)
 
-      elsif (h.state == 'timing_out') and h.on_timeout
+      elsif h.state == 'timing_out' and h.on_timeout
 
         trigger('on_timeout', workitem)
 
+      elsif h.lost and h.state == nil
+
+        # do not reply, sit here (and wait for cancellation probably)
+
       else # vanilla reply
 
-        #unpersist_or_raise if delete
-        #try_unpersist if delete
-        if delete
-          do_unpersist || return
-        end
+        (do_unpersist || return) if delete
+          # remove expression from storage
 
         if h.parent_id
 
@@ -281,7 +322,9 @@ module Ruote::Exp
       end
     end
 
-    def do_reply (msg)
+    # Wraps #reply (does the administrative part of the reply work).
+    #
+    def do_reply(msg)
 
       @msg = Ruote.fulldup(msg)
         # keeping the message, for 'retry' in collision cases
@@ -318,7 +361,7 @@ module Ruote::Exp
 
     # A default implementation for all the expressions.
     #
-    def reply (workitem)
+    def reply(workitem)
 
       reply_to_parent(workitem)
     end
@@ -326,7 +369,9 @@ module Ruote::Exp
     # The raw handling of messages passed to expressions (the fine handling
     # is done in the #cancel method).
     #
-    def do_cancel (msg)
+    def do_cancel(msg)
+
+      @msg = Ruote.fulldup(msg)
 
       flavour = msg['flavour']
 
@@ -375,7 +420,7 @@ module Ruote::Exp
     # This default implementation cancels all the [registered] children
     # of this expression.
     #
-    def cancel (flavour)
+    def cancel(flavour)
 
       return reply_to_parent(h.applied_workitem) if h.children.empty?
         #
@@ -420,7 +465,13 @@ module Ruote::Exp
       #end
     end
 
-    def do_fail (msg)
+    # Called when handling an on_error, will place itself in a 'failing' state
+    # and cancel the children (when the reply from the children comes back,
+    # the on_reply will get triggered).
+    #
+    def do_fail(msg)
+
+      @msg = Ruote.fulldup(msg)
 
       @h['state'] = 'failing'
       @h['applied_workitem'] = msg['workitem']
@@ -437,15 +488,18 @@ module Ruote::Exp
     # misc
     #++
 
-    def launch_sub (pos, subtree, opts={})
+    # Launches a subprocesses (usually called from the #apply of certain
+    # expression implementations.
+    #
+    def launch_sub(pos, subtree, opts={})
 
-      i = h.fei.dup
-      i['sub_wfid'] = get_next_sub_wfid
-      i['expid'] = pos
+      i = h.fei.merge(
+        'subid' => Ruote.generate_subid(h.fei.inspect),
+        'expid' => pos)
 
       #p '=== launch_sub ==='
-      #p [ :launcher, h.fei['expid'], h.fei['sub_wfid'], h.fei['wfid'] ]
-      #p [ :launched, i['expid'], i['sub_wfid'], i['wfid'] ]
+      #p [ :launcher, h.fei['expid'], h.fei['subid'], h.fei['wfid'] ]
+      #p [ :launched, i['expid'], i['subid'], i['wfid'] ]
 
       forget = opts[:forget]
 
@@ -468,7 +522,7 @@ module Ruote::Exp
     # Returns true if the given fei points to an expression in the parent
     # chain of this expression.
     #
-    def ancestor? (fei)
+    def ancestor?(fei)
 
       return false unless h.parent_id
       return true if h.parent_id == fei
@@ -489,14 +543,15 @@ module Ruote::Exp
         par = parent
           # :( get_parent would probably be a better name for #parent
 
-        unless par
-          puts "~~"
-          puts "parent gone for"
-          p h.fei
-          p h.parent_id
-          p tree
-          puts "~~"
-        end
+        #if par.nil? && ($DEBUG || ARGV.include?('-d'))
+        #  puts "~~"
+        #  puts "parent gone for"
+        #  puts "fei          #{Ruote.sid(h.fei)}"
+        #  puts "tree         #{tree.inspect}"
+        #  puts "replying to  #{Ruote.sid(h.parent_id)}"
+        #  puts "~~"
+        #end
+          # is sometimes helpful during debug sessions
 
         par ? par.lookup_on_error : nil
 
@@ -508,7 +563,7 @@ module Ruote::Exp
 
     # Looks up parent with on_error attribute and triggers it
     #
-    def handle_on_error (msg, error)
+    def handle_on_error(msg, error)
 
       return false if h.state == 'failing'
 
@@ -524,8 +579,13 @@ module Ruote::Exp
 
       workitem = msg['workitem']
 
-      workitem['fields']['__error__'] = [
-        h.fei, Ruote.now_to_utc_s, error.class.to_s, error.message, error.backtrace ]
+      workitem['fields']['__error__'] = {
+        'fei' => fei,
+        'at' => Ruote.now_to_utc_s,
+        'class' => error.class.to_s,
+        'message' => error.message,
+        'trace' => error.backtrace
+      }
 
       @context.storage.put_msg(
         'fail',
@@ -562,49 +622,43 @@ module Ruote::Exp
     #   seq.updated_tree[2] << [ 'participant', { 'ref' => 'bob' }, [] ]
     #   seq.do_persist
     #
-    def update_tree (t=nil)
+    def update_tree(t=nil)
       h.updated_tree = t || Ruote.fulldup(h.original_tree)
     end
 
+    # Returns the name of this expression, like 'sequence', 'participant',
+    # 'cursor', etc...
+    #
     def name
+
       tree[0]
     end
 
+    # Returns the attributes of this expression (like { 'ref' => 'toto' } or
+    # { 'timeout' => '2d' }.
+    #
     def attributes
-      tree[1]
-    end
 
-    def tree_children
-      tree[2]
+      tree[1]
     end
 
-    # A tiny class-bound counter used when generating subprocesses ids.
-    #
-    @@sub_wfid_counter = -1
-
-    # Generates a sub_wfid, without hitting storage.
+    # Returns the "AST" view on the children of this expression...
     #
-    # There's a better implementation for sure...
-    #
-    def get_next_sub_wfid
-
-      i = [
-        $$, Time.now.to_f.to_s, self.hash.to_s, @h['fei'].inspect
-      ].join('-').hash
-
-      @@sub_wfid_counter = (@@sub_wfid_counter + 1) % 1000
-      i = i * 1000 + (@@sub_wfid_counter)
+    def tree_children
 
-      (i < 0 ? "1#{i * -1}" : "0#{i}").to_s
+      tree[2]
     end
 
     protected
 
-    def to_dot (opts)
+    # Returns a Graphviz dot string representing this expression (and its
+    # children).
+    #
+    def to_dot(opts)
 
       i = fei()
 
-      label = "#{[ i.wfid, i.sub_wfid, i.expid].join(" ")} #{tree.first}"
+      label = "#{[ i.wfid, i.subid, i.expid].join(' ')} #{tree.first}"
       label += " (#{h.state})" if h.state
 
       a = []
@@ -625,9 +679,14 @@ module Ruote::Exp
       a
     end
 
-    def pre_apply_child (child_index, workitem, forget)
+    # Used locally but also by ConcurrenceExpression, when preparing children
+    # before they get applied.
+    #
+    def pre_apply_child(child_index, workitem, forget)
 
-      child_fei = h.fei.merge('expid' => "#{h.fei['expid']}_#{child_index}")
+      child_fei = h.fei.merge(
+        'expid' => "#{h.fei['expid']}_#{child_index}",
+        'subid' => Ruote.generate_subid(h.fei.inspect))
 
       h.children << child_fei unless forget
 
@@ -643,29 +702,43 @@ module Ruote::Exp
       msg
     end
 
-    def apply_child (child_index, workitem, forget=false)
+    # Used by expressions when, well, applying a child expression of theirs.
+    #
+    def apply_child(child_index, workitem, forget=false)
 
       msg = pre_apply_child(child_index, workitem, forget)
 
       persist_or_raise unless forget
+        # no need to persist the parent (this) if the child is to be forgotten
 
       @context.storage.put_msg('apply', msg)
     end
 
-    def register_child (fei)
+    # Some expressions have to keep track of their (instantiated) children,
+    # this method does the registration (of the child's fei).
+    #
+    def register_child(fei)
 
       h.children << fei
       persist_or_raise
     end
 
+    # Called to check if the expression has a :tag attribute. If yes,
+    # will register the tag in a variable (and in the workitem).
+    #
     def consider_tag
 
       if h.tagname = attribute(:tag)
 
         set_variable(h.tagname, h.fei)
 
+        Ruote::Workitem.add_tag(h.applied_workitem, h.tagname)
+
         @context.storage.put_msg(
-          'entered_tag', 'tag' => h.tagname, 'fei' => h.fei)
+          'entered_tag',
+          'tag' => h.tagname,
+          'fei' => h.fei,
+          'workitem' => h.applied_workitem)
       end
     end
 
@@ -679,9 +752,10 @@ module Ruote::Exp
     # Called by consider_timeout (FlowExpression) and schedule_timeout
     # (ParticipantExpression).
     #
-    def do_schedule_timeout (timeout)
+    def do_schedule_timeout(timeout)
+
+      timeout = timeout.to_s
 
-      return unless timeout
       return if timeout.strip == ''
 
       h.timeout_schedule_id = @context.storage.put_schedule(
@@ -695,7 +769,7 @@ module Ruote::Exp
 
     # (Called by trigger_on_cancel & co)
     #
-    def supplant_with (tree, opts)
+    def supplant_with(tree, opts)
 
       # at first, nuke self
 
@@ -724,7 +798,7 @@ module Ruote::Exp
 
     # 'on_{error|timeout|cancel|re_apply}' triggering
     #
-    def trigger (on, workitem)
+    def trigger(on, workitem)
 
       hon = h[on]
 
@@ -732,20 +806,21 @@ module Ruote::Exp
 
       if on == 'on_error'
 
-        if hon == 'redo'
+        if hon == 'redo' or hon == 'retry'
 
           t = tree
 
-        elsif hon == 'undo'
+        elsif hon == 'undo' or hon == 'pass'
 
           h.state = 'failed'
           reply_to_parent(workitem)
+
           return
         end
 
       elsif on == 'on_timeout'
 
-        t = tree if hon == 'redo'
+        t = tree if hon == 'redo' or hon == 'retry'
       end
 
       supplant_with(t, 'trigger' => on)