openwferu 0.9.8 → 0.9.9

data/lib/openwfe/expressions/environment.rb

@@ -59,9 +59,9 @@ module OpenWFE
             :variables
 
         def initialize \
-            (id, parent, environment_id, application_context, attributes)
+            (fei, parent, environment_id, application_context, attributes)
 
-            super(id, parent, environment_id, application_context, attributes)
+            super(fei, parent, environment_id, application_context, attributes)
 
             @variables = {}
         end
@@ -147,14 +147,36 @@ module OpenWFE
         end
 
         #
-        # Returns the top environment for the process instance.
+        # Returns the top environment for the process instance (the
+        # environment just before the engine environment).
         #
-        def get_root_environment ()
+        def get_root_environment
+            #ldebug { "get_root_environment\n#{self}" }
+            return self if not @parent_id
+            get_parent.get_root_environment
+        end
 
-            #ldebug { "get_root_environment()\n#{self}" }
+        #def get_subprocess_environment
+        #    return self if not @parent_id
+        #    return self if @parent_id.sub_instance_id != @fei.sub_instance_id
+        #    get_parent.get_subprocess_environment
+        #end
 
-            return self if not @parent_id
-            return get_parent().get_root_environment()
+        #
+        # Returns a deep copy of this environment.
+        #
+        def dup
+
+            env = Environment.new(
+                @fei.dup, 
+                @parent_id, 
+                @environment_id, 
+                @application_context, 
+                OpenWFE::fulldup(@attributes))
+
+            env.variables = OpenWFE::fulldup self.variables
+
+            env
         end
     end
 

data/lib/openwfe/expressions/expressionmap.rb

@@ -60,6 +60,9 @@ require 'openwfe/expressions/fe_iterator'
 require 'openwfe/expressions/fe_fqv'
 require 'openwfe/expressions/fe_cancel'
 require 'openwfe/expressions/fe_do'
+require 'openwfe/expressions/fe_save'
+require 'openwfe/expressions/fe_filter_definition'
+require 'openwfe/expressions/fe_filter'
 
 
 module OpenWFE
@@ -84,6 +87,8 @@ module OpenWFE
             register ConcurrenceExpression
             register GenericSyncExpression
 
+            register ConcurrentIteratorExpression
+
             register SubProcessRefExpression
 
             register SetValueExpression
@@ -123,6 +128,12 @@ module OpenWFE
             register UndoExpression
             register RedoExpression
 
+            register SaveWorkItemExpression
+            register RestoreWorkItemExpression
+
+            register FilterDefinitionExpression
+            register FilterExpression
+
             register Environment
                 #
                 # only used by get_expression_names()
@@ -134,6 +145,9 @@ module OpenWFE
         #
         def get_class (expression_name)
 
+            expression_name = expression_name.expression_name \
+                if expression_name.kind_of?(RawExpression)
+
             expression_name = OpenWFE::symbol_to_name(expression_name)
 
             @expressions[expression_name]
@@ -152,7 +166,8 @@ module OpenWFE
 
             c = get_class(expression_name)
 
-            c == DefineExpression
+            #c == DefineExpression
+            (c and c.is_definition?)
         end
 
         #

data/lib/openwfe/expressions/fe_concurrence.rb

@@ -41,8 +41,10 @@
 
 require 'openwfe/utils'
 require 'openwfe/rudefinitions'
+require 'openwfe/expressions/merge'
 require 'openwfe/expressions/condition'
 require 'openwfe/expressions/flowexpression'
+require 'openwfe/expressions/fe_iterator'
 
 
 #
@@ -120,12 +122,16 @@ module OpenWFE
     # [override]  The default : no mix of values between the workitems do occur
     # [mix]       Priority is given to the 'winning' workitem but their values
     #             get mixed
+    # [isolate]   the attributes of the workitem of each branch is placed 
+    #             in a field in the resulting workitem. For example, the 
+    #             attributes of the first branch will be stored under the
+    #             field named '0' of the resulting workitem.
     #
     # The merge occurs are the top level of workitem attributes.
     #
     # More complex merge behaviour can be obtained by extending the 
     # GenericSyncExpression class. But the default sync options are already
-    # numerous and powerful.
+    # numerous and powerful by their combinations.
     #
     class ConcurrenceExpression < SequenceExpression
         include ConditionMixin
@@ -139,8 +145,8 @@ module OpenWFE
 
             sync = lookup_attribute(:sync, workitem, :generic)
 
-            @sync_expression = \
-                get_expression_map().get_sync_class(sync).new(self, workitem)
+            @sync_expression = 
+                get_expression_map.get_sync_class(sync).new(self, workitem)
 
             @children.each do |child|
                 @sync_expression.add_child(child)
@@ -150,12 +156,16 @@ module OpenWFE
 
             concurrence = self
 
-            @children.each do |child|
+            @children.each_with_index do |child, index|
                 Thread.new do
                     begin
                         #ldebug { "apply() child : #{child.to_debug_s}" }
                         concurrence.synchronize do
-                            get_expression_pool().apply(child, workitem.dup)
+
+                            get_expression_pool().apply(
+                                child, 
+                                #workitem.dup)
+                                get_workitem(workitem, index))
                         end
                     rescue Exception => e
                         lwarn do 
@@ -186,6 +196,66 @@ module OpenWFE
         def reply (workitem)
             @sync_expression.reply(self, workitem)
         end
+
+        protected
+
+            def get_workitem (workitem, index)
+                workitem.dup
+            end
+    end
+
+    #
+    # This expression is a mix between a 'concurrence' and an 'iterator'.
+    # It understands the same attributes and behaves as an interator that
+    # forks its children concurrently.
+    #
+    # (See ConcurrenceExpression and IteratorExpression).
+    #
+    class ConcurrentIteratorExpression < ConcurrenceExpression
+
+        names :concurrent_iterator
+
+        #attr_accessor :iterator
+
+        def apply (workitem)
+
+            if @children.length < 1
+                reply_to_parent workitem
+                return
+            end
+
+            template = @children[0]
+
+            @children.clear
+
+            @workitems = []
+
+            iterator = Iterator.new(self, workitem)
+
+            while iterator.has_next?
+
+                wi = workitem.dup
+
+                @workitems << wi
+
+                vars = iterator.next self, wi
+
+                rawexp = get_expression_pool.prepare_from_template(
+                    self, iterator.index, template, vars)
+
+                @children << rawexp.fei
+            end
+
+            get_expression_pool.remove(template)
+
+            super
+        end
+
+        protected
+
+            def get_workitem (workitem, index)
+                @workitems[index]
+            end
     end
 
     #
@@ -236,6 +306,8 @@ module OpenWFE
             merge = synchable.lookup_attribute(:merge, workitem, :first)
             merge_type = synchable.lookup_attribute(:merge_type, workitem, :mix)
 
+            #synchable.ldebug { "new() merge_type is '#{merge_type}'" }
+
             @merge_array = MergeArray.new(merge, merge_type)
 
             @unready_queue = []
@@ -297,7 +369,7 @@ module OpenWFE
             def do_reply (synchable, workitem)
 
                 synchable.ldebug do 
-                    "#{self.class}.do_reply()  "+
+                    "#{self.class}.do_reply() from"+
                     "#{workitem.last_expression_id.to_debug_s}"
                 end
 
@@ -307,6 +379,11 @@ module OpenWFE
 
                 @remaining_children.delete(workitem.last_expression_id)
 
+                #synchable.ldebug do
+                #    "#{self.class}.do_reply()  "+
+                #    "remaining children : #{@remaining_children.length}"
+                #end
+
                 if @remaining_children.length <= 0
                     reply_to_parent(synchable)
                     return true
@@ -364,8 +441,7 @@ module OpenWFE
                     if @cancel_remaining
                         expool.cancel(child)
                     else
-                        #expool.remove(child)
-                        expool.forget(child)
+                        expool.forget(synchable, child)
                     end
                 end
             end
@@ -388,11 +464,13 @@ module OpenWFE
             end
 
             #
-            # This inner class is used to gather workitems before the final
-            # merge, which is triggered by calling the do_merge() method
-            # which returns the merged workitem.
+            # This inner class is used to gather workitems (via push()) before 
+            # the final merge
+            # This final merge is triggered by calling the do_merge() method
+            # which will return the resulting, merged workitem.
             #
             class MergeArray
+                include MergeMixin
 
                 attr_accessor \
                     :workitem,
@@ -403,8 +481,8 @@ module OpenWFE
 
                 def initialize (merge, merge_type)
 
-                    @merge = merge.downcase
-                    @merge_type = merge_type.downcase
+                    @merge = merge.strip.downcase.intern
+                    @merge_type = merge_type.strip.downcase.intern
 
                     ensure_merge_settings()
 
@@ -418,22 +496,48 @@ module OpenWFE
 
                 def push (synchable, wi)
 
-                    if not @workitems_by_arrival
-                        #
-                        # last or first
-                        #
-                        source, target = if first?
-                            [ @workitem, wi ]
-                        else
-                            [ wi, @workitem ]
-                        end
-                        @workitem = merge(target, source)
+                    #synchable.ldebug do
+                    #    "push() isolate? #{isolate?}"
+                    #end
 
-                        return
+                    if isolate?
+                        push_in_isolation wi
+                    elsif last? or first?
+                        push_by_position wi
+                    else
+                        push_by_arrival wi
                     end
+                end
+
+                def push_by_position (wi)
+
+                    source, target = if first?
+                        [ @workitem, wi ]
+                    else
+                        [ wi, @workitem ]
+                    end
+                    @workitem = merge_workitems target, source, override?
+                end
 
-                    index = synchable.children.index(
-                        wi.last_expression_id)
+                def push_in_isolation (wi)
+
+                    unless @workitem
+                        @workitem = wi.dup
+                        att = @workitem.attributes
+                        @workitem.attributes = {}
+                    end
+
+                    #key = synchable.children.index wi.last_expression_id
+                    key = wi.last_expression_id.child_id
+
+                    @workitem.attributes[key.to_s] = 
+                        OpenWFE::fulldup(wi.attributes)
+                end
+
+                def push_by_arrival (wi)
+
+                    #index = synchable.children.index wi.last_expression_id
+                    index = Integer(wi.last_expression_id.child_id)
 
                     @workitems_by_arrival << wi
                     @workitems_by_altitude[index] = wi
@@ -460,7 +564,7 @@ module OpenWFE
 
                     list.each do |wi|
                         next unless wi
-                        result = merge(result, wi)
+                        result = merge_workitems result, wi, override?
                     end
 
                     #puts "___ result :"
@@ -473,23 +577,26 @@ module OpenWFE
                 protected
 
                     def first?
-                        @merge == "first"
+                        @merge == :first
                     end
                     def last?
-                        @merge == "last"
+                        @merge == :last
                     end
                     def highest?
-                        @merge == "highest"
+                        @merge == :highest
                     end
                     def lowest?
-                        @merge == "lowest"
+                        @merge == :lowest
                     end
 
                     def mix?
-                        @merge_type == "mix"
+                        @merge_type == :mix
                     end
                     def override?
-                        @merge_type == "override"
+                        @merge_type == :override
+                    end
+                    def isolate?
+                        @merge_type == :isolate
                     end
 
                     #
@@ -498,28 +605,8 @@ module OpenWFE
                     #
                     def ensure_merge_settings
 
-                        @merge_type = "mix" unless override?
-                        @merge = "first" unless last? or highest? or lowest?
-                    end
-
-                    def merge (wiTarget, wiSource)
-
-                        return wiSource unless wiTarget
-                        return wiTarget unless wiSource
-
-                        return wiSource if override?
-
-                        wiSource.attributes.each do |k, v|
-
-                            #puts "merge() '#{k}' => '#{v}'"
-
-                            nk = OpenWFE::fulldup(k)
-                            nv = OpenWFE::fulldup(v)
-
-                            wiTarget.attributes[nk] = nv
-                        end
-
-                        wiTarget
+                        @merge_type = :mix unless override? or isolate?
+                        @merge = :first unless last? or highest? or lowest?
                     end
             end
 

data/lib/openwfe/expressions/fe_cursor.rb

@@ -60,12 +60,37 @@ module OpenWFE
     C_CANCEL = "cancel"
     C_REWIND = "rewind"
     C_CONTINUE = "continue"
+    C_JUMP = "jump"
 
     A_STEP = "step"
 
     #
     # The 'cursor' is much like a sequence, but you can go
-    # back and forth within it.
+    # back and forth within it, as it reads the field '\_\_cursor_command__' (or
+    # the field specified in the 'command-field' attribute) at each
+    # transition (each time it's supposed to move from one child expression to
+    # the next).
+    #
+    #     cursor do
+    #         participant "alpha"
+    #         skip :step => "2"
+    #         participant "bravo"
+    #         participant "charly"
+    #         set :field => "__cursor_command__", value => "2"
+    #         participant "delta"
+    #         participant "echo"
+    #         skip 2
+    #         participant "fox"
+    #         #
+    #         # in that cursor example, only the participants alpha, charly and
+    #         # echo will be handed a workitem
+    #         # (notice the last 'skip' with its light syntax)
+    #         #
+    #     end
+    #
+    # As you can see, you can directly set the value of the field 
+    # '\_\_cursor_command__' or use a CursorCommandExpression like 'skip' or
+    # 'jump'.
     #
     class CursorExpression < WithTemplateExpression
 
@@ -100,22 +125,36 @@ module OpenWFE
                 return
             end
 
-            command_field = lookup_command_field(workitem)
-            command = lookup_command(command_field, workitem)
-            disallow_list = lookup_disallow(workitem)
+            command_field = lookup_command_field workitem
+
+            command, step = lookup_command command_field, workitem
+
+            disallow_list = lookup_disallow workitem
 
             command = nil \
-                if disallow_list and disallow_list.include? command
+                if disallow_list and disallow_list.include?(command)
+
+            ldebug { "reply() command is '#{command} #{step}'" }
 
             if command == C_BREAK or command == C_CANCEL
-                reply_to_parent(workitem)
+                reply_to_parent workitem
                 return
             end
 
             if command == C_REWIND or command == C_CONTINUE
+
                 @current_child_id = 0
-            else
-                step = lookup_step(command)
+
+            elsif command and command.match "^#{C_JUMP}"
+
+                @current_child_id = step
+                @current_child_id = 0 if @current_child_id < 0
+
+                @current_child_id = @children.length - 1 \
+                    if @current_child_id >= @children.length
+
+            else # C_SKIP or C_BACK
+
                 @current_child_id = @current_child_id + step
 
                 @current_child_id = 0 if @current_child_id < 0
@@ -148,87 +187,151 @@ module OpenWFE
         #
         # takes care of cancelling the current child if necessary
         #
-        def cancel ()
+        def cancel
             get_expression_pool.cancel(@current_child_fei) \
                 if @current_child_fei
-            super()
+            super
         end
 
         #
-        # returns false, the child class LoopExpression does return true.
+        # Returns false, the child class LoopExpression does return true.
         #
         def is_loop
-            return false
+            false
         end
 
         protected
 
-            def lookup_step (command)
-
-                return 1 if not command
-
-                step = 1
-
-                ss = command.split()
-
-                if ss.length > 1
-                    step = Integer(ss[1])
-                end
-
-                step = -step if OpenWFE::starts_with(command, C_BACK)
-
-                return step
-            end
-
+            #
+            # Makes sure that only flow expression are left in the cursor
+            # children list (text and comment nodes get discarded).
+            #
             def clean_children_list
 
                 c = @children
                 @children = []
                 c.each do |child|
                     @children << child \
-                        if child.kind_of? OpenWFE::FlowExpressionId
+                        if child.kind_of?(OpenWFE::FlowExpressionId)
                 end
             end
 
+            #
+            # Looks up the value in the command field.
+            #
             def lookup_command_field (workitem)
 
-                return lookup_attribute(A_COMMAND_FIELD, workitem, F_COMMAND)
+                lookup_attribute(A_COMMAND_FIELD, workitem, F_COMMAND)
             end
 
+            #
+            # Returns the command and the step
+            #
             def lookup_command (command_field, workitem)
 
                 command = workitem.attributes[command_field]
-                command = command.strip() if command
 
-                return command
+                return [ nil, 1 ] unless command
+                    #
+                    # this corresponds to the "just one step forward" default
+
+                command, step = command.strip.split
+
+                step = if step
+                    step.to_i
+                else
+                    1
+                end
+
+                step = -step if command == C_BACK
+
+                [ command, step ]
             end
 
+            #
+            # Fetches the value of the 'disallow' cursor attribute.
+            #
             def lookup_disallow (workitem)
 
-                return lookup_comma_list_attribute(A_DISALLOW, workitem)
+                lookup_comma_list_attribute(A_DISALLOW, workitem)
             end
     end
 
     #
     # The 'loop' expression is like 'cursor' but it doesn't exit until
-    # it's broken.
+    # it's broken (with 'break' or 'cancel').
     #
     class LoopExpression < CursorExpression
 
         names :loop
 
         def is_loop
-            return true
+            true
         end
     end
 
     #
-    # 'skip', 'continue', and the like
+    # This class implements the following expressions :  back, break,
+    # cancel, continue, jump, rewind, skip.
+    #
+    # They are generally used inside of a 'cursor' (CursorExpression) or 
+    # a 'loop' (LoopExpression), they can be used outside, but their result
+    # (the value of the field '\_\_cursor_command__' will be used as soon as the
+    # flow enters a cursor or a loop).
+    #
+    # In fact, this expression is only a nice wrapper that sets the
+    # value of the field "\_\_cursor_command__" to its name ('back' for example)
+    # plus to the 'step' attribute value.
+    #
+    # For example <skip step="3"/> simply sets the value of the field 
+    # '\_\_cursor_command__' to 'skip 3'.
+    #
+    # (The field \_\_cursor_command__ is, by default, read and 
+    # obeyed by the 'cursor' expression).
+    #
+    # With Ruby process definitions, you can directly write :
+    #
+    #     skip 2
+    #     jump "0"
+    #
+    # instead of 
+    #
+    #     skip :step => "2"
+    #     jump :step => "0"
+    #
+    # Likewise, in an XML process definition, you can write
+    #
+    #     <skip>2</skip>
+    #
+    # although that might still look lighter (it's longer though) :
+    #
+    #     <skip step="2"/>
+    #
+    #
+    # About the command themselves :
+    #
+    # * back : will go back from the number of given steps, 1 by default
+    # * break : will exit the cursor (or the loop)
+    # * cancel : an alias for 'break'
+    # * continue : will exit the cursor, if in a loop, will get back at step 0
+    # * jump : will move the cursor (or loop) to an absolute given position (count starts at 0)
+    # * rewind : an alias for continue
+    # * skip : skips the given number of steps
+    #
+    #
+    # All those command support an 'if' attribute to restrict their execution :
+    #
+    #     cursor do
+    #         go_to_shop
+    #         check_prices
+    #         _break :if => "${price} > ${f:current_cash}"
+    #         buy_stuff
+    #     end
     #
     class CursorCommandExpression < FlowExpression
         include ConditionMixin
 
-        names :back, :skip, :continue, :break, :cancel, :rewind
+        names :back, :skip, :continue, :break, :cancel, :rewind, :jump
 
         def apply (workitem)
 
@@ -240,15 +343,17 @@ module OpenWFE
 
                 command = @fei.expression_name
 
-                step = lookup_attribute(A_STEP, workitem, "1")
+                step = lookup_attribute(A_STEP, workitem)
+                step = fetch_text_content(workitem) unless step
+                step = 1 unless step
                 step = Integer(step)
 
-                command = "#{command} #{step}" if step != 1
+                command = "#{command} #{step}" #if step != 1
 
                 workitem.attributes[F_COMMAND] = command
             end
 
-            reply_to_parent(workitem)
+            reply_to_parent workitem
         end
     end