openwferu 0.9.16 → 0.9.17

data/lib/openwfe/expressions/fe_define.rb

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2006-2007, John Mettraux, OpenWFE.org
+# Copyright (c) 2006-2008, John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -52,6 +52,9 @@ module OpenWFE
 
         names :define, :process_definition, :workflow_definition
 
+        #
+        # A pointer to the body expression of this process definition.
+        #
         attr_accessor :body_fei
 
         #--

data/lib/openwfe/expressions/fe_do.rb

@@ -30,8 +30,6 @@
 # POSSIBILITY OF SUCH DAMAGE.
 #++
 #
-# $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
-#
 
 #
 # "made in Japan"
@@ -85,7 +83,7 @@ module OpenWFE
 
             if tag
                 #OpenWFE::call_in_thread(fei.expression_name, self) do
-                process_tag(tag)
+                process_tag tag
                 #end
 
                 undo_self = tag.fei.ancestor_of?(@fei)

data/lib/openwfe/expressions/fe_equals.rb

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2006-2007, John Mettraux, OpenWFE.org
+# Copyright (c) 2006-2008, John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -48,10 +48,61 @@ require 'openwfe/expressions/flowexpression'
 
 module OpenWFE
 
+    #
+    # A Mixin shared by CompareExpression and DefinedExpression.
+    #
+    module LookupMixin
+
+        protected
+
+            def lookup_var_value (workitem, suffix=nil)
+
+                v = lookup_var workitem, suffix
+
+                return lookup_variable(v) if v
+                
+                nil
+            end
+
+            def lookup_field_value (workitem, suffix=nil)
+
+                f = lookup_field workitem, suffix
+
+                return workitem.attributes[f] if f
+
+                nil
+            end
+
+            def lookup_var (workitem, suffix=nil)
+
+                do_lookup workitem, suffix, [ :variable, :var, :v ]
+            end
+
+            def lookup_field (workitem, suffix=nil)
+
+                do_lookup workitem, suffix, [ :field, :f ]
+            end
+
+            def do_lookup (workitem, suffix, atts)
+
+                atts.each do |a|
+                    a = a.to_s + '-' + suffix if suffix
+                    v = lookup_string_attribute a, workitem
+                    return v if v
+                end
+
+                nil
+            end
+    end
+
     #
     # A parent class for the 'equals' expression.
     #
+    # (there should be a 'greater-than' and a 'lesser-than' expression,
+    # but there are not that needed for now).
+    #
     class ComparisonExpression < FlowExpression
+        include LookupMixin
 
         def apply (workitem)
 
@@ -85,7 +136,7 @@ module OpenWFE
                 value_a = lookup_value workitem
                 value_b = lookup_value workitem, :prefix => 'other'
 
-                value_c = lookup_variable_or_field workitem
+                value_c = lookup_variable_or_field_value workitem
 
                 if not value_a and value_b
                     value_a = value_c
@@ -100,20 +151,65 @@ module OpenWFE
             # Returns the value pointed at by the variable attribute or by
             # the field attribute, in that order.
             #
-            def lookup_variable_or_field (workitem)
-
-                v = lookup_string_attribute :variable, workitem
-                return lookup_variable(v) if v
-
-                f = lookup_string_attribute :field, workitem
-                return workitem.attributes[f] if f
+            def lookup_variable_or_field_value (workitem)
 
-                nil
+                lookup_var_value(workitem) || lookup_field_value(workitem)
             end
     end
 
     #
-    #     <equals value="x" other-value="y"/>
+    # The 'equals' expression compares two values. If those values are equal,
+    # the field (attribute) of the workitem named '__result__' will be
+    # set to true (else false).
+    #
+    # Usually, this expression is used within the 'if' expression.
+    #
+    #     <if>
+    #         <equals field-value="customer_name" other-value="Dupont" />
+    #         <!-- then -->
+    #         <participant ref="special_salesman" />
+    #         <!-- else -->
+    #         <participant ref="ordinary_salesman" />
+    #     </if>
+    #
+    # (The 'if' expression reads the '__result__' field to route the flow
+    # either towards the then branch, either towards the else one).
+    #
+    #
+    # With a Ruby process definition, a variation on the same 'equals' :
+    #
+    #     equals :field_value => "phone", :other_value => "090078367"
+    #     equals :field_val => "phone", :other_value => "090078367"
+    #     equals :f_value => "phone", :other_value => "090078367"
+    #     equals :f_val => "phone", :other_value => "090078367"
+    #     equals :f_val => "phone", :other_val => "090078367"
+    #
+    # Thus, note that 'variable' in an expression attribute can be 
+    # shortened to 'var' or 'v'. 'value' can be shortened to 'val' and
+    # 'field' to 'f'.
+    #
+    # Usually, the "test" attribute of the "if" expression is preferred
+    # over this 'equals' expression, like in :
+    #
+    #     <if test="${f:customer_name} == Dupont">
+    #         <!-- then -->
+    #         <participant ref="special_salesman" />
+    #         <!-- else -->
+    #         <participant ref="ordinary_salesman" />
+    #     </if>
+    #
+    # Another shortcut : the 'participant' and the 'subprocess' expressions
+    # accept an optional 'if' (or 'unless') attribute, so that ifs can be
+    # contracted to :
+    #
+    #     participant :ref => "toto", :if => "${f:customer_name} == Alfred"
+    #     subprocess :ref => "special_delivery", :if => "'${f:special}' != ''"
+    #
+    # This also works with the implicit form of the participant and the 
+    # subprocess :
+    #
+    #     toto :if => "${f:customer_name} == Alfred"
+    #     special_delivery :if => "'${f:special}' != ''"
     #
     class EqualsExpression < ComparisonExpression
 
@@ -122,37 +218,52 @@ module OpenWFE
         protected
 
             def compare (a, b)
-                #ldebug { "compare()  #{fei.to_debug_s}" }
-                #ldebug { "compare() '#{a}' == '#{b}'" }
-                return a == b
+
+                (a == b)
             end
     end
 
     #
     # This expression class actually implements 'defined' and 'undefined'.
     #
+    # They are some kind of 'equals' for validating the presence or not
+    # of a variable or a workitem field (attribute).
+    #
+    #     <if>
+    #         <defined field="customer">
+    #         <!-- then -->
+    #         <subprocess ref="call_customer" />
+    #     </if>
+    #
+    # Since OpenWFEru 0.9.17, 'defined' and 'undefined' can be easily replaced
+    # by the "is [not ]set" suffix in the dollar notation :
+    #
+    #     <if test="${f:customer_name} is set">
+    #         <!-- then -->
+    #         <subprocess ref="call_customer" />
+    #     </if>
+    #
     class DefinedExpression < FlowExpression
+        include LookupMixin
 
         names :defined, :undefined
 
         def apply (workitem)
 
-            fname = lookup_string_attribute(:field_value, workitem)
-            fname = lookup_string_attribute(:field, workitem) unless fname
+            fname = lookup_field(workitem, 'value') || lookup_field(workitem)
 
             fmatch = lookup_string_attribute(:field_match, workitem)
 
-            vname = lookup_string_attribute(:variable_value, workitem)
-            vname = lookup_string_attribute(:variable, workitem) unless vname
+            vname = lookup_var(workitem, 'value') || lookup_var(workitem)
 
             result = if fname
-                workitem.has_attribute? fname
+                workitem.has_attribute?(fname)
             elsif vname
                 lookup_variable(vname) != nil
             elsif fmatch
                 field_match?(workitem, fmatch)
             else
-                false
+                false # when in doubt, say 'no' (even when 'undefined' ?)
             end
 
             result = ( ! result) \

data/lib/openwfe/expressions/fe_fqv.rb

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2007, John Mettraux, OpenWFE.org
+# Copyright (c) 2007-2008, John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -155,10 +155,34 @@ module OpenWFE
 
         def apply workitem
 
-            text = fetch_text_content workitem
+            #text = fetch_text_content workitem
+            #text = text.strip
+            #result = if text[0, 3] == "---"
+            #    YAML.load text
+            #else
+            #    d = REXML::Document.new text
+            #    XmlCodec::decode_attribute d.root
+            #end
+
+            child = @children.first
+
+            text = if child.is_a?(String)
+
+                child
+
+            elsif child.is_a?(FlowExpressionId)
+
+                exp = get_expression_pool.fetch_expression child
+                ExpressionTree.to_s exp.raw_representation
+
+            else
+
+                child.to_s
+            end
+
             text = text.strip
 
-            result = if text[0, 3] == "---"
+            result = if text[0, 3] == '---'
                 YAML.load text
             else
                 d = REXML::Document.new text

data/lib/openwfe/expressions/fe_iterator.rb

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2007, John Mettraux, OpenWFE.org
+# Copyright (c) 2007-2008, John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -134,7 +134,7 @@ module OpenWFE
             store_itself
 
             get_expression_pool.launch_template(
-                self, @iterator.index, @children[0], workitem, vars)
+                self, nil, @iterator.index, @children[0], workitem, vars)
         end
     end
 
@@ -173,10 +173,17 @@ module OpenWFE
 
             @iteration_index = 0
 
-            raw_list = iterator_expression.lookup_vf_attribute(
-                workitem, :value, :prefix => :on)
+            #raw_list = iterator_expression.lookup_vf_attribute(
+            #    workitem, :value, :prefix => :on)
+            #raw_list ||= iterator_expression.lookup_attribute(:on, workitem)
 
-            @iteration_list = extract_iteration_list(raw_list)
+            raw_list = 
+                iterator_expression.lookup_vf_attribute(
+                    workitem, :value, :prefix => :on) ||
+                iterator_expression.lookup_vf_attribute(
+                    workitem, nil, :prefix => :on)
+
+            @iteration_list = extract_iteration_list raw_list
 
             workitem.attributes[ITERATOR_COUNT] = @iteration_list.length
         end
@@ -283,7 +290,7 @@ module OpenWFE
                 if is_suitable_list?(raw_list)
                     raw_list
                 else
-                    extract_list_from_string(raw_list.to_s)
+                    extract_list_from_string raw_list.to_s
                 end
             end
 
@@ -304,7 +311,7 @@ module OpenWFE
             #
             def extract_list_from_string (s)
 
-                s.split(@value_separator)
+                s.split @value_separator
             end
     end
 

data/lib/openwfe/expressions/fe_listen.rb

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2007, John Mettraux, OpenWFE.org
+# Copyright (c) 2007-2008, John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -300,7 +300,12 @@ module OpenWFE
                     parent = @once ? self : nil
 
                     get_expression_pool.launch_template(
-                        parent, @call_count - 1, @children[0], workitem, nil)
+                        parent, 
+                        nil, 
+                        @call_count - 1, 
+                        @children[0], 
+                        workitem, 
+                        nil)
                 else
                     #
                     # 'blocking listen'

data/lib/openwfe/expressions/fe_misc.rb

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2006-2007, John Mettraux, OpenWFE.org
+# Copyright (c) 2006-2008, John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -37,8 +37,9 @@
 # John Mettraux at openwfe.org
 #
 
-require 'openwfe/util/safe'
+require 'rufus/eval'
 require 'openwfe/expressions/flowexpression'
+require 'openwfe/expressions/value'
 
 
 module OpenWFE
@@ -65,14 +66,13 @@ module OpenWFE
     # OpenWFEru test suite uses this expression).
     #
     class PrintExpression < FlowExpression
+        include ValueMixin
 
         names :print
 
-        def apply (workitem)
-
-            escape = lookup_boolean_attribute('escape', workitem, false)
+        def reply (workitem)
 
-            text = fetch_text_content workitem, escape
+            text = workitem.get_result.to_s
             text << "\n"
 
             tracer = @application_context['__tracer']
@@ -123,7 +123,15 @@ module OpenWFE
     # Don't embed too much Ruby into your process definitions, it might
     # hurt...
     #
+    # Reval can also be used with the 'code' attribute (or 'field-code' or 
+    # 'variable-code') :
+    #
+    #     <reval field-code="f0" />
+    #
+    # to eval the Ruby code held in the field named "f0".
+    #
     class RevalExpression < FlowExpression
+        include ValueMixin
 
         names :reval
 
@@ -131,25 +139,23 @@ module OpenWFE
         # See for an explanation on Ruby safety levels :
         # http://www.rubycentral.com/book/taint.html
         #
+        # 'reval' is entitled a safe level of 3.
+        #
         SAFETY_LEVEL = 3
 
-        def apply (workitem)
+
+        def reply (workitem)
 
             raise "evaluation of ruby code is not allowed" \
                 if @application_context[:ruby_eval_allowed] != true
 
-            escape = lookup_boolean_attribute('escape', workitem, false)
-
-            code = lookup_vf_attribute(workitem, 'code')
-
-            code = fetch_text_content(workitem, escape) \
-                unless code
-
+            code = lookup_vf_attribute(workitem, 'code') || workitem.get_result
             code = code.to_s
 
-            wi = workitem
+            wi = workitem 
+                # so that the ruby code being evaluated sees 'wi' and 'workitem'
 
-            result = OpenWFE::eval_safely code, SAFETY_LEVEL, binding()
+            result = Rufus::eval_safely code, SAFETY_LEVEL, binding()
 
             workitem.set_result(result) \
                 if result != nil  # 'false' is a valid result
@@ -158,6 +164,168 @@ module OpenWFE
         end
     end
 
+    #
+    # An advanced expression : it takes the value in a field or variable (or
+    # the nested value) and evaluates it as a process definition.
+    #
+    #     sequence
+    #         set :field => "code", :value => "<print>hello 0</print>"
+    #         _eval :field_def => "code"
+    #         set :field => "code", :value => "_print 'hello 1'"
+    #         _eval :field_def => "code"
+    #     end
+    #
+    # will print "hello0\nhello1".
+    #
+    # This expression can be useful for evaluating process definition snippets
+    # coming from participants directly.
+    #
+    # It's also dangerous. This 'eval' expression will raise an error if
+    # the parameter :dynamic_eval_allowed in the engine's application context
+    # is not set to true.
+    #
+    class EvalExpression < FlowExpression
+        include ValueMixin
+
+        names :eval
+
+
+        def reply (workitem)
+
+            raise "dynamic evaluation of process definitions is not allowed" \
+                if @application_context[:dynamic_eval_allowed] != true
+
+            df = lookup_vf_attribute(workitem, 'def') || workitem.get_result
+
+            return reply_to_parent(workitem) unless df
+                #
+                # currently, 'nothing to eval' means, 'just go on'
+
+            ldebug { "apply() def is >#{df}<" }
+
+            raw_expression = build_raw_expression df
+
+            #puts
+            #puts "======================================"
+            #puts raw_expression.to_s
+            #puts raw_expression.raw_representation
+            #puts "======================================"
+            #puts
+
+            raw_expression.apply workitem
+        end
+
+        protected
+
+            def build_raw_expression (df)
+
+                procdf = get_expression_pool.determine_rep df
+
+                RawExpression.new_raw(
+                    fei, parent_id, environment_id, application_context, procdf)
+            end
+    end
+
+    #
+    # Some kind of limited 'eval' expression.
+    #
+    # Here is an usage example :
+    #
+    #     class ExampleDef < OpenWFE::ProcessDefinition
+    #
+    #         sequence do
+    #
+    #             exp :name => "p0"
+    #             exp :name => "sub0"
+    #
+    #             exp :name => "sequence" do
+    #                 p0
+    #                 sub0
+    #             end
+    #
+    #             set :var => "a", :value => { "ref" => "p0" }
+    #             exp :name => "participant", :variable_attributes => "a"
+    #         end
+    #
+    #         process_definition :name => "sub0" do
+    #             _print "sub0"
+    #         end
+    #     end
+    #
+    # This example is a bit static, but the point is that the 'exp'
+    # is extracting the real expression name (or participant or subprocess
+    # name) from its 'name' attribute.
+    #
+    # The 'eval' expression is about evaluating a complete process definition
+    # branch, 'exp' is only about one node in the process definition.
+    #
+    class ExpExpression < RawExpression
+
+        names :exp
+
+        #--
+        #def initialize (fei, parent_id, env_id, app_context, att)
+        #    #
+        #    # this responds to the FlowExpression constructor...
+        #    super fei, parent_id, env_id, app_context, nil
+        #        #
+        #        # but this triggers the RawExpression constructor :)
+        #    @attributes = att
+        #        #
+        #        # as this is not done by the RawExpression constructor
+        #end
+        #++
+
+        def apply (workitem)
+
+            @applied_workitem = workitem
+
+            super
+        end
+
+        protected
+
+            #
+            # Evaluates the 'name' attribute, if it's not present or empty,
+            # will return the value for the 'default' attribute.
+            #
+            def expression_name
+
+                n = lookup_attribute(:name, @applied_workitem)
+
+                return lookup_attribute(:default, @applied_workitem) \
+                    if (not n) or (n.strip == '')
+
+                n
+            end
+
+            #
+            # If the 'attributes' attribute is present, will return its
+            # value. Else, will simply return the attributes of the 'exp'
+            # expression itself ('name' and 'default' included).
+            #
+            def extract_attributes
+
+                att = lookup_vf_attribute @applied_workitem, :attributes
+                    # will currently only work with an attribute hash
+                    # whose keys are strings... symbols :(
+
+                att || @attributes
+            end
+
+            def extract_descriptions
+                []
+            end
+
+            def extract_children
+                @children
+            end
+
+            def extract_parameters
+                []
+            end
+    end
+
     #
     # This expression simply emits a message to the application
     # log (by default logs/openwferu.log).
@@ -184,14 +352,13 @@ module OpenWFE
     # 'fatal'.
     #
     class LogExpression < FlowExpression
+        include ValueMixin
 
         names :log
 
-        def apply (workitem)
+        def reply (workitem)
 
-            escape = lookup_boolean_attribute('escape', workitem, false)
-            text = fetch_text_content(workitem, escape)
-            text = lookup_attribute('message', workitem) unless text
+            text = lookup_attribute('message', workitem) || workitem.get_result
 
             level = lookup_attribute('level', workitem)
             level = level.downcase.to_sym if level