openwferu 0.9.15 → 0.9.16

data/lib/openwfe/expressions/fe_equals.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
             def lookup_values (workitem)
 
                 value_a = lookup_value workitem
-                value_b = lookup_value workitem, 'other'
+                value_b = lookup_value workitem, :prefix => 'other'
 
                 value_c = lookup_variable_or_field workitem
 
@@ -104,26 +102,18 @@ module OpenWFE
             #
             def lookup_variable_or_field (workitem)
 
-                v = lookup_attribute :variable, workitem
+                v = lookup_string_attribute :variable, workitem
                 return lookup_variable(v) if v
 
-                f = lookup_attribute :field, workitem
+                f = lookup_string_attribute :field, workitem
                 return workitem.attributes[f] if f
 
                 nil
             end
-
-            #
-            # This method has to be implemented by extending classes
-            #
-            def compare (a, b)
-
-                raise "not yet implemented : '#{@fei.expressionName}'"
-            end
     end
 
     #
-    #     <equals/>
+    #     <equals value="x" other-value="y"/>
     #
     class EqualsExpression < ComparisonExpression
 
@@ -147,13 +137,13 @@ module OpenWFE
 
         def apply (workitem)
 
-            fname = lookup_attribute(:field_value, workitem)
-            fname = lookup_attribute(:field, workitem) unless fname
+            fname = lookup_string_attribute(:field_value, workitem)
+            fname = lookup_string_attribute(:field, workitem) unless fname
 
-            fmatch = lookup_attribute(:field_match, workitem)
+            fmatch = lookup_string_attribute(:field_match, workitem)
 
-            vname = lookup_attribute(:variable_value, workitem)
-            vname = lookup_attribute(:variable, workitem) unless vname
+            vname = lookup_string_attribute(:variable_value, workitem)
+            vname = lookup_string_attribute(:variable, workitem) unless vname
 
             result = if fname
                 workitem.has_attribute? fname
@@ -165,8 +155,8 @@ module OpenWFE
                 false
             end
 
-            result = ( ! result) if result != nil \
-                if fei.expression_name == 'undefined'
+            result = ( ! result) \
+                if result != nil and fei.expression_name == 'undefined'
 
             workitem.set_result result
 

data/lib/openwfe/expressions/fe_filter_definition.rb

@@ -30,8 +30,6 @@
 # POSSIBILITY OF SUCH DAMAGE.
 #++
 #
-# $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
-#
 
 #
 # "made in Japan"

data/lib/openwfe/expressions/fe_fqv.rb

@@ -30,8 +30,6 @@
 # POSSIBILITY OF SUCH DAMAGE.
 #++
 #
-# $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
-#
 
 #
 # "made in Japan"
@@ -39,7 +37,7 @@
 # John Mettraux at openwfe.org
 #
 
-require 'openwfe/rest/xmlcodec'
+require 'openwfe/orest/xmlcodec'
 require 'openwfe/expressions/flowexpression'
 
 

data/lib/openwfe/expressions/fe_if.rb

@@ -99,17 +99,26 @@ module OpenWFE
 
         names :if
 
-        attr_accessor \
-            :condition_replied
+        #
+        # This boolean is set to true when the conditional claused has
+        # been evaluated and the 'if' is waiting for the consequence's
+        # reply.
+        #
+        attr_accessor :condition_replied
+
 
         def apply (workitem)
 
-            workitem.unset_result
+            #workitem.unset_result
+                #
+                # since OpenWFEru 0.9.16 previous __result__ values
+                # are not erased before an 'if'.
 
             test = eval_condition(:test, workitem, :not)
 
             if @children.length < 1
-                workitem.set_result test if test
+                #workitem.set_result test if test
+                workitem.set_result((test != nil and test != false))
                 reply_to_parent(workitem) 
                 return
             end
@@ -129,10 +138,8 @@ module OpenWFE
 
         def reply (workitem)
 
-            if @condition_replied
-                reply_to_parent(workitem)
-                return
-            end
+            return reply_to_parent(workitem) \
+                if @condition_replied
 
             result = workitem.attributes[FIELD_RESULT]
 
@@ -143,7 +150,14 @@ module OpenWFE
             apply_consequence result, workitem
         end
 
+        #
+        # This reply_to_parent takes care of cleaning all the children
+        # before replying to the parent expression, this is important
+        # because only the 'then' or the 'else' child got evaluated, the 
+        # remaining one has to be cleaned out here.
+        #
         def reply_to_parent(workitem)
+
             clean_children()
             super workitem
         end
@@ -202,13 +216,24 @@ module OpenWFE
 
         names :case, :switch
 
-        attr_accessor \
-            :offset,
-            :evaluating_condition
+        #
+        # keeping track of where we are in the case iteration
+        #
+        attr_accessor :offset
+
+        #
+        # set to 'true' when the case expression is actually evaluating
+        # a condition (ie not triggering a consequence).
+        #
+        attr_accessor :evaluating_condition
+
 
         def apply (workitem)
 
-            workitem.unset_result
+            #workitem.unset_result
+                #
+                # since OpenWFEru 0.9.16 previous __result__ values
+                # are not erased before a 'case'.
 
             @offset = nil
 

data/lib/openwfe/expressions/fe_iterator.rb

@@ -174,7 +174,7 @@ module OpenWFE
             @iteration_index = 0
 
             raw_list = iterator_expression.lookup_vf_attribute(
-                workitem, :value, :on)
+                workitem, :value, :prefix => :on)
 
             @iteration_list = extract_iteration_list(raw_list)
 

data/lib/openwfe/expressions/fe_listen.rb

@@ -30,8 +30,6 @@
 # POSSIBILITY OF SUCH DAMAGE.
 #++
 #
-# $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
-#
 
 #
 # "made in Japan"
@@ -39,6 +37,7 @@
 # John Mettraux at openwfe.org
 #
 
+require 'openwfe/expressions/merge'
 require 'openwfe/expressions/timeout'
 require 'openwfe/expressions/condition'
 require 'openwfe/expressions/flowexpression'
@@ -101,53 +100,140 @@ module OpenWFE
     # be instructed to stop listening after a certain amount of time (here,
     # after one month and two weeks).
     #
+    # Since OpenWFEru 0.9.16, the listen expression is usable without a
+    # child expression. It blocks until a valid messages comes in the 
+    # channel, at which point it resumes the process, with workitem that came
+    # as the message (not with the workitem at apply time).
+    # (no merge implemented for now).
+    #
+    #     sequence do
+    #         listen :to => "channel_z", :upon => :reply
+    #         participant :the_rest_of_the_process
+    #     end
+    #
+    # In this example, the process will block until a workitem comes for
+    # a participant named 'channel_z'.
+    #
+    # Note that since OpenWFEru 0.9.16, the engine accept (in its reply() 
+    # method) workitems that don't belong to a process intance (ie workitems
+    # that have a nil flow_expression_id). So it's entirely feasible to
+    # send 'notifications only' workitems to the OpenWFEru engine.
+    # (see http://openwferu.rubyforge.org/svn/trunk/openwfe-ruby/test/ft_54b_listen.rb)
+    #
+    # Since OpenWFEru 0.9.16, this expression has been aliased 'intercept'
+    # and 'receive'. It also accepts the 'on' parameter as an alias parameter
+    # to the 'to' parameter. Think "listen to" and "receive on".
+    #
+    # A 'merge' attribute was added as well in 0.9.16, if set to true (the 
+    # default value being false), the incoming workitem will be merged
+    # with a copy of the workitem that 'applied' (activated) the listen
+    # expression.
+    #
     class ListenExpression < FlowExpression
-        include TimeoutMixin, ConditionMixin
+        include TimeoutMixin
+        include ConditionMixin
+        include MergeMixin
+
+        names :listen, :intercept, :receive
+
+        #
+        # the channel on which this expression 'listens'
+        #
+        attr_accessor :participant_regex
+
+        #
+        # is set to true if the expression listen to 1! workitem and
+        # then replies to its parent.
+        # When set to true, it listens until the process it belongs to
+        # terminates.
+        # The default value is true.
+        #
+        attr_accessor :once
 
-        names :listen
+        #
+        # can take :apply or :reply as a value, if not set (nil), will listen
+        # on both 'directions'.
+        #
+        attr_accessor :upon
+
+        #
+        # 'listen' accepts a :merge attribute, when set to true, this
+        # field will contain a copy of the workitem that activated the
+        # listen activity. This copy will be merged with incoming (listened
+        # for) workitems when triggering the listen child.
+        #
+        attr_accessor :applied_workitem
+
+        #
+        # how many messages were received (can more than 0 or 1 if 'once'
+        # is set to false).
+        #
+        attr_accessor :call_count
 
-        attr_accessor \
-            :participant_regex, 
-            :once, 
-            :upon,
-            :call_count
 
         def apply (workitem)
 
-            if @children.size < 1
-                reply_to_parent workitem
-                return
-            end
+            #if @children.size < 1
+            #    reply_to_parent workitem
+            #    return
+            #end
+                #
+                # 'listen' now blocks if there is no children
+
+            @participant_regex = lookup_string_attribute(:to, workitem)
 
-            @participant_regex = lookup_attribute :to, workitem
+            @participant_regex = lookup_string_attribute(:on, workitem) \
+                unless @participant_regex
 
             raise "attribute 'to' is missing for expression 'listen'" \
                 unless @participant_regex
 
+            ldebug { "apply() listening to '#{@participant_regex}'" }
+
+            #
+            # once
+
             @once = lookup_boolean_attribute :once, workitem, true
 
+            @once = true if @children.size < 1
+                # a 'blocking listen' can only get triggered once.
+
             ldebug { "apply() @once is #{@once}" }
 
-            @upon = lookup_attribute(:upon, workitem, "apply")[0, 5].downcase
-            @upon = if @upon == "reply"
-                :reply
-            else
-                :apply
-            end
+            #
+            # merge
+
+            merge = lookup_boolean_attribute :merge, workitem, false
+
+            ldebug { "apply() merge is #{@merge}" }
+
+            @applied_workitem = workitem.dup if merge
+
+            #
+            # upon
+
+            @upon = lookup_sym_attribute(
+                :upon, workitem, :default => :apply)
+
+            @upon = (@upon == :reply) ? :reply : :apply
+
+            ldebug { "apply() @upon is #{@upon}" }
 
             @call_count = 0
 
-            determine_timeout()
+            determine_timeout
             reschedule(get_scheduler)
 
             store_itself
         end
 
         def cancel
+
             stop_observing
         end
 
         def reply_to_parent (workitem)
+
             stop_observing
             super
         end
@@ -156,6 +242,7 @@ module OpenWFE
         # Only called in case of timeout.
         #
         def trigger (params)
+
             reply_to_parent workitem
         end
 
@@ -167,6 +254,8 @@ module OpenWFE
 
                 upon = args[0]
 
+                ldebug { "call() channel : '#{channel}' upon '#{upon}'" }
+
                 return if upon != @upon
 
                 workitem = args[1].dup
@@ -181,21 +270,43 @@ module OpenWFE
 
                 return if @once and @call_count > 0
 
-                ldebug { "call() through for #{workitem.fei.to_s}" }
+                #
+                # workitem does match...
+
+                ldebug do 
+                    "call() "+
+                    "through for fei #{workitem.fei} / "+
+                    "'#{workitem.participant_name}'"
+                end
 
                 @call_count += 1
                 store_itself()
 
                 #ldebug { "call() @call_count is #{@call_count}" }
 
-                parent = if @once
-                    self
+                #
+                # eventual merge
+                
+                workitem = merge_workitems @applied_workitem.dup, workitem \
+                    if @applied_workitem
+
+                #
+                # reply or launch nested child expression
+
+                if @children.size > 0
+                    #
+                    # listen with child
+
+                    parent = @once ? self : nil
+
+                    get_expression_pool.launch_template(
+                        parent, @call_count - 1, @children[0], workitem, nil)
                 else
-                    nil
+                    #
+                    # 'blocking listen'
+                    
+                    reply_to_parent workitem
                 end
-
-                get_expression_pool.launch_template(
-                    parent, @call_count - 1, @children[0], workitem, nil)
             end
         end
 
@@ -211,11 +322,19 @@ module OpenWFE
 
         protected
 
+            #
+            # Start observing a [participant name] channel.
+            #
             def start_observing
+
                 get_participant_map.add_observer @participant_regex, self
             end
 
+            #
+            # Expression's job is over, deregister.
+            #
             def stop_observing
+
                 get_participant_map.remove_observer self
             end
     end

data/lib/openwfe/expressions/fe_losfor.rb

@@ -52,18 +52,24 @@ module OpenWFE
     #         <participant ref="toto" />
     #     </lose>
     #
-    # Useful only some special process cases.
+    # Useful only some special process cases (like a concurrence
+    # expecting only a certain number of replies).
+    #
+    # The brother expressions is 'forget', but 'forget' triggers its child
+    # and immediately replies, whereas 'lose' doesn't reply.
     #
     class LoseExpression < FlowExpression
 
         names :lose
 
         def apply (workitem)
+
             get_expression_pool.apply(children[0], workitem) \
                 if (@children and @children.length > 0)
         end
 
         def reply (workitem)
+
             get_expression_pool.remove(self)
         end
     end
@@ -72,6 +78,12 @@ module OpenWFE
     # This expression triggers its child (in its own thread) and then
     # forgets about it. It immediately replies to its parent expression.
     #
+    # The brother expression 'lose' triggers its child but never replies to its
+    # parent expression.
+    # 
+    # The 'forget' expression is useful for triggering process segments
+    # that are, well, dead ends.
+    #
     class ForgetExpression < FlowExpression
 
         names :forget

data/lib/openwfe/expressions/fe_misc.rb

@@ -43,18 +43,36 @@ require 'openwfe/expressions/flowexpression'
 
 module OpenWFE
 
+    #
+    # A debug/test expression (it's mostly used in the test suite
+    # used for the development of OpenWFEru).
+    # Outputs a message to the STDOUT (via the "puts" Ruby method).
+    #
+    #     <print>hello</print>
+    #
+    #     _print "hello"
+    #     _print do
+    #         "in a block"
+    #     end
+    #
+    # Note that when expressing the process in Ruby, an underscore has to be
+    # placed in front of the expression name to avoid a collision with the
+    # Ruby 'print' function.
+    #
+    # If there is an object bound in the application context under the
+    # name '__tracer', this expression will append its message to this
+    # instance instead of emitting to the STDOUT. (this is how the 
+    # OpenWFEru test suite uses this expression).
+    #
     class PrintExpression < FlowExpression
 
         names :print
 
-        #
-        # apply / reply
-
         def apply (workitem)
 
             escape = lookup_boolean_attribute('escape', workitem, false)
 
-            text = fetch_text_content(workitem, escape)
+            text = fetch_text_content workitem, escape
             text << "\n"
 
             tracer = @application_context['__tracer']
@@ -65,16 +83,10 @@ module OpenWFE
                 puts text
             end
 
-            reply_to_parent(workitem)
+            reply_to_parent workitem
         end
-
-        #def reply (workitem)
-        #end
-
     end
 
-    #
-    # <reval/>
     #
     # Evals some Ruby code contained within the process definition 
     # or within the workitem.
@@ -146,5 +158,52 @@ module OpenWFE
         end
     end
 
+    #
+    # This expression simply emits a message to the application
+    # log (by default logs/openwferu.log).
+    #
+    #     <sequence>
+    #         <log>before participant alpha</log>
+    #         <participant ref="alpha" />
+    #         <log>after participant alpha</log>
+    #         <log level="warn">after participant alpha</log>
+    #     </sequence>
+    #
+    # And an example with a Ruby process definition :
+    #
+    #     sequence do
+    #         log "simple debug message"
+    #         log do
+    #             "another debug message"
+    #         end
+    #         log :message => "yet another debug message"
+    #         log :message => "an info level message", :level => "info"
+    #     end
+    #
+    # Possible log levels are 'debug' (the default), 'info', 'warn' and
+    # 'fatal'.
+    #
+    class LogExpression < FlowExpression
+
+        names :log
+
+        def apply (workitem)
+
+            escape = lookup_boolean_attribute('escape', workitem, false)
+            text = fetch_text_content(workitem, escape)
+            text = lookup_attribute('message', workitem) unless text
+
+            level = lookup_attribute('level', workitem)
+            level = level.downcase.to_sym if level
+
+            level = :debug \
+                unless [ :info, :warn, :error, :fatal ].include?(level)
+
+            get_engine.llog(level, text) if text
+
+            reply_to_parent workitem
+        end
+    end
+
 end
 

data/lib/openwfe/expressions/fe_participant.rb

@@ -122,9 +122,9 @@ module OpenWFE
 
         names :participant
 
-        attr_accessor \
-            :participant_name,
-            :applied_workitem
+        attr_accessor :participant_name
+        attr_accessor :applied_workitem
+
 
         def apply (workitem)
 

data/lib/openwfe/expressions/fe_reserve.rb

@@ -88,7 +88,7 @@ module OpenWFE
                 return
             end
 
-            @mutex_name = lookup_attribute :mutex, workitem
+            @mutex_name = lookup_string_attribute :mutex, workitem
 
             super
         end