ruote 0.9.18

data/lib/openwfe/expressions/fe_losfor.rb

@@ -0,0 +1,111 @@
+#
+#--
+# 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'
+
+
+module OpenWFE
+
+    #
+    # Triggers the first (and supposedly unique child of this expression)
+    # but never wait for its reply (lose it).
+    #
+    # A 'lose' expression never replies to its parent expression.
+    #
+    #     <lose>
+    #         <participant ref="toto" />
+    #     </lose>
+    #
+    # Useful only some special process cases (like a concurrence
+    # expecting only a certain number of replies).
+    #
+    # The brother expressions is 'forget', but 'forget' triggers its child
+    # and immediately replies, whereas 'lose' doesn't reply.
+    #
+    class LoseExpression < FlowExpression
+
+        names :lose
+
+        def apply (workitem)
+
+            get_expression_pool.apply(children[0], workitem) \
+                if (@children and @children.length > 0)
+        end
+
+        def reply (workitem)
+
+            get_expression_pool.remove self
+        end
+    end
+
+    #
+    # This expression triggers its child (in its own thread) and then
+    # forgets about it. It immediately replies to its parent expression.
+    #
+    # The brother expression 'lose' triggers its child but never replies to its
+    # parent expression.
+    # 
+    # The 'forget' expression is useful for triggering process segments
+    # that are, well, dead ends.
+    #
+    class ForgetExpression < FlowExpression
+
+        names :forget
+
+        def apply (workitem)
+
+            if (@children and @children.length > 0)
+
+                wi = workitem.dup
+
+                child = @children[0]
+                get_expression_pool.forget self, child
+                get_expression_pool.apply child, wi
+            end
+
+            reply_to_parent workitem
+        end
+
+        def reply (workitem)
+            # never gets called
+        end
+    end
+
+end
+

data/lib/openwfe/expressions/fe_misc.rb

@@ -0,0 +1,421 @@
+#
+#--
+# 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 'rufus/eval'
+require 'openwfe/expressions/flowexpression'
+require 'openwfe/expressions/value'
+
+
+module OpenWFE
+
+    #
+    # The 'description' expression, simply binds the given text in
+    # the 'description' variable in the current process.
+    #
+    #     class TestDefinition2 < OpenWFE::ProcessDefinition
+    #
+    #         description :lang => "fr" do "rien de rien" end
+    #
+    #         sequence do
+    #             _print "${description}"
+    #             _print "${description__fr}"
+    #         end
+    #     end
+    #
+    class DescriptionExpression < FlowExpression
+        include ValueMixin
+
+        is_definition
+
+        names :description
+
+        DESC = 'description'
+
+
+        def reply (workitem)
+
+            lang =
+                lookup_attribute(:lang, workitem) ||
+                lookup_attribute(:language, workitem)
+
+            vname = DESC
+            vname += "__#{lang}" if lang
+
+            text = lookup_attribute('text', workitem) || workitem.get_result
+
+            set_variable(vname, text)
+            set_variable(DESC, text) unless lookup_variable(DESC)
+                # set default if not set
+
+            reply_to_parent workitem
+        end
+    end
+
+    #
+    # A debug/test expression (it's mostly used in the test suite
+    # used for the development of OpenWFEru).
+    # Outputs a message to the STDOUT (via the "puts" Ruby method).
+    #
+    #     <print>hello</print>
+    #
+    #     _print "hello"
+    #     _print do
+    #         "in a block"
+    #     end
+    #
+    # Note that when expressing the process in Ruby, an underscore has to be
+    # placed in front of the expression name to avoid a collision with the
+    # Ruby 'print' function.
+    #
+    # If there is an object bound in the application context under the
+    # name '__tracer', this expression will append its message to this
+    # instance instead of emitting to the STDOUT. (this is how the
+    # OpenWFEru test suite uses this expression).
+    #
+    class PrintExpression < FlowExpression
+        include ValueMixin
+
+        names :print
+
+        def reply (workitem)
+
+            text = workitem.get_result.to_s
+            text << "\n"
+
+            tracer = @application_context['__tracer']
+
+            if tracer
+                tracer << text
+            else
+                puts text
+            end
+
+            reply_to_parent workitem
+        end
+    end
+
+    #
+    # Evals some Ruby code contained within the process definition
+    # or within the workitem.
+    #
+    # The code is evaluated at a SAFE level of 3.
+    #
+    # If the :ruby_eval_allowed isn't set to true
+    # (<tt>engine.application_context[:ruby_eval_allowed] = true</tt>), this
+    # expression will throw an exception at apply.
+    #
+    # some examples :
+    #
+    #     <reval>
+    #         workitem.customer_name = "doug"
+    #         # or for short
+    #         wi.customer_address = "midtown 21_21 design"
+    #     </reval>
+    #
+    # in a Ruby process definition :
+    #
+    #     sequence do
+    #         _set :field => "customer" do
+    #             reval """
+    #                 {
+    #                     :name => "Cheezburger",
+    #                     :age => 34,
+    #                     :comment => "I can haz ?",
+    #                     :timestamp => Time.now.to_s
+    #                 }
+    #             """
+    #         end
+    #     end
+    #
+    # Don't embed too much Ruby into your process definitions, it might
+    # hurt...
+    #
+    # Reval can also be used with the 'code' attribute (or 'field-code' or
+    # 'variable-code') :
+    #
+    #     <reval field-code="f0" />
+    #
+    # to eval the Ruby code held in the field named "f0".
+    #
+    class RevalExpression < FlowExpression
+        include ValueMixin
+
+        names :reval
+
+        #
+        # See for an explanation on Ruby safety levels :
+        # http://www.rubycentral.com/book/taint.html
+        #
+        # 'reval' is entitled a safe level of 3.
+        #
+        SAFETY_LEVEL = 3
+
+
+        def reply (workitem)
+
+            raise "evaluation of ruby code is not allowed" \
+                if @application_context[:ruby_eval_allowed] != true
+
+            code = lookup_vf_attribute(workitem, 'code') || workitem.get_result
+            code = code.to_s
+
+            wi = workitem
+                # so that the ruby code being evaluated sees 'wi' and 'workitem'
+
+            result = Rufus::eval_safely code, SAFETY_LEVEL, binding()
+
+            workitem.set_result(result) \
+                if result != nil  # 'false' is a valid result
+
+            reply_to_parent workitem
+        end
+    end
+
+    #
+    # An advanced expression : it takes the value in a field or variable (or
+    # the nested value) and evaluates it as a process definition.
+    #
+    #     sequence
+    #         set :field => "code", :value => "<print>hello 0</print>"
+    #         _eval :field_def => "code"
+    #         set :field => "code", :value => "_print 'hello 1'"
+    #         _eval :field_def => "code"
+    #     end
+    #
+    # will print "hello0\nhello1".
+    #
+    # This expression can be useful for evaluating process definition snippets
+    # coming from participants directly.
+    #
+    # It's also dangerous. This 'eval' expression will raise an error if
+    # the parameter :dynamic_eval_allowed in the engine's application context
+    # is not set to true.
+    #
+    class EvalExpression < FlowExpression
+        include ValueMixin
+
+        names :eval
+
+
+        def reply (workitem)
+
+            raise "dynamic evaluation of process definitions is not allowed" \
+                if @application_context[:dynamic_eval_allowed] != true
+
+            df = lookup_vf_attribute(workitem, 'def') || workitem.get_result
+
+            return reply_to_parent(workitem) unless df
+                #
+                # currently, 'nothing to eval' means, 'just go on'
+
+            ldebug { "apply() def is >#{df}<" }
+
+            raw_expression = build_raw_expression df
+
+            #puts
+            #puts "======================================"
+            #puts raw_expression.to_s
+            #puts raw_expression.raw_representation
+            #puts "======================================"
+            #puts
+
+            raw_expression.apply workitem
+        end
+
+        protected
+
+            def build_raw_expression (df)
+
+                procdf = get_expression_pool.determine_rep df
+
+                RawExpression.new_raw(
+                    fei, parent_id, environment_id, application_context, procdf)
+            end
+    end
+
+    #
+    # Some kind of limited 'eval' expression.
+    #
+    # Here is an usage example :
+    #
+    #     class ExampleDef < OpenWFE::ProcessDefinition
+    #
+    #         sequence do
+    #
+    #             exp :name => "p0"
+    #             exp :name => "sub0"
+    #
+    #             exp :name => "sequence" do
+    #                 p0
+    #                 sub0
+    #             end
+    #
+    #             set :var => "a", :value => { "ref" => "p0" }
+    #             exp :name => "participant", :variable_attributes => "a"
+    #         end
+    #
+    #         process_definition :name => "sub0" do
+    #             _print "sub0"
+    #         end
+    #     end
+    #
+    # This example is a bit static, but the point is that the 'exp'
+    # is extracting the real expression name (or participant or subprocess
+    # name) from its 'name' attribute.
+    #
+    # The 'eval' expression is about evaluating a complete process definition
+    # branch, 'exp' is only about one node in the process definition.
+    #
+    class ExpExpression < RawExpression
+
+        names :exp
+
+        #--
+        #def initialize (fei, parent_id, env_id, app_context, att)
+        #    #
+        #    # this responds to the FlowExpression constructor...
+        #    super fei, parent_id, env_id, app_context, nil
+        #        #
+        #        # but this triggers the RawExpression constructor :)
+        #    @attributes = att
+        #        #
+        #        # as this is not done by the RawExpression constructor
+        #end
+        #++
+
+        def apply (workitem)
+
+            @applied_workitem = workitem
+
+            super
+        end
+
+        protected
+
+            #
+            # Evaluates the 'name' attribute, if it's not present or empty,
+            # will return the value for the 'default' attribute.
+            #
+            def expression_name
+
+                n = lookup_attribute :name, @applied_workitem
+
+                return lookup_attribute(:default, @applied_workitem) \
+                    if (not n) or (n.strip == '')
+
+                n
+            end
+
+            #
+            # If the 'attributes' attribute is present, will return its
+            # value. Else, will simply return the attributes of the 'exp'
+            # expression itself ('name' and 'default' included).
+            #
+            def extract_attributes
+
+                att = lookup_vf_attribute @applied_workitem, :attributes
+                    # will currently only work with an attribute hash
+                    # whose keys are strings... symbols :(
+
+                att || @attributes
+            end
+
+            #--
+            #def extract_descriptions
+            #    []
+            #end
+            #++
+
+            def extract_children
+                @children
+            end
+
+            def extract_parameters
+                []
+            end
+    end
+
+    #
+    # This expression simply emits a message to the application
+    # log (by default logs/openwferu.log).
+    #
+    #     <sequence>
+    #         <log>before participant alpha</log>
+    #         <participant ref="alpha" />
+    #         <log>after participant alpha</log>
+    #         <log level="warn">after participant alpha</log>
+    #     </sequence>
+    #
+    # And an example with a Ruby process definition :
+    #
+    #     sequence do
+    #         log "simple debug message"
+    #         log do
+    #             "another debug message"
+    #         end
+    #         log :message => "yet another debug message"
+    #         log :message => "an info level message", :level => "info"
+    #     end
+    #
+    # Possible log levels are 'debug' (the default), 'info', 'warn' and
+    # 'fatal'.
+    #
+    class LogExpression < FlowExpression
+        include ValueMixin
+
+        names :log
+
+        def reply (workitem)
+
+            text = lookup_attribute('message', workitem) || workitem.get_result
+
+            level = lookup_attribute('level', workitem)
+            level = level.downcase.to_sym if level
+
+            level = :debug \
+                unless [ :info, :warn, :error, :fatal ].include?(level)
+
+            get_engine.llog(level, text) if text
+
+            reply_to_parent workitem
+        end
+    end
+
+end
+