ruote 2.2.0 → 2.3.0

data/lib/ruote/exp/iterator.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2012, 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
@@ -42,7 +42,7 @@ module Ruote::Exp
 
       if count = attribute(:times) || attribute(:branches)
 
-        list = ((1..count.to_i).to_a rescue nil)
+        list = ((0...count.to_i).to_a rescue nil)
 
         if list
           h.times_iterator = true

data/lib/ruote/exp/merge.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2012, 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
@@ -30,43 +30,104 @@ module Ruote::Exp
   #
   module MergeMixin
 
+    # Given a list of workitems and a merge_type, will merge according to
+    # the merge type.
     #
+    # The return value is the merged workitem.
+    #
+    def merge_workitems(workitems, merge_type)
+
+      workitems.inject(nil) do |t, wi|
+        merge_workitem(workitems.index(wi), t, wi, merge_type)
+      end
+    end
+
     # Merge workitem 'source' into workitem 'target'.
     #
     # If type is 'override', the source will prevail and be returned.
     #
-    # If type is 'mix', the source fields will be merge into the target fields.
+    # If type is 'mix', the source fields will be merged into the target fields.
     #
     # If type is 'isolate', the source fields will be placed in a separte field
     # in the target workitem. The name of this field is the child_id of the
     # source workitem (a string from '0' to '99999' and beyond)
     #
-    def merge_workitems(index, target, source, type)
+    # The 'concat' type merges hashes and concats arrays. The 'union' type
+    # behaves much like 'concat', but it makes sure to remove duplicates.
+    #
+    # Warning: 'union' will remove duplicates that were present _before_ the
+    # merge.
+    #
+    def merge_workitem(index, target, source, merge_type)
 
-      return source if type == 'override'
+      return source if merge_type == 'override'
 
       if target == nil
-        case type
+
+        case merge_type
+
+          #when 'mix'
+             # do nothing
+
+          when 'stack'
+            source['fields'] = { 'stack' => [ source['fields'] ] }
+
           when 'isolate'
             source['fields'] = { index.to_s => source['fields'] }
+
+          #when 'union', 'concat'
+             # do nothing
+        end
+
+        source
+
+      else
+
+        case merge_type
+
+          when 'mix'
+
+            target['fields'].merge!(source['fields'])
+
           when 'stack'
-            source['fields'] = { 'stack' => [ source['fields'] ] }
+
+            target['fields']['stack'] << source['fields']
+            target['fields']['stack_attributes'] = compile_atts
+
+          when 'isolate'
+
+            target['fields'][index.to_s] = source['fields']
+
+          when 'union', 'concat', 'deep'
+
+            source['fields'].each do |k, sv|
+
+              tv = target['fields'][k]
+
+              if sv.is_a?(Array) and tv.is_a?(Array)
+                tv.concat(sv)
+                tv.uniq! if merge_type == 'union'
+              elsif sv.is_a?(Hash) and tv.is_a?(Hash)
+                merge_type == 'deep' ? deep_merge!(tv, sv) : tv.merge!(sv)
+              else
+                target['fields'][k] = sv
+              end
+            end
         end
+
+        target
       end
+    end
 
-      return source unless target
+    protected
 
-      case type
-        when 'mix'
-          target['fields'].merge!(source['fields'])
-        when 'stack'
-          target['fields']['stack'] << source['fields']
-          target['fields']['stack_attributes'] = expand_atts
-        else # 'isolate'
-          target['fields'][index.to_s] = source['fields']
-      end
+    # Inspired by the one found in ActiveSupport, though not strictly equivalent.
+    #
+    def deep_merge!(target, source)
 
-      target
+      target.merge!(source) do |k, o, n|
+        o.is_a?(Hash) && n.is_a?(Hash) ? deep_merge!(o, n) : n
+      end
     end
   end
 end

data/lib/ruote/exp/ro_attributes.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2012, 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
@@ -60,7 +60,7 @@ module Ruote::Exp
       elsif escape
         v
       else
-        @context.dollar_sub.s(v, self, workitem)
+        dsub(v, workitem)
       end
 
       v = v.to_s if v and string
@@ -72,19 +72,11 @@ module Ruote::Exp
     # in the array list 'values'. If not, the default value is returned.
     # By default, the default value is the first element of 'values'.
     #
-    def att(key, values, opts={})
+    def att(keys, values, opts={})
 
       default = opts[:default] || values.first
 
-      val = attribute(key)
-      val = val.to_s if val
-
-      #raise(
-      #  ArgumentError.new("attribute '#{key}' missing in #{tree}")
-      #) if opts[:mandatory] && val == nil
-      #raise(
-      #  ArgumentError.new("attribute '#{key}' has invalid value in #{tree}")
-      #) if opts[:enforce] && (not values.include?(val))
+      val = Array(keys).collect { |key| attribute(key) }.compact.first.to_s
 
       values.include?(val) ? val : default
     end
@@ -115,24 +107,8 @@ module Ruote::Exp
     #
     def compile_atts(opts={})
 
-      attributes.keys.inject({}) { |r, k|
-        r[k] = attribute(k, h.applied_workitem, opts)
-        r
-      }
-    end
-
-    # Like compile_atts, but the keys are expanded as well.
-    #
-    # Useful for things like
-    #
-    #   set "f:${v:field_name}" => "${v:that_variable}"
-    #
-    def expand_atts(opts={})
-
-      attributes.keys.inject({}) { |r, k|
-        kk = @context.dollar_sub.s(k, self, h.applied_workitem)
-        r[kk] = attribute(k, h.applied_workitem, opts)
-        r
+      attributes.keys.each_with_object({}) { |k, r|
+        r[dsub(k)] = attribute(k, h.applied_workitem, opts)
       }
     end
 
@@ -154,15 +130,51 @@ module Ruote::Exp
 
       text = attributes.keys.find { |k| attributes[k] == nil }
 
-      @context.dollar_sub.s(text.to_s, self, workitem)
+      dsub(text.to_s, workitem)
+    end
+
+    # Equivalent to #attribute_text, but will return nil if there
+    # is no attribute whose values is nil.
+    #
+    def att_text(workitem=h.applied_workitem)
+
+      text = attributes.keys.find { |k| attributes[k] == nil }
+
+      text ? dsub(text.to_s, workitem) : nil
     end
 
     protected
 
+    # dollar substitution for expressions.
+    #
+    def dsub(o, wi=h.applied_workitem)
+
+      case o
+        when String; @context.dollar_sub.s(o, self, wi)
+        when Array; o.collect { |e| dsub(e, wi) }
+        when Hash; o.remap { |(k, v), h| h[dsub(k, wi)] = dsub(v, wi) }
+        else o
+      end
+    end
+
+    # 'tos' meaning 'many "to"'
+    #
     def determine_tos
 
-      [ attribute(:to_v) || attribute(:to_var) || attribute(:to_variable),
-        attribute(:to_f) || attribute(:to_fld) || attribute(:to_field) ]
+      to_v = attribute(:to_v) || attribute(:to_var) || attribute(:to_variable)
+      to_f = attribute(:to_f) || attribute(:to_fld) || attribute(:to_field)
+
+      if to = attribute(:to)
+        pre, key = to.split(':')
+        pre, key = [ 'f', pre ] if key == nil
+        if pre.match(/^f/)
+          to_f = key
+        else
+          to_v = key
+        end
+      end
+
+      [ to_v, to_f ]
     end
 
     # Val and Value (Sense and Sensibility ?)
@@ -188,9 +200,7 @@ module Ruote::Exp
       elsif k = has_att(*flds)
 
         k = attribute(k, h.applied_workitem, att_options)
-        h.applied_workitem['fields'][k]
-
-        # TODO : what about leveraging workitem#lookup ?
+        Ruote.lookup(h.applied_workitem['fields'], k)
 
       else
 

data/lib/ruote/exp/ro_filters.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2012, 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
@@ -76,7 +76,13 @@ module Ruote::Exp
 
         workitem['fields'] =
           Ruote.filter(
-            filter, workitem['fields'], :double_tilde => h.fields_pre_filter)
+            filter,
+            workitem['fields'],
+            :double_tilde =>
+              h.fields_pre_filter || h.applied_workitem['fields'])
+
+        workitem['fields'].delete('params')
+          # take and discard tend to copy it over, so let's remove it
       end
     end
 
@@ -85,21 +91,41 @@ module Ruote::Exp
     #
     # Returns nil, if there is no filter. Raises an ArgumentError if the
     # filter is not usable. Returns the instantiated participant if the
-    # filter points to one.
+    # filter points to a participant filter.
     #
     def lookup_filter(workitem)
 
       f = attribute(:filter)
 
+      if f.nil? and workitem
+
+        reply = if t = attribute(:take)
+          Array(t).collect { |tt| { 'field' => tt, 'take' => true } }
+        elsif d = attribute(:discard)
+          if d == true
+            [ { 'field' => /.+/, 'discard' => 'all' } ]
+          else
+            Array(d).collect { |dd| { 'field' => dd, 'discard' => true } }
+          end
+        else
+          nil
+        end
+
+        f = { 'reply' => reply } if reply
+      end
+
       return nil unless f
+        # no filter
 
-      3.times { f = narrow_filter(f, workitem) }
+      if f.is_a?(Hash)
+        f['in'] = [] unless f['in'] or f['apply']
+        f['out'] = [] unless f['out'] or f['reply']
+      end
+        # empty ins and outs for a sucessful narrowing
 
-      raise ArgumentError.new(
-        "found no filter corresponding to '#{f}'"
-      ) unless f
+      3.times { f = narrow_filter(f, workitem) }
 
-      f
+      f or raise ArgumentError.new("found no filter corresponding to '#{f}'")
     end
 
     # Called successively to dig for the filter (Array or Participant).

data/lib/ruote/exp/ro_on_x.rb

@@ -0,0 +1,431 @@
+#--
+# Copyright (c) 2005-2012, 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
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+module Ruote::Exp
+
+  #
+  # 're-opening' the FlowExpression class to add methods and classes about
+  # on_error, on_cancel, on_timeout, ...
+  #
+  class FlowExpression
+
+    # Given this expression and an error, deflates the error into a hash
+    # (serializable).
+    #
+    def deflate(err)
+
+      {
+        'fei' => h.fei,
+        'at' => Ruote.now_to_utc_s,
+        'class' => err.class.to_s,
+        'message' => err.message,
+        'trace' => err.backtrace,
+        'details' => err.respond_to?(:ruote_details) ? err.ruote_details : nil,
+        'deviations' => err.respond_to?(:deviations) ? err.deviations : nil,
+        'tree' => tree
+      }
+    end
+
+    # Returns a dummy expression. Only used by the error_handler service.
+    #
+    def self.dummy(h)
+
+      class << h; include Ruote::HashDot; end
+
+      fe = self.allocate
+      fe.instance_variable_set(:@h, h)
+
+      fe
+    end
+
+    # Looks up parent with on_error attribute and triggers it
+    #
+    def handle_on_error(msg, error)
+
+      return false if h.state == 'failing'
+
+      err = deflate(error)
+      oe_parent = lookup_on_error(err)
+
+      return false unless oe_parent
+        # no parent with on_error attribute found
+
+      handler = oe_parent.local_on_error(err)
+
+      return false if handler.to_s == ''
+        # empty on_error handler nullifies ancestor's on_error
+
+      workitem = msg['workitem']
+      workitem['fields']['__error__'] = err
+
+      immediate = if handler.is_a?(String)
+        !! handler.match(/^!/)
+      elsif handler.is_a?(Array)
+        !! handler.first.to_s.match(/^!/)
+      else
+        false
+      end
+
+      # NOTE: why not pass the handler in the msg?
+      #       no, because of HandlerEntry (not JSON serializable)
+
+      @context.storage.put_msg(
+        'fail',
+        'fei' => oe_parent.h.fei,
+        'workitem' => workitem,
+        'immediate' => immediate)
+
+      true # yes, error is being handled.
+    end
+
+    protected
+
+    #
+    # Used by on_error when patterns are involved. Gathers much of the
+    # pattern logic...
+    #
+    class HandlerEntry
+
+      attr_reader :pattern, :action, :child_id
+
+      def initialize(on_error_entry)
+
+        if on_error_entry.is_a?(Hash)
+          on_error_entry = on_error_entry.to_a.flatten
+        end
+
+        @pattern, @action, @child_id = on_error_entry
+        @pat = Ruote.regex_or_s(@pattern) || //
+      end
+
+      def split(pat)
+
+        @action.split(pat)
+      end
+
+      def match(regex_or_err)
+
+        if regex_or_err.is_a?(Regexp)
+          @action.match(regex_or_err)
+        else
+          @pat.match(regex_or_err['message']) ||
+          @pat.match(regex_or_err['class'])
+        end
+      end
+
+      def narrow
+
+        @action.is_a?(Array) ? @action : self
+      end
+
+      def update_tree(tree, retries)
+
+        child = tree[2][@child_id]
+
+        if @pattern
+          if retries.empty?
+            child[1].delete(@pattern)
+          else
+            child[1][@pattern] = retries.join(', ')
+          end
+        else
+          key, _ = child[1].find { |k, v| v.nil? }
+          child[1].delete(key)
+          child[1][retries.join(', ')] = nil if retries.any?
+        end
+      end
+    end
+
+    # Given an error, returns the on_error registered for it, or nil if none.
+    #
+    def local_on_error(err)
+
+      if h.on_error.is_a?(String) or Ruote.is_tree?(h.on_error)
+
+        return h.on_error
+      end
+
+      if h.on_error.is_a?(Array)
+
+        # all for the 'on_error' expression
+        # see test/functional/eft_38_
+
+        h.on_error.each do |oe|
+
+          if (he = HandlerEntry.new(oe)).match(err)
+            return he.narrow
+          end
+        end
+      end
+
+      nil
+    end
+
+    # Looks up "on_error" attribute locally and in the parent expressions,
+    # if any.
+    #
+    def lookup_on_error(err)
+
+      if local_on_error(err)
+        return self
+      end
+      if par = parent
+        return par.lookup_on_error(err)
+      end
+
+      nil
+    end
+
+    # Called by #trigger when it encounters something like
+    #
+    #   :on_error => '5m: retry, pass'
+    #
+    def schedule_retries(handler, err)
+
+      retries = handler.split(/\s*,\s*/)
+      after, action = retries.shift.split(/:/)
+
+      # deal with "* 3"
+
+      if m = action.match(/^ *([^ ]+) *\* *(\d+)$/)
+
+        count = m[2].to_i - 1
+
+        if count == 1
+          retries.unshift("#{after}: #{m[1]}")
+        elsif count > 1
+          retries.unshift("#{after}: #{m[1]} * #{count}")
+        end
+      end
+
+      # rewrite tree to remove current retry
+
+      t = Ruote.fulldup(tree)
+
+      if h.on_error.is_a?(Array)
+        handler.update_tree(t, retries)
+      else
+        if retries.empty?
+          t[1].delete('on_error')
+        else
+          t[1]['on_error'] = retries.join(', ')
+        end
+      end
+
+      update_tree(t)
+
+      # schedule current retry
+
+      after = after.strip
+      action = action.strip
+
+      msg = {
+        'action' => 'cancel',
+        'fei' => h.fei,
+        'flavour' => 'retry',
+        're_apply' => true }
+
+      (h.timers ||= []) <<
+        [ @context.storage.put_schedule('at', h.fei, after, msg), 'retry' ]
+
+      # over
+
+      persist_or_raise
+
+    rescue => e
+
+      raise Ruote::MetaError.new(__method__.to_s, e)
+    end
+
+    # 'on_{error|timeout|cancel|re_apply}' triggering
+    #
+    def trigger(on, workitem)
+
+      tree = tree()
+      err = h.applied_workitem['fields']['__error__']
+
+      handler = on == 'on_error' ? local_on_error(err) : h[on]
+
+      if on == 'on_error' && handler.to_s.match(/^!(.+)$/)
+        handler = $1
+      end
+
+      if handler.is_a?(Hash) # on_re_apply
+
+        wi = handler['workitem']
+        fi = handler['fields']
+        me = handler['merge_in_fields']
+
+        workitem = if wi == 'applied' || me
+          h.applied_workitem
+        elsif wi
+          wi
+        else
+          workitem
+        end
+
+        workitem['fields'] = fi if fi
+        workitem['fields'].merge!(me) if me
+      end
+
+      if h.trigger && t = workitem['fields']["__#{h.trigger}__"]
+        #
+        # the "second take"...
+
+        handler = t
+        tree = h.supplanted['original_tree']
+        workitem = h.supplanted['applied_workitem']
+      end
+
+      if on == 'on_error' && handler.respond_to?(:match) && handler.match(/:/)
+        return schedule_retries(handler, err)
+      end
+
+      new_tree = case handler
+        when Hash then handler['tree']
+        when Array then handler
+        when HandlerEntry then [ handler.action, {}, [] ]
+        else [ handler.to_s, {}, [] ]
+      end
+
+      handler = handler.action if handler.is_a?(HandlerEntry)
+      handler = handler.strip if handler.respond_to?(:strip)
+
+      if handler =~ /^can(cel|do)$/ && (on == 'on_cancel' || h.on_cancel == nil)
+        handler = handler == 'cancel' ? 'undo' : 'redo'
+      end
+
+      h.on_reply = nil if on == 'on_reply'
+        # preventing cascades
+
+      case handler
+
+        when 'redo', 'retry'
+          #
+          # retry with the same tree as before
+
+          new_tree = tree
+
+        when 'undo', 'pass', ''
+          #
+          # let's forget it
+
+          h.state = on == 'on_cancel' ? 'cancelled' : 'failed'
+
+          reply_to_parent(workitem); return
+
+        when 'cancel'
+          #
+          # let's trigger on the on_cancel
+
+          trigger('on_cancel', workitem); return
+
+        when 'cando'
+          #
+          # trigger on_cancel, then redo
+
+          h.on_reply = tree
+
+          trigger('on_cancel', workitem); return
+
+        when 'raise'
+          #
+          # re-raise
+
+          raise Ruote.constantize(err['class']), err['message'], err['trace']
+
+        when CommandExpression::REGEXP
+          #
+          # a command like 'jump to shark'...
+
+          hh = handler.split(' ')
+          command = hh.first
+          step = hh.last
+
+          h.state = nil
+          workitem['fields'][CommandMixin::F_COMMAND] = [ command, step ]
+
+          reply(workitem); return
+
+        #else
+        #
+        #  if h.trigger
+        #    #
+        #    # do not accept participant or subprocess names
+        #    # for "second trigger"
+        #
+        #    h.state = 'failed'
+        #    reply_to_parent(workitem)
+        #    return
+        #  end
+          #
+          # actually, let's not care about that, let's trust people.
+      end
+
+      workitem = h.applied_workitem if on == 'on_error'
+
+      #
+      # supplant this expression with new tree
+
+      r = try_unpersist
+
+      raise(
+        "failed to remove exp to supplant " +
+        "#{Ruote.to_storage_id(h.fei)} #{tree.first}"
+      ) if r.respond_to?(:keys)
+
+      if new_tree[0].match(/^!(.+)$/); new_tree[0] = $1; end
+      new_tree[1]['_triggered'] = on
+
+      attributes.each { |k, v|
+        new_tree[1][k] = v if (k.match(/^on_/) && k != on) || k == 'tag'
+      }
+        #
+        # let the triggered tree have the same on_ attributes as the original
+        # expression, so that on_cancel/on_error/on_x effects still apply
+        #
+        # 'tag' is copied as well. (so that 'left_tag' is emitted too)
+        #
+        # Should 'timeout', should other common attributes be copied as well?
+
+      @context.storage.put_msg(
+        'apply',
+        { 'fei' => h.fei,
+          'parent_id' => h.parent_id,
+          'tree' => new_tree,
+          'workitem' => workitem,
+          'variables' => h.variables,
+          'trigger' => on,
+          'on_reply' => h.on_reply,
+          'supplanted' => {
+            'tree' => tree,
+            'original_tree' => original_tree,
+            'applied_workitem' => h.applied_workitem,
+            'variables' => h.variables
+          }})
+    end
+  end
+end
+