ruote 2.2.0 → 2.3.0

data/lib/ruote/svc/dollar_sub.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
@@ -25,7 +25,6 @@
 
 require 'rufus/dollar' # gem 'rufus-dollar'
 require 'ruote/svc/treechecker'
-require 'ruote/util/lookup'
 
 
 module Ruote
@@ -65,10 +64,8 @@ module Ruote
 
       elsif text.is_a?(Hash)
 
-        text.inject({}) { |h, (k, v)|
-
+        text.remap { |(k, v), h|
           h[s(k, flow_expression, workitem)] = s(v, flow_expression, workitem)
-          h
         }
 
       else
@@ -90,7 +87,7 @@ module Ruote
 
     # If the final text is of the form "$f:x" or "$v:y" will lookup the
     # x field or the y variable. If the lookup is successful (not nil) will
-    # return the, not the text.
+    # return the value, not the text (the value.to_s).
     #
     def literal_sub(s, fexp, wi)
 
@@ -123,9 +120,9 @@ module Ruote
       attr_reader :fexp
       attr_reader :workitem
 
-      def initialize(flowexpression, workitem)
+      def initialize(flow_expression, workitem)
 
-        @fexp = flowexpression
+        @fexp = flow_expression
         @workitem = workitem
       end
 
@@ -137,6 +134,11 @@ module Ruote
         return @fexp.fei.subid if key == 'sub_wfid' # deprecated in 2.1.12
         return @fexp.fei.expid if key == 'expid'
         return @fexp.fei.engine_id if key == 'engine_id'
+        return @fexp.fei.mnemo_id if key == 'mnemo_id'
+
+        return @workitem['fields']['__tags__'] if key == 'tags'
+        return (@workitem['fields']['__tags__'] || []).last if key == 'tag'
+        return (@workitem['fields']['__tags__'] || []).join('/') if key == 'full_tag'
 
         pr, k = extract_prefix(key)
 

data/lib/ruote/svc/error_handler.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
@@ -26,7 +26,21 @@
 module Ruote
 
   #
-  # A ruote service for turning exceptions into process errors (or letting
+  # For errors occuring when handling errors.
+  #
+  class MetaError < StandardError
+
+    attr_reader :error
+
+    def initialize(message, error)
+
+      super("#{message}: #{error.to_s}")
+      @error = error
+    end
+  end
+
+  #
+  # A ruote service for turning errors into process errors (or letting
   # those error fire any potential :on_error attributes in the process
   # definition).
   #
@@ -42,18 +56,36 @@ module Ruote
 
     # As used by the dispatch pool and the worker.
     #
-    def msg_handle(msg, exception)
+    def msg_handle(msg, err)
 
       fexp = Ruote::Exp::FlowExpression.fetch(
         @context, msg['fei'] || msg['workitem']['fei']
       ) rescue nil
 
-      handle(msg, fexp, exception)
+      handle(msg, fexp, err)
+    end
+
+    # Packages the error in a 'raise' msg and places it in the storage,
+    # for a worker to pick it up.
+    #
+    def msg_raise(msg, err)
+
+      fei = msg['fei']
+      wfid = msg['wfid'] || msg.fetch('fei', {})['wfid']
+
+      @context.storage.put_msg(
+        'raise',
+        'fei' => fei,
+        'wfid' => wfid,
+        'msg' => msg,
+        'error' => deflate(err, fei))
     end
 
     # As used by some receivers (see ruote-beanstalk's receiver).
     #
-    def action_handle(action, fei, exception)
+    # TODO: at some point, merge that with #msg_raise
+    #
+    def action_handle(action, fei, err)
 
       fexp = Ruote::Exp::FlowExpression.fetch(@context, fei)
 
@@ -61,74 +93,98 @@ module Ruote
         'action' => action,
         'fei' => fei,
         'participant_name' => fexp.h.participant_name,
-        'workitem' => fexp.h.applied_workitem }
+        'workitem' => fexp.h.applied_workitem,
+        'put_at' => Ruote.now_to_utc_s }
 
-      handle(msg, fexp, exception)
+      handle(msg, fexp, err)
     end
 
     protected
 
-    # As used by the worker.
+    # Called by msg_handle or action_handle.
     #
-    def handle(msg, fexp, exception)
+    def handle(msg, fexp, err)
 
-      wfid = msg['wfid'] || (msg['fei']['wfid'] rescue nil)
-      fei = msg['fei'] || (fexp.h.fei rescue nil)
+      err = RaisedError.new(err) unless err.respond_to?(:backtrace)
 
-      backtrace = exception.backtrace || []
-
-      # debug only
-
-      if $DEBUG || ARGV.include?('-d')
-
-        puts "\n== worker intercepted error =="
-        puts
-        p exception
-        puts backtrace[0, 20].join("\n")
-        puts "..."
-        puts
-        puts "-- msg --"
-        key_length = msg.keys.collect { |k| k.length }.max + 1
-        msg.keys.sort.each { |k|
-          v = msg[k]
-          v = (Ruote.sid(v) rescue nil) if k == 'fei' || k == 'parent_id'
-          printf("%*s : %s\n", key_length, k, v.inspect)
-        }
-        puts "-- . --"
-        puts
-      end
+      meta = err.is_a?(Ruote::MetaError)
+
+      fei = msg['fei'] || (fexp.h.fei rescue nil)
+      wfid = msg['wfid'] || (fei || {})['wfid']
 
       # on_error ?
 
-      return if fexp && fexp.handle_on_error(msg, exception)
+      return if ( ! meta) && fexp && fexp.handle_on_error(msg, err)
 
       # emit 'msg'
       #
       # (this message might get intercepted by a tracker)
 
-      @context.storage.put_msg(
-        'error_intercepted',
-        'error' => {
-          'fei' => fei,
-          'at' => Ruote.now_to_utc_s,
-          'class' => exception.class.name,
-          'message' => exception.message,
-          'trace' => backtrace
-        },
-        'wfid' => wfid,
-        'fei' => fei,
-        'msg' => msg)
+      herr = deflate(err, fei, fexp)
 
       # fill error in the error journal
 
       @context.storage.put(
-        'type' => 'errors',
-        '_id' => "err_#{Ruote.to_storage_id(fei)}",
-        'message' => exception.inspect,
-        'trace' => backtrace.join("\n"),
-        'fei' => fei,
-        'msg' => msg
+        herr.merge(
+          'type' => 'errors',
+          '_id' => "err_#{Ruote.to_storage_id(fei)}",
+          'message' => err.inspect,                     # :-(
+          'trace' => (err.backtrace || []).join("\n"),  # :-(
+          'msg' => msg)
       ) if fei
+
+      # advertise 'error_intercepted'
+
+      @context.storage.put_msg(
+        'error_intercepted',
+        'error' => herr, 'wfid' => wfid, 'fei' => fei, 'msg' => msg)
+
+    rescue => e
+
+      raise e unless @context.worker
+
+      @context.worker.send(
+        :handle_step_error,
+        e,
+        { 'action' => 'error_intercepted',
+          'error' => deflate(err, fei),
+          'fei' => fei,
+          'wfid' => wfid,
+          'msg' => msg })
+    end
+
+    # Returns a serializable hash with all the details of the error.
+    #
+    def deflate(err, fei, fexp=nil)
+
+      return err unless err.respond_to?(:backtrace)
+
+      fexp ||=
+        Ruote::Exp::FlowExpression.dummy('fei' => fei, 'original_tree' => nil)
+
+      fexp.deflate(err)
+    end
+
+    # The 'raise' action/msg passes deflated errors. This wrapper class
+    # "inflates" them.
+    #
+    class RaisedError
+      def initialize(h)
+        @h = h
+      end
+      def class
+        Ruote.constantize(@h['class'])
+      end
+      def message
+        @h['message']
+      end
+      def backtrace
+        @h['trace']
+      end
+      def to_s
+        "raised: #{@h['class']}: #{@h['message']}"
+      end
+      alias inspect to_s
     end
   end
 end

data/lib/ruote/svc/expression_map.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
@@ -29,12 +29,12 @@ module Exp
 end
 end
 
-require 'ruote/exp/flowexpression'
+require 'ruote/exp/flow_expression'
 
 
 exppath = File.join(File.dirname(__FILE__), '..', 'exp')
 
-Dir.new(exppath).entries.each do |pa|
+Dir.new(exppath).entries.sort.each do |pa|
   require(File.join('ruote', 'exp', pa)) if pa.match(/^fe_.*\.rb$/)
 end
 

data/lib/ruote/svc/participant_list.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
@@ -24,7 +24,10 @@
 
 
 require 'sourcify'
+
+require 'ruote/part/local_participant'
 require 'ruote/part/block_participant'
+require 'ruote/part/code_participant'
 
 
 module Ruote
@@ -38,41 +41,75 @@ module Ruote
   #
   class ParticipantList
 
+    # Vanilla service #initialize.
+    #
     def initialize(context)
 
       @context = context
     end
 
-    # Registers a participant. Called by Engine#register_participant.
+    # Used by #register and by Ruote::ParticipantRegistrationProxy
     #
-    def register(name, participant, options, block)
+    def to_entry(name, participant, options, block)
 
       raise(
         ArgumentError.new(
-          "can only accept strings (classnames) or classes as participant arg")
+          'can only accept strings (classnames) or classes as participant arg')
       ) unless [ String, Class, NilClass ].include?(participant.class)
 
       klass = (participant || Ruote::BlockParticipant).to_s
 
-      options = options.inject({}) { |h, (k, v)|
-        h[k.to_s] = v.is_a?(Symbol) ? v.to_s : v
-        h
+      options = options.remap { |(k, v), h|
+        h[k.to_s] = case v
+          when Symbol then v.to_s
+          when Proc then v.to_raw_source
+          else v
+        end
       }
 
-      if block
-        options['block'] = block.to_source
-        @context.treechecker.block_check(options['block'])
+      extract_blocks(block).each do |meth, code|
+        @context.treechecker.block_check(code)
+        options[meth] = code
       end
 
-      key = (name.is_a?(Regexp) ? name : Regexp.new("^#{name}$")).source
+      [
+        (name.is_a?(Regexp) ? name : Regexp.new("^#{name}$")).source,
+        [ klass, options ]
+      ]
+    end
+
+    # Registers a participant. Called by Engine#register_participant.
+    #
+    def register(name, participant, options, block)
+
+      entry = to_entry(name, participant, options, block)
 
-      entry = [ key, [ klass, options ] ]
+      key = entry.first
+      options = entry.last.last
 
       list = get_list
 
-      list['list'].delete_if { |e| e.first == key }
+      position = options['position'] || options['pos'] || 'last'
+
+      if position == 'before'
+
+        position = list['list'].index { |e| e.first == key } || -1
+
+      elsif position == 'after'
+
+        position = (list['list'].rindex { |e| e.first == key } || -2) + 1
+
+      elsif position == 'over'
+
+        position = list['list'].index { |e| e.first == key } || -1
+        list['list'].delete_at(position) unless position == -1
+
+      elsif options.delete('override') != false
+
+        list['list'].delete_if { |e| e.first == key }
+          # enforces only one instance of a participant per key/regex
+      end
 
-      position = options['position'] || 'last'
       case position
         when 'last' then list['list'] << entry
         when 'first' then list['list'].unshift(entry)
@@ -147,6 +184,10 @@ module Ruote
     #
     def lookup_info(pname, workitem)
 
+      wi = workitem ?
+        Ruote::Workitem.new(workitem.merge('participant_name' => pname)) :
+        nil
+
       get_list['list'].each do |regex, pinfo|
 
         next unless pname.match(regex)
@@ -156,12 +197,11 @@ module Ruote
         pa = instantiate(pinfo, :if_respond_to? => :accept?)
 
         return pinfo if pa.nil?
-
-        return pinfo if pa.accept?(
-          Ruote::Workitem.new(workitem.merge('participant_name' => pname))
-        )
+        return pinfo if Ruote.participant_send(pa, :accept?, 'workitem' => wi)
       end
 
+      # nothing found...
+
       nil
     end
 
@@ -169,13 +209,6 @@ module Ruote
     #
     def instantiate(pinfo, opts={})
 
-      #pinfo = @instantiated_participants[pinfo] if pinfo.is_a?(String)
-      #if pinfo.respond_to?(:consume)
-      #  return (pinfo.respond_to?(irt) ? pinfo : nil) if irt
-      #  return pinfo
-      #end
-      #return nil unless pinfo
-
       pa_class_name, options = pinfo
 
       if rp = options['require_path']
@@ -251,6 +284,7 @@ module Ruote
     def list=(pl)
 
       list = get_list
+
       list['list'] = pl.collect { |e|
         ParticipantEntry.read(e)
       }.collect { |e|
@@ -262,12 +296,73 @@ module Ruote
         #
         # put failed, have to redo it
         #
-        list=(pl)
+        self.list=(pl)
       end
     end
 
+    # Clears this participant list.
+    #
+    # Used by Engine#register(&block)
+    #
+    def clear
+
+      self.list=([])
+    end
+
     protected
 
+    # Used by #extract_blocks when evaluating sub-blocks.
+    #
+    class BlockParticipantContext
+      attr_reader :blocks
+      def initialize
+        @blocks = {}
+      end
+      def method_missing(m, *args, &block)
+        @blocks[m.to_s] = block.to_raw_source
+      end
+    end
+
+    # If the given block is nil, will return {}, else tries to determine
+    # if it's a single "on_workitem" block or a block that has sub-blocks,
+    # like in
+    #
+    #   dashboard.register 'toto' do
+    #     on_workitem do
+    #       puts "hey I'm toto"
+    #     end
+    #     accept? do
+    #       workitem.fields.length > 3
+    #     end
+    #   end
+    #
+    def extract_blocks(block)
+
+      return {} unless block
+
+      source = block.to_raw_source
+      tree = Ruote.parse_ruby(source)
+
+      multi =
+        tree[0, 3] == [ :iter, [ :call, nil, :proc, [ :arglist ] ], nil ] &&
+        tree[3].is_a?(Array) &&
+        tree[3].first == :block &&
+        tree[3][1..-1].all? { |e|
+          e[0] == :iter &&
+          e[2] == nil &&
+          e[1][0, 2] == [ :call, nil ] &&
+          e[1][3] == [ :arglist ]
+        }
+
+      if multi
+        bpc = BlockParticipantContext.new
+        bpc.instance_eval(&block)
+        bpc.blocks
+      else
+        { 'on_workitem' => source }
+      end
+    end
+
     # Fetches and returns the participant list in the storage.
     #
     def get_list
@@ -302,13 +397,13 @@ module Ruote
     attr_accessor :regex, :classname, :options
 
     def initialize(a)
+
       @regex = a.first
-      if a.last.is_a?(Array)
-        @classname = a.last.first
-        @options = a.last.last
+
+      @classname, @options = if a.last.is_a?(Array)
+        [ a.last.first, a.last.last ]
       else
-        @classname = a.last
-        @options = nil
+        [ a.last, nil ]
       end
     end
 
@@ -328,39 +423,49 @@ module Ruote
     #
     def self.read(elt)
 
-      return elt.to_a if elt.is_a?(ParticipantEntry)
+      case elt
 
-      if elt.is_a?(Hash)
+        when ParticipantEntry
 
-        options = elt['options'] || elt.reject { |k, v|
-          %w[ name regex regexp class classname ].include?(k)
-        }
+          elt.to_a
 
-        name = elt.find { |k, v| v == nil }
-        if name
-          name = name.first
-          elt.delete(name)
-          options.delete(name)
-        end
-        name = name || elt['name']
-        name = Ruote.regex_or_s(name)
+        when Hash
 
-        regex = name
-        unless name
-          regex = Ruote.regex_or_s(elt['regex'] || elt['regexp'])
-          regex = regex.is_a?(String) ? Regexp.new(regex) : regex
-        end
+          options = elt['options'] || elt.reject { |k, v|
+            %w[ name regex regexp class classname ].include?(k)
+          }
 
-        klass = elt['classname'] || elt['class']
+          name, _ = elt.find { |k, v| v == nil }
+          if name
+            elt.delete(name)
+            options.delete(name)
+          end
+          name = name || elt['name']
+          name = Ruote.regex_or_s(name)
 
-        return [ regex, [ klass, options ] ]
-      end
+          regex = name
+          if name.nil?
+            regex = Ruote.regex_or_s(elt['regex'] || elt['regexp'])
+            regex = regex.is_a?(String) ? Regexp.new(regex) : regex
+          end
+
+          klass = (elt['classname'] || elt['class']).to_s
 
-      # else elt is a Array
+          [ regex, [ klass, options ] ]
 
-      return [ Ruote.regex_or_s(elt[0]), [ elt[1], elt[2] ] ] if elt.size == 3
+        when Array
 
-      [ Ruote.regex_or_s(elt[0]), elt[1] ]
+          if elt.size == 3
+            [ Ruote.regex_or_s(elt[0]), [ elt[1].to_s, elt[2] ] ]
+          else
+            [ Ruote.regex_or_s(elt[0]), elt[1] ]
+          end
+
+        else
+
+          raise ArgumentError.new(
+            "cannot read participant out of #{elt.inspect} (#{elt.class})")
+      end
     end
   end
 end