openwferu 0.9.8 → 0.9.9

data/lib/openwfe/expressions/fe_define.rb

@@ -39,66 +39,83 @@
 # John Mettraux at openwfe.org
 #
 
-require 'openwfe/rudefinitions'
+#require 'openwfe/rudefinitions'
 require 'openwfe/expressions/flowexpression'
+require 'openwfe/expressions/fe_sequence'
 
 
 module OpenWFE
 
-    class DefineExpression < FlowExpression
+    #
+    # The <process-definition> expression.
+    #
+    class DefineExpression < SequenceExpression
+
+        is_definition
 
         names :define, :process_definition, :workflow_definition
 
+
+        attr_accessor :body_fei, :eval_only
+
+        #
+        # Evaluates the definition, but doesn't apply its body, will 
+        # simply return the body fei.
+        #
         def evaluate (workitem)
+            @eval_only = true
+            apply workitem
+            return @body_fei
+        end
 
-            #ldebug { "evaluate()  #{@fei.to_s}" }
+        #
+        # Called at the end of the 'evaluation', the 'apply' operation on
+        # the body of the definition is done here.
+        #
+        def reply_to_parent (workitem)
 
-            #
-            # spot the body of this expression
-            # define each sub-definition
+            return if @eval_only
 
-            body_fei = nil
+            unless @body_fei
+                super workitem
+                return
+            end
 
-            @children.each do |fei|
+            fei = @body_fei
+            @body_fei = nil
 
-                #ldebug { "evaluate() looking at  #{fei.to_debug_s}" }
+            store_itself()
 
-                rawchild, _fei = get_expression_pool().fetch(fei)
+            get_expression_pool.apply fei, workitem
+        end
 
-                if not rawchild.is_definition?
-                    body_fei = rawchild.fei if not body_fei
-                    next
-                end
+        protected
 
-                # then it's a definition
+            def get_to_next_child
 
-                get_environment()[rawchild.definition_name()] = fei
-            end
-            
-            #
-            # store self
+                next_fei = super
 
-            store_itself()
+                return nil unless next_fei
 
-            #
-            # return the id of the body
+                rawchild = get_expression_pool.fetch_expression next_fei
 
-            return body_fei
-        end
+                unless rawchild.is_definition?
+                    @body_fei = next_fei unless @body_fei
+                    return get_to_next_child
+                end
 
-        #
-        # apply / reply
+                exp_class = get_expression_map.get_class rawchild
 
-        def apply (workitem)
-            #
-            # apply the body
+                if exp_class == DefineExpression
+                    get_environment()[rawchild.definition_name()] = next_fei
+                    return get_to_next_child
+                end
 
-            body_fei = evaluate(workitem)
-            get_expression_pool().apply(body_fei, workitem)
-        end
+                #
+                # our next child will simply get applied
 
-        #def reply (workitem)
-        #end
+                next_fei
+            end
     end
 
 end

data/lib/openwfe/expressions/fe_filter.rb

@@ -0,0 +1,129 @@
+#
+#--
+# 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/expressions/filter'
+
+
+module OpenWFE
+
+    #
+    # This expression applies a filter to the workitem used by the process
+    # segment nested within it.
+    #
+    #     class TestFilter48a0 < ProcessDefinition
+    #         sequence do
+    #
+    #             set :field => "readable", :value => "bible"
+    #             set :field => "writable", :value => "sand"
+    #             set :field => "randw", :value => "notebook"
+    #             set :field => "hidden", :value => "playboy"
+    #
+    #             alice
+    #
+    #             filter :name => "filter0" do
+    #                 sequence do
+    #                     bob
+    #                     charly
+    #                 end
+    #             end
+    #
+    #             doug
+    #         end
+    #
+    #         filter_definition :name => "filter0" do
+    #             field :regex => "readable", :permissions => "r"
+    #             field :regex => "writable", :permissions => "w"
+    #             field :regex => "randw", :permissions => "rw"
+    #             field :regex => "hidden", :permissions => ""
+    #         end
+    #     end
+    #
+    # In this example, the filter 'filter0' is applied upon entering bob and
+    # charly's sequence.
+    #
+    # Please note that the filter will not be enforced between bob and charly,
+    # it is enforced just before entering the sequence and just after leaving 
+    # it.
+    #
+    # Note also that the ParticipantExpression accepts a 'filter' attribute,
+    # thus :
+    #
+    #     <filter name="filter0">
+    #         <participant ref="toto" />
+    #     </filter>
+    #
+    # can be simplified to :
+    #
+    #     <participant ref="toto" filter="filter0" />
+    #
+    class FilterExpression < FlowExpression
+        include FilterMixin
+
+        names :filter
+
+        attr_accessor :applied_workitem, :filter
+
+
+        def apply workitem
+
+            if @children.length < 1
+                reply_to_parent workitem
+                return
+            end
+
+            @applied_workitem = workitem.dup
+            filter_in workitem, :name
+
+            store_itself
+
+            get_expression_pool.apply @children[0], workitem
+        end
+
+        def reply workitem
+
+            filter_out workitem
+
+            reply_to_parent workitem
+        end
+    end
+
+end
+

data/lib/openwfe/expressions/fe_filter_definition.rb

@@ -0,0 +1,170 @@
+#
+#--
+# 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/filterdef'
+
+
+module OpenWFE
+
+    #
+    # This expression binds a filter definition into a variable.
+    #
+    #     class TestFilter48a0 < ProcessDefinition
+    #         sequence do
+    #
+    #             set :field => "readable", :value => "bible"
+    #             set :field => "writable", :value => "sand"
+    #             set :field => "randw", :value => "notebook"
+    #             set :field => "hidden", :value => "playboy"
+    #
+    #             alice
+    #
+    #             filter :name => "filter0" do
+    #                 sequence do
+    #                     bob
+    #                     charly
+    #                 end
+    #             end
+    #
+    #             doug
+    #         end
+    #
+    #         filter_definition :name => "filter0" do
+    #             field :regex => "readable", :permissions => "r"
+    #             field :regex => "writable", :permissions => "w"
+    #             field :regex => "randw", :permissions => "rw"
+    #             field :regex => "hidden", :permissions => ""
+    #         end
+    #     end
+    #
+    # In that example, the filter definition is done for filter 'filter0'.
+    #
+    # A filter definition accepts 4 attributes :
+    #
+    # * 'name' - simply naming the filter, the filter is then bound as a variable. This is the only mandatory attribute.
+    #
+    # * 'closed' - by default, set to 'false'. A closed filter will not allow modifications to unspecified fields.
+    #
+    # * 'add' - by default, set to 'true'. When true, this filter accepts adding new fields to the filtered workitem.
+    #
+    # * 'remove' - by default, set to 'true'. When true, this filter accepts removing fields to the filtered workitem.
+    #
+    #
+    # Inside of the process definition, fields are identified via regular 
+    # expressions ('regex'), a 'permissions' string is then expected with four 
+    # possible values "rw", "w", "r" and "".
+    #
+    class FilterDefinitionExpression < FlowExpression
+
+        is_definition
+
+        names :filter_definition
+
+
+        #
+        # Will build the filter and bind it as a variable.
+        #
+        def apply (workitem)
+
+            filter = build_filter workitem
+            filter_name = lookup_attribute :name, workitem
+
+            set_variable filter_name, filter \
+                if filter_name and filter
+
+            reply_to_parent workitem
+        end
+
+        protected
+
+            #
+            # Builds the filter (as described in the process definition) 
+            # and returns it.
+            #
+            def build_filter (workitem)
+
+                filter = FilterDefinition.new
+
+                # filter attributes
+
+                type = lookup_downcase_attribute :type, workitem
+                closed = lookup_downcase_attribute :closed, workitem
+
+                filter.closed = (type == "closed" or closed == "true")
+
+                add = lookup_downcase_attribute :add, workitem
+                remove = lookup_downcase_attribute :remove, workitem
+
+                filter.add_allowed = (add == "true")
+                filter.remove_allowed = (remove == "true")
+
+                # field by field
+
+                @children.each do |fei|
+
+                    rawexp = get_expression_pool.fetch_expression fei
+                    get_expression_pool.remove fei
+
+                    add_field filter, rawexp, workitem
+                end
+
+                filter
+            end
+
+            #
+            # builds and add a field (a line) of the filter.
+            #
+            def add_field (filter, rawexp, workitem)
+
+                rawexp.load_attributes
+
+                regex = rawexp.lookup_attribute :regex, workitem
+                regex = rawexp.lookup_attribute :name, workitem unless regex
+
+                permissions = 
+                    rawexp.lookup_downcase_attribute :permissions, workitem
+
+                filter.add_field regex, permissions
+            end
+    end
+
+end
+

data/lib/openwfe/expressions/fe_iterator.rb

@@ -39,6 +39,7 @@
 # John Mettraux at openwfe.org
 #
 
+require 'openwfe/expressions/wtemplate'
 require 'openwfe/expressions/flowexpression'
 
 
@@ -57,16 +58,15 @@ module OpenWFE
     #         />
     #     </iterator>
     #
-    # Within the iteration, the workitem field "__ic__" contains the number
-    # of elements in the iteration and the field "__ip__" the index of the
+    # Within the iteration, the workitem field "\_\_ic__" contains the number
+    # of elements in the iteration and the field "\_\_ip__" the index of the
     # current iteration.
     #
     class IteratorExpression < WithTemplateExpression
 
         names :iterator
 
-        attr_accessor \
-            :iterator
+        attr_accessor :iterator
 
         def apply (workitem)
 
@@ -77,7 +77,7 @@ module OpenWFE
 
             @iterator = Iterator.new(self, workitem)
 
-            reply(workitem)
+            reply workitem
         end
 
         def reply (workitem)
@@ -87,12 +87,12 @@ module OpenWFE
                 return
             end
 
-            @iterator.next(self, workitem)
+            vars = @iterator.next(self, workitem)
 
             store_itself()
 
             get_expression_pool.launch_template(
-                self, @iterator.counter-1, @children[0], workitem, nil)
+                self, @iterator.index, @children[0], workitem, vars)
         end
     end
 
@@ -103,6 +103,9 @@ module OpenWFE
     #
     class Iterator
 
+        ITERATOR_COUNT = "__ic__"
+        ITERATOR_POSITION = "__ip__"
+
         attr_accessor \
             :iteration_list,
             :to_field,
@@ -129,7 +132,7 @@ module OpenWFE
 
             @iteration_list = extract_iteration_list(raw_list)
 
-            workitem.attributes['__ic__'] = @iteration_list.length
+            workitem.attributes[ITERATOR_COUNT] = @iteration_list.length
         end
 
         #
@@ -145,17 +148,27 @@ module OpenWFE
         #
         def next (iterator_expression, workitem)
 
+            result = {}
+
             value = @iteration_list.pop
 
             if @to_field
                 workitem.attributes[@to_field] = value
             else
-                iterator_expression.set_variable(@to_variable, value)
+                #iterator_expression.set_variable(@to_variable, value)
+                result[@to_variable] = value
             end
 
-            workitem.attributes['__ip__'] = @counter
+            workitem.attributes[ITERATOR_POSITION] = @counter
+            result[ITERATOR_POSITION] = @counter
 
             @counter = @counter + 1
+
+            result
+        end
+
+        def index
+            return @counter - 1
         end
 
         protected