ruote 2.1.10 → 2.1.11

data/lib/ruote/storage/base.rb

@@ -95,7 +95,7 @@ module Ruote
 
     def empty? (type)
 
-      (get_many(type) == [])
+      (get_many(type, nil, :count => true) == 0)
     end
 
     #--
@@ -104,13 +104,34 @@ module Ruote
 
     def find_root_expression (wfid)
 
-      get_many('expressions', /!#{wfid}$/).sort { |a, b|
-        a['fei']['expid'] <=> b['fei']['expid']
+      get_many('expressions', wfid).sort_by { |fexp|
+        fexp['fei']['expid']
       }.select { |e|
         e['parent_id'].nil?
       }.first
     end
 
+    # Given all the expressions stored here, returns a sorted list of unique
+    # wfids (this is used in Engine#processes(opts).
+    #
+    # Understands the :skip, :limit and :descending options.
+    #
+    # This is a base implementation, different storage implementations may
+    # come up with different implementations (think CouchDB,  which could
+    # provide a view for it).
+    #
+    def expression_wfids (opts)
+
+      wfids = ids('expressions').collect { |fei| fei.split('!').last }.uniq.sort
+
+      wfids = wfids.reverse if opts[:descending]
+
+      skip = opts[:skip] || 0
+      limit = opts[:limit] || wfids.length
+
+      wfids[skip, limit]
+    end
+
     #--
     # trackers
     #++
@@ -145,14 +166,20 @@ module Ruote
       #end
     end
 
+    # Places schedule in storage. Returns the id of the 'schedule' document.
+    # If the schedule got triggered immediately, nil is returned.
+    #
     def put_schedule (flavour, owner_fei, s, msg)
 
-      if doc = prepare_schedule_doc(flavour, owner_fei, s, msg)
-        put(doc)
-        return doc['_id']
-      end
+      doc = prepare_schedule_doc(flavour, owner_fei, s, msg)
+
+      return nil unless doc
 
-      nil
+      r = put(doc)
+
+      raise "put_schedule failed" if r != nil
+
+      doc['_id']
     end
 
     def delete_schedule (schedule_id)
@@ -194,7 +221,9 @@ module Ruote
         configurations errors expressions msgs schedules variables workitems
       ].each do |type|
 
-        get_many(type).each do |item|
+        ids(type).each do |id|
+
+          item = get(type, id)
 
           item.delete('_rev')
           target.put(item)
@@ -207,6 +236,18 @@ module Ruote
       counter
     end
 
+    # Used when doing integration tests, removes all
+    # msgs, schedules, errors, expressions and workitems.
+    #
+    # NOTE that it doesn't remove engine variables (danger)
+    #
+    def clear
+
+      %w[ msgs schedules errors expressions workitems ].each do |type|
+        purge_type!(type)
+      end
+    end
+
     protected
 
     # Used by put_msg
@@ -272,11 +313,35 @@ module Ruote
 
     # Returns all the ats whose due date arrived (now or earlier)
     #
-    def filter_schedules (scheds, now)
+    def filter_schedules (schedules, now)
 
       now = Ruote.time_to_utc_s(now)
 
-      scheds.select { |sched| sched['at'] <= now }
+      schedules.select { |sch| sch['at'] <= now }
+    end
+
+    ## Returns true if the doc wfid is included in the wfids passed.
+    ##
+    #def wfid_match? (doc, wfids)
+    #  wfids.find { |wfid| doc['_id'].index(wfid) } != nil
+    #end
+
+    # Used by #get_many. Returns true whenever one of the keys matches the
+    # doc['_id']. Works with strings (_id ends with key) or regexes (_id matches
+    # key).
+    #
+    # It's a class method meant to be used by the various storage
+    # implementations.
+    #
+    def self.key_match? (keys, doc)
+
+      _id = doc.is_a?(Hash) ? doc['_id'] : doc
+
+      if keys.first.is_a?(String)
+        keys.find { |key| _id[-key.length..-1] == key }
+      else # Regexp
+        keys.find { |key| key.match(_id) }
+      end
     end
   end
 end

data/lib/ruote/storage/fs_storage.rb

@@ -35,6 +35,8 @@ Rufus::Json.detect_backend
 require 'rufus/cloche'
   # gem install rufus-cloche
 
+require 'ruote/storage/base'
+
 
 module Ruote
 
@@ -84,6 +86,12 @@ module Ruote
 
     def get_many (type, key=nil, opts={})
 
+      if key
+        key = Array(key)
+        key = key.map { |k| "!#{k}" } if key.first.is_a?(String)
+      end
+        # assuming /!#{wfid}$/...
+
       @cloche.get_many(type, key, opts)
     end
 
@@ -92,6 +100,8 @@ module Ruote
       @cloche.ids(type)
     end
 
+    # Purges the storage completely.
+    #
     def purge!
 
       FileUtils.rm_rf(@cloche.dir)

data/lib/ruote/storage/hash_storage.rb

@@ -57,7 +57,6 @@ module Ruote
 
         pre = get(doc['type'], doc['_id'])
 
-        #if pre && ( ! opts[:update_rev]) && pre['_rev'] != doc['_rev']
         if pre && pre['_rev'] != doc['_rev']
           return pre
         end
@@ -122,15 +121,25 @@ module Ruote
 
       synchronize do
 
-        docs = key ?
-          @h[type].values.select { |doc| doc['_id'].match(key) } :
+        keys = key ?
+          Array(key).map { |k| k.is_a?(String) ? "!#{k}" : k } : nil
+
+        docs = keys ?
+          @h[type].values.select { |doc|
+            Ruote::StorageBase.key_match?(keys, doc)
+          } :
           @h[type].values
 
-        if l = opts[:limit]
-          docs[0, l]
-        else
-          docs
-        end
+        docs = docs.sort_by { |d| d['_id'] }
+
+        return docs.size if opts[:count]
+
+        docs = docs.reverse if opts[:descending]
+
+        skip = opts[:skip] || 0
+        limit = opts[:limit] || docs.size
+
+        docs[skip, limit]
       end
     end
 
@@ -141,6 +150,8 @@ module Ruote
       @h[type].keys.sort
     end
 
+    # Purges the storage completely.
+    #
     def purge!
 
       @h = %w[

data/lib/ruote/{part → svc}/dispatch_pool.rb

@@ -57,7 +57,7 @@ module Ruote
 
       flavour = msg['flavour']
 
-      participant = @context.plist.lookup(msg['participant_name'])
+      participant = @context.plist.instantiate(msg['participant'])
 
       begin
         participant.cancel(Ruote::FlowExpressionId.new(msg['fei']), flavour)
@@ -73,7 +73,8 @@ module Ruote
 
     def dispatch (msg)
 
-      participant = @context.plist.lookup(msg['participant_name'])
+      participant = @context.plist.lookup(
+        msg['participant'] || msg['participant_name'], msg['workitem'])
 
       if participant.respond_to?(:do_not_thread) && participant.do_not_thread
         do_dispatch(participant, msg)

data/lib/ruote/svc/dollar_sub.rb

@@ -0,0 +1,265 @@
+#--
+# Copyright (c) 2005-2010, 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.
+#++
+
+
+require 'rufus/dollar' # gem 'rufus-dollar'
+require 'ruote/svc/treechecker'
+require 'ruote/util/lookup'
+
+
+module Ruote
+
+  #
+  # This service is in charge of extrapolating strings like
+  # "${f:nada} == ${f:y}".
+  #
+  # It relies on the rufus-dollar gem.
+  #
+  # It's OK to override this service with your own.
+  #
+  class DollarSubstitution
+
+    def initialize (context)
+
+      @context = context
+    end
+
+    # Performs 'dollar substitution' on a piece of text with as input
+    # a flow expression and a workitem (fields and variables).
+    #
+    # With help from Nick Petrella (2008/03/20)
+    #
+    def s (text, flow_expression, workitem)
+
+      if text.is_a?(String)
+
+        Rufus.dsub(text, dict_class.new(flow_expression, workitem))
+
+      elsif text.is_a?(Array)
+
+        text.collect { |e| s(e, flow_expression, workitem) }
+
+      elsif text.is_a?(Hash)
+
+        text.inject({}) { |h, (k, v)|
+
+          h[s(k, flow_expression, workitem)] = s(v, flow_expression, workitem)
+          h
+        }
+
+      else
+
+        text
+      end
+    end
+
+    # This method is public, for easy overriding. This implementation returns
+    # Ruote::Dollar::Dict whose instances are used to extrapolate dollar
+    # strings like "${f:customer}" or "${r:Time.now.to_s}/${f:year_target}"
+    #
+    def dict_class
+
+      ::Ruote::Dollar::Dict
+    end
+  end
+
+
+  #
+  # A mini-namespace Ruote::Dollar for Dict and RubyContext, just to separate
+  # them from the rest of Ruote.
+  #
+  module Dollar
+
+    #
+    # Wrapping a flow expression and the current workitem as a
+    # Hash-like object ready for lookup at substitution time.
+    #
+    class Dict
+
+      attr_reader :fexp
+      attr_reader :workitem
+
+      def initialize (flowexpression, workitem)
+
+        @fexp = flowexpression
+        @workitem = workitem
+      end
+
+      def [] (key)
+
+        return @fexp.fei.to_storage_id if key == 'fei'
+        return @fexp.fei.wfid if key == 'wfid'
+        return @fexp.fei.sub_wfid if key == 'sub_wfid'
+        return @fexp.fei.expid if key == 'expid'
+
+        pr, k = extract_prefix(key)
+
+        # stage 0
+
+        v = lookup(pr[0, 1], k)
+
+        return v if v != nil
+
+        # stage 1
+
+        return '' if pr.size < 2
+
+        lookup(pr[1, 1], k)
+      end
+
+      def []= (key, value)
+
+        pr, k = extract_prefix(key)
+        pr = pr[0, 1]
+
+        if pr == 'f'
+
+          @workitem.set_attribute(k, value)
+
+        elsif @fexp
+
+          @fexp.set_variable(k, value)
+        end
+      end
+
+      def has_key? (key)
+
+        pr, k = extract_prefix(key)
+
+        return true if pr == 'r'
+
+        (self[key] != nil)
+      end
+
+      protected
+
+      def lookup (pr, key)
+
+        case pr
+          when 'v' then @fexp.lookup_variable(key)
+          when 'f' then Ruote.lookup(@workitem['fields'], key)
+          when 'r' then ruby_eval(key)
+          else nil
+        end
+      end
+
+      def extract_prefix (key)
+
+        i = key.index(':')
+
+        return [ 'f', key ] if not i
+          # 'f' is the default prefix (field, not variable)
+
+        pr = key[0..i-1] # until ':'
+        pr = pr[0, 2] # the first two chars
+
+        pr = pr[0, 1] unless (pr == 'vf') or (pr == 'fv')
+
+        [ pr, key[i+1..-1] ]
+      end
+
+      # TODO : rdoc me
+      #
+      def ruby_eval (ruby_code)
+
+        return '' if @fexp.context['ruby_eval_allowed'] != true
+
+        @fexp.context.treechecker.check(ruby_code)
+
+        RubyContext.new(self).instance_eval(ruby_code)
+      end
+    end
+
+    # Dict uses this RubyContext class to evaluate ruby code. The method
+    # of this instance are directly visible to "${r:ruby_code}" ruby code.
+    #
+    class RubyContext < Ruote::BlankSlate
+
+      attr_reader :workitem
+
+      def initialize (dict)
+
+        @dict = dict
+        @workitem = Ruote::Workitem.new(@dict.workitem)
+      end
+
+      # The FlowExpression for which the rendering/substitution is occurring.
+      #
+      def flow_expression
+        @dict.fexp
+      end
+      alias fe flow_expression
+      alias fexp flow_expression
+
+      # The FlowExpressionId of the expression for which the
+      # rendering/substitution is occurring.
+      #
+      def fei
+        @dict.fexp.fei
+      end
+
+      alias wi workitem
+
+      # The engine_id, if any.
+      #
+      def engine_id
+        @dict.fexp.context.engine_id
+      end
+
+      # This 'd' function can be called from inside ${r:...} notations.
+      #
+      #   pdef = Ruote.process_definition do
+      #     sequence do
+      #       set 'f:toto' => 'person'
+      #       echo "${r:d('f:toto')}"
+      #     end
+      #   end
+      #
+      # will yield "person".
+      #
+      def d (s)
+
+        Rufus.dsub("${#{s}}", @dict)
+      end
+
+      # Given a workitem with the field "newspaper" set to "NYT",
+      # "${r:newspaper}" will eval to "NYT".
+      #
+      # If the field "cars" hold the value [ "bmw", "volkswagen" ],
+      # "${r:cars[0]}" will eval to "bmw".
+      #
+      # Else the regular NoMethodError will be raised.
+      #
+      def method_missing (m, *args)
+
+        if args.length < 1 && v = @workitem.fields[m.to_s]
+          return v
+        end
+
+        super
+      end
+    end
+  end
+end
+

data/lib/ruote/{error_handler.rb → svc/error_handler.rb}

@@ -45,7 +45,8 @@ module Ruote
     def msg_handle (msg, exception)
 
       fexp = Ruote::Exp::FlowExpression.fetch(
-        @context, msg['fei'] || msg['workitem']['fei'])
+        @context, msg['fei'] || msg['workitem']['fei']
+      ) rescue nil
 
       handle(msg, fexp, exception)
     end
@@ -102,6 +103,10 @@ module Ruote
 
       @context.storage.put_msg(
         'error_intercepted',
+        'error_class' => exception.class.name,
+        'error_message' => exception.message,
+        'error_backtrace' => exception.backtrace,
+        # for backward compatibility
         'message' => exception.inspect,
         'wfid' => wfid,
         'msg' => msg)

data/lib/ruote/{exp → svc}/expression_map.rb

@@ -30,16 +30,13 @@ end
 end
 
 require 'ruote/exp/flowexpression'
-require 'ruote/exp/raw'
 
 
-exppath = File.dirname(__FILE__)
+exppath = File.join(File.dirname(__FILE__), '..', 'exp')
 
-Dir.new(exppath).entries.select { |p|
-  p.match(/^fe_.*\.rb$/)
-}.each { |p|
-  require exppath + '/' + p
-}
+Dir.new(exppath).entries.each do |pa|
+  require(File.join('ruote', 'exp', pa)) if pa.match(/^fe_.*\.rb$/)
+end
 
 
 module Ruote
@@ -48,41 +45,38 @@ module Ruote
   # Mapping from expression names (sequence, concurrence, ...) to expression
   # classes (Ruote::SequenceExpression, Ruote::ConcurrenceExpression, ...)
   #
+  # Requiring this ruote/svc/expression_map.rb file will automatically load
+  # all the expressions in ruote/exp/fe_*.rb.
+  #
+  # When the ExpressionMap is
+  # instantiated by the engine, it will look at the Ruote::Exp namespace
+  # and register as expression any constant in there whose name ends with
+  # "Expression", like "SequenceExpression" or "ParticipantExpression".
+  #
+  # So adding expressions to ruote should be as simple as making sure the
+  # engine sees your classes under Ruote::Exp before it instantiates this
+  # expression map (so that the expression map will automatically register
+  # your expressions).
+  #
   class ExpressionMap
 
+    # Will load any expression in the Ruote::Exp:: namespace and map
+    # its names to its class.
+    #
     def initialize (worker)
 
       @map = {}
-      add(Ruote::Exp::RawExpression)
-      add(Ruote::Exp::DefineExpression)
-      add(Ruote::Exp::SequenceExpression)
-      add(Ruote::Exp::EchoExpression)
-      add(Ruote::Exp::ParticipantExpression)
-      add(Ruote::Exp::SetExpression)
-      add(Ruote::Exp::SubprocessExpression)
-      add(Ruote::Exp::ConcurrenceExpression)
-      add(Ruote::Exp::ConcurrentIteratorExpression)
-      add(Ruote::Exp::ForgetExpression)
-      add(Ruote::Exp::UndoExpression)
-      add(Ruote::Exp::RedoExpression)
-      add(Ruote::Exp::CancelProcessExpression)
-      add(Ruote::Exp::WaitExpression)
-      add(Ruote::Exp::ListenExpression)
-      add(Ruote::Exp::CommandExpression)
-      add(Ruote::Exp::IteratorExpression)
-      add(Ruote::Exp::CursorExpression)
-      add(Ruote::Exp::IfExpression)
-      add(Ruote::Exp::EqualsExpression)
-      add(Ruote::Exp::ReserveExpression)
-      add(Ruote::Exp::SaveExpression)
-      add(Ruote::Exp::RestoreExpression)
-      add(Ruote::Exp::NoOpExpression)
-      add(Ruote::Exp::ApplyExpression)
-      add(Ruote::Exp::AddBranchesExpression)
-      add(Ruote::Exp::ErrorExpression)
-      add(Ruote::Exp::IncExpression)
-      add(Ruote::Exp::WhenExpression)
-      add(Ruote::Exp::CronExpression)
+
+      Ruote::Exp.constants.each do |con|
+
+        con = con.to_s
+        next unless con.match(/Expression$/)
+
+        cla = Ruote::Exp.const_get(con)
+        next unless cla.respond_to?(:expression_names)
+
+        add(cla)
+      end
     end
 
     # Returns the expression class for the given expression name