ruote 0.9.18

data/lib/openwfe/expressions/expressionmap.rb

@@ -0,0 +1,258 @@
+#
+#--
+# 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
+#
+
+require 'openwfe/expressions/raw'
+require 'openwfe/expressions/environment'
+require 'openwfe/expressions/fe_define'
+require 'openwfe/expressions/fe_misc'
+require 'openwfe/expressions/fe_set'
+require 'openwfe/expressions/fe_if'
+require 'openwfe/expressions/fe_equals'
+require 'openwfe/expressions/fe_sequence'
+require 'openwfe/expressions/fe_subprocess'
+require 'openwfe/expressions/fe_concurrence'
+require 'openwfe/expressions/fe_participant'
+require 'openwfe/expressions/fe_sleep'
+require 'openwfe/expressions/fe_cron'
+require 'openwfe/expressions/fe_when'
+require 'openwfe/expressions/fe_wait'
+require 'openwfe/expressions/fe_reserve'
+require 'openwfe/expressions/fe_losfor'
+require 'openwfe/expressions/fe_command'
+require 'openwfe/expressions/fe_cursor'
+require 'openwfe/expressions/fe_iterator'
+require 'openwfe/expressions/fe_fqv'
+require 'openwfe/expressions/fe_cancel'
+require 'openwfe/expressions/fe_do'
+require 'openwfe/expressions/fe_save'
+require 'openwfe/expressions/fe_filter_definition'
+require 'openwfe/expressions/fe_filter'
+require 'openwfe/expressions/fe_listen'
+require 'openwfe/expressions/fe_timeout'
+require 'openwfe/expressions/fe_step'
+
+
+module OpenWFE
+
+    #
+    # The mapping between expression names like 'sequence', 'participant', etc
+    # and classes like 'ParticipantExpression', 'SequenceExpression', etc.
+    #
+    class ExpressionMap
+
+        def initialize
+
+            super
+
+            @expressions = {}
+            @ancestors = {}
+
+            register DefineExpression
+
+            register DescriptionExpression
+
+            register SequenceExpression
+            register ParticipantExpression
+
+            register ConcurrenceExpression
+            register GenericSyncExpression
+
+            register ConcurrentIteratorExpression
+
+            register SubProcessRefExpression
+
+            register SetValueExpression
+            register UnsetValueExpression
+
+            register DefinedExpression
+
+            register IfExpression
+            register CaseExpression
+
+            register EqualsExpression
+
+            register SleepExpression
+            register CronExpression
+            register WhenExpression
+            register WaitExpression
+
+            register ReserveExpression
+
+            register RevalExpression
+            register PrintExpression
+            register LogExpression
+
+            register LoseExpression
+            register ForgetExpression
+
+            register CursorExpression
+            register LoopExpression
+
+            register CursorCommandExpression
+
+            register IteratorExpression
+
+            register FqvExpression
+            register AttributeExpression
+
+            register CancelProcessExpression
+
+            register UndoExpression
+            register RedoExpression
+
+            register SaveWorkItemExpression
+            register RestoreWorkItemExpression
+
+            register FilterDefinitionExpression
+            register FilterExpression
+
+            register ListenExpression
+
+            register TimeoutExpression
+
+            register EvalExpression
+            register ExpExpression
+
+            register StepExpression
+
+            register Environment
+                #
+                # only used by get_expression_names()
+
+            register_ancestors RawExpression
+            #register_ancestors XmlRawExpression
+            #register_ancestors ProgRawExpression
+                #
+                # just register the ancestors for those two
+        end
+
+        #
+        # Returns the expression class corresponding to the given
+        # expression name
+        #
+        def get_class (expression_name)
+
+            expression_name = expression_name.expression_name \
+                if expression_name.kind_of?(RawExpression)
+
+            expression_name = OpenWFE::symbol_to_name(expression_name)
+
+            @expressions[expression_name]
+        end
+
+        def get_sync_class (expression_name)
+
+            get_class(expression_name)
+        end
+
+        #
+        # Returns true if the given expression name ('sequence',
+        # 'process-definition', ...) is a DefineExpression.
+        #
+        def is_definition? (expression_name)
+
+            c = get_class(expression_name)
+
+            #c == DefineExpression
+            (c and c.is_definition?)
+        end
+
+        #
+        # Returns an array of expression names whose class are assignable
+        # from the given expression_class.
+        #
+        def get_expression_names (expression_class)
+
+            return expression_class.expression_names \
+                if expression_class.method_defined?(:expression_names)
+
+            names = []
+            @expressions.each do |k, v|
+                names << k if v.ancestors.include? expression_class
+            end
+            names
+        end
+
+        #
+        # Returns an array of expression classes that have the given
+        # class/module among their ancestors.
+        #
+        def get_expression_classes (ancestor)
+
+            @ancestors[ancestor]
+        end
+
+        def to_s
+            s = ""
+            @expressions.keys.sort.each do |name|
+                s << "- '#{name}' -> '#{@expressions[name].to_s}'\n"
+            end
+            s
+        end
+
+        #
+        # Registers an Expression class within this expression map.
+        # This method is usually never called from out of the ExpressionMap
+        # class, but, who knows, it could prove useful one day as a 'public'
+        # method.
+        #
+        def register (expression_class)
+
+            expression_class.expression_names.each do |name|
+                name = OpenWFE::to_dash(name)
+                @expressions[name] = expression_class
+            end
+            register_ancestors expression_class
+        end
+
+        protected
+
+            #
+            # registers all the ancestors of an expression class
+            #
+            def register_ancestors (expression_class)
+
+                expression_class.ancestors.each do |ancestor|
+                    (@ancestors[ancestor] ||= []) << expression_class
+                end
+            end
+    end
+
+end
+

data/lib/openwfe/expressions/fe_cancel.rb

@@ -0,0 +1,109 @@
+#
+#--
+# 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.
+#++
+#
+# $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+require 'openwfe/expressions/condition'
+require 'openwfe/expressions/flowexpression'
+
+
+module OpenWFE
+
+    #
+    # This expression cancels the current process instance. Use with care.
+    #
+    #     <sequence>
+    #         <participant ref="before" />
+    #         <cancel-process />
+    #         <participant ref="after" />
+    #     </sequence>
+    #
+    # the message "after" will never get printed.
+    #
+    # Use rather in scenarii like that one :
+    #
+    #     class TestDefinition1 < ProcessDefinition
+    #         def make
+    #             process_definition :name => "25_cancel", :revision => "1" do
+    #                 sequence do
+    #                     participant "customer"
+    #                     _cancel_process :if => "${f:no_thanks} == true"
+    #                     concurrence do
+    #                         participant "accounting"
+    #                         participant "logistics"
+    #                     end
+    #                 end
+    #             end
+    #         end
+    #     end
+    #
+    # Note that the expression accepts an "if" attribute.
+    #
+    class CancelProcessExpression < FlowExpression
+        include ConditionMixin
+
+        names :cancel_process, :cancel_flow
+
+        #
+        # apply / reply
+
+        def apply (workitem)
+
+            conditional = eval_condition(:if, workitem, :unless)
+                #
+                # for example : <cancel-process if="${approved} == false"/>
+
+            return reply_to_parent(workitem) \
+                if conditional == false
+
+            #
+            # else, do cancel the process
+
+            get_expression_pool.cancel_process self
+
+            # no need to reply to parent
+        end
+
+        #def reply (workitem)
+        #end
+
+    end
+
+end
+

data/lib/openwfe/expressions/fe_command.rb

@@ -0,0 +1,241 @@
+#
+#--
+# 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 'openwfe/expressions/condition'
+
+
+module OpenWFE
+
+    #
+    # Some constants shared by 'cursor', 'loop', 'iterator' and
+    # the CommandExpression.
+    #
+    module CommandConstants
+
+        protected
+
+            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"
+            C_JUMP = "jump"
+
+            A_STEP = "step"
+    end
+
+    #
+    # A mixin shared by 'iterator' and 'cursor' ('loop'), simply
+    # provides the methods for looking up the "command" (break, skip, 
+    # rewind, ...) from the workitem and the process.
+    #
+    module CommandMixin
+        include CommandConstants
+
+        protected
+
+            def determine_command_and_step (workitem)
+
+                command_field = lookup_command_field workitem
+
+                command, step = lookup_command command_field, workitem
+
+                disallow_list = lookup_disallow workitem
+
+                command = nil \
+                    if disallow_list and disallow_list.include?(command)
+
+                workitem.attributes.delete(command_field)
+
+                [ command, step ]
+            end
+
+        private
+
+            #
+            # Looks up the value in the command field.
+            #
+            def lookup_command_field (workitem)
+
+                lookup_attribute(
+                    A_COMMAND_FIELD, workitem, :default => F_COMMAND)
+            end
+
+            #
+            # Returns the command and the step
+            #
+            def lookup_command (command_field, workitem)
+
+                command = workitem.attributes[command_field]
+
+                return [ nil, 1 ] unless command
+                    #
+                    # this corresponds to the "just one step forward" default
+
+                command, step = command.strip.split
+
+                step = if step
+                    step.to_i
+                else
+                    1
+                end
+
+                step = -step if command == C_BACK
+
+                [ command, step ]
+            end
+
+            #
+            # Fetches the value of the 'disallow' cursor attribute.
+            #
+            def lookup_disallow (workitem)
+
+                lookup_array_attribute A_DISALLOW, workitem
+            end
+    end
+
+    #
+    # This class implements the following expressions :  back, break,
+    # cancel, continue, jump, rewind, skip.
+    #
+    # They are generally used inside of a 'cursor' (CursorExpression) or 
+    # a 'loop' (LoopExpression), they can be used outside, but their result
+    # (the value of the field '\_\_cursor_command__' will be used as soon as the
+    # flow enters a cursor or a loop).
+    #
+    # In fact, this expression is only a nice wrapper that sets the
+    # value of the field "\_\_cursor_command__" to its name ('back' for example)
+    # plus to the 'step' attribute value.
+    #
+    # For example <skip step="3"/> simply sets the value of the field 
+    # '\_\_cursor_command__' to 'skip 3'.
+    #
+    # (The field \_\_cursor_command__ is, by default, read and 
+    # obeyed by the 'cursor' expression).
+    #
+    # With Ruby process definitions, you can directly write :
+    #
+    #     skip 2
+    #     jump "0"
+    #
+    # instead of 
+    #
+    #     skip :step => "2"
+    #     jump :step => "0"
+    #
+    # Likewise, in an XML process definition, you can write
+    #
+    #     <skip>2</skip>
+    #
+    # although that might still look lighter (it's longer though) :
+    #
+    #     <skip step="2"/>
+    #
+    #
+    # About the command themselves :
+    #
+    # * back : will go back from the number of given steps, 1 by default
+    # * break : will exit the cursor (or the loop)
+    # * cancel : an alias for 'break'
+    # * continue : will exit the cursor, if in a loop, will get back at step 0
+    # * jump : will move the cursor (or loop) to an absolute given position (count starts at 0)
+    # * rewind : an alias for continue
+    # * skip : skips the given number of steps
+    #
+    #
+    # All those command support an 'if' attribute to restrict their execution :
+    #
+    #     cursor do
+    #         go_to_shop
+    #         check_prices
+    #         _break :if => "${price} > ${f:current_cash}"
+    #         buy_stuff
+    #     end
+    #
+    # The 'rif' attribute may be used instead of the 'if' attribute. Its value
+    # is some ruby code that, when evaluating to true will let the command
+    # be executed.
+    #
+    #     _skip 2, :rif => "workitem.customers.size % 2 == 0"
+    #         #
+    #         # skips if the nb of customers is pair
+    #
+    # Note that the 'rif' attribute will work only if the 
+    # <tt>:ruby_eval_allowed</tt> parameter is set to true in the engine's
+    # application context.
+    #
+    #     engine.application_context[:ruby_eval_allowed] = true
+    #
+    class CursorCommandExpression < FlowExpression
+        include CommandConstants
+        include ConditionMixin
+
+        names :back, :skip, :continue, :break, :cancel, :rewind, :jump
+
+        def apply (workitem)
+
+            conditional = eval_condition(:if, workitem, :unless)
+                #
+                # for example : <break if="${approved} == true"/>
+
+            if conditional == nil or conditional
+
+                command = @fei.expression_name
+
+                step = lookup_attribute(A_STEP, workitem)
+                step = fetch_text_content(workitem) unless step
+                step = 1 unless step
+                step = Integer(step)
+
+                command = "#{command} #{step}" #if step != 1
+
+                workitem.attributes[F_COMMAND] = command
+            end
+
+            reply_to_parent workitem
+        end
+    end
+
+end
+