ruote 0.9.18

data/lib/openwfe/expressions/timeout.rb

@@ -0,0 +1,178 @@
+#
+#--
+# Copyright (c) 2007-2008, John Mettraux, 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.
+#++
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+require 'rufus/otime'
+
+
+#
+# Managing timeout for expressions like 'participant' and 'when'
+#
+
+module OpenWFE
+
+    #
+    # The timeout behaviour is implemented here, making it easy
+    # to mix it in into ParticipantExpression and WhenExpression.
+    #
+    module TimeoutMixin
+        include Rufus::Schedulable
+
+        attr_accessor \
+            :timeout_at,
+            :timeout_job_id
+        
+        #
+        # Looks for the "timeout" attribute in its process definition
+        # and then sets the @timeout_at field (if there is a timeout).
+        #
+        def determine_timeout (timeout_attname=:timeout)
+
+            #@timeout_at = nil
+            #@timeout_job_id = nil
+
+            timeout = lookup_attribute(timeout_attname, @applied_workitem)
+            return unless timeout
+
+            timeout = Rufus::parse_time_string(timeout)
+            @timeout_at = Time.new.to_f + timeout
+        end
+
+        #
+        # Providing a default reschedule() implementation for the expressions
+        # that use this mixin.
+        # This default implementation just reschedules the timeout.
+        #
+        def reschedule (scheduler)
+            to_reschedule(scheduler)
+        end
+
+        #
+        # Combines a call to determine_timeout and to reschedule.
+        #
+        def schedule_timeout (timeout_attname=:timeout)
+
+            determine_timeout(timeout_attname)
+            to_reschedule(get_scheduler)
+        end
+
+        #--
+        # Overrides the parent method to make sure a potential
+        # timeout schedules gets removed.
+        #
+        # Well... Leave that to classes that mix this in...
+        # No method override in a mixin...
+        #
+        #def reply_to_parent (workitem)
+        #    unschedule_timeout()
+        #    super(workitem)
+        #end
+        #++
+
+        #
+        # Places a "__timed_out__" field in the workitem.
+        #
+        def set_timedout_flag (workitem)
+
+            workitem.attributes["__timed_out__"] = "true"
+        end
+
+        #
+        # Removes any "__timed_out__" field in the workitem.
+        #
+        def remove_timedout_flag (workitem)
+
+            workitem.attributes.delete("__timed_out__")
+        end
+
+        protected
+
+            #
+            # prefixed with "to_" for easy mix in
+            #
+            def to_reschedule (scheduler)
+
+                #return if @timeout_job_id
+                    #
+                    # already rescheduled
+
+                return unless @timeout_at
+                    #
+                    # no need for a timeout
+
+                @timeout_job_id = "timeout_#{self.fei.to_s}"
+
+                scheduler.schedule_at(
+                    @timeout_at, 
+                    { :schedulable => self, 
+                      :job_id => @timeout_job_id,
+                      :do_timeout! => true,
+                      :tags => [ "timeout", self.class.name ] })
+
+                ldebug do 
+                    "to_reschedule() will timeout at " +
+                    "#{Rufus::to_iso8601_date(@timeout_at)}" +
+                    " @timeout_job_id is #{@timeout_job_id}" +
+                    " (oid #{object_id})"
+                end
+
+                #store_itself()
+                    #
+                    # done in the including expression
+            end
+
+            #
+            # Unschedules the timeout
+            #
+            def unschedule_timeout ()
+
+                ldebug do 
+                    "unschedule_timeout() " +
+                    "@timeout_job_id is #{@timeout_job_id}" +
+                    " (oid #{object_id})"
+                end
+
+                #ldebug_callstack "unschedule_timeout()"
+
+                get_scheduler.unschedule(@timeout_job_id) \
+                    if @timeout_job_id
+            end
+    end
+
+end
+

data/lib/openwfe/expressions/value.rb

@@ -0,0 +1,126 @@
+#
+#--
+# Copyright (c) 2006-2008, John Mettraux, 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.
+#++
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+module OpenWFE
+
+    #
+    # A small mixin providing value for looking up the attributes
+    # variable/var/v and field/fld/f.
+    #
+    module ValueMixin
+
+        #
+        # Expressions that include the ValueMixin let it gather values and
+        # then, in their reply() methods do the job with the values.
+        # The gathering task is performed by the ValueMixin.
+        #
+        def apply (workitem)
+
+            escape = lookup_boolean_attribute('escape', workitem, false)
+
+            if @children.length < 1
+
+                workitem.attributes[FIELD_RESULT] =
+                    lookup_value workitem, :escape => escape
+
+                reply workitem
+                return
+            end
+
+            child = @children.first
+
+            if child.kind_of?(OpenWFE::FlowExpressionId)
+
+                handle_child child, workitem
+                return
+            end
+
+            workitem.attributes[FIELD_RESULT] =
+                fetch_text_content workitem, escape
+
+            reply workitem
+        end
+
+        def lookup_variable_attribute (workitem)
+
+            lookup [ "variable", "var", "v" ], workitem
+        end
+
+        def lookup_field_attribute (workitem)
+
+            lookup [ "field", "fld", "f" ], workitem
+        end
+
+        protected
+
+            def handle_child (child, workitem)
+
+                raw_child, _fei = get_expression_pool.fetch(child)
+
+                if raw_child.is_definition?
+
+                    #body_fei = get_expression_pool.evaluate child, workitem
+                    #workitem.attributes[FIELD_RESULT] = body_fei
+
+                    workitem.attributes[FIELD_RESULT] = raw_child
+                        #
+                        # storing the child raw expression
+
+                    reply workitem
+                else
+
+                    get_expression_pool.apply raw_child, workitem
+                end
+            end
+
+        private
+
+            def lookup (name_array, workitem)
+
+                name_array.each do |n|
+                    v = lookup_string_attribute n, workitem
+                    return v if v
+                end
+
+                nil
+            end
+    end
+
+end
+

data/lib/openwfe/filterdef.rb

@@ -0,0 +1,259 @@
+#
+#--
+# Copyright (c) 2007, John Mettraux 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