ruote 0.9.18

data/lib/openwfe/expressions/fe_define.rb

@@ -0,0 +1,192 @@
+#
+#--
+# 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/flowexpression'
+require 'openwfe/expressions/fe_sequence'
+
+
+module OpenWFE
+
+    #
+    # The <process-definition> expression.
+    #
+    #     <process-definition name="myprocess" revision="2">
+    #         <sequence>
+    #             <participant ref="alpha" />
+    #             <subprocess ref="sub0" />
+    #         </sequence>
+    #         <process-definition name="sub0">
+    #             <participant ref="bravo" />
+    #         </process-definition>
+    #     </process-definition>
+    #
+    # In a Ruby process definition :
+    #
+    #     class Test0 < OpenWFE::ProcessDefinition
+    #
+    #         sequence do
+    #             sub0
+    #             sub1
+    #             sub2
+    #             sub3
+    #         end
+    #
+    #         process_definition :name => "sub0" do
+    #             _print "sub0"
+    #         end
+    #         define :name => "sub1" do
+    #             _print "sub1"
+    #         end
+    #         process_definition "sub2" do
+    #             _print "sub2"
+    #         end
+    #         define "sub3" do
+    #             _print "sub3"
+    #         end
+    #     end
+    #
+    # It is most often used with its "process-definition" name, but "define"
+    # and "workflow-definition" are accepted as well.
+    #
+    class DefineExpression < SequenceExpression
+
+        is_definition
+
+        names :define, :process_definition, :workflow_definition
+
+        #
+        # A pointer to the body expression of this process definition.
+        #
+        attr_accessor :body_fei
+
+        #--
+        # Evaluates the definition, but doesn't apply its body, will
+        # simply return the body fei.
+        #
+        #def evaluate (workitem)
+        #    @eval_only = true
+        #    apply workitem
+        #    @body_fei
+        #end
+        #++
+
+        #
+        # Called at the end of the 'evaluation', the 'apply' operation on
+        # the body of the definition is done here.
+        #
+        def reply_to_parent (workitem)
+
+            #return if @eval_only
+
+            #puts "/// \n   bf #{@body_fei} \n   wi.fei #{workitem.fei}"
+
+            return super(workitem) \
+                if @body_fei == nil or @body_fei == workitem.fei
+                #unless @body_fei
+
+            #_fei = @body_fei
+            #@body_fei = nil
+            #store_itself
+            #get_expression_pool.apply _fei, workitem
+
+            get_expression_pool.apply @body_fei, workitem
+        end
+
+        #
+        # Overrides the set_variable in FlowExpression to
+        # make sure to intercept requests for binding subprocesses
+        # at the engine level and to store a copy of the raw expression,
+        # not only the flow expression id.
+        #
+        def set_variable (name, fei)
+
+            if name[0, 2] == "//"
+
+                raw_exp = get_expression_pool.fetch_expression(fei).dup
+                raw_exp.parent_id = nil
+                raw_exp.fei = raw_exp.fei.dup
+                fei = raw_exp.fei
+                fei.wfid = get_wfid_generator.generate
+
+                raw_exp.store_itself
+            end
+
+            super name, fei
+        end
+
+        protected
+
+            #
+            # Determines the flowExpressionId of the next child to apply.
+            #
+            def next_child (current_fei)
+
+                next_fei = super
+
+                return nil unless next_fei
+
+                rawchild = get_expression_pool.fetch_expression next_fei
+
+                return next_child(next_fei) unless rawchild
+
+                unless rawchild.is_definition?
+
+                    unless @body_fei
+                        @body_fei = next_fei
+                        store_itself
+                    end
+                    return next_child(next_fei)
+                end
+
+                exp_class = get_expression_map.get_class rawchild
+
+                if exp_class == DefineExpression
+                    set_variable rawchild.definition_name, next_fei
+                    return next_child(next_fei)
+                end
+
+                next_fei
+                    #
+                    # expression is a 'set', a 'filter-definition' or
+                    # something like that, let it get applied
+            end
+    end
+
+end
+

data/lib/openwfe/expressions/fe_do.rb

@@ -0,0 +1,168 @@
+#
+#--
+# 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/utils'
+require 'openwfe/expressions/flowexpression'
+
+
+#
+# redo / undo (cancel)
+#
+
+module OpenWFE
+
+    #
+    # Every expression in OpenWFEru accepts a 'tag' attribute. This tag
+    # can later be referenced by an 'undo' or 'redo' expression.
+    # Tags are active as soon as an expression is applied and they vanish
+    # when the expression replies to its parent expression or is cancelled.
+    #
+    # Calling for the undo of a non-existent tag throws no error, the flow 
+    # simply resumes.
+    #
+    #     concurrence do
+    #         sequence :tag => "side_job" do
+    #             participant "alice"
+    #             participant "bob"
+    #         end
+    #         sequence do
+    #             participant "charly"
+    #             undo :ref => "side_job"
+    #         end
+    #     end
+    #
+    # In this example, as soon as the participant charly is over, the sequence
+    # 'side_job' gets undone (cancelled). If the sequence 'side_job' was
+    # already over, the "undo" will have no effect.
+    #
+    class UndoExpression < FlowExpression
+
+        names :undo
+
+        def apply (workitem)
+
+            tag = lookup_tag(workitem)
+
+            undo_self = false
+
+            if tag
+                #OpenWFE::call_in_thread(fei.expression_name, self) do
+                process_tag tag
+                #end
+
+                undo_self = tag.fei.ancestor_of?(@fei)
+            end
+
+            reply_to_parent(workitem) unless undo_self
+        end
+
+        #
+        # Calls the expression pool cancel() method upon the tagged
+        # expression.
+        #
+        def process_tag (tag)
+
+            ldebug do
+                "process_tag() #{fei.to_debug_s} to undo #{tag.fei.to_debug_s}"
+            end
+
+            #get_expression_pool.cancel_and_reply_to_parent(
+            #    tag.raw_expression.fei, tag.workitem)
+
+            exp = get_expression_pool.fetch_expression(tag.raw_expression.fei)
+
+            get_expression_pool.cancel(tag.raw_expression.fei)
+
+            get_expression_pool.reply_to_parent(exp, tag.workitem, false)
+                #
+                # 'remove' is set to false, cancel already removed the
+                # expression
+        end
+
+        #def reply (workitem)
+        #end
+
+        protected
+
+            def lookup_tag (workitem)
+
+                tagname = lookup_attribute :ref, workitem
+
+                tag = lookup_variable tagname
+
+                lwarn { "lookup_tag() no tag named '#{tagname}' found" } \
+                    unless tag
+
+                tag
+            end
+    end
+
+    #
+    # Every expression in OpenWFEru accepts a 'tag' attribute. This tag
+    # can later be referenced by an 'undo' or 'redo' expression.
+    #
+    # Calling for the undo of a non-existent tag throws no error, the flow 
+    # simply resumes.
+    #
+    class RedoExpression < UndoExpression
+
+        names :redo
+
+        def process_tag (tag)
+
+            ldebug do
+                "process_tag() #{fei.to_debug_s} to redo #{tag.fei.to_debug_s}"
+            end
+
+            #
+            # cancel
+
+            get_expression_pool.cancel(tag.fei)
+
+            #
+            # [re]apply
+
+            tag.raw_expression.application_context = @application_context
+
+            get_expression_pool.apply tag.raw_expression, tag.workitem
+        end
+    end
+
+end
+

data/lib/openwfe/expressions/fe_equals.rb

@@ -0,0 +1,291 @@
+#
+#--
+# 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/workitem'
+require 'openwfe/flowexpressionid'
+require 'openwfe/expressions/flowexpression'
+
+
+#
+# expressions like 'set' and 'unset' and their utility methods
+#
+
+module OpenWFE
+
+    #
+    # A Mixin shared by CompareExpression and DefinedExpression.
+    #
+    module LookupMixin
+
+        protected
+
+            def lookup_var_value (workitem, suffix=nil)
+
+                v = lookup_var workitem, suffix
+
+                return lookup_variable(v) if v
+                
+                nil
+            end
+
+            def lookup_field_value (workitem, suffix=nil)
+
+                f = lookup_field workitem, suffix
+
+                return workitem.attributes[f] if f
+
+                nil
+            end
+
+            def lookup_var (workitem, suffix=nil)
+
+                do_lookup workitem, suffix, [ :variable, :var, :v ]
+            end
+
+            def lookup_field (workitem, suffix=nil)
+
+                do_lookup workitem, suffix, [ :field, :f ]
+            end
+
+            def do_lookup (workitem, suffix, atts)
+
+                atts.each do |a|
+                    a = a.to_s + '-' + suffix if suffix
+                    v = lookup_string_attribute a, workitem
+                    return v if v
+                end
+
+                nil
+            end
+    end
+
+    #
+    # A parent class for the 'equals' expression.
+    #
+    # (there should be a 'greater-than' and a 'lesser-than' expression,
+    # but there are not that needed for now).
+    #
+    class ComparisonExpression < FlowExpression
+        include LookupMixin
+
+        def apply (workitem)
+
+            #
+            # preparing for children handling... later...
+            #
+
+            reply workitem
+        end
+
+        def reply (workitem)
+
+            value_a, value_b = lookup_values workitem
+
+            result = compare value_a, value_b
+
+            ldebug { "apply() result is '#{result}'  #{@fei.to_debug_s}" }
+
+            workitem.set_result result
+
+            reply_to_parent workitem
+        end
+
+        protected
+
+            #
+            # The bulk job of looking up the values to compare
+            #
+            def lookup_values (workitem)
+
+                value_a = lookup_value workitem
+                value_b = lookup_value workitem, :prefix => 'other'
+
+                value_c = lookup_variable_or_field_value workitem
+
+                if not value_a and value_b
+                    value_a = value_c
+                elsif value_a and not value_b
+                    value_b = value_c
+                end
+
+                [ value_a, value_b ]
+            end
+
+            #
+            # Returns the value pointed at by the variable attribute or by
+            # the field attribute, in that order.
+            #
+            def lookup_variable_or_field_value (workitem)
+
+                lookup_var_value(workitem) || lookup_field_value(workitem)
+            end
+    end
+
+    #
+    # The 'equals' expression compares two values. If those values are equal,
+    # the field (attribute) of the workitem named '__result__' will be
+    # set to true (else false).
+    #
+    # Usually, this expression is used within the 'if' expression.
+    #
+    #     <if>
+    #         <equals field-value="customer_name" other-value="Dupont" />
+    #         <!-- then -->
+    #         <participant ref="special_salesman" />
+    #         <!-- else -->
+    #         <participant ref="ordinary_salesman" />
+    #     </if>
+    #
+    # (The 'if' expression reads the '__result__' field to route the flow
+    # either towards the then branch, either towards the else one).
+    #
+    #
+    # With a Ruby process definition, a variation on the same 'equals' :
+    #
+    #     equals :field_value => "phone", :other_value => "090078367"
+    #     equals :field_val => "phone", :other_value => "090078367"
+    #     equals :f_value => "phone", :other_value => "090078367"
+    #     equals :f_val => "phone", :other_value => "090078367"
+    #     equals :f_val => "phone", :other_val => "090078367"
+    #
+    # Thus, note that 'variable' in an expression attribute can be 
+    # shortened to 'var' or 'v'. 'value' can be shortened to 'val' and
+    # 'field' to 'f'.
+    #
+    # Usually, the "test" attribute of the "if" expression is preferred
+    # over this 'equals' expression, like in :
+    #
+    #     <if test="${f:customer_name} == Dupont">
+    #         <!-- then -->
+    #         <participant ref="special_salesman" />
+    #         <!-- else -->
+    #         <participant ref="ordinary_salesman" />
+    #     </if>
+    #
+    # Another shortcut : the 'participant' and the 'subprocess' expressions
+    # accept an optional 'if' (or 'unless') attribute, so that ifs can be
+    # contracted to :
+    #
+    #     participant :ref => "toto", :if => "${f:customer_name} == Alfred"
+    #     subprocess :ref => "special_delivery", :if => "'${f:special}' != ''"
+    #
+    # This also works with the implicit form of the participant and the 
+    # subprocess :
+    #
+    #     toto :if => "${f:customer_name} == Alfred"
+    #     special_delivery :if => "'${f:special}' != ''"
+    #
+    class EqualsExpression < ComparisonExpression
+
+        names :equals
+
+        protected
+
+            def compare (a, b)
+
+                (a == b)
+            end
+    end
+
+    #
+    # This expression class actually implements 'defined' and 'undefined'.
+    #
+    # They are some kind of 'equals' for validating the presence or not
+    # of a variable or a workitem field (attribute).
+    #
+    #     <if>
+    #         <defined field="customer">
+    #         <!-- then -->
+    #         <subprocess ref="call_customer" />
+    #     </if>
+    #
+    # Since OpenWFEru 0.9.17, 'defined' and 'undefined' can be easily replaced
+    # by the "is [not ]set" suffix in the dollar notation :
+    #
+    #     <if test="${f:customer_name} is set">
+    #         <!-- then -->
+    #         <subprocess ref="call_customer" />
+    #     </if>
+    #
+    class DefinedExpression < FlowExpression
+        include LookupMixin
+
+        names :defined, :undefined
+
+        def apply (workitem)
+
+            fname = lookup_field(workitem, 'value') || lookup_field(workitem)
+
+            fmatch = lookup_string_attribute(:field_match, workitem)
+
+            vname = lookup_var(workitem, 'value') || lookup_var(workitem)
+
+            result = if fname
+                workitem.has_attribute?(fname)
+            elsif vname
+                lookup_variable(vname) != nil
+            elsif fmatch
+                field_match?(workitem, fmatch)
+            else
+                false # when in doubt, say 'no' (even when 'undefined' ?)
+            end
+
+            result = ( ! result) \
+                if result != nil and fei.expression_name == 'undefined'
+
+            workitem.set_result result
+
+            reply_to_parent workitem
+        end
+
+        protected
+
+            def field_match? (workitem, regex)
+
+                workitem.attributes.each do |k, v|
+
+                    return true if k.match(regex)
+                end
+
+                false
+            end
+    end
+
+end
+