ruote 0.9.20 → 2.1.1

data/lib/ruote/exp/fe_define.rb

@@ -0,0 +1,112 @@
+#--
+# Copyright (c) 2005-2010, 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.
+#++
+
+
+module Ruote::Exp
+
+  #
+  # The main names for this expression are 'define' and 'process_definition'.
+  # It simply encloses a process definition (and gives it a name and revision
+  # if needed).
+  #
+  #   pdef = Ruote.process_definition :name => 'test', :revision => '0' do
+  #     sequence do
+  #       participant :ref => 'alice'
+  #       participant :ref => 'bob'
+  #     end
+  #   end
+  #
+  # It's used for subprocess definitions as well.
+  #
+  #   pdef = Ruote.process_definition :name => 'test', :revision => '0' do
+  #     sequence do
+  #       buy_food
+  #       cook_food
+  #     end
+  #     define 'buy_food' do
+  #       participant :ref => 'alice'
+  #     end
+  #     define :name => 'cook_food' do
+  #       participant :ref => 'bob'
+  #     end
+  #   end
+  #
+  # == like a sequence
+  #
+  # Ruote 2.0 treats the child expressions of a 'define' expression like a
+  # 'sequence' expression does. Thus, this
+  #
+  #   pdef = Ruote.process_definition :name => 'test' do
+  #     sequence do
+  #       buy_food
+  #       cook_food
+  #     end
+  #   end
+  #
+  # is equivalent to
+  #
+  #   pdef = Ruote.process_definition :name => 'test' do
+  #     buy_food
+  #     cook_food
+  #   end
+  #
+  class DefineExpression < FlowExpression
+
+    names :define, :process_definition, :workflow_definition
+
+    def apply
+
+      t = self.class.reorganize(tree).last
+
+      name = attribute(:name) || attribute_text
+
+      set_variable(name, [ h.fei['expid'], t ]) if name
+        #
+        # fei.expid : keeping track of the expid/branch for the subprocess
+        #             (so that graphical representations match)
+
+      reply_to_parent(h.applied_workitem)
+    end
+
+    # Returns true if the tree's root expression is a definition
+    # (define, process_definition, ...)
+    #
+    def self.is_definition? (tree)
+
+      self.expression_names.include?(tree.first)
+    end
+
+    # Used by instances of this class and also the expression pool,
+    # when launching a new process instance.
+    #
+    def self.reorganize (tree)
+
+      definitions, bodies = tree[2].partition { |b| is_definition?(b) }
+      name = tree[1]['name'] || tree[1].keys.find { |k| tree[1][k] == nil }
+
+      [ name, [ 'define', tree[1], definitions + bodies ] ]
+    end
+  end
+end
+

data/lib/{openwfe/engine/fs_engine.rb → ruote/exp/fe_echo.rb}

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2009, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2010, 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
@@ -23,32 +23,38 @@
 #++
 
 
-require 'openwfe/engine/engine'
-require 'openwfe/expool/fs_expstorage'
-require 'openwfe/expool/yaml_errorjournal'
-
-
-module OpenWFE
+module Ruote::Exp
 
   #
-  # An engine persisted to the file system (work/expool/ by default).
+  # An expression for echoing text to STDOUT or to a :s_tracer service
+  # (if there is one bound in the engine context).
+  #
+  #   sequence do
+  #     participant :ref => 'toto'
+  #     echo 'toto replied'
+  #   end
   #
-  class FsPersistedEngine < Engine
+  class EchoExpression < FlowExpression
 
-    protected
+    names :echo
 
-    #
-    # Overrides the method already found in Engine with a persisted
-    # expression storage
-    #
-    def build_expression_storage
+    def apply
 
-      init_storage(FsExpressionStorage)
+      text = "#{attribute_text}\n"
+
+      if t = @context['s_tracer']
+        t << text
+      else
+        print(text)
+      end
+
+      reply_to_parent(h.applied_workitem)
     end
 
-    def build_error_journal
+    def reply (workitem)
 
-      init_service(:s_error_journal, YamlErrorJournal)
+      # never called
     end
   end
 end
+

data/lib/ruote/exp/fe_equals.rb

@@ -0,0 +1,115 @@
+#--
+# Copyright (c) 2005-2010, 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.
+#++
+
+
+module Ruote::Exp
+
+  #
+  # This expression fell out of favour a long ago. At first it was used with
+  # the 'if' expression :
+  #
+  #   _if do
+  #     equals :field_value => 'customer', :other_value => 'British Petroleum'
+  #     participant :ref => 'Allister'
+  #   end
+  #
+  # but lately, the :test attribute of the 'if' expression is used :
+  #
+  #   _if :test => '${f:customer} == British Petroleum' do
+  #     participant :ref => 'Allister'
+  #   end
+  #
+  # In some cases, the 'if' expression vanishes and the :if attribute shared
+  # by all expressions is used :
+  #
+  #   participant :ref => 'Al', :if => '${f:customer} == British Petroleum'
+  #
+  #
+  # == attributes
+  #
+  # The 'equals' expression accepts those attributes :
+  #
+  # * :value
+  # * :field_value
+  # * :variable_value
+  # * :val
+  # * :field_val
+  # * :variable_val
+  #
+  # and
+  #
+  # * :other_value
+  # * :other_field_value
+  # * :other_variable_value
+  # * :other_val
+  # * :other_field_val
+  # * :other_variable_val
+  #
+  # With a bit of luck, they make sense on their own.
+  #
+  class EqualsExpression < FlowExpression
+
+    names :equals
+
+    def apply
+
+      vals = grab_values
+
+      h.applied_workitem['fields']['__result__'] = if vals.size < 2
+        false
+      else
+        (vals.first == vals.last)
+      end
+
+      reply_to_parent(h.applied_workitem)
+    end
+
+    protected
+
+    OTHER_REGEX = /^other\_(.+)$/
+
+    def grab_values
+
+      keys = attributes.keys.select { |k| ! COMMON_ATT_KEYS.include?(k) }
+
+      keys.collect { |k| grab_value(k) }
+    end
+
+    def grab_value (k)
+
+      attval = attribute(k)
+
+      if m = OTHER_REGEX.match(k)
+        k = m[1]
+      end
+
+      case k
+        when /^f/ then h.applied_workitem['fields'][attval]
+        when /^var/ then lookup_variable(attval)
+        when /^val/ then attval
+      end
+    end
+  end
+end
+

data/lib/ruote/exp/fe_error.rb

@@ -0,0 +1,90 @@
+#--
+# Copyright (c) 2005-2010, 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.
+#++
+
+
+module Ruote
+
+  #
+  # This error is used by the 'error' expression, when an error is triggered
+  # from the process definition.
+  #
+  class ForcedError < RuntimeError
+  end
+end
+
+module Ruote::Exp
+
+  #
+  # Triggers an error directly from the process definition.
+  #
+  #   Ruote.process_definition :name => 'log1' do
+  #     sequence do
+  #       perform_inventory
+  #       error 'inventory issue', :if => '${f:level} < 1'
+  #       order_new_stuff
+  #       store_new_stuff
+  #     end
+  #   end
+  #
+  # Replaying the error will 'unlock' the process.
+  #
+  class ErrorExpression < FlowExpression
+
+    names :error
+
+    def apply
+
+      # making the error occurs in the reply() phase
+      # so that the replay_at_error targets the reply and not the apply
+
+      @context.storage.put_msg(
+        'reply',
+        'fei' => h.fei,
+        'workitem' => h.applied_workitem)
+    end
+
+    def reply (workitem)
+
+      return reply_to_parent(workitem) if h.triggered
+
+      msg = attribute(:msg) || attribute(:message) || attribute_text
+      msg = 'error triggered from process definition' if msg.strip == ''
+
+      h.triggered = true
+
+      persist_or_raise # to keep track of h.triggered
+
+      raise(Ruote::ForcedError.new(msg))
+    end
+
+    def cancel (flavour)
+
+      # TODO : should the error get removed from the process status ?
+      #        it's currently done when the exp gets 'unpersisted'
+
+      reply_to_parent(h.applied_workitem)
+    end
+  end
+end
+

data/lib/ruote/exp/fe_forget.rb

@@ -0,0 +1,81 @@
+#--
+# Copyright (c) 2005-2010, 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.
+#++
+
+
+module Ruote::Exp
+
+  #
+  # Forgets all of its children.
+  #
+  # This expression is somehow deprecated in favour of the :forget attribute
+  # that any expression understands.
+  #
+  #   sequence do
+  #     participant 'alpha'
+  #     forget do
+  #       sequence do
+  #         participant 'bravo'
+  #         participant 'charly'
+  #       end
+  #     end
+  #     participant 'delta'
+  #   end
+  #
+  # In this example above, the flow goes from alpha to bravo and delta. The
+  # bravo-charly segment is independent of the main process flow. Charly's
+  # reply will be forgotten.
+  #
+  # Now the equivalent process definition, but using the :forget attribute :
+  #
+  #   sequence do
+  #     participant 'alpha'
+  #     sequence :forget => true do
+  #       participant 'bravo'
+  #       participant 'charly'
+  #     end
+  #     participant 'delta'
+  #   end
+  #
+  # This expression can be useful for fire-and-forget parallelism in processes.
+  #
+  class ForgetExpression < FlowExpression
+
+    names :forget
+
+    def apply
+
+      tree_children.each_with_index do |t, index|
+        apply_child(index, Ruote.fulldup(h.applied_workitem), true)
+      end
+
+      reply_to_parent(h.applied_workitem)
+    end
+
+    def reply (workitem)
+
+      # never gets called
+    end
+  end
+end
+