ruote 0.9.20 → 2.1.1

data/lib/ruote/exp/fe_reserve.rb

@@ -0,0 +1,126 @@
+#--
+# 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
+
+  #
+  # Prevents two process branches from executing at the same time.
+  #
+  #   pdef = Ruote.process_definition :name => 'test' do
+  #     concurrence do
+  #       reserve :mutex => 'a' do
+  #         alpha
+  #       end
+  #       reserve 'a' do
+  #         alpha
+  #       end
+  #     end
+  #   end
+  #
+  # (Nice and tiny example, turns a concurrence into a sequence...)
+  #
+  class ReserveExpression < FlowExpression
+
+    names :reserve
+
+    def apply
+
+      return reply_to_parent(h.applied_workitem) if tree_children.empty?
+
+      h.mutex_name = attribute(:mutex) || attribute_text
+      h.mutex_name = 'reserve' if h.mutex_name.strip == ''
+
+      raise(
+        ArgumentError.new("can't bind reserve mutex at engine level")
+      ) if h.mutex_name.match(/^\/\//)
+
+      set_mutex
+    end
+
+    def reply (workitem)
+
+      release_mutex
+
+      reply_to_parent(workitem)
+    end
+
+    def cancel (flavour)
+
+      super
+
+      release_mutex
+    end
+
+    def enter
+
+      apply_child(0, h.applied_workitem)
+    end
+
+    protected
+
+    def set_mutex
+
+      target, var = locate_var(h.mutex_name)
+
+      val = target.variables[var]
+
+      # [ 'mutex', name, [ fei0, fei1, ... ] ]
+
+      mutex = val ? val : [ 'mutex', var, [] ]
+
+      mutex.last << h.fei
+
+      target.variables[var] = mutex
+
+      r = target.try_persist
+
+      return set_mutex if r != nil
+
+      if mutex.last.first == h.fei
+        enter
+      else
+        persist_or_raise
+      end
+    end
+
+    def release_mutex
+
+      target, var = locate_var(h.mutex_name)
+
+      mutex = target.variables[var]
+
+      mutex.last.shift
+
+      r = target.try_persist
+
+      return release_mutex if r != nil
+
+      next_fei = mutex.last.first
+
+      Ruote::Exp::FlowExpression.fetch(@context, next_fei).enter if next_fei
+    end
+  end
+end
+

data/lib/ruote/exp/fe_restore.rb

@@ -0,0 +1,102 @@
+#--
+# 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.
+#++
+
+
+require 'ruote/exp/merge'
+
+
+module Ruote::Exp
+
+  #
+  # Restores the fields of the current workitem. That means usually copying
+  # them from a saved version in a variable or in a separate field.
+  #
+  #   restore :from_var => 'v'
+  #
+  # or
+  #
+  #   restore :from_f => 'customer.address.street', :to_f => 'delivery.street'
+  #
+  # (yes, this sets the field 'street' inside of the field 'delivery')
+  #
+  # == set_fields
+  #
+  # This expressions has a 'set_fields' alias. It can be handy (and readable)
+  # to set a bunch of workitem fields in one sweep somewhere in a process :
+  #
+  #   Ruote.process_definition :name => 'working hard' do
+  #     sequence do
+  #       set_fields :val => { 'customer' => { 'name' => 'Fred', 'age' => 40 } }
+  #       participant :ref => 'delivery'
+  #       participant :ref => 'invoincing'
+  #     end
+  #   end
+  #
+  class RestoreExpression < FlowExpression
+
+    include MergeMixin
+
+    names :restore, :set_fields
+
+    def apply
+
+      from =
+        has_attribute(*%w[ v var variable ].map { |k| "from_#{k}" }) ||
+        has_attribute(*%w[ f fld field ].map { |k| "from_#{k}" }) ||
+        has_attribute(*%w[ val value ])
+
+      to =
+        has_attribute(*%w[ f fld field ].map { |k| "to_#{k}" }) ||
+        has_attribute('to')
+
+      from = 'from_var' if from == 'from_v'
+
+      afrom = attribute(from)
+
+      fields = if from.match(/var/)
+        lookup_variable(afrom)
+      elsif from.match(/f/)
+        Ruote.lookup(h.applied_workitem['fields'], afrom)
+      else # val
+        afrom
+      end
+
+      if to
+        Ruote.set(h.applied_workitem['fields'], attribute(to), fields)
+      else
+        h.applied_workitem['fields'] = fields
+      end
+
+      # TODO : merge strategies
+
+      reply_to_parent(h.applied_workitem)
+    end
+
+    def reply (workitem)
+
+      # empty, never called
+    end
+  end
+end
+

data/lib/ruote/exp/fe_save.rb

@@ -0,0 +1,79 @@
+#--
+# 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
+
+  #
+  # Saves the current workitem fields into a variable or into a field.
+  #
+  #   save :to_field => 'old_workitem'
+  #     #
+  #     # saves a copy of the fields of the current workitem into itself,
+  #     # in the field named 'old_workitem'
+  #
+  #   save :to_variable => '/wix'
+  #     #
+  #     # saves a copy of the current workitem in the varialbe 'wix' at
+  #     # the root of the process
+  #
+  # See also the 'restore' expression (Ruote::Exp::RestoreExpression).
+  #
+  class SaveExpression < FlowExpression
+
+    names :save
+
+    def apply
+
+      tk =
+        has_attribute(*%w[ v var variable ].map { |k| "to_#{k}" }) ||
+        has_attribute(*%w[ f fld field ].map { |k| "to_#{k}" })
+
+      return reply_to_parent(h.applied_workitem) unless tk
+
+      key = attribute(tk)
+
+      if tk.match(/^to_v/)
+
+        set_variable(key, h.applied_workitem['fields'])
+
+      elsif tk.match(/^to_f/)
+
+        Ruote.set(
+          h.applied_workitem['fields'],
+          key,
+          Ruote.fulldup(h.applied_workitem['fields']))
+      end
+
+      reply_to_parent(h.applied_workitem)
+    end
+
+    def reply (workitem)
+
+      # empty, never called
+    end
+  end
+end
+

data/lib/ruote/exp/fe_sequence.rb

@@ -0,0 +1,60 @@
+#--
+# 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 plain 'sequence' expression.
+  #
+  #   sequence do
+  #     participant 'alpha'
+  #     participant 'bravo'
+  #     participant 'charly'
+  #   end
+  #
+  class SequenceExpression < FlowExpression
+
+    names :sequence
+
+    def apply
+
+      reply(h.applied_workitem)
+    end
+
+    def reply (workitem)
+
+      position = workitem['fei'] == h.fei ?
+        0 :
+        Ruote::FlowExpressionId.new(workitem['fei']).child_id + 1
+
+      if position < tree_children.size
+        apply_child(position, workitem)
+      else
+        reply_to_parent(workitem)
+      end
+    end
+  end
+end
+

data/lib/ruote/exp/fe_set.rb

@@ -0,0 +1,160 @@
+#--
+# 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
+
+  #
+  # Setting a workitem field or a process variable.
+  #
+  #   sequence do
+  #     set :field => 'subject', :value => 'food and beverage'
+  #     set :field => 'date', :val => 'tomorrow'
+  #     participant :ref => 'attendees'
+  #   end
+  #
+  # :field can be abbreviated to :f or :fld. :variable can be abbreviated to
+  # :v or :var. Likewise, :val and :value are interchangeable.
+  #
+  # == field_value, variable_value
+  #
+  # Usually, grabbing a value from a field or a value will look like
+  #
+  #   set :f => 'my_field', :value => '${v:my_variable}'
+  #
+  # But doing those ${} substitutions always result in a string result. What
+  # if the variable or the field holds a non-string value ?
+  #
+  #   set :f => 'my_field', :var_value => 'my_variable'
+  #
+  # Is the way to go then. 'set' understands v_value, var_value, variable_value
+  # and f_value, fld_value and field_value.
+  #
+  # == :escape
+  #
+  # If the value to insert contains ${} stuff but this has to be preserved,
+  # setting the attribute :escape to true will do the trick.
+  #
+  #   set :f => 'my_field', :value => 'oh and ${whatever}', :escape => true
+  #
+  # == ruote 2.0's shorter form
+  #
+  # Ruote 2.0 introduces a shorter form for the 'set' expression :
+  #
+  #   sequence do
+  #     set :field => 'f', :value => 'val0'
+  #     set :variable => 'v', :value => 'val1'
+  #     set :field => 'f_${v:v}', :value => 'val2'
+  #   end
+  #
+  # can be rewritten as
+  #
+  #   sequence do
+  #     set 'f:f' => 'val0'
+  #     set 'v:v' => 'val1'
+  #     set 'f:f_${v:v}' => 'val2'
+  #   end
+  #
+  # since 'f:' is the default for the 'dollar notation', the shortest form
+  # becomes
+  #
+  #   sequence do
+  #     set 'f' => 'val0'
+  #     set 'v:v' => 'val1'
+  #     set 'f_${v:v}' => 'val2'
+  #   end
+  #
+  class SetExpression < FlowExpression
+
+    names :set, :unset
+
+    def apply
+
+      opts = { :escape => attribute(:escape) }
+
+      value = lookup_val(opts)
+        # a nil value is totally OK
+
+      if var_key = has_attribute(:v, :var, :variable)
+
+        set_v(attribute(var_key), value)
+
+      elsif field_key = has_attribute(:f, :fld, :field)
+
+        set_f(attribute(field_key), value)
+
+      elsif value == nil && kv = expand_atts(opts).find { |k, v| k != 'escape' }
+
+        set_vf(*kv)
+
+      else
+
+        raise ArgumentError.new(
+          "missing a variable or field target in #{tree.inspect}")
+      end
+
+      reply_to_parent(h.applied_workitem)
+    end
+
+    def reply (workitem)
+
+      # never called
+    end
+
+    protected
+
+    def set_v (key, value)
+
+      if name == 'unset'
+        unset_variable(key)
+      else
+        set_variable(key, value)
+      end
+    end
+
+    def set_f (key, value)
+
+      if name == 'unset'
+        h.applied_workitem['fields'].delete(key)
+      else
+        Ruote.set(h.applied_workitem['fields'], key, value)
+      end
+    end
+
+    PREFIX_REGEX = /^([^:]+):(.+)$/ unless defined?(PREFIX_REGEX)
+
+    def set_vf (key, value)
+
+      field = true
+
+      if m = PREFIX_REGEX.match(key)
+        field = m[1][0, 1] == 'f'
+        key = m[2]
+      end
+
+      field ? set_f(key, value) : set_v(key, value)
+    end
+  end
+end
+