ruote 2.3.0.1 → 2.3.0.2

data/lib/ruote/exp/fe_cancel_process.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2012, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2013, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal

data/lib/ruote/exp/fe_command.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2012, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2013, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -114,9 +114,8 @@ module Ruote::Exp
 
         fei = lookup_variable(ref)
 
-        target = Ruote::FlowExpressionId.is_a_fei?(fei) ?
+        target = Ruote.is_a_fei?(fei) ?
           Ruote::Exp::FlowExpression.fetch(@context, fei) : nil
-
         target = target.is_a?(Ruote::Exp::CommandedExpression) ?
           target : nil
 

data/lib/ruote/exp/fe_concurrence.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2012, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2013, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -22,8 +22,7 @@
 # Made in Japan.
 #++
 
-
-require 'ruote/exp/merge'
+require 'ruote/merge'
 
 
 module Ruote::Exp
@@ -94,6 +93,25 @@ module Ruote::Exp
   #
   # :wait_for can be shortened to :wf.
   #
+  #
+  # === :over_if (and :over_unless) attribute
+  #
+  # Like the :count attribute controls how many branches have to reply before
+  # a concurrence ends, the :over attribute is used to specify a condition
+  # upon which the concurrence will [prematurely] end.
+  #
+  #   concurrence :over_if => '${f:over}'
+  #     alpha
+  #     bravo
+  #     charly
+  #   end
+  #
+  # will end the concurrence as soon as one of the branches replies with a
+  # workitem whose field 'over' is set to true. (the remaining branches will
+  # get cancelled unless :remaining => :forget is set).
+  #
+  # :over_unless needs no explanation.
+  #
   # === :remaining
   #
   # As said for :count, the remaining branches get cancelled. By setting
@@ -152,23 +170,23 @@ module Ruote::Exp
   #
   # === :merge_type
   #
-  # ==== :override
+  # ==== :merge_type => :override (default)
   #
   # By default, the merge type is set to 'override', which means that the
   # 'winning' workitem's payload supplants all other workitems' payloads.
   #
-  # ==== :mix
+  # ==== :merge_type => :mix
   #
   # Setting :merge_type to :mix, will actually attempt to merge field by field,
   # making sure that the field value of the winner(s) are used.
   #
-  # ==== :isolate
+  # ==== :merge_type => :isolate
   #
   # :isolate will rearrange the resulting workitem payload so that there is
   # a new field for each branch. The name of each field is the index of the
   # branch from '0' to ...
   #
-  # ==== :stack
+  # ==== :merge_type => :stack
   #
   # :stack will stack the workitems coming back from the concurrence branches
   # in an array whose order is determined by the :merge attributes. The array
@@ -194,7 +212,7 @@ module Ruote::Exp
   # This could prove useful for participant having to deal with multiple merge
   # strategy results.
   #
-  # ==== :union
+  # ==== :merge_type => :union
   #
   # (Available from ruote 2.3.0)
   #
@@ -214,7 +232,7 @@ module Ruote::Exp
   # Warning: duplicates in arrays present _before_ the merge will be removed
   # as well.
   #
-  # ==== :concat
+  # ==== :merge_type => :concat
   #
   # (Available from ruote 2.3.0)
   #
@@ -229,14 +247,14 @@ module Ruote::Exp
   #     'b' => [ 'x', 'y', 'y', 'z' ],
   #     'c' => { 'aa' => 'bb', 'cc' => 'dd' } }
   #
-  # ==== :deep
+  # ==== :merge_type => :deep
   #
   # (Available from ruote 2.3.0)
   #
   # Identical to :concat but hashes are merged with deep_merge (ActiveSupport
   # flavour).
   #
-  # ==== :ignore
+  # ==== :merge_type => :ignore
   #
   # (Available from ruote 2.3.0)
   #
@@ -246,33 +264,20 @@ module Ruote::Exp
   #
   # :merge_type can be shortened to :mt.
   #
-  #
-  # === :over_if (and :over_unless) attribute
-  #
-  # Like the :count attribute controls how many branches have to reply before
-  # a concurrence ends, the :over attribute is used to specify a condition
-  # upon which the concurrence will [prematurely] end.
-  #
-  #   concurrence :over_if => '${f:over}'
-  #     alpha
-  #     bravo
-  #     charly
-  #   end
-  #
-  # will end the concurrence as soon as one of the branches replies with a
-  # workitem whose field 'over' is set to true. (the remaining branches will
-  # get cancelled unless :remaining => :forget is set).
-  #
-  # :over_unless needs no explanation.
-  #
   class ConcurrenceExpression < FlowExpression
 
-    include MergeMixin
-
     names :concurrence
 
     COUNT_R = /^-?\d+$/
 
+    # This method is used by some walking routines when analyzsing
+    # execution trees. Returns true for concurrence (and concurrent iterator).
+    #
+    def is_concurrent?
+
+      true
+    end
+
     def apply
 
       return do_reply_to_parent(h.applied_workitem) if tree_children.empty?
@@ -304,7 +309,14 @@ module Ruote::Exp
         [ :remaining, :rem, :r ],
         %w[ cancel forget wait ])
 
-      h.workitems = (h.cmerge == 'first' || h.cmerge == 'last') ? [] : {}
+      #h.workitems = (h.cmerge == 'first' || h.cmerge == 'last') ? [] : {}
+        #
+        # now merging iteratively, not keeping track of all the workitems,
+        # but still able to deal with old flows with active h.workitems
+        #
+      h.workitems = [] if %w[ highest lowest ].include?(h.cmerge)
+        #
+        # still need to keep track of rank to get the right merging
 
       h.over = false
 
@@ -325,12 +337,6 @@ module Ruote::Exp
         # a copy of the workitem (so that history, coming afterwards,
         # doesn't see a modified version of the workitem)
 
-      if h.cmerge == 'first' || h.cmerge == 'last'
-        h.workitems << workitem
-      else
-        h.workitems[workitem['fei']['expid']] = workitem
-      end
-
       if h.wait_for && tag = workitem['fields']['__left_tag__']
         h.wait_for.delete(tag)
       end
@@ -338,7 +344,11 @@ module Ruote::Exp
       over = h.over
       h.over = over || over?(workitem)
 
+      keep(workitem)
+        # is done after the over? determination for its looks at 'winner'
+
       if (not over) && h.over
+        #
         # just became 'over'
 
         reply_to_parent(nil)
@@ -362,6 +372,42 @@ module Ruote::Exp
 
     protected
 
+    def keep(workitem)
+
+      h.workitems = h.workitems.values if h.workitems.is_a?(Hash)
+        # align legacy expressions on new simplified way
+
+      if h.workitems
+        #
+        # the old way (still used for highest / lowest)
+
+        h.workitems << workitem
+        return
+      end
+
+      #
+      # the new way, merging immediately
+
+      h.workitem_count = (h.workitem_count || 0) + 1
+
+      return if h.cmerge_type == 'ignore'
+
+      # preparing target and source in the right order for merging
+
+      target, source = h.workitem, workitem
+      if
+        h.cmerge == 'first' &&
+        ! %w[ stack union concat deep isolate ].include?(h.cmerge_type)
+      then
+        target, source = source, target
+      end
+      target, source = source, target if target && target.delete('winner')
+      target, source = source, target if source == nil
+
+      h.workitem = Ruote.merge_workitem(
+        workitem_index(workitem), target, source, h.cmerge_type)
+    end
+
     def apply_children
 
       # a) register children
@@ -393,7 +439,8 @@ module Ruote::Exp
       elsif h.wait_for
         h.wait_for.empty?
       else
-        (h.workitems.size >= expected_count)
+        (workitem_count + 1 >= expected_count)
+          # the + 1 is necessary since #keep hasn't yet been called
       end
     end
 
@@ -425,13 +472,13 @@ module Ruote::Exp
 
       if h.remaining == 'wait'
 
-        if h.workitems.size >= count_list_size
+        if workitem_count >= count_list_size
           #
           # all children have replied
 
-          workitem = merge_all_workitems
+          h.workitem = final_merge
 
-          do_unpersist && super(workitem, false)
+          do_unpersist && super(h.workitem, false)
 
         elsif h.children_cancelled == nil
           #
@@ -450,17 +497,17 @@ module Ruote::Exp
       #
       # remaining 'forget' and 'cancel' cases
 
-      workitem = merge_all_workitems
+      h.workitem = final_merge
 
       if h.children.empty?
 
-        do_unpersist && super(workitem, false)
+        do_unpersist && super(h.workitem, false)
 
       elsif h.remaining == 'cancel'
 
         if do_unpersist
 
-          super(workitem, false)
+          super(h.workitem, false)
 
           h.children.each { |i| @context.storage.put_msg('cancel', 'fei' => i) }
         end
@@ -470,35 +517,84 @@ module Ruote::Exp
         h.variables = compile_variables
         h.forgotten = true
 
-        do_persist && super(workitem, false)
+        do_persist && super(h.workitem, false)
       end
     end
 
     # Called by #reply_to_parent, returns the unique, merged, workitem that
     # will be fed back to the parent expression.
     #
-    def merge_all_workitems
-
-      return h.applied_workitem if h.workitems.size < 1
-      return h.applied_workitem if h.cmerge_type == 'ignore'
-
-      wis = case h.cmerge
-        when 'first'
-          h.workitems.reverse
-        when 'last'
-          h.workitems
-        when 'highest', 'lowest'
-          is = h.workitems.keys.sort.collect { |k| h.workitems[k] }
-          h.cmerge == 'highest' ? is.reverse : is
+    def final_merge
+
+      wi = if h.workitem
+
+        h.workitem
+
+      elsif h.cmerge_type == 'ignore' || h.workitems.nil? || h.workitems.empty?
+
+        h.applied_workitem
+
+      else
+
+        wis = h.workitems
+
+        if %w[ highest lowest ].include?(h.cmerge)
+          wis = h.workitems.sort_by { |wi| wi['fei']['expid'] }
+        end
+
+        if
+          %w[ first highest ].include?(h.cmerge) &&
+          ! %w[ stack union concat deep ].include?(h.cmerge_type)
+        then
+          wis = wis.reverse
+        end
+
+        as, bs = wis.partition { |wi| wi.delete('winner') }
+        wis = bs + as
+          #
+          # the 'winner' is the workitem that triggered successfully the
+          # :over_if or :over_unless, let's take him precedence in the merge...
+
+        merge_workitems(wis, h.cmerge_type)
       end
 
-      as, bs = wis.partition { |wi| wi.delete('winner') }
-      wis = bs + as
-        #
-        # the 'winner' is the workitem that triggered successfully the
-        # :over_if or :over_unless, let's take him precedence in the merge...
+      if h.cmerge_type == 'stack'
+        wi['fields']['stack_attributes'] = compile_atts
+      end
+
+      wi
+    end
+
+    # Returns the current count of workitem replies.
+    #
+    def workitem_count
 
-      merge_workitems(wis, h.cmerge_type)
+      h.workitems ? h.workitems.size : (h.workitem_count || 0)
+    end
+
+    # Given a workitem, returns its index (highest to lowest in the tree
+    # children... z-index?).
+    #
+    # Is overriden by the concurrent-iterator.
+    #
+    def workitem_index(workitem)
+
+      Ruote.extract_child_id(workitem['fei'])
+    end
+
+    # Given a list of workitems and a merge_type, will merge according to
+    # the merge type.
+    #
+    # The return value is the merged workitem.
+    #
+    # (Still used when dealing with highest/lowest merge_type and legacy
+    # concurrence/citerator expressions)
+    #
+    def merge_workitems(workitems, merge_type)
+
+      workitems.inject(nil) do |t, wi|
+        Ruote.merge_workitem(workitem_index(wi), t, wi, merge_type)
+      end
     end
   end
 end

data/lib/ruote/exp/fe_concurrent_iterator.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2012, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2013, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -150,8 +150,8 @@ module Ruote::Exp
   # the concurrent_iterator accepts the same options for merging as its bigger
   # brother, the concurrence expression.
   #
-  # :count, :merge (override, mix, isolate), remaining (cancel, forget) and
-  # :over.
+  # :count, :merge (override, mix, isolate, stack, union, concat, deep, ignore),
+  # :remaining (cancel, forget) and :over.
   #
   #
   # == add branches
@@ -228,7 +228,11 @@ module Ruote::Exp
         end
 
         launch_sub(
-          expid, subtree, :workitem => workitem, :variables => variables)
+          expid,
+          subtree,
+          :workitem => workitem,
+          :variables => variables,
+          :child_id => h.list_size - 1)
       end
     end
 
@@ -238,9 +242,10 @@ module Ruote::Exp
 
         add_branches(ab)
 
-        if h.fei['wfid'] != workitem['fei']['wfid'] ||
-           ( ! workitem['fei']['expid'].match(/^#{h.fei['expid']}_\d+$/))
-
+        if
+          h.fei['wfid'] != workitem['fei']['wfid'] ||
+          ( ! workitem['fei']['expid'].match(/^#{h.fei['expid']}_\d+$/))
+        then
           do_persist
           return
         end
@@ -275,6 +280,19 @@ module Ruote::Exp
 
       h.list_size
     end
+
+    # TODO
+    #
+    def workitem_index(workitem)
+
+      if %w[ highest lowest ].include?(h.cmerge)
+        nil
+      elsif m = workitem['fei']['subid'].match(/k(\d)+$/)
+        m[1].to_i
+      else
+        nil
+      end
+    end
   end
 end