ruote 2.2.0 → 2.3.0

data/lib/ruote/exp/ro_persist.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2012, 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
@@ -34,6 +34,13 @@ module Ruote::Exp
     # PERSISTENCE
     #++
 
+    # Outputs ids like "0_2!d218c1b", no wfid, only <expid>!<subid>[0, 7]
+    #
+    def debug_id
+
+      "#{h.fei['expid']}!#{h.fei['subid'][0, 7]}"
+    end
+
     # Persists and fetches the _rev identifier from the storage.
     #
     # Only used by the worker when creating the expression.
@@ -43,7 +50,7 @@ module Ruote::Exp
       r = @context.storage.put(@h, :update_rev => true)
 
       #t = Thread.current.object_id.to_s[-3..-1]
-      #puts "+ per #{h.fei['expid']} #{tree[0]} r#{h._rev} t#{t} -> #{r.class}"
+      #puts "+ per #{debug_id} #{tree[0]} r#{h._rev} t#{t} -> #{r.class}"
       #Ruote.p_caller('+ per')
 
       raise_or_return('initial_persist failed', r)
@@ -54,7 +61,8 @@ module Ruote::Exp
       r = @context.storage.put(@h)
 
       #t = Thread.current.object_id.to_s[-3..-1]
-      #puts "+ per #{h.fei['expid']} #{tree[0]} r#{h._rev} t#{t} -> #{r.class}"
+      #puts "+ per #{debug_id} #{tree[0]} r#{h._rev} t#{t} -> #{r.class}"
+      #p self.h.children.collect { |i| Ruote.sid(i) }
       #Ruote.p_caller('+ per')
 
       r
@@ -65,7 +73,7 @@ module Ruote::Exp
       r = @context.storage.delete(@h)
 
       #t = Thread.current.object_id.to_s[-3..-1]
-      #puts "- unp #{h.fei['expid']} #{tree[0]} r#{h._rev} t#{t} -> #{r.class}"
+      #puts "- unp #{debug_id} #{tree[0]} r#{h._rev} t#{t} -> #{r.class}"
       #Ruote.p_caller('- unp')
 
       return r if r
@@ -93,11 +101,15 @@ module Ruote::Exp
     alias persist persist_or_raise
     alias unpersist unpersist_or_raise
 
+    # Make sure to persist (retry if necessary).
+    #
     def do_persist
 
       do_p(true)
     end
 
+    # Make sure to unpersist (retry if necessary).
+    #
     def do_unpersist
 
       do_p(false)
@@ -131,9 +143,9 @@ module Ruote::Exp
       raise_or_return(pers, r)
     end
 
-    # Does persist or unpersist, if successful then return true. If the
-    # expression is gone, return false.
-    # If there is a 'fresher' version of the expression, re-attempt and return
+    # Does persist or unpersist, if successful then returns true. If the
+    # expression is gone, returns false.
+    # If there is a 'fresher' version of the expression, re-attempt and returns
     # false.
     #
     def do_p(pers)

data/lib/ruote/exp/ro_timers.rb

@@ -0,0 +1,123 @@
+#--
+# Copyright (c) 2005-2012, 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.
+#++
+
+
+module Ruote::Exp
+
+  #
+  # 're-opening' the FlowExpression class to add timers related methods.
+  #
+  class FlowExpression
+
+    protected
+
+    # Reads the :timeout and :timers attributes and schedule as necessary.
+    #
+    def consider_timers
+
+      h.has_timers = (attribute(:timers) || attribute(:timeout)) != nil
+        # to enforce pdef defined timers vs participant defined timers
+
+      timers = (attribute(:timers) || '').split(/,/)
+
+      if to = attribute(:timeout)
+        timers << "#{to}: timeout" unless to.strip == ''
+      end
+
+      schedule_timers(timers)
+    end
+
+    # Used by #consider_timers and
+    # ParticipantExpression#consider_participant_timers
+    #
+    # Takes care of registering the timers/timeout for an expression.
+    #
+    def schedule_timers(timers)
+
+      timers.each do |t|
+
+        after, action = if t.is_a?(String)
+          i = t.rindex(':')
+          [ t[0..i - 1], t[i + 1..-1] ]
+        else
+          t
+        end
+
+        after = after.strip
+        action = action.strip
+
+        next if after == ''
+
+        msg = case action
+
+          when 'timeout', 'undo', 'pass'
+
+            { 'action' => 'cancel',
+              'fei' => h.fei,
+              'flavour' => action == 'timeout' ? 'timeout' : nil }
+
+          when 'redo', 'retry'
+
+            { 'action' => 'cancel',
+              'fei' => h.fei,
+              're_apply' => true }
+
+          when /^err(or)?( *.+)?$/
+
+            message = if $~[2]
+              $~[2].to_s.strip
+            else
+              "timer induced error (\"#{after}: #{action}\")"
+            end
+
+            { 'action' => 'cancel',
+              'fei' => h.fei,
+              're_apply' => { 'tree' => [ 'error', { message => nil }, [] ] } }
+
+          when CommandExpression::REGEXP
+
+            { 'action' => 'cancel',
+              'fei' => h.fei,
+              're_apply' => {
+                'tree' => [
+                  $~[1], { $~[2].split(' ').last.to_s => nil }, [] ] } }
+
+          else
+
+            { 'action' => 'apply',
+              'wfid' => h.fei['wfid'],
+              'expid' => h.fei['expid'],
+              'parent_id' => h.fei,
+              'flanking' => true,
+              'tree' => [ action, {}, [] ],
+              'workitem' => h.applied_workitem }
+        end
+
+        (h.timers ||= []) <<
+          [ @context.storage.put_schedule('at', h.fei, after, msg), action ]
+      end
+    end
+  end
+end
+

data/lib/ruote/exp/ro_variables.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2012, 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
@@ -56,17 +56,16 @@ module Ruote::Exp
 
       var, prefix = split_prefix(var, prefix)
 
-      return @context.storage.get_engine_variable(var) \
-        if prefix.length >= 2
-
-      return parent.lookup_variable(var, prefix) \
-        if h.parent_id && prefix.length >= 1
-
-      if h.variables
+      if prefix == '//'
+        return @context.storage.get_engine_variable(var)
+      end
 
-        val = Ruote.lookup(h.variables, var)
+      if prefix == '/' && par = parent
+        return par.lookup_variable(var, prefix)
+      end
 
-        return val if val != nil
+      if h.variables and Ruote.has_key?(h.variables, var)
+        return Ruote.lookup(h.variables, var)
       end
 
       if h.parent_id && h.parent_id['engine_id'] == @context.engine_id
@@ -91,23 +90,23 @@ module Ruote::Exp
     # Sets a variable to a given value.
     # (will set at the appropriate level).
     #
-    def set_variable(var, val)
+    def set_variable(var, val, override=false)
 
-      fexp, v = locate_var(var)
+      fexp, v = locate_set_var(var, override) || locate_var(var)
 
       fexp.un_set_variable(:set, v, val, (fexp.h.fei != h.fei)) if fexp
     end
 
     # Unbinds a variables.
     #
-    def unset_variable(var)
+    def unset_variable(var, override=false)
 
-      fexp, v = locate_var(var)
+      fexp, v = locate_set_var(var, override) || locate_var(var)
 
       fexp.un_set_variable(:unset, v, nil, (fexp.h.fei != h.fei)) if fexp
     end
 
-    # TODO : redoc rewrite needed
+    # TODO : rdoc rewrite needed
     #
     # This method is mostly used by the worker when looking up
     # a process name or participant name bound under a variable.
@@ -129,7 +128,7 @@ module Ruote::Exp
     #
     def un_set_variable(op, var, val, should_persist)
 
-      if op == :set
+      result = if op == :set
         Ruote.set(h.variables, var, val)
       else # op == :unset
         Ruote.unset(h.variables, var)
@@ -144,9 +143,11 @@ module Ruote::Exp
 
         @context.storage.put_msg("variable_#{op}", 'var' => var, 'fei' => h.fei)
       end
+
+      result
     end
 
-    VAR_PREFIX_REGEX = /^(\/*)/
+    VAR_PREFIX_REGEX = /^(\/{0,2})\/*(.+)$/
 
     # Used by lookup_variable and set_variable to extract the
     # prefix in a variable name
@@ -154,10 +155,9 @@ module Ruote::Exp
     def split_prefix(var, prefix)
 
       if prefix.nil?
-        var = var.to_s
-        m = VAR_PREFIX_REGEX.match(var)
-        prefix = m ? m[1][0, 2] : ''
-        var = var[prefix.length..-1]
+        m = VAR_PREFIX_REGEX.match(var.to_s)
+        prefix = m[1]
+        var = m[2]
       end
 
       [ var, prefix ]
@@ -166,23 +166,84 @@ module Ruote::Exp
     # Returns the flow expression that owns a variable (or the one
     # that should own it) and the var without its potential / prefixes.
     #
+    # In other words:
+    #
+    #   [ owner, varname_without_slashes ]
+    #
+    # When a location for the variable could not be found, it returns:
+    #
+    #   [ nil, nil ]
+    #
     def locate_var(var, prefix=nil)
 
       var, prefix = split_prefix(var, prefix)
 
-      return nil if prefix.length >= 2 # engine variable
-      return parent.locate_var(var, prefix) if prefix.length == 1 && h.parent_id
+      if prefix == '//' # engine variable
+        nil
+      elsif prefix == '/' && par = parent # process variable
+        par.locate_var(var, prefix)
+      elsif h.variables # it's here
+        [ self, var ]
+      elsif par = parent # look in the parent expression
+        par.locate_var(var, prefix)
+      else # uprooted var lookup...
+        [ nil, nil ]
+      end
+    end
+
+    # When used with override = true(ish), will try to locate the binding site
+    # for the variable and return it.
+    #
+    # If override is set to 'sub', will stop before digging into the parent
+    # subprocess.
+    #
+    def locate_set_var(var, override)
+
+      hk = h.variables && h.variables.has_key?(var)
+
+      if ( ! override) || var.match(/^\//)
+        false
+      elsif override == 'sub' && DefineExpression.is_definition?(tree) && ! hk
+        false
+      elsif hk
+        [ self, var ]
+      elsif par = parent
+        par.locate_set_var(var, override)
+      else
+        false
+      end
+    end
+
+    def set_v(key, value, opts={})
+
+      if opts[:unset]
+        unset_variable(key, opts[:override])
+      else
+        set_variable(key, value, opts[:override])
+      end
+    end
+
+    def set_f(key, value, opts={})
+
+      if opts[:unset]
+        Ruote.unset(h.applied_workitem['fields'], key)
+      else
+        Ruote.set(h.applied_workitem['fields'], key, value)
+      end
+    end
 
-      # no prefix...
+    PREFIX_REGEX = /^([^:]+):(.+)$/
+    F_PREFIX_REGEX = /^f/
 
-      return [ self, var ] if h.variables
+    def set_vf(key, value, opts={})
 
-      if par = parent
-        return parent.locate_var(var, prefix) rescue nil
+      field, key = if m = PREFIX_REGEX.match(key)
+        [ F_PREFIX_REGEX.match(m[1]), m[2] ]
+      else
+        [ true, key ]
       end
 
-      #raise "uprooted var lookup, something went wrong"
-      [ nil, nil ]
+      field ? set_f(key, value, opts) : set_v(key, value, opts)
     end
   end
 end

data/lib/ruote/fei.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2012, 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
@@ -69,6 +69,26 @@ module Ruote
     Ruote::FlowExpressionId.extract_h(o)
   end
 
+  # Given something, tries to return the fei (Ruote::FlowExpressionId) in it.
+  #
+  def self.extract_fei(o)
+
+    Ruote::FlowExpressionId.extract(o)
+  end
+
+  # Given an object, will return the wfid (workflow instance id) nested into
+  # it (or nil if it can't find or doesn't know how to find).
+  #
+  # The wfid is a String instance.
+  #
+  def self.extract_wfid(o)
+
+    return o.strip == '' ? nil : o if o.is_a?(String)
+    return o.wfid if o.respond_to?(:wfid)
+    return o['wfid'] || o.fetch('fei', {})['wfid'] if o.respond_to?(:[])
+    nil
+  end
+
   # This function is used to generate the subids. Each flow
   # expression receives such an id (it's useful for cursors, loops and
   # forgotten branches).
@@ -106,8 +126,10 @@ module Ruote
       @h = h
       class << h; include Ruote::HashDot; end
 
-      @h['subid'] = @h.delete('sub_wfid') if @h['sub_wfid']
-        # TODO : for 2.1.13, remove this
+      sub_wfid = @h.delete('sub_wfid')
+      @h['subid'] ||= sub_wfid
+        #
+        # TODO : for 2.2.2, remove those two lines
     end
 
     def expid; @h['expid']; end
@@ -118,10 +140,26 @@ module Ruote
     alias sub_wfid subid
 
     def to_storage_id
+
       "#{@h['expid']}!#{@h['subid']}!#{@h['wfid']}"
     end
+
     alias sid to_storage_id
 
+    #   expid!subid[0, 5]!wfid
+    #
+    def short_sid
+
+      "#{@h['expid']}!#{@h['subid'][0, 5]}!#{@h['wfid']}"
+    end
+
+    #   wfid!!expid
+    #
+    def to_sortable_id
+
+      "#{@h['wfid']}!!#{@h['expid']}"
+    end
+
     def self.to_storage_id(hfei)
 
       hfei.respond_to?(:to_storage_id) ?
@@ -146,11 +184,27 @@ module Ruote
       h.expid.split(CHILD_SEP).last.to_i
     end
 
+    # Returns a rufus-mnemo version of the first 9 hexdigits in the subid.
+    #
+    def mnemo_id
+
+      Rufus::Mnemo.from_i(@h['subid'][0, 9].to_i(16))
+    end
+
+    # For proper hashing and sorting.
+    #
     def hash
 
       to_storage_id.hash
     end
 
+    # For proper hashing and sorting.
+    #
+    def <=>(other)
+
+      self.to_sortable_id <=> other.to_sortable_id
+    end
+
     # Returns true if the other is a FlowExpressionId instance and it
     # points to the same expression as this one.
     #