ruote 2.1.11 → 2.2.0

data/lib/ruote/engine/process_error.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
@@ -30,7 +30,7 @@ module Ruote
   #
   class ProcessError
 
-    def initialize (h)
+    def initialize(h)
       @h = h
     end
 
@@ -65,7 +65,7 @@ module Ruote
     # A shortcut for modifying the tree of an expression when it has had
     # an error upon being applied.
     #
-    def tree= (t)
+    def tree=(t)
       @h['msg']['tree'] = t
     end
 
@@ -83,7 +83,7 @@ module Ruote
     # Exposes the workitem fields directly.
     #
     def fields
-      @h['msg']['workitem']['fields']
+      @h['msg']['workitem'] && @h['msg']['workitem']['fields']
     end
 
     # Returns an instance of Ruote::Workitem
@@ -94,7 +94,7 @@ module Ruote
 
     protected
 
-    def to_dot (opts)
+    def to_dot(opts)
 
       i = fei.to_storage_id
       label = "error : #{message.gsub(/"/, "'")}"

data/lib/ruote/engine/process_status.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
@@ -38,6 +38,10 @@ module Ruote
     #
     attr_reader :expressions
 
+    # Returns the expression at the root of the process instance.
+    #
+    attr_reader :root_expression
+
     # An array of the workitems currently in the storage participant for this
     # process instance.
     #
@@ -55,7 +59,7 @@ module Ruote
     #
     attr_reader :schedules
 
-    def initialize (context, expressions, stored_workitems, errors, schedules)
+    def initialize(context, expressions, stored_workitems, errors, schedules)
 
       @expressions = expressions.collect { |e|
         Ruote::Exp::FlowExpression.from_h(context, e) }
@@ -67,16 +71,8 @@ module Ruote
 
       @errors = errors.sort! { |a, b| a.fei.expid <=> b.fei.expid }
       @schedules = schedules.sort! { |a, b| a['owner'].sid <=> b['owner'].sid }
-    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 }
-        # vanilla implementation
 
-      root_expressions.first
+      @root_expression = root_expressions.first
     end
 
     # Returns a list of all the expressions that have no parent expression.
@@ -87,7 +83,7 @@ module Ruote
       roots = @expressions.select { |e| e.h.parent_id == nil }
 
       roots = roots.inject({}) { |h, e|
-        h["#{e.h.fei['expid']}__#{e.h.fei['sub_wfid']}"] = e; h
+        h["#{e.h.fei['expid']}__#{e.h.fei['subid']}"] = e; h
       }
 
       roots.keys.sort.collect { |k| roots[k] }
@@ -96,7 +92,7 @@ module Ruote
     # Given an expression id, returns the root (top ancestor) for its
     # expression.
     #
-    def root_expression_for (fei)
+    def root_expression_for(fei)
 
       sfei = Ruote.sid(fei)
 
@@ -112,7 +108,7 @@ module Ruote
     #
     def variables
 
-      root_expression.variables
+      @root_expression && @root_expression.variables
     end
 
     # Returns a hash fei => variable_hash containing all the variable bindings
@@ -131,7 +127,7 @@ module Ruote
     #
     def tags
 
-      variables.select { |k, v| FlowExpressionId.is_a_fei?(v) }
+      Hash[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
@@ -163,7 +159,8 @@ module Ruote
     #
     def definition_name
 
-      root_expression.attribute('name') || root_expression.attribute_text
+      @root_expression && (
+        @root_expression.attribute('name') || @root_expression.attribute_text)
     end
 
     # For a process
@@ -177,7 +174,7 @@ module Ruote
     #
     def definition_revision
 
-      root_expression.attribute('revision')
+      @root_expression && @root_expression.attribute('revision')
     end
 
     # Returns the 'position' of the process.
@@ -198,9 +195,16 @@ module Ruote
     def position
 
       workitems.collect { |wi|
+
         r = [ wi.fei.sid, wi.participant_name ]
-        params = wi.fields['params'].dup
+
+        params = (wi.fields['params'] || {}).dup
         params.delete('ref')
+
+        if err = errors.find { |e| e.fei == wi.fei }
+          params['error'] = err.message
+        end
+
         r << params
         r
       }
@@ -245,14 +249,14 @@ module Ruote
     #
     def original_tree
 
-      root_expression.original_tree
+      @root_expression && @root_expression.original_tree
     end
 
     # Returns a Time instance indicating when the process instance was launched.
     #
     def launched_time
 
-      root_expression.created_time
+      @root_expression && @root_expression.created_time
     end
 
     def to_s
@@ -267,18 +271,33 @@ module Ruote
 
     def inspect
 
+      vars = variables rescue nil
+      avars = all_variables.inject({}) { |h, (k, v)| h[Ruote.sid(k)] = v; h }
+
       s = [ "== #{self.class} ==" ]
       s << "   expressions : #{@expressions.size}"
       @expressions.each do |e|
-        s << "     #{e.fei.to_storage_id} : #{e}"
+        s << "     #{e.fei.to_storage_id}"
+        s << "       | #{e.name}"
+        s << "       | #{e.attributes.inspect}"
+        s << "       `-parent--> #{e.h.parent_id ? e.parent_id.to_storage_id : 'nil'}"
       end
+      s << "   schedules : #{@schedules.size}"
+      s << "   stored workitems : #{@stored_workitems.size}"
+      s << "   variables :     #{vars.inspect}"
+      s << "   all_variables : #{avars.inspect}"
       s << "   errors : #{@errors.size}"
       @errors.each do |e|
+        s << "     ***"
         s << "     #{e.fei.to_storage_id} :" if e.fei
-        s << "     #{e.inspect}"
+        s << "     action : #{e.action}"
+        s << "     message : #{e.message}"
+        s << "     trace :"
+        e.trace.split("\n").each do |line|
+          s << "       #{line}"
+        end
+        s << "     fields : #{e.fields.inspect}"
       end
-      s << "   schedules : #{@schedules.size}"
-      s << "   stored workitems : #{@stored_workitems.size}"
 
       s.join("\n") + "\n"
     end
@@ -286,7 +305,7 @@ module Ruote
     # Returns a 'dot' representation of the process. A graph describing
     # the tree of flow expressions that compose the process.
     #
-    def to_dot (opts={})
+    def to_dot(opts={})
 
       s = [ "digraph \"process wfid #{wfid}\" {" ]
       @expressions.each { |e| s.push(*e.send(:to_dot, opts)) }
@@ -347,7 +366,7 @@ module Ruote
 
     protected
 
-    def original_tree_from_parent (e)
+    def original_tree_from_parent(e)
 
       parent = @expressions.find { |exp| exp.fei == e.parent_id }
 
@@ -355,14 +374,14 @@ module Ruote
     end
   end
 
-  def self.decompose_tree (t, pos='0', h={})
+  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')
+  def self.recompose_tree(h, pos='0')
 
     t = h[pos]
 

data/lib/ruote/exp/command.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
@@ -37,7 +37,7 @@ module Ruote::Exp
 
     # TODO : :ignore_workitem / :disallow => 'workitem' thing ?
 
-    def get_command (workitem)
+    def get_command(workitem)
 
       command, step = workitem['fields'].delete(F_COMMAND)
       command, step = lookup_attribute_command(workitem) unless command
@@ -57,30 +57,27 @@ module Ruote::Exp
       [ command, step ]
     end
 
-    def set_command (workitem, command, step=nil)
+    def set_command(workitem, command, step=nil)
 
       workitem['fields'][F_COMMAND] = [ command, step ]
     end
 
-    def lookup_attribute_command (workitem)
+    def lookup_attribute_command(workitem)
 
       lookup_att_com('if', workitem) || lookup_att_com('unless', workitem)
     end
 
-    def lookup_att_com (dir, workitem)
+    def lookup_att_com(dir, workitem)
 
       ATT_COMMANDS.each do |com|
 
-        c =
-          attribute("#{com}_#{dir}", workitem) ||
-          attribute("#{com}-#{dir}", workitem)
+        c = attribute("#{com}_#{dir}", workitem)
 
         next unless c
 
         c = Condition.true?(c)
 
-        return [ com, nil ] \
-          if (dir == 'if' && c) || (dir == 'unless' && ( ! c))
+        return [ com, nil ] if (dir == 'if' && c) || (dir == 'unless' && ( ! c))
       end
 
       nil

data/lib/ruote/exp/commanded.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
@@ -36,7 +36,7 @@ module Ruote::Exp
 
     include CommandMixin
 
-    def reply (workitem)
+    def reply(workitem)
 
       workitem = h.command_workitem || workitem
       h.command_workitem = nil

data/lib/ruote/exp/condition.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
@@ -25,12 +25,32 @@
 
 module Ruote::Exp
 
+  #
+  # A few helper methods for evaluating :if and :unless expression
+  # attributes in process definitions.
+  #
   module Condition
 
-    SET_REGEX = /(\S*?)( +is)?( +not)?( +set)$/
-    COMPARISON_REGEX = /(.*?) *(==|!=|>=|<=|>|<|=~) *(.*)/
+    #
+    # A runtime error for unusable comparison strings.
+    #
+    class ConditionError < RuntimeError
 
-    def self.apply? (sif, sunless)
+      def initialize(code)
+        super(
+          "couldn't interpret >#{code}<, " +
+          "if it comes from a ${xx} construct, please use ${\"xx} or ${'yy}")
+      end
+    end
+
+    REGEXES = {
+      'evl_set' => /^(.+?)( +is)?( +not)?( +set)$/,
+      'evl_null' => /^(.+?)( +is)?( +not)?( +null)$/,
+      'evl_empty' => /^(.+[\]}"'])( +is)?( +not)?( +empty)$/,
+      'evl_in' => /^(.+?)( +is)?( +not)?( +in +)(\[.*\]|\{.*\})$/
+    }
+
+    def self.apply?(sif, sunless)
 
       return (true?(sif)) if sif
       return ( ! true?(sunless)) if sunless
@@ -38,77 +58,144 @@ module Ruote::Exp
       true
     end
 
-    # TODO : rconditional
-    #        is it really necessary ? there is already ${r:xxx}
-
-    def self.true? (conditional)
+    # Returns true if the given conditional string evaluates to true.
+    #
+    def self.true?(conditional)
 
-      conditional = unescape(conditional)
+      conditional = unescape(conditional.to_s)
 
-      if m = SET_REGEX.match(conditional)
-        eval_is(m)
-      elsif m = COMPARISON_REGEX.match(conditional)
-        compare(m)
-      else
-        to_b(conditional)
+      REGEXES.each do |method, regex|
+        if m = regex.match(conditional)
+          return self.send(method, m)
+        end
       end
+
+      evl(conditional) ? true : false
+
+    rescue ArgumentError => ae
+
+      raise ConditionError.new(conditional)
+    end
+
+    # Evaluates the given [conditional] code string and returns the
+    # result.
+    #
+    # Note : this is not a full Ruby evaluation !
+    #
+    def self.eval(code)
+
+      evl(code)
+
+    rescue ArgumentError => ae
+
+      raise ConditionError.new(code)
     end
 
     protected
 
-    def self.eval_is (match)
+    def self.parse(conditional)
 
-      match = match[1..-2].select { |e| e != nil }
+      Rufus::TreeChecker.parse(conditional)
 
-      negative = match.find { |m| m == ' not' }
+    rescue NoMethodError => nme
 
-      first = match.first.strip
-      is_set = first != '' && first != 'is'
+      raise NoMethodError.new(
+        "/!\\ please upgrade your rufus-treechecker gem /!\\"
+      )
 
-      negative ? (not is_set) : is_set
+    rescue => e
+
+      [ :false ]
     end
 
-    def self.unescape (s)
+    def self.unescape(s)
 
-      s ? s.to_s.gsub('&amp;', '&').gsub('&gt;', '>').gsub('&lt;', '<') : nil
+      s.gsub('&amp;', '&').gsub('&gt;', '>').gsub('&lt;', '<')
     end
 
-    def self.to_b (o)
+    COMPARATORS = %w[ == > < != >= <= ].collect { |c| c.to_sym }
 
-      o = o.strip if o.is_a?(String)
+    def self.evl(tree)
 
-      not(o == nil || o == false || o == 'false' || o == '')
-    end
+      return evl(parse(tree)) if tree.is_a?(String)
+
+      return nil if tree == []
+
+      return tree.last if tree.first == :str
+      return tree.last if tree.first == :lit
+      return tree.last.to_s if tree.first == :const
+      return nil if tree == [ :nil ]
+      return true if tree == [ :true ]
+      return false if tree == [ :false ]
 
-    def self.compare (m)
+      return ( ! evl(tree.last)) if tree.first == :not
 
-      return (m[1].=~(Regexp.new(m[3])) != nil) if m[2] == '=~'
+      return evl(tree[1]) && evl(tree[2]) if tree[0] == :and
+      return evl(tree[1]) || evl(tree[2]) if tree[0] == :or
 
-      a = narrow_to_f(m[1])
-      b = narrow_to_f(m[3])
+      return tree[1..-1].collect { |e| evl(e) } if tree[0] == :array
+      return Hash.[](*tree[1..-1].collect { |e| evl(e) }) if tree[0] == :hash
 
-      if a.class != b.class
-        a = m[1]
-        b = m[3]
+      if tree[0] == :match3
+        return evl(tree[2]) =~ evl(tree[1])
       end
+      if tree[0] == :call && tree[2] == :=~
+        return evl(tree[1]) =~ Regexp.new(evl(tree.last.last).to_s)
+      end
+
+      if tree[0] == :call && COMPARATORS.include?(tree[2])
+        return evl(tree[1]).send(tree[2], evl(tree.last.last))
+      end
+
+      return flatten(tree) if tree[0] == :call
+
+      raise ArgumentError
+
+      #require 'ruby2ruby'
+      #Ruby2Ruby.new.process(Sexp.from_array(tree))
+        # returns the raw Ruby as a String
+        # it's nice but "Loan/Grant" becomes "(Loan / Grant)"
+    end
+
+    KEYWORDS = %w[ call const arglist ].collect { |w| w.to_sym }
+
+    def self.flatten(tree)
 
-      #a.send(m[2], b)
-        # ruby 1.8.x doesn't like that one
+      (tree.flatten - KEYWORDS).collect { |e| e.nil? ? ' ' : e.to_s }.join.strip
+    end
+
+    def self.evl_set(match)
+
+      set = evl(match[1])
+      set = set != nil && set != ''
+      set = false if match[1].match(/is$/) && match[2].nil?
+
+      match[3].nil? ? set : ( ! set)
+    end
 
-      a = strip(a)
-      b = strip(b)
+    def self.evl_empty(match)
+
+      object = evl(match[1])
+
+      empty = if object.respond_to?(:empty?)
+        object.empty?
+      elsif object.nil?
+        true
+      else
+        false
+      end
 
-      m[2] == '!=' ? ( ! a.send('==', b)) : a.send(m[2], b)
+      ( ! match[3].nil? ^ empty)
     end
 
-    def self.narrow_to_f (s)
+    def self.evl_null(match)
 
-      Float(s) rescue s
+      ( ! match[3].nil? ^ evl(match[1]).nil?)
     end
 
-    def self.strip (s)
+    def self.evl_in(match)
 
-      s.respond_to?(:strip) ? s.strip : s
+      ( ! match[3].nil? ^ evl(match[5]).include?(evl(match[1]))) rescue false
     end
   end
 end