openwferu 0.9.15 → 0.9.16

data/lib/openwfe/expressions/fe_save.rb

@@ -30,8 +30,6 @@
 # POSSIBILITY OF SUCH DAMAGE.
 #++
 #
-# $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
-#
 
 #
 # "made in Japan"
@@ -73,17 +71,20 @@ module OpenWFE
 
         def apply (workitem)
 
-            field = lookup_attribute :to_field, workitem
-            variable = lookup_attribute :to_variable, workitem
+            field = lookup_string_attribute :to_field, workitem
+            variable = lookup_string_attribute :to_variable, workitem
 
             wi = workitem.dup
 
             if field
-                #workitem.attributes[field] = wi.attributes
+
                 workitem.set_attribute field, wi.attributes
+
             elsif variable
+
                 set_variable variable, wi
             end
+
             # else, simply don't save
 
             reply_to_parent workitem
@@ -134,9 +135,9 @@ module OpenWFE
 
         def apply (workitem)
 
-            from_field = lookup_attribute :from_field, workitem
-            from_variable = lookup_attribute :from_variable, workitem
-            merge_lead = lookup_attribute :merge_lead, workitem
+            from_field = lookup_string_attribute :from_field, workitem
+            from_variable = lookup_string_attribute :from_variable, workitem
+            merge_lead = lookup_sym_attribute :merge_lead, workitem
 
             source = if from_field
 
@@ -186,10 +187,10 @@ module OpenWFE
                     source
                 end
 
-                to_field = lookup_attribute :to_field, workitem
+                to_field = lookup_string_attribute :to_field, workitem
 
                 if to_field
-                    workitem.set_attribute to_field.strip, attributes
+                    workitem.set_attribute to_field, attributes
                 else
                     workitem.attributes = attributes
                 end
@@ -209,8 +210,6 @@ module OpenWFE
                     source = wi
                 end
 
-                merge_lead = merge_lead.strip.downcase.intern
-
                 wiTarget, wiSource = if merge_lead == :current
                     [ source, workitem ]
                 else

data/lib/openwfe/expressions/fe_sequence.rb

@@ -30,8 +30,6 @@
 # POSSIBILITY OF SUCH DAMAGE.
 #++
 #
-# $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
-#
 
 #
 # "made in Japan"
@@ -57,61 +55,56 @@ module OpenWFE
 
         names :sequence
 
-        attr_accessor \
-            :current_child_id
-
 
         def apply (workitem)
 
-            @current_child_id = -1
+            #store_itself
+                #
+                # remove that !
 
             reply workitem
         end
 
         def reply (workitem)
 
-            cfei = get_to_next_child()
+            cfei = next_child workitem.fei
 
-            unless cfei
-                reply_to_parent workitem
-                return
-            end
+            return reply_to_parent(workitem) \
+                unless cfei
 
             #ldebug do 
             #    "reply() self : \n#{self.to_s}\n" +
             #    "reply() next is #{@current_child_id} : #{cfei.to_debug_s}"
             #end
 
-            store_itself()
-
             get_expression_pool.apply cfei, workitem
         end
 
         protected
 
-            def get_to_next_child ()
+            #
+            # Returns the flowExpressionId of the next child to apply, or
+            # nil if the sequence is over.
+            #
+            def next_child (current_fei)
 
-                #return nil if @children.length < 1 
-
-                @current_child_id += 1
-
-                return nil if @current_child_id >= @children.length
+                next_id = if (current_fei == self.fei)
+                    0
+                else
+                    current_fei.child_id.to_i + 1
+                end
 
-                #ldebug do
-                #    "get_to_next_child() " +
-                #    "len: #{@children.length} / id: #{@current_child_id}"
-                #end
+                loop do
 
-                @children[@current_child_id..-1].each do |c|
+                    break if next_id >= @children.length
 
-                    return c if c.kind_of? OpenWFE::FlowExpressionId
+                    child = @children[next_id]
+                    return child if child.is_a?(FlowExpressionId)
 
-                    @current_child_id += 1
+                    next_id += 1
                 end
 
-                nil 
-                    #
-                    # did not find any child expression
+                nil
             end
     end
 

data/lib/openwfe/expressions/fe_sleep.rb

@@ -69,8 +69,8 @@ module OpenWFE
 
         def apply (workitem)
 
-            sfor = lookup_attribute(:for, workitem)
-            suntil = lookup_attribute(:until, workitem)
+            sfor = lookup_string_attribute(:for, workitem)
+            suntil = lookup_string_attribute(:until, workitem)
 
             sfor = fetch_text_content(workitem) \
                 if sfor == nil and suntil == nil
@@ -98,22 +98,23 @@ module OpenWFE
             @awakening_time = tuntil
             @applied_workitem = workitem.dup
 
+            determine_scheduler_tags
+
             reschedule(get_scheduler)
         end
 
-        #def reply (workitem)
-        #end
-
         #
         # This is the method called by the Scheduler instance attached to
         # the workflow engine when the 'sleep' of this expression is 
         # over
         #
         def trigger (params)
+
             ldebug do 
                 "trigger() #{@fei.to_debug_s} waking up (#{Time.new.to_f}) "+
                 "(scheduler #{get_scheduler.object_id})"
             end
+
             reply_to_parent(@applied_workitem)
         end
 
@@ -137,14 +138,17 @@ module OpenWFE
             
             scheduler.schedule_at(
                 @awakening_time,
-                { :schedulable => self, :job_id => @scheduler_job_id })
+                { 
+                    :schedulable => self, 
+                    :job_id => @scheduler_job_id,
+                    :tags => @scheduler_tags })
 
             ldebug do 
                 "[re]schedule() @scheduler_job_id is '#{@scheduler_job_id}' "+
                 " (scheduler #{scheduler.object_id})"
             end
 
-            store_itself()
+            store_itself
         end
     end
 

data/lib/openwfe/expressions/fe_subprocess.rb

@@ -101,15 +101,15 @@ module OpenWFE
 
         names :subprocess
 
+        attr_accessor :subprocess_fei
+
 
         def apply (workitem)
 
             conditional = eval_condition(:if, workitem, :unless)
 
-            if conditional == false
-                reply_to_parent workitem
-                return
-            end
+            return reply_to_parent(workitem) \
+                if conditional == false
 
             ref = lookup_ref(workitem)
 
@@ -124,8 +124,11 @@ module OpenWFE
 
             forget = lookup_boolean_attribute(:forget, workitem)
 
-            requester = @fei
-            requester = @fei.workflow_instance_id if forget
+            requester = if forget
+                @fei.workflow_instance_id
+            else
+                @fei
+            end
 
             params = lookup_attributes(workitem)
 
@@ -136,14 +139,25 @@ module OpenWFE
             #puts " ... params are #{params.keys.join(', ')}"
             #puts " ... values are #{params.values.join(', ')}"
 
-            get_expression_pool.launch_template(
+            sub_fei = get_expression_pool.launch_template(
                 requester, get_next_sub_id, template, workitem, params)
 
-            reply_to_parent(workitem) if forget
+            if forget
+                reply_to_parent(workitem.dup) 
+            else
+                @subprocess_fei = sub_fei.dup
+                store_itself # to keep track of @subprocess_fei
+            end
         end
 
-        #def reply (workitem)
-        #end
+        #
+        # Takes care of cancelling the subprocess as well if any
+        #
+        def cancel
+
+            return nil unless @subprocess_fei
+            get_expression_pool.cancel @subprocess_fei
+        end
     end
 
 end

data/lib/openwfe/expressions/fe_value.rb

@@ -65,7 +65,7 @@ module OpenWFE
             def lookup (name_array, workitem)
 
                 name_array.each do |n|
-                    v = lookup_attribute(n, workitem)
+                    v = lookup_string_attribute n, workitem
                     return v if v
                 end
 
@@ -88,7 +88,7 @@ module OpenWFE
     # they will be evaluated sequentially before the body gets applied 
     # (executed).
     #
-    # Since OpenWFEru 0.9.14, shorter attributes are OK :
+    # Shorter attributes are OK :
     #
     #     <set f="price" val="CHF 12.00" />
     #     <set v="/stage" val="3" />
@@ -98,6 +98,13 @@ module OpenWFE
     #     set :f => "price", :val => "USD 12.50"
     #     set :v => "toto", :val => "elvis"
     #
+    # In case you need the value not to be evaluated if it contains
+    # dollar expressions, you can do
+    #
+    #     set :v => "v0", :val => "my ${template} thing", :escape => true
+    #
+    # to prevent evaluation (i.e. to escape).
+    #
     class SetValueExpression < FlowExpression
         include ValueMixin
 
@@ -108,23 +115,29 @@ module OpenWFE
 
         def apply (workitem)
 
+            escape = lookup_boolean_attribute('escape', workitem, false)
+
             if @children.length < 1
-                workitem.attributes[FIELD_RESULT] = lookup_value(workitem)
-                reply(workitem)
+
+                workitem.attributes[FIELD_RESULT] = \
+                    lookup_value(workitem, :escape => escape)
+
+                reply workitem
                 return
             end
 
             child = @children[0]
 
-            if child.kind_of? OpenWFE::FlowExpressionId
-                handle_child(child, workitem)
+            if child.kind_of?(OpenWFE::FlowExpressionId)
+
+                handle_child child, workitem
                 return
             end
 
-            #workitem.attributes[FIELD_RESULT] = child.to_s
-            workitem.attributes[FIELD_RESULT] = fetch_text_content(workitem)
+            workitem.attributes[FIELD_RESULT] = \
+                fetch_text_content(workitem, escape)
 
-            reply(workitem)
+            reply workitem
         end
 
         def reply (workitem)
@@ -151,14 +164,21 @@ module OpenWFE
 
             def handle_child (child, workitem)
 
-                child, _fei = get_expression_pool().fetch(child)
+                raw_child, _fei = get_expression_pool.fetch(child)
+
+                if raw_child.is_definition?
+
+                    #body_fei = get_expression_pool.evaluate child, workitem
+                    #workitem.attributes[FIELD_RESULT] = body_fei
 
-                if child.is_definition?
-                    fei = get_expression_pool().evaluate(child, workitem)
-                    workitem.attributes[FIELD_RESULT] = fei
-                    reply(workitem)
+                    workitem.attributes[FIELD_RESULT] = raw_child
+                        #
+                        # storing the child raw expression
+
+                    reply workitem
                 else
-                    get_expression_pool().apply(child, workitem)
+
+                    get_expression_pool.apply raw_child, workitem
                 end
             end
     end

data/lib/openwfe/expressions/fe_when.rb

@@ -30,8 +30,6 @@
 # POSSIBILITY OF SUCH DAMAGE.
 #++
 #
-# $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
-#
 
 #
 # "made in Japan"
@@ -116,7 +114,7 @@ module OpenWFE
             @condition_sub_id = -1
             @consequence_triggered = false
 
-            super(workitem)
+            super workitem
         end
 
         def reply (workitem)
@@ -130,7 +128,7 @@ module OpenWFE
                 return
             end
 
-            super(workitem)
+            super workitem
         end
 
         protected

data/lib/openwfe/expressions/flowexpression.rb

@@ -144,7 +144,7 @@ module OpenWFE
         #
         def apply (workitem)
 
-            get_parent().reply(workitem) if @parent_id
+            get_parent.reply(workitem) if @parent_id
         end
 
         #
@@ -180,7 +180,7 @@ module OpenWFE
 
             @children.each do |child|
 
-                next if child.kind_of? String
+                next if child.kind_of?(String)
 
                 i = get_expression_pool().cancel(child)
                 inflowitem = i unless inflowitem
@@ -197,6 +197,7 @@ module OpenWFE
         # as the FlowExpression instance it is).
         #
         def get_parent
+
             #parent, parent_fei = get_expression_pool.fetch @parent_id
             #parent
             get_expression_pool.fetch_expression @parent_id
@@ -210,7 +211,8 @@ module OpenWFE
         # simply if the expression got swapped out of memory and reloaded later.
         #
         def store_itself
-            #ldebug { "store_itself() for  #{@fei.to_debug_s}" }
+
+            ldebug { "store_itself() for  #{@fei.to_debug_s}" }
             #ldebug { "store_itself() \n#{OpenWFE::caller_to_s(0, 6)}" }
             get_expression_pool.update self
         end
@@ -307,10 +309,10 @@ module OpenWFE
 
             env, var = lookup_environment(varname)
 
-            #ldebug do 
-            #    "set_variable() '#{varname}' to '#{value}' " +
-            #    "in  #{env.fei.to_debug_s}"
-            #end
+            ldebug do 
+                "set_variable() '#{varname}' to '#{value}' " +
+                "in  #{env.fei.to_debug_s}"
+            end
 
             env[var] = value
         end
@@ -360,42 +362,58 @@ module OpenWFE
         # variable substitution.
         # It's ok to pass a Symbol for the attribute name.
         #
-        def lookup_attribute (attname, workitem, default=nil)
+        def lookup_attribute (attname, workitem, options={})
+
+            default = options[:default]
+            escape = options[:escape]
 
             attname = OpenWFE::symbol_to_name(attname) \
-                if attname.kind_of? Symbol
+                if attname.kind_of?(Symbol)
 
             #ldebug { "lookup_attribute() '#{attname}' in #{@fei.to_debug_s}" }
 
             text = @attributes[attname]
 
-            default = default.to_s if default
+            return default if text == nil
+            return text unless text.is_a?(String)
 
-            return default if not text
+            return text if escape == true
+                # returns text if escape is set and is set to true
 
-            OpenWFE::dosub(text, self, workitem)
+            OpenWFE::dosub text, self, workitem
         end
 
         #
-        # Like lookup_attribute() but returns the value downcased.
-        # Returns nil if no such attribute was found.
+        # Returns the attribute value as a String (or nil if it's not found).
         #
-        def lookup_downcase_attribute (attname, workitem, default=nil)
-            result = lookup_attribute attname, workitem, default
-            result = result.downcase if result
+        def lookup_string_attribute (attname, workitem, options={})
+
+            result = lookup_attribute attname, workitem, options
+            result = result.to_s if result
             result
         end
 
         #
-        # Returns true if the expression has the given attribute.
-        # The attname parameter can be a String or a Symbol.
+        # Like lookup_attribute() but returns the value downcased [
+        # (and stripped).
+        # Returns nil if no such attribute was found.
         #
-        def has_attribute (attname)
+        def lookup_downcase_attribute (attname, workitem, options={})
 
-            attname = OpenWFE::symbol_to_name(attname) \
-                if attname.kind_of? Symbol
+            result = lookup_string_attribute attname, workitem, options
+            result = result.strip.downcase if result
+            result
+        end
 
-            @attributes[attname] != nil
+        #
+        # Returns the value of the attribute as a Symbol.
+        # Returns nil if there is no attribute under the given name.
+        #
+        def lookup_sym_attribute (attname, workitem, options={})
+
+            result = lookup_downcase_attribute attname, workitem, options
+            result = result.to_sym if result
+            result
         end
 
         #
@@ -404,10 +422,22 @@ module OpenWFE
         #
         def lookup_boolean_attribute (attname, workitem, default=false)
 
-            value = lookup_attribute(attname, workitem)
-            return default if not value
+            result = lookup_downcase_attribute attname, workitem
+            return default if result == nil
+
+            (result == 'true')
+        end
+
+        #
+        # Returns true if the expression has the given attribute.
+        # The attname parameter can be a String or a Symbol.
+        #
+        def has_attribute (attname)
+
+            attname = OpenWFE::symbol_to_name(attname) \
+                if attname.kind_of?(Symbol)
 
-            (value.downcase == 'true')
+            @attributes[attname] != nil
         end
 
         #
@@ -454,9 +484,9 @@ module OpenWFE
         #
         #     [ 'a', 'b', 'c' ]
         #
-        def lookup_comma_list_attribute (attname, workitem, default=nil)
+        def lookup_comma_list_attribute (attname, workitem, options={})
 
-            a = lookup_attribute(attname, workitem, default)
+            a = lookup_attribute(attname, workitem, options)
 
             return nil if not a
 
@@ -595,10 +625,10 @@ module OpenWFE
         # looks up for 'value', 'variable-value' and then for 'field-value'
         # if necessary.
         #
-        def lookup_value (workitem, prefix='')
+        def lookup_value (workitem, options={})
 
-            v = lookup_vf_attribute(workitem, 'value', prefix)
-            v = lookup_vf_attribute(workitem, 'val', prefix) unless v
+            v = lookup_vf_attribute(workitem, 'value', options)
+            v = lookup_vf_attribute(workitem, 'val', options) unless v
             v
         end
 
@@ -608,25 +638,31 @@ module OpenWFE
         #
         def lookup_ref (workitem, prefix='')
 
-            lookup_vf_attribute(workitem, 'ref', prefix)
+            ref = lookup_vf_attribute(workitem, 'ref', :prefix => prefix)
+            return ref.to_s if ref
+            nil
         end
 
         #
         # Looks up for value attributes like 'field-ref' or 'variable-value'
         #
-        def lookup_vf_attribute (workitem, att_name, prefix='')
+        def lookup_vf_attribute (workitem, att_name, options={})
 
+            prefix = options[:prefix] || ''
             prefix = "#{prefix.to_s}-" if prefix != ''
 
-            v = lookup_attribute("#{prefix}#{att_name}", workitem)
+            v = lookup_attribute(
+                "#{prefix}#{att_name}", workitem, options)
 
             return v if v
 
-            v = lookup_attribute("#{prefix}variable-#{att_name}", workitem)
+            v = lookup_attribute(
+                "#{prefix}variable-#{att_name}", workitem, options)
 
             return lookup_variable(v) if v
 
-            v = lookup_attribute("#{prefix}field-#{att_name}", workitem)
+            v = lookup_attribute(
+                "#{prefix}field-#{att_name}", workitem, options)
 
             return workitem.attributes[v] if v
 
@@ -638,7 +674,7 @@ module OpenWFE
         #
         def to_s
 
-            s = "* #{@fei.to_debug_s}"
+            s =    "* #{@fei.to_debug_s} [#{self.class.name}]"
 
             s << "\n   `--p--> #{@parent_id.to_debug_s}" \
                 if @parent_id

data/lib/openwfe/expressions/merge.rb

@@ -30,8 +30,6 @@
 # POSSIBILITY OF SUCH DAMAGE.
 #++
 #
-# $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
-#
 
 #
 # "made in Japan"
@@ -66,8 +64,8 @@ module OpenWFE
         
                 #puts "merge() '#{k}' => '#{v}'"
         
-                nk = OpenWFE::fulldup(k)
-                nv = OpenWFE::fulldup(v)
+                nk = OpenWFE::fulldup k
+                nv = OpenWFE::fulldup v
         
                 wiTarget.attributes[nk] = nv
             end