openwferu 0.9.1 → 0.9.2

data/lib/openwfe/expressions/fe_cursor.rb

@@ -0,0 +1,236 @@
+#
+#--
+# 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/flowexpression'
+
+
+#
+# 'cursor' and 'loop' expressions
+#
+
+module OpenWFE
+
+    A_COMMAND_FIELD = "command-field"
+    F_COMMAND = "__cursor_command__"
+    A_DISALLOW = "disallow"
+
+    C_BACK = "back"
+    C_SKIP = "skip"
+    C_BREAK = "break"
+    C_CANCEL = "cancel"
+    C_REWIND = "rewind"
+    C_CONTINUE = "continue"
+
+    A_STEP = "step"
+
+    #
+    # The 'cursor' is much like a sequence, but you can go
+    # back and forth within it.
+    #
+    class CursorExpression < WithTemplateExpression
+
+        attr_accessor \
+            :current_child_id,
+            :current_child_fei
+
+        #
+        # apply / reply
+
+        def apply (workitem)
+
+            @current_child_id = -1
+
+            clean_children_list()
+
+            reply(workitem)
+        end
+
+        def reply (workitem)
+
+            if @children.length < 1
+                #
+                # well, currently, no infinite empty loop allowed
+                #
+                reply_to_parent(workitem)
+                return
+            end
+
+            command_field = lookup_command_field(workitem)
+            command = lookup_command(command_field, workitem)
+            disallow_list = lookup_disallow(workitem)
+
+            command = nil \
+                if disallow_list and disallow_list.include? command
+
+            if command == C_BREAK or command == C_CANCEL
+                reply_to_parent(workitem)
+                return
+            end
+
+            if command == C_REWIND or command == C_CONTINUE
+                @current_child_id = 0
+            else
+                step = lookup_step(command)
+                @current_child_id = @current_child_id + step
+
+                @current_child_id = 0 if @current_child_id < 0
+
+                if @current_child_id >= @children.length
+                    if not is_loop
+                        reply_to_parent(workitem)
+                        return
+                    end
+                    @current_child_id = 0
+                end
+            end
+
+            workitem.attributes.delete(command_field)
+
+            @current_child_fei = nil
+
+            store_itself()
+
+            @current_child_fei = @children[@current_child_id]
+
+            #
+            # launch the next child as a template
+
+            get_expression_pool\
+                .launch_template(self, @current_child_fei, workitem, nil)
+        end
+
+        #
+        # takes care of cancelling the current child if necessary
+        #
+        def cancel ()
+            get_expression_pool.cancel(@current_child_fei) \
+                if @current_child_fei
+            super()
+        end
+
+        #
+        # returns false, the child class LoopExpression does return true.
+        #
+        def is_loop
+            return false
+        end
+
+        protected
+
+            def lookup_step (command)
+
+                return 1 if not command
+
+                step = 1
+
+                ss = command.split()
+
+                if ss.length > 1
+                    step = Integer(ss[1])
+                end
+
+                step = -step if OpenWFE::starts_with(command, C_BACK)
+
+                return step
+            end
+
+            def clean_children_list
+
+                c = @children
+                @children = []
+                c.each do |child|
+                    @children << child \
+                        if child.kind_of? OpenWFE::FlowExpressionId
+                end
+            end
+
+            def lookup_command_field (workitem)
+
+                return lookup_attribute(A_COMMAND_FIELD, workitem, F_COMMAND)
+            end
+
+            def lookup_command (command_field, workitem)
+
+                command = workitem.attributes[command_field]
+                command = command.strip() if command
+
+                return command
+            end
+
+            def lookup_disallow (workitem)
+
+                return lookup_comma_list_attribute(A_DISALLOW, workitem)
+            end
+    end
+
+    #
+    # The 'loop' expression is like 'cursor' but it doesn't exit until
+    # it's broken.
+    #
+    class LoopExpression < CursorExpression
+
+        def is_loop
+            return true
+        end
+    end
+
+    #
+    # 'skip', 'continue', and the like
+    #
+    class CursorCommandExpression < FlowExpression
+
+        def apply (workitem)
+
+            command = @fei.expression_name
+
+            step = lookup_attribute(A_STEP, workitem, "1")
+            step = Integer(step)
+
+            command = "#{command} #{step}" if step != 1
+
+            workitem.attributes[F_COMMAND] = command
+
+            reply_to_parent(workitem)
+        end
+    end
+
+end
+

data/lib/{ru → openwfe/expressions}/fe_define.rb

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2006, John Mettraux, OpenWFE.org
+# Copyright (c) 2006-2007, John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -39,11 +39,11 @@
 # John Mettraux at openwfe.org
 #
 
-require 'ru/rudefinitions'
-require 'ru/flowexpression'
+require 'openwfe/rudefinitions'
+require 'openwfe/expressions/flowexpression'
 
 
-module OpenWFEru
+module OpenWFE
 
     class DefineExpression < FlowExpression
 
@@ -61,7 +61,7 @@ module OpenWFEru
 
                 #ldebug { "evaluate() looking at  #{fei.to_debug_s}" }
 
-                rawchild = get_expression_pool().fetch(fei)
+                rawchild, _fei = get_expression_pool().fetch(fei)
 
                 if not rawchild.is_definition?
                     body_fei = rawchild.fei if not body_fei

data/lib/openwfe/expressions/fe_fqv.rb

@@ -0,0 +1,99 @@
+#
+#--
+# 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/flowexpression'
+
+
+#
+# 'f', 'q' and 'v' expressions
+#
+
+module OpenWFE
+
+    #
+    # The 'cursor' is much like a sequence, but you can go
+    # back and forth within it.
+    #
+    class FqvExpression < FlowExpression
+
+        #
+        # apply / reply
+
+        def apply (workitem)
+
+            name = @fei.expression_name[0, 1]
+            text = OpenWFE::fetch_text_content(self, workitem)
+
+            method = MAP[name]
+
+            result = self.send(method, text, workitem)
+
+            OpenWFE::set_result(workitem, result) if result != nil
+
+            reply_to_parent(workitem)
+        end
+
+        #def reply (workitem)
+        #end
+
+        protected
+
+            MAP = { 
+                "f" => :field, 
+                "q" => :quote, 
+                "v" => :variable 
+            }
+
+            def field (text, workitem)
+                workitem.attributes[text]
+            end
+
+            def quote (text, workitem)
+                text
+            end
+
+            def variable (text, workitem)
+                self.lookup_variable(text)
+            end
+    end
+
+end
+

data/lib/openwfe/expressions/fe_iterator.rb

@@ -0,0 +1,182 @@
+#
+#--
+# 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/flowexpression'
+require 'openwfe/expressions/fe_utils'
+
+
+module OpenWFE
+
+    #
+    # The 'iterator' expression can be used like that for example :
+    #
+    #     <iterator
+    #         on-value="alice, bob, charles"
+    #         to-variable="user-name"
+    #     >
+    #         <set 
+    #             field="${user-name} comment" 
+    #             value="(please fill this field)"
+    #         />
+    #     </iterator>
+    #
+    # 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
+
+        attr_accessor :iterator
+
+        def apply (workitem)
+
+            if @children.length < 1
+                reply_to_parent(workitem)
+                return
+            end
+
+            @iterator = Iterator.new(self, workitem)
+
+            reply(workitem)
+        end
+
+        def reply (workitem)
+
+            unless @iterator.has_next?
+                reply_to_parent(workitem)
+                return
+            end
+
+            @iterator.next(self, workitem)
+
+            store_itself()
+
+            get_expression_pool\
+                .launch_template(self, @children[0], workitem, nil)
+        end
+    end
+
+    #
+    # Iterator instances keep track of the position of an iteration.
+    # This class is meant to be used both by <iterator> and 
+    # <concurrent-iterator>.
+    #
+    class Iterator
+
+        attr_accessor \
+            :iteration_list,
+            :to_field,
+            :to_variable,
+            :value_separator,
+            :counter
+
+        def initialize (iterator_expression, workitem)
+
+            @to_field = iterator_expression\
+                .lookup_attribute(:to_field, workitem)
+            @to_variable = iterator_expression\
+                .lookup_attribute(:to_variable, workitem)
+
+            @value_separator = iterator_expression\
+                .lookup_attribute(:value_separator, workitem, /,\s*/)
+
+            @counter = 0
+
+            raw_list = OpenWFE::lookup_vf_attribute(
+                iterator_expression, workitem, :value, :on)
+
+            @iteration_list = extract_iteration_list(raw_list)
+
+            workitem.attributes['__ic__'] = @iteration_list.length
+        end
+
+        #
+        # Has the iteration a next element ?
+        #
+        def has_next?
+            @iteration_list.length > 0
+        end
+
+        #
+        # Prepares the iterator expression and the workitem for the next 
+        # iteration.
+        #
+        def next (iterator_expression, workitem)
+
+            value = @iteration_list.pop
+
+            if @to_field
+                workitem.attributes[@to_field] = value
+            else
+                iterator_expression.set_variable(@to_variable, value)
+            end
+
+            workitem.attributes['__ip__'] = @counter
+
+            @counter = @counter + 1
+        end
+
+        protected
+
+            def extract_iteration_list (raw_list)
+
+                l = if is_suitable_list(raw_list)
+                    raw_list
+                else
+                    extract_list_from_string(raw_list.to_s)
+                end
+
+                return l.reverse
+            end
+
+            def is_suitable_list (instance)
+                instance.respond_to? :pop and \
+                instance.respond_to? :reverse and \
+                instance.respond_to? :length
+            end
+
+            def extract_list_from_string (s)
+                s.split(@value_separator)
+            end
+    end
+
+end
+