openwferu 0.9.8 → 0.9.9

data/lib/openwfe/expressions/raw_prog.rb

@@ -155,28 +155,31 @@ module OpenWFE
 
             context.pop_parent_expression
 
-            return exp
+            exp
+        end
+
+        def do_make
+            ProcessDefinition.do_make(self)
         end
 
         #
         # A class method for actually "making" the process 
         # segment raw representation
         #
-        def ProcessDefinition.do_make ()
-
-            context = nil
-
-            if @ccontext
-                context = @ccontext
-            else
+        def ProcessDefinition.do_make (instance=nil)
+
+            context = if @ccontext
+                @ccontext
+            elsif instance
+                instance.make
+                instance.context
+            else    
                 pdef = self.new
                 pdef.make
-                context = pdef.context
+                pdef.context
             end
 
-            exp = context.top_expression
-
-            return exp if exp
+            return context.top_expression if context.top_expression
 
             name, revision = 
                 extract_name_and_revision(self.metaclass.to_s[8..-2])
@@ -190,7 +193,7 @@ module OpenWFE
 
             top_expression.children = context.top_expressions
 
-            return top_expression
+            top_expression
         end
 
         protected
@@ -218,13 +221,13 @@ module OpenWFE
                 m = Regexp.compile(".*::(.*$)").match(s)
                 return [ as_name(m[1]), '0' ] if m
 
-                return [ as_name(s), '0' ]
+                [ as_name(s), '0' ]
             end
 
             def ProcessDefinition.as_name (s)
 
                 return s[0..-11] if s.match(".*Definition$")
-                return s
+                s
             end
 
             def ProcessDefinition.as_revision (s)
@@ -269,7 +272,7 @@ module OpenWFE
                     return nil if @top_expressions.size > 1
                     exp = @top_expressions[0]
                     return exp if exp.name == "process-definition"
-                    return nil
+                    nil
                 end
             end
     end
@@ -402,14 +405,14 @@ module OpenWFE
             method_name = OpenWFE::to_underscore(method_name)
             return "_" + method_name \
                 if KEYWORDS.include? eval(":"+method_name)
-            return method_name
+            method_name
         end
 
         def OpenWFE.to_expression_name (method_name)
             method_name = method_name.to_s
             method_name = method_name[1..-1] if method_name[0, 1] == "_"
             method_name = OpenWFE::to_dash(method_name)
-            return method_name
+            method_name
         end
 
 end

data/lib/openwfe/filterdef.rb

@@ -0,0 +1,259 @@
+#
+#--
+# Copyright (c) 2007, John Mettraux, Nicolas Modrzyk OpenWFE.org
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without 
+# modification, are permitted provided that the following conditions are met:
+# 
+# . Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.  
+# 
+# . Redistributions in binary form must reproduce the above copyright notice, 
+#   this list of conditions and the following disclaimer in the documentation 
+#   and/or other materials provided with the distribution.
+# 
+# . Neither the name of the "OpenWFE" nor the names of its contributors may be
+#   used to endorse or promote products derived from this software without
+#   specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+# POSSIBILITY OF SUCH DAMAGE.
+#++
+#
+# $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+require 'openwfe/utils'
+
+
+module OpenWFE
+
+    #
+    # A 'filter' is used to restrict what a participant / user / segment
+    # of a process may see of a workitem (filter_in) and also enforces
+    # restrictions on modifications (filter_out).
+    #
+    class FilterDefinition
+
+        attr_accessor \
+            :closed,
+            :add_ok,
+            :remove_ok,
+            :fields
+
+        def initialize
+            @closed = false
+            @add_ok = true
+            @remove_ok = true
+            @fields = []
+        end
+
+        def add_allowed= (b)
+            @add_ok = b
+        end
+        def remove_allowed= (b)
+            @remove_ok = b
+        end
+
+        def may_add?
+            return @add_ok
+        end
+        def may_remove?
+            return @remove_ok
+        end
+
+        #
+        # Adds a field to the filter definition
+        #
+        #     filterdef.add_field("readonly", "r")
+        #     filterdef.add_field("hidden", nil)
+        #     filterdef.add_field("writable", :w)
+        #     filterdef.add_field("read_write", :rw)
+        #     filterdef.add_field("^toto_.*", :r)
+        #
+        def add_field (regex, permissions)
+            f = Field.new
+            f.regex = regex
+            f.permissions = permissions
+            @fields << f
+        end
+
+        #
+        # Takes a hash as input and returns a hash. The result will
+        # contain only the readable fields.
+        #
+        # Consider the following test cases to see this 
+        # 'constraining' in action :
+        #
+        #     f0 = OpenWFE::FilterDefinition.new
+        #     f0.closed = true
+        #     f0.add_field("a", "r")
+        #     f0.add_field("b", "rw")
+        #     f0.add_field("c", "")
+        #
+        #     m0 = {
+        #         "a" => "A",
+        #         "b" => "B",
+        #         "c" => "C",
+        #         "d" => "D",
+        #     }
+        #
+        #     m1 = f0.filter_in m0
+        #     assert_equal m1, { "a" => "A", "b" => "B" }
+        #
+        #     f0.closed = false
+        #
+        #     m2 = f0.filter_in m0
+        #     assert_equal m2, { "a" => "A", "b" => "B", "d" => "D" }
+        #
+        def filter_in (map)
+
+            result = {}
+
+            map.each do |key, value|
+
+                field = get_field key
+
+                if @closed
+                    result[key] = value if field and field.may_read?
+                else
+                    result[key] = value if (not field) or field.may_read?
+                end
+            end
+
+            result
+        end
+
+        def filter_out (original_map, map)
+
+            # method with a high cyclomatic score :)
+
+            result = {}
+
+            build_out_map(original_map, map).each do |key, v|
+
+                field, ovalue, nvalue = v
+
+                #
+                # adding a brand new field...
+
+                isnew = ((not field) and (ovalue == nil) and (nvalue != nil))
+
+                if isnew
+                    result[key] = nvalue if @add_ok
+                    next
+                end
+
+                #
+                # removing a field
+
+                isremoval = ((ovalue != nil) and (nvalue == nil))
+
+                if isremoval
+                    result[key] = ovalue unless @remove_ok
+                    next
+                end
+
+                #
+                # no modification
+
+                haschanged = (ovalue != nvalue)
+
+                #puts "haschanged ? #{haschanged}"
+
+                if haschanged
+
+                    result[key] = unless field
+                        if @closed
+                            ovalue
+                        else
+                            nvalue
+                        end
+                    else
+                        if field.may_write?
+                            nvalue
+                        else
+                            ovalue
+                        end
+                    end
+
+                    next
+                end
+
+                # else, just use, the old value
+
+                result[key] = ovalue
+            end
+
+            result
+        end
+
+        #
+        # Returns a deep copy of this filter instance.
+        #
+        def dup
+            OpenWFE::fulldup self
+        end
+
+        protected
+
+            #
+            # pre-digesting the two maps
+            #
+            def build_out_map (original_map, map)
+
+                keys = {}
+                keys.merge! original_map
+                keys.merge! map
+
+                m = {}
+                keys.keys.each do |k|
+                    m[k] = [ get_field(k), original_map[k], map[k] ]
+                end
+
+                #require 'pp'; pp m
+                m
+            end
+
+            #
+            # Returns the first field mapping a given key
+            #
+            def get_field (key)
+                @fields.detect do |f|
+                    key.match f.regex
+                end
+            end
+
+            class Field
+                attr_accessor :regex, :permissions
+
+                def may_read?
+                    @permissions.to_s.index("r") != nil
+                end
+
+                def may_write?
+                    @permissions.to_s.index("w") != nil
+                end
+
+                def no_rights?
+                    @permissions.to_s == ""
+                end
+            end
+    end
+end

data/lib/openwfe/flowexpressionid.rb

@@ -143,6 +143,7 @@ module OpenWFE
         #def to_debug_s
         #    "#{to_s}  (h#{hash}) (i#{object_id})"
         #end
+
         def to_debug_s
             "(fei #{@workflow_definition_name} #{@workflow_definition_revision} #{@workflow_instance_id} #{@expression_id} #{@expression_name})"
         end
@@ -151,6 +152,14 @@ module OpenWFE
             "(fei #{@workflow_instance_id} #{@expression_id} #{@expression_name})"
         end
 
+        #
+        # Yet another debugging method. Just returns the sub_instance_id and
+        # the expression_id, in a string.
+        #
+        def to_env_s
+            "i#{sub_instance_id}  #{@expression_id}"
+        end
+
         #
         # Returns the workflow instance id without any subflow indices.
         # For example, if the wfid is "1234.0.1", this method will
@@ -158,13 +167,37 @@ module OpenWFE
         #
         def parent_workflow_instance_id
             i = workflow_instance_id.index(".")
-            return workflow_instance_id if not i
-            #return workflow_instance_id[0..i]
-            return workflow_instance_id[0..i-1]
+            return workflow_instance_id unless i
+            workflow_instance_id[0..i-1]
         end
 
         alias :parent_wfid :parent_workflow_instance_id
 
+        #
+        # Returns "" if this expression id belongs to a top process,
+        # returns something like ".0" or ".1.3" if this exp id belongs to
+        # an expression in a subprocess.
+        # (Only used in some unit tests for now)
+        #
+        def sub_instance_id
+            i = workflow_instance_id.index(".")
+            return "" unless i
+            workflow_instance_id[i..-1]
+        end
+
+        #
+        # Returns the last part of the expression_id. For example, if
+        # the expression_id is "0.1.0.4", "4" will be returned.
+        #
+        # This method is used in "concurrence" when merging workitems coming
+        # backing from the children expressions.
+        #
+        def child_id
+            i = @expression_id.rindex(".")
+            return @expression_id unless i
+            @expression_id[i+1..-1]
+        end
+
         #
         # This class method parses a string into a FlowExpressionId instance
         #

data/lib/openwfe/participants/participants.rb

@@ -156,6 +156,12 @@ module OpenWFE
     # Having the FlowExpression instance at hand allows for advanced tricks,
     # beware...
     #
+    # It's also OK to register a block participant without params :
+    #
+    #     engine.register_participant :alice do
+    #         puts "Alice received a workitem"
+    #     end
+    #
     class BlockParticipant 
         include LocalParticipant
 
@@ -180,7 +186,7 @@ module OpenWFE
             end
 
             if result
-                ldebug { "consume() result is of class #{result.class.name}" }
+                #ldebug { "consume() result is of class #{result.class.name}" }
                 workitem.set_result(result) 
             end
 

data/lib/openwfe/rest/xmlcodec.rb

@@ -413,7 +413,7 @@ module OpenWFE
 
                 # add filter ? no
 
-                encode_history(item, root)
+                encode_history(item, root) if item.history
 
                 doc << root
 

data/lib/openwfe/util/dollar.rb

@@ -48,7 +48,7 @@ require 'openwfe/util/safe'
 
 module OpenWFE
 
-    SAFETY_LEVEL = 3
+    DSUB_SAFETY_LEVEL = 3
         #
         # Ruby code ${ruby:...} will be evaluated with this
         # safety level.
@@ -215,7 +215,9 @@ module OpenWFE
 
                 #eval(ruby_code, binding).to_s
                 #eval(ruby_code).to_s
-                OpenWFE::eval_safely(ruby_code, SAFETY_LEVEL, binding()).to_s
+
+                OpenWFE::eval_safely(
+                    ruby_code, DSUB_SAFETY_LEVEL, binding()).to_s
             end
     end