ruote 0.9.20 → 2.1.1

data/lib/{openwfe/expressions/merge.rb → ruote/engine/process_error.rb}

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2007-2009, John Mettraux, jmettraux@gmail.com
+# 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
@@ -23,40 +23,51 @@
 #++
 
 
-require 'openwfe/utils'
-
-
-module OpenWFE
+module Ruote
 
   #
-  # Gathering methods for mixing (merging) workitems.
+  # Encapsulating all the information about an error in a process instance.
   #
-  module MergeMixin
+  class ProcessError
 
-    #
-    # Merges a source workitem into a target workitem (the fields
-    # of the source will overwrite the fields in the target).
-    #
-    # Returns the resulting (merged) workitem.
-    #
-    def merge_workitems (wi_target, wi_source, override=false)
+    def initialize (h)
+      @h = h
+    end
 
-      return wi_source unless wi_target
-      return wi_target unless wi_source
+    def message
+      @h['message']
+    end
 
-      return wi_source if override
+    def trace
+      @h['trace']
+    end
 
-      wi_source.attributes.each do |k, v|
+    def msg
+      @h['msg']
+    end
 
-        nk = OpenWFE.fulldup(k)
-        nv = OpenWFE.fulldup(v)
+    def fei
+      Ruote::FlowExpressionId.new(msg['fei'])
+    end
 
-        wi_target.attributes[nk] = nv
-      end
+    def tree
+      @h['msg']['tree']
+    end
 
-      wi_target
+    def at
+      @h['msg']['put_at']
+    end
+
+    # A shortcut for modifying the tree of an expression when it has had
+    # an error upon being applied.
+    #
+    def tree= (t)
+      @h['msg']['tree'] = t
     end
-  end
 
+    def to_h
+      @h
+    end
+  end
 end
 

data/lib/ruote/engine/process_status.rb

@@ -0,0 +1,236 @@
+#--
+# 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 'ruote/engine/process_error'
+
+
+module Ruote
+
+  #
+  # A 'view' on the status of a process instance.
+  #
+  # Returned by the #process and the #processes methods of the Engine.
+  #
+  class ProcessStatus
+
+    # The expressions that compose the process instance.
+    #
+    attr_reader :expressions
+
+    # An array of errors currently plaguing the process instance. Hopefully,
+    # this array is empty.
+    #
+    attr_reader :errors
+
+    def initialize (context, expressions, errors)
+
+      @expressions = expressions.collect { |e|
+        Ruote::Exp::FlowExpression.from_h(context, e) }
+
+      @errors = errors.collect { |e|
+        ProcessError.new(e) }
+    end
+
+    # Returns the expression at the root of the process instance.
+    #
+    def root_expression
+
+      @expressions.find { |e| e.fei.expid == '0' && e.fei.sub_wfid == nil }
+    end
+
+    # Returns the process variables set for this process instance.
+    #
+    def variables
+
+      root_expression.variables
+    end
+
+    # Returns a hash fei => variable_hash containing all the variable bindings
+    # (expression by expression) of the process instance.
+    #
+    def all_variables
+
+      @expressions.inject({}) do |h, exp|
+        h[exp.fei] = exp.variables if exp.variables
+        h
+      end
+    end
+
+    # Returns a hash tagname => fei of tags set at the root of the process
+    # instance.
+    #
+    def tags
+
+      variables.select { |k, v| FlowExpressionId.is_a_fei?(v) }
+    end
+
+    # Returns a hash tagname => array of feis of all the tags set in the process
+    # instance.
+    #
+    def all_tags
+
+      all_variables.inject({}) do |h, (fei, vars)|
+        vars.each { |k, v| (h[k] ||= []) << v if FlowExpressionId.is_a_fei?(v) }
+        h
+      end
+    end
+
+    # Returns the unique identifier for this process instance.
+    #
+    def wfid
+
+      root_expression.fei.wfid
+    end
+
+    def definition_name
+
+      root_expression.attribute('name') || root_expression.attribute_text
+    end
+
+    def definition_revision
+
+      root_expression.attribute('revision')
+    end
+
+    # Returns the process definition tree as it was when this process instance
+    # was launched.
+    #
+    def original_tree
+
+      root_expression.original_tree
+    end
+
+    # Returns a Time instance indicating when the process instance was launched.
+    #
+    def launched_time
+
+      root_expression.created_time
+    end
+
+    def to_s
+
+      "(process_status wfid '#{wfid}', " +
+      "expressions #{@expressions.size}, " +
+      "errors #{@errors.size})"
+    end
+
+    def inspect
+
+      s = "== #{self.class} ==\n"
+      s << "   expressions : #{@expressions.size}\n"
+      @expressions.each do |e|
+        s << "     #{e.fei.to_storage_id} : #{e}\n"
+      end
+      s << "   errors : #{@errors.size}\n"
+      @errors.each do |e|
+        s << "     #{e.inspect}\n"
+      end
+
+      s
+    end
+
+    def to_h
+
+      h = {}
+
+      %w[
+        wfid
+        definition_name definition_revision
+        original_tree current_tree
+        variables tags
+      ].each { |m| h[m] = self.send(m) }
+
+      h['launched_time'] = launched_time.to_s
+
+      # all_variables and all_tags ?
+
+      h['root_expression'] = nil
+      h['expressions'] = @expressions.collect { |e| e.fei.to_h }
+      h['errors'] = @errors.collect { |e| e.to_h }
+
+      h
+    end
+
+    # Returns the current version of the process definition tree. If no
+    # manipulation (gardening) was performed on the tree, this method yields
+    # the same result as the #original_tree method.
+    #
+    def current_tree
+
+      h = Ruote.decompose_tree(original_tree)
+
+      @expressions.sort { |e0, e1|
+        e0.fei.expid <=> e1.fei.expid
+      }.each { |e|
+        tree = if v = e.tree[1]['_triggered']
+          t = original_tree_from_parent(e).dup
+          t[1]['_triggered'] = v
+          t
+        else
+          e.tree
+        end
+        h.merge!(Ruote.decompose_tree(tree, e.fei.expid))
+      }
+
+      Ruote.recompose_tree(h)
+    end
+
+    protected
+
+    def original_tree_from_parent (e)
+
+      parent = @expressions.find { |exp| exp.fei == e.parent_id }
+
+      parent ? parent.tree[2][e.fei.child_id] : e.tree
+    end
+  end
+
+  def self.decompose_tree (t, pos='0', h={})
+
+    h[pos] = t[0, 2]
+    t[2].each_with_index { |c, i| decompose_tree(c, "#{pos}_#{i}", h) }
+    h
+  end
+
+  def self.recompose_tree (h, pos='0')
+
+    t = h[pos]
+
+    return nil unless t
+
+    t << []
+
+    i = 0
+
+    loop do
+      tt = recompose_tree(h, "#{pos}_#{i}")
+      break unless tt
+      t.last << tt
+      i = i + 1
+    end
+
+    t
+  end
+end
+

data/lib/ruote/evt/tracker.rb

@@ -0,0 +1,110 @@
+#--
+# 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.
+#++
+
+
+module Ruote
+
+  class Tracker
+
+    def initialize (context)
+
+      @context = context
+
+      if @context.worker
+        #
+        # this is a worker context, DO log
+        #
+        @context.worker.subscribe(:all, self)
+      #else
+        #
+        # this is not a worker context, no notifications. BUT
+        # honour calls to add_tracker/remove_tracker
+        #
+      end
+    end
+
+    def notify (msg)
+
+      doc = @context.storage.get_trackers
+
+      doc['trackers'].values.each do |tracker|
+
+        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 unless does_match?(msg, tracker['conditions'])
+
+        m = tracker['msg']
+
+        @context.storage.put_msg(
+          m.delete('action'),
+          m.merge!('workitem' => msg['workitem']))
+      end
+    end
+
+    def does_match? (msg, conditions)
+
+      conditions.each do |k, v|
+        val = msg[k]
+        return false unless val && val.match(v)
+      end
+
+      true
+    end
+
+    def add_tracker (wfid, action, fei, conditions, msg, doc=nil)
+
+      doc ||= @context.storage.get_trackers
+
+      doc['trackers'][Ruote.to_storage_id(fei)] =
+        { 'wfid' => wfid,
+          'action' => action,
+          'fei' => fei,
+          'conditions' => conditions,
+          'msg' => msg }
+
+      r = @context.storage.put(doc)
+
+      add_tracker(wfid, action, fei, msg, r) if r
+        # the put failed, have to redo the work
+    end
+
+    def remove_tracker (fei, doc=nil)
+
+      doc ||= @context.storage.get_trackers
+
+      doc['trackers'].delete(Ruote.to_storage_id(fei))
+
+      r = @context.storage.put(doc)
+
+      remove_tracker(fei, r) if r
+        # the put failed, have to redo the work
+    end
+  end
+end
+

data/lib/ruote/exp/command.rb

@@ -0,0 +1,88 @@
+#--
+# 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.
+#++
+
+
+module Ruote::Exp
+
+  #
+  # Commands are understood by the cursor, loop and iterator expressions.
+  #
+  module CommandMixin
+
+    F_COMMAND = '__command__'
+    ATT_COMMANDS = %w[ break rewind over stop ]
+
+    protected
+
+    # TODO : :ignore_workitem / :disallow => 'workitem' thing ?
+
+    def get_command (workitem)
+
+      command, step = workitem['fields'].delete(F_COMMAND)
+      command, step = lookup_attribute_command(workitem) unless command
+      command = 'break' if command == 'over' || command == 'stop'
+
+      return nil if command == nil
+
+      if command == 'back'
+        command = 'skip'
+        step = step ? -step : -1
+      elsif command == 'skip'
+        step ||= 1
+      end
+
+      [ command, step ]
+    end
+
+    def set_command (workitem, command, step=nil)
+
+      workitem['fields'][F_COMMAND] = [ command, step ]
+    end
+
+    def lookup_attribute_command (workitem)
+
+      lookup_att_com('if', workitem) || lookup_att_com('unless', workitem)
+    end
+
+    def lookup_att_com (dir, workitem)
+
+      ATT_COMMANDS.each do |com|
+
+        c =
+          attribute("#{com}_#{dir}", workitem) ||
+          attribute("#{com}-#{dir}", workitem)
+
+        next unless c
+
+        c = Condition.true?(c)
+
+        return [ com, nil ] \
+          if (dir == 'if' && c) || (dir == 'unless' && ( ! c))
+      end
+
+      nil
+    end
+  end
+end
+