ruote 0.9.20 → 2.1.1

data/lib/openwfe/expressions/fe_losfor.rb

@@ -1,102 +0,0 @@
-#--
-# Copyright (c) 2006-2009, John Mettraux, jmettraux@gmail.com
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# Made in Japan.
-#++
-
-
-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)
-
-      child = first_expression_child
-
-      return unless child
-
-      apply_child(child, workitem)
-    end
-
-    def reply (workitem)
-
-      get_expression_pool.remove(self)
-    end
-  end
-
-  #
-  # This expression triggers its child 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)
-
-      child = first_expression_child
-
-      get_expression_pool.tlaunch_child(
-        self,
-        child,
-        raw_children.index(child),
-        workitem.dup,
-        :orphan => true,
-        :dup_environment => true
-      ) if child
-
-      reply_to_parent(workitem)
-    end
-
-    def reply (workitem)
-      # never gets called
-    end
-  end
-
-end
-

data/lib/openwfe/expressions/fe_misc.rb

@@ -1,374 +0,0 @@
-#--
-# Copyright (c) 2006-2009, John Mettraux, jmettraux@gmail.com
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# Made in Japan.
-#++
-
-
-require 'openwfe/expressions/flowexpression'
-require 'openwfe/expressions/value'
-require 'openwfe/util/treechecker'
-
-
-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, :echo
-
-    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.
-  #
-  # 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... It's probably better to embed some ruby code in a BlockParticipant,
-  # like in
-  #
-  #   engine.register_participant :compute_total do |workitem|
-  #     sum = workitem.items.inject(0) do |sum, item|
-  #       sum += item['count'] * item['price']
-  #     end
-  #   end
-  #
-  # 2 advantages : not too much ruby code in the process definition, and the
-  # participant can be reused for another process.
-  #
-  # 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".
-  #
-  # Note that currently, the actual evaluation of the ruby code is done in
-  # the work thread, so while this ruby code is executing, there is no
-  # chance for other process instances to progress. Using a block participant
-  # (like explained a few paragraphs up here) avoids this problem altogether.
-  #
-  class RevalExpression < FlowExpression
-    include ValueMixin
-
-    names :reval
-
-
-    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'
-
-      get_tree_checker.check(code)
-
-      result = eval(code, binding())
-
-      workitem.set_result(result) \
-        if result != nil  # as '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'
-
-      tree = get_def_parser.determine_rep(df)
-
-      get_expression_pool.substitute_and_apply(self, tree, workitem)
-    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 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_children
-      @children
-    end
-
-    def extract_parameters
-      []
-    end
-  end
-
-  #
-  # This expression simply emits a message to the application
-  # log (by default logs/ruote.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
-