ruote 2.1.11 → 2.2.0

data/lib/ruote/svc/expression_map.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2011, 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
@@ -63,7 +63,7 @@ module Ruote
     # Will load any expression in the Ruote::Exp:: namespace and map
     # its names to its class.
     #
-    def initialize (worker)
+    def initialize(worker)
 
       @map = {}
 
@@ -81,14 +81,14 @@ module Ruote
 
     # Returns the expression class for the given expression name
     #
-    def expression_class (exp_name)
+    def expression_class(exp_name)
 
       @map[exp_name]
     end
 
     protected
 
-    def add (exp_class)
+    def add(exp_class)
 
       exp_class.expression_names.each { |n| @map[n] = exp_class }
     end

data/lib/ruote/svc/participant_list.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2011, 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
@@ -23,6 +23,7 @@
 #++
 
 
+require 'sourcify'
 require 'ruote/part/block_participant'
 
 
@@ -37,33 +38,35 @@ module Ruote
   #
   class ParticipantList
 
-    attr_reader :instantiated_participants
-
-    def initialize (context)
+    def initialize(context)
 
       @context = context
-      @instantiated_participants = {}
     end
 
     # Registers a participant. Called by Engine#register_participant.
     #
-    def register (name, participant, options, block)
+    def register(name, participant, options, block)
+
+      raise(
+        ArgumentError.new(
+          "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
       }
 
-      entry = if participant.is_a?(Class) || participant.is_a?(String)
-        [ participant.to_s, options ]
-      else
-        "inpa_#{name.inspect}"
-          # INstantiated PArticipant
+      if block
+        options['block'] = block.to_source
+        @context.treechecker.block_check(options['block'])
       end
 
       key = (name.is_a?(Regexp) ? name : Regexp.new("^#{name}$")).source
 
-      entry = [ key, entry ]
+      entry = [ key, [ klass, options ] ]
 
       list = get_list
 
@@ -82,23 +85,12 @@ module Ruote
         # if put returns something it means the put failed, have to redo the
         # work...
         #
-        return register(name, participant, options, block, r)
+        return register(name, participant, options, block)
       end
 
-      if entry.last.is_a?(String)
-
-        participant = BlockParticipant.new(block, options) if block
-
-        participant.context = @context if participant.respond_to?(:context=)
-        @instantiated_participants[entry.last] = participant
-        #participant
-
+      if entry.last.first == 'Ruote::StorageParticipant'
+        Ruote::StorageParticipant.new(@context)
       else
-
-        if entry.last.first == 'Ruote::StorageParticipant'
-          return Ruote::StorageParticipant.new(@context)
-        end
-
         nil
       end
     end
@@ -108,37 +100,19 @@ module Ruote
     #
     # Called usually by Engine#unregister_participant.
     #
-    def unregister (name_or_participant)
+    def unregister(name_or_participant)
 
       code = nil
       entry = nil
       list = get_list
 
-      if name_or_participant.is_a?(Symbol)
-        name_or_participant = name_or_participant.to_s
-      end
-
-      if name_or_participant.is_a?(String)
-
-        entry = list['list'].find { |re, pa| name_or_participant.match(re) }
-
-        return nil unless entry
+      name_or_participant = name_or_participant.to_s
 
-        code = entry.last if entry.last.is_a?(String)
+      entry = list['list'].find { |re, pa| name_or_participant.match(re) }
 
-      else # we've been given a participant instance
+      return nil unless entry
 
-        code = @instantiated_participants.find { |k, v|
-          v == name_or_participant
-        }
-
-        return nil unless code
-
-        code = code.first
-
-        entry = list['list'].find { |re, pa| pa == code }
-
-      end
+      code = entry.last if entry.last.is_a?(String)
 
       list['list'].delete(entry)
 
@@ -146,11 +120,9 @@ module Ruote
         #
         # put failed, have to redo it
         #
-        return unregister(name_or_participant, r)
+        return unregister(name_or_participant)
       end
 
-      @instantiated_participants.delete(code) if code
-
       entry.first
     end
 
@@ -159,15 +131,13 @@ module Ruote
     #
     # Mostly a combination of #lookup_info and #instantiate.
     #
-    def lookup (participant_name, workitem, opts={})
+    def lookup(participant_name, workitem, opts={})
 
-      pinfo = participant_name
+      pinfo = participant_name.is_a?(String) ?
+        lookup_info(participant_name, workitem) : participant_name
 
-      if participant_name.is_a?(String) && participant_name[0, 5] != 'inpa_'
-        pinfo = lookup_info(participant_name, workitem)
-      end
-
-      pinfo ? instantiate(pinfo, opts) : nil
+      pinfo ?
+        instantiate(pinfo, opts) : nil
     end
 
     # Given a participant name, returns
@@ -175,15 +145,17 @@ module Ruote
     # Returns nil if there is no participant registered that covers the given
     # participant name.
     #
-    def lookup_info (pname, workitem)
+    def lookup_info(pname, workitem)
 
       get_list['list'].each do |regex, pinfo|
 
         next unless pname.match(regex)
 
+        return pinfo if workitem.nil?
+
         pa = instantiate(pinfo, :if_respond_to? => :accept?)
 
-        return pinfo unless pa
+        return pinfo if pa.nil?
 
         return pinfo if pa.accept?(
           Ruote::Workitem.new(workitem.merge('participant_name' => pname))
@@ -195,18 +167,14 @@ module Ruote
 
     # Returns an instance of a participant
     #
-    def instantiate (pinfo, opts={})
+    def instantiate(pinfo, opts={})
 
-      irt = opts[:if_respond_to?]
-
-      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
+      #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
 
@@ -220,18 +188,26 @@ module Ruote
       pa_class = Ruote.constantize(pa_class_name)
       pa_m = pa_class.instance_methods
 
+      irt = opts[:if_respond_to?]
+
       if irt && ! (pa_m.include?(irt.to_s) || pa_m.include?(irt.to_sym))
         return nil
       end
 
-      pa = if pa_class.instance_method(:initialize).arity > 0
-        pa_class.new(options)
+      initialize_participant(pa_class, options)
+    end
+
+    def initialize_participant(klass, options)
+
+      participant = if klass.instance_method(:initialize).arity == 0
+        klass.new
       else
-        pa_class.new
+        klass.new(options)
       end
-      pa.context = @context if pa.respond_to?(:context=)
 
-      pa
+      participant.context = @context if participant.respond_to?(:context=)
+
+      participant
     end
 
     # Return a list of names (regex) for the registered participants
@@ -241,14 +217,18 @@ module Ruote
       get_list['list'].collect { |re, pa| re }
     end
 
-    # Shuts down the 'instantiated participants' (engine worker participants)
-    # if they respond to #shutdown.
+    # Calls #shutdown on any participant that sports this method.
     #
     def shutdown
 
-      @instantiated_participants.each { |re, pa|
-        pa.shutdown if pa.respond_to?(:shutdown)
-      }
+      get_list['list'].each do |re, (kl, op)|
+
+        kl = (Ruote.constantize(kl) rescue nil)
+
+        if (kl.instance_method(:shutdown) rescue false)
+          initialize_participant(kl, op).shutdown
+        end
+      end
     end
 
     # Used by Engine#participant_list
@@ -268,16 +248,21 @@ module Ruote
     #
     # See ParticipantList#list
     #
-    def list= (pl)
+    def list=(pl)
 
       list = get_list
-      list['list'] = pl.collect { |e| ParticipantEntry.read(e) }
+      list['list'] = pl.collect { |e|
+        ParticipantEntry.read(e)
+      }.collect { |e|
+        e[0] = e[0].source if e[0].is_a?(Regexp)
+        e
+      }
 
       if r = @context.storage.put(list)
         #
         # put failed, have to redo it
         #
-        list= (pl)
+        list=(pl)
       end
     end
 
@@ -316,7 +301,7 @@ module Ruote
 
     attr_accessor :regex, :classname, :options
 
-    def initialize (a)
+    def initialize(a)
       @regex = a.first
       if a.last.is_a?(Array)
         @classname = a.last.first
@@ -328,34 +313,54 @@ module Ruote
     end
 
     def to_a
-      @classname[0, 5] == 'inpa_' ?
-        [ @regex, @classname ] :
-        [ @regex, [ @classname, @options ] ]
+
+      [ @regex, [ @classname, @options ] ]
     end
 
     def to_s
+
       "/#{@regex}/ ==> #{@classname} #{@options.inspect}"
     end
 
-    def self.read (elt)
+    # Makes sense of whatever is given to it, returns something like
+    #
+    #   [ regex, [ klass, opts ] ]
+    #
+    def self.read(elt)
 
-      if elt.is_a?(ParticipantEntry)
-        return elt.to_a
-      end
+      return elt.to_a if elt.is_a?(ParticipantEntry)
 
       if elt.is_a?(Hash)
-        return elt['classname'][0, 5] == 'inpa_' ?
-          [ elt['regex'], elt['classname'] ] :
-          [ elt['regex'], [ elt['classname'], elt['options'] ] ]
+
+        options = elt['options'] || elt.reject { |k, v|
+          %w[ name regex regexp class classname ].include?(k)
+        }
+
+        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)
+
+        regex = name
+        unless name
+          regex = Ruote.regex_or_s(elt['regex'] || elt['regexp'])
+          regex = regex.is_a?(String) ? Regexp.new(regex) : regex
+        end
+
+        klass = elt['classname'] || elt['class']
+
+        return [ regex, [ klass, options ] ]
       end
 
       # else elt is a Array
 
-      if elt.size == 3
-        return [ elt[0], [ elt[1], elt[2] ] ]
-      end
+      return [ Ruote.regex_or_s(elt[0]), [ elt[1], elt[2] ] ] if elt.size == 3
 
-      elt
+      [ Ruote.regex_or_s(elt[0]), elt[1] ]
     end
   end
 end

data/lib/ruote/svc/tracker.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2011, 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
@@ -34,7 +34,7 @@ module Ruote
   #
   class Tracker
 
-    def initialize (context)
+    def initialize(context)
 
       @context = context
 
@@ -54,52 +54,83 @@ module Ruote
     # The worker passes all the messages it has to process to the tracker via
     # this method.
     #
-    def notify (msg)
+    def notify(msg)
 
-      doc = @context.storage.get_trackers
+      m_error = msg['error']
+      m_wfid = msg['wfid'] || (msg['fei']['wfid'] rescue nil)
+      m_action = msg['action']
+
+      @context.storage.get_trackers['trackers'].each do |tracker_id, tracker|
 
-      doc['trackers'].values.each do |tracker|
+        # filter msgs
 
         t_wfid = tracker['wfid']
         t_action = tracker['action']
-        m_wfid = msg['wfid'] || (msg['fei']['wfid'] rescue nil)
 
         next if t_wfid && t_wfid != m_wfid
-        next if t_action && t_action != msg['action']
+        next if t_action && t_action != m_action
 
         next unless does_match?(msg, tracker['conditions'])
 
+        msg = msg['msg'] if m_action == 'error_intercepted'
+
+        if tracker_id == 'on_error' || tracker_id == 'on_terminate'
+
+          fields = msg['workitem']['fields']
+
+          next if m_action == 'error_intercepted' && fields['__error__']
+          next if m_action == 'terminated' && (fields['__error__'] || fields['__terminate__'])
+        end
+
+        # prepare and emit/put 'reaction' message
+
         m = tracker['msg']
 
-        @context.storage.put_msg(
-          m.delete('action'),
-          m.merge!('workitem' => msg['workitem']))
+        action = m.delete('action')
+
+        m['wfid'] = m_wfid if m['wfid'] == 'replace'
+        m['wfid'] ||= @context.wfidgen.generate
+
+        m['workitem'] = msg['workitem'] if m['workitem'] == 'replace'
+
+        if tracker_id == 'on_error' && m_action == 'error_intercepted'
+          m['workitem']['fields']['__error__'] = m_error
+        elsif tracker_id == 'on_terminate' && m_action == 'terminated'
+          m['workitem']['fields']['__terminate__'] = { 'wfid' => m_wfid }
+        end
+
+        if m['variables'] == 'compile'
+          fexp = Ruote::Exp::FlowExpression.fetch(@context, msg['fei'])
+          m['variables'] = fexp ? fexp.compile_variables : {}
+        end
+
+        @context.storage.put_msg(action, m)
       end
     end
 
     # Adds a tracker (usually when a 'listen' expression gets applied).
     #
-    def add_tracker (wfid, action, fei, conditions, msg, doc=nil)
+    def add_tracker(wfid, action, id, conditions, msg)
 
-      doc ||= @context.storage.get_trackers
+      doc = @context.storage.get_trackers
 
-      doc['trackers'][Ruote.to_storage_id(fei)] =
+      doc['trackers'][id] =
         { 'wfid' => wfid,
           'action' => action,
-          'fei' => fei,
+          'id' => id,
           'conditions' => conditions,
           'msg' => msg }
 
       r = @context.storage.put(doc)
 
-      add_tracker(wfid, action, fei, msg, r) if r
+      add_tracker(wfid, action, id, msg) if r
         # the put failed, have to redo the work
     end
 
     # Removes a tracker (usually when a 'listen' expression replies to its
     # parent expression or is cancelled).
     #
-    def remove_tracker (fei, doc=nil)
+    def remove_tracker(fei, doc=nil)
 
       doc ||= @context.storage.get_trackers
 
@@ -113,11 +144,20 @@ module Ruote
 
     protected
 
-    def does_match? (msg, conditions)
+    def does_match?(msg, conditions)
+
+      return true unless conditions
 
       conditions.each do |k, v|
+
         val = msg[k]
-        return false unless val && val.match(v)
+        v = Ruote.regex_or_s(v)
+
+        if v.is_a?(String)
+          return false unless val && v == val
+        else
+          return false unless val && v.match(val)
+        end
       end
 
       true