openwferu 0.9.7 → 0.9.8

data/lib/openwfe/expressions/expressionmap.rb

@@ -39,11 +39,12 @@
 # John Mettraux at openwfe.org
 #
 
-#require 'openwfe/util/model'
 require 'openwfe/expressions/environment'
 require 'openwfe/expressions/fe_define'
 require 'openwfe/expressions/fe_misc'
 require 'openwfe/expressions/fe_value'
+require 'openwfe/expressions/fe_if'
+require 'openwfe/expressions/fe_equals'
 require 'openwfe/expressions/fe_sequence'
 require 'openwfe/expressions/fe_subprocess'
 require 'openwfe/expressions/fe_concurrence'
@@ -51,11 +52,14 @@ require 'openwfe/expressions/fe_participant'
 require 'openwfe/expressions/fe_sleep'
 require 'openwfe/expressions/fe_cron'
 require 'openwfe/expressions/fe_when'
+require 'openwfe/expressions/fe_wait'
+require 'openwfe/expressions/fe_reserve'
 require 'openwfe/expressions/fe_losfor'
 require 'openwfe/expressions/fe_cursor'
 require 'openwfe/expressions/fe_iterator'
 require 'openwfe/expressions/fe_fqv'
 require 'openwfe/expressions/fe_cancel'
+require 'openwfe/expressions/fe_do'
 
 
 module OpenWFE
@@ -85,12 +89,19 @@ module OpenWFE
             register SetValueExpression
             register UnsetValueExpression
 
+            register DefinedExpression
+
             register IfExpression
+            register CaseExpression
+
             register EqualsExpression
 
             register SleepExpression
             register CronExpression
             register WhenExpression
+            register WaitExpression
+
+            register ReserveExpression
 
             register RevalExpression
             register PrintExpression
@@ -109,6 +120,9 @@ module OpenWFE
 
             register CancelProcessExpression
 
+            register UndoExpression
+            register RedoExpression
+
             register Environment
                 #
                 # only used by get_expression_names()

data/lib/openwfe/expressions/fe_concurrence.rb

@@ -384,7 +384,7 @@ module OpenWFE
                 return -1 if not s
                 i = s.to_i
                 return -1 if i < 1
-                return i
+                i
             end
 
             #
@@ -467,7 +467,7 @@ module OpenWFE
                     #puts result.to_s
                     #puts
 
-                    return result
+                    result
                 end
 
                 protected
@@ -509,7 +509,7 @@ module OpenWFE
 
                         return wiSource if override?
 
-                        wiSource.attributes.each do | k, v |
+                        wiSource.attributes.each do |k, v|
 
                             #puts "merge() '#{k}' => '#{v}'"
 
@@ -519,7 +519,7 @@ module OpenWFE
                             wiTarget.attributes[nk] = nv
                         end
 
-                        return wiTarget
+                        wiTarget
                     end
             end
 

data/lib/openwfe/expressions/fe_cron.rb

@@ -43,13 +43,9 @@
 require 'openwfe/utils'
 require 'openwfe/util/otime'
 require 'openwfe/util/scheduler'
-require 'openwfe/expressions/fe_sleep'
+require 'openwfe/expressions/time'
 
 
-#
-# expressions like 'sleep' and 'cron'
-#
-
 module OpenWFE
 
     #

data/lib/openwfe/expressions/fe_do.rb

@@ -39,61 +39,131 @@
 # John Mettraux at openwfe.org
 #
 
+require 'openwfe/utils'
 require 'openwfe/expressions/flowexpression'
 
 
 #
-# do / redo / undo
+# redo / undo (cancel)
 #
 
 module OpenWFE
 
     #
-    # in preparation.
+    # Every expression in OpenWFEru accepts a 'tag' attribute. This tag
+    # can later be referenced by an 'undo' or 'redo' expression.
+    # Tags are active as soon as an expression is applied and they vanish
+    # when the expression replies to its parent expression or is cancelled.
     #
-    class DoExpression < FlowExpression
-
-        attr_accessor \
-            :name
+    # Calling for the undo of a non-existent tag throws no error, the flow 
+    # simply resumes.
+    #
+    #     concurrence do
+    #         sequence :tag => "side_job" do
+    #             participant "alice"
+    #             participant "bob"
+    #         end
+    #         sequence do
+    #             participant "charly"
+    #             undo :ref => "side_job"
+    #         end
+    #     end
+    #
+    # In this example, as soon as the participant charly is over, the sequence
+    # 'side_job' gets undone (cancelled). If the sequence 'side_job' was
+    # already over, the "undo" will have no effect.
+    #
+    class UndoExpression < FlowExpression
 
-        #
-        # apply / reply
+        names :undo
 
         def apply (workitem)
-        end
 
-        def reply (workitem)
-        end
-    end
+            tag = lookup_tag(workitem)
 
-    #
-    # in preparation.
-    #
-    class UndoExpression < FlowExpression
+            undo_self = false
+
+            if tag
+                #OpenWFE::call_in_thread(fei.expression_name, self) do
+                process_tag(tag)
+                #end
+
+                undo_self = tag.fei.ancestor_of?(@fei)
+            end
+
+            reply_to_parent(workitem) unless undo_self
+        end
 
         #
-        # apply / reply
+        # Calls the expression pool cancel() method upon the tagged
+        # expression.
+        #
+        def process_tag (tag)
 
-        def apply (workitem)
+            ldebug do
+                "process_tag() #{fei.to_debug_s} to undo #{tag.fei.to_debug_s}"
+            end
+
+            #get_expression_pool.cancel_and_reply_to_parent(
+            #    tag.raw_expression.fei, tag.workitem)
+
+            exp = get_expression_pool.fetch_expression(tag.raw_expression.fei)
+
+            get_expression_pool.cancel(tag.raw_expression.fei)
+
+            get_expression_pool.reply_to_parent(exp, tag.workitem, false)
+                #
+                # 'remove' is set to false, cancel already removed the
+                # expression
         end
 
         #def reply (workitem)
         #end
+
+        protected
+
+            def lookup_tag (workitem)
+
+                tagname = lookup_attribute(:ref, workitem)
+
+                tag = lookup_variable(tagname)
+
+                lwarn { "lookup_tag() no tag named '#{tagname}' found" } \
+                    unless tag
+
+                tag
+            end
     end
 
     #
-    # in preparation.
+    # Every expression in OpenWFEru accepts a 'tag' attribute. This tag
+    # can later be referenced by an 'undo' or 'redo' expression.
     #
-    class RedoExpression < FlowExpression
+    # Calling for the undo of a non-existent tag throws no error, the flow 
+    # simply resumes.
+    #
+    class RedoExpression < UndoExpression
 
-        #
-        # apply / reply
+        names :redo
 
-        def apply (workitem)
-        end
+        def process_tag (tag)
 
-        #def reply (workitem)
-        #end
+            ldebug do
+                "process_tag() #{fei.to_debug_s} to redo #{tag.fei.to_debug_s}"
+            end
+
+            #
+            # cancel
+
+            get_expression_pool.cancel(tag.fei)
+
+            #
+            # [re]apply
+
+            tag.raw_expression.application_context = @application_context
+
+            get_expression_pool.apply(tag.raw_expression, tag.workitem)
+        end
     end
 
 end

data/lib/openwfe/expressions/fe_equals.rb

@@ -0,0 +1,190 @@
+#
+#--
+# Copyright (c) 2006-2007, John Mettraux, OpenWFE.org
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without 
+# modification, are permitted provided that the following conditions are met:
+# 
+# . Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.  
+# 
+# . Redistributions in binary form must reproduce the above copyright notice, 
+#   this list of conditions and the following disclaimer in the documentation 
+#   and/or other materials provided with the distribution.
+# 
+# . Neither the name of the "OpenWFE" nor the names of its contributors may be
+#   used to endorse or promote products derived from this software without
+#   specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+# POSSIBILITY OF SUCH DAMAGE.
+#++
+#
+# $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+require 'openwfe/workitem'
+require 'openwfe/flowexpressionid'
+require 'openwfe/expressions/flowexpression'
+
+
+#
+# expressions like 'set' and 'unset' and their utility methods
+#
+
+module OpenWFE
+
+    #
+    # A parent class for the 'equals' expression.
+    #
+    class ComparisonExpression < FlowExpression
+
+        def apply (workitem)
+
+            #
+            # preparing for children handling... later...
+            #
+
+            reply workitem
+        end
+
+        def reply (workitem)
+
+            value_a, value_b = lookup_values workitem
+
+            result = compare value_a, value_b
+
+            ldebug { "apply() result is '#{result}'  #{@fei.to_debug_s}" }
+
+            workitem.set_result result
+
+            reply_to_parent workitem
+        end
+
+        protected
+
+            #
+            # The bulk job of looking up the values to compare
+            #
+            def lookup_values (workitem)
+
+                value_a = lookup_value workitem
+                value_b = lookup_value workitem, 'other'
+
+                value_c = lookup_variable_or_field workitem
+
+                if not value_a and value_b
+                    value_a = value_c
+                elsif value_a and not value_b
+                    value_b = value_c
+                end
+
+                [ value_a, value_b ]
+            end
+
+            #
+            # 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_attribute :variable, workitem
+                return lookup_variable(v) if v
+
+                f = lookup_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/>
+    #
+    class EqualsExpression < ComparisonExpression
+
+        names :equals
+
+        protected
+
+            def compare (a, b)
+                #ldebug { "compare()  #{fei.to_debug_s}" }
+                #ldebug { "compare() '#{a}' == '#{b}'" }
+                return a == b
+            end
+    end
+
+    #
+    # This expression class actually implements 'defined' and 'undefined'.
+    #
+    class DefinedExpression < FlowExpression
+
+        names :defined, :undefined
+
+        def apply (workitem)
+
+            fname = lookup_attribute(:field_value, workitem)
+            fname = lookup_attribute(:field, workitem) unless fname
+
+            fmatch = lookup_attribute(:field_match, workitem)
+
+            vname = lookup_attribute(:variable_value, workitem)
+            vname = lookup_attribute(:variable, workitem) unless vname
+
+            result = if fname
+                workitem.has_attribute? fname
+            elsif vname
+                lookup_variable(vname) != nil
+            elsif fmatch
+                field_match?(workitem, fmatch)
+            else
+                false
+            end
+
+            result = ( ! result) if result != nil \
+                if fei.expression_name == 'undefined'
+
+            workitem.set_result result
+
+            reply_to_parent workitem
+        end
+
+        protected
+
+            def field_match? (workitem, regex)
+
+                workitem.attributes.each do |k, v|
+
+                    return true if k.match(regex)
+                end
+
+                false
+            end
+    end
+
+end
+

data/lib/openwfe/expressions/fe_fqv.rb

@@ -49,8 +49,29 @@ require 'openwfe/expressions/flowexpression'
 module OpenWFE
 
     #
-    # The 'cursor' is much like a sequence, but you can go
-    # back and forth within it.
+    # This expression implementation gathers the 'f', 'q' and 'v' expressions,
+    # along with their fullname 'field', 'variable' and 'quote'.
+    #
+    # These expressions place the value of the corresponding, field, variable
+    # or quoted (direct value) in the 'result' field of the current workitem.
+    #
+    #     sequence do
+    #
+    #         set :field => "f0", :value => "fox"
+    #         set :variable => "v0", :value => "vixen"
+    #
+    #         set :field => "f1" do
+    #             v "v0"
+    #         end
+    #         set :variable => "v1" do
+    #             f "f0"
+    #         end
+    #         set :variable => "v2" do
+    #             f "f0"
+    #         end
+    #     end
+    #
+    # Well, this is perhaps not the best example.
     #
     class FqvExpression < FlowExpression
 
@@ -62,20 +83,17 @@ module OpenWFE
         def apply (workitem)
 
             name = @fei.expression_name[0, 1]
-            text = OpenWFE::fetch_text_content(self, workitem)
+            text = fetch_text_content(workitem)
 
             method = MAP[name]
 
             result = self.send(method, text, workitem)
 
-            OpenWFE::set_result(workitem, result) if result != nil
+            workitem.set_result(result) if result != nil
 
             reply_to_parent(workitem)
         end
 
-        #def reply (workitem)
-        #end
-
         protected
 
             MAP = {