ruote 0.9.20 → 2.1.1

data/lib/ruote/exp/commanded.rb

@@ -0,0 +1,69 @@
+#--
+# 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/command'
+require 'ruote/exp/iterator'
+
+
+module Ruote::Exp
+
+  #
+  # A parent class for CursorExpression and IteratorExpression
+  #
+  class CommandedExpression < FlowExpression
+
+    include CommandMixin
+
+    def reply (workitem)
+
+      workitem = h.command_workitem || workitem
+      h.command_workitem = nil
+
+      # command/answer may come from
+      #
+      # a) a child, regular case, easy
+      # b) somewhere else, which means we have to cancel the current child
+      #    and then make sure the comand is interpreted
+
+      # a)
+
+      if Ruote::FlowExpressionId.direct_child?(h.fei, workitem['fei'])
+        return move_on(workitem)
+      end
+
+      # b)
+
+      h.command_workitem = workitem
+      h.command_workitem['fei'] = h.children.first
+
+      do_persist || return
+
+      @context.storage.put_msg('cancel', 'fei' => h.children.first)
+
+      # iteration will be done at when cancelled child replies
+    end
+  end
+end
+

data/lib/ruote/exp/condition.rb

@@ -0,0 +1,120 @@
+#--
+# 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
+
+  module Condition
+
+    SET_REGEX = /(\S*?)( +is)?( +not)?( +set)$/
+    COMPARISON_REGEX = /(.*?) *(==|!=|>=|<=|>|<|=~) *(.*)/
+
+    def self.apply? (sif, sunless)
+
+      return (true?(sif)) if sif
+      return ( ! true?(sunless)) if sunless
+
+      true
+    end
+
+    # TODO : rconditional
+    #        is it really necessary ? there is already ${r:xxx}
+
+    def self.true? (conditional)
+
+      conditional = unescape(conditional)
+
+      if m = SET_REGEX.match(conditional)
+        eval_is(m)
+      elsif m = COMPARISON_REGEX.match(conditional)
+        compare(m)
+      else
+        to_b(conditional)
+      end
+    end
+
+    protected
+
+    def self.eval_is (match)
+
+      match = match[1..-2].select { |e| e != nil }
+
+      negative = match.find { |m| m == ' not' }
+
+      first = match.first.strip
+      is_set = first != '' && first != 'is'
+
+      negative ? (not is_set) : is_set
+    end
+
+    def self.unescape (s)
+
+      s ? s.to_s.gsub('&amp;', '&').gsub('&gt;', '>').gsub('&lt;', '<') : nil
+    end
+
+    #def self.ruby_eval (s)
+    #  treechecker.check_conditional(s)
+    #  eval(s)
+    #end
+
+    def self.to_b (o)
+
+      o = o.strip if o.is_a?(String)
+
+      not(o == nil || o == false || o == 'false' || o == '')
+    end
+
+    def self.compare (m)
+
+      return (m[1].=~(Regexp.new(m[3])) != nil) if m[2] == '=~'
+
+      a = narrow_to_f(m[1])
+      b = narrow_to_f(m[3])
+
+      if a.class != b.class
+        a = m[1]
+        b = m[3]
+      end
+
+      #a.send(m[2], b)
+        # ruby 1.8.x doesn't like that one
+
+      a = strip(a)
+      b = strip(b)
+
+      m[2] == '!=' ? ( ! a.send('==', b)) : a.send(m[2], b)
+    end
+
+    def self.narrow_to_f (s)
+
+      Float(s) rescue s
+    end
+
+    def self.strip (s)
+
+      s.respond_to?(:strip) ? s.strip : s
+    end
+  end
+end
+

data/lib/ruote/exp/expression_map.rb

@@ -0,0 +1,103 @@
+#--
+# 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
+module Exp
+  # just introducing the namespace
+end
+end
+
+require 'ruote/exp/flowexpression'
+require 'ruote/exp/raw'
+
+
+exppath = File.dirname(__FILE__)
+
+Dir.new(exppath).entries.select { |p|
+  p.match(/^fe_.*\.rb$/)
+}.each { |p|
+  require exppath + '/' + p
+}
+
+
+module Ruote
+
+  #
+  # Mapping from expression names (sequence, concurrence, ...) to expression
+  # classes (Ruote::SequenceExpression, Ruote::ConcurrenceExpression, ...)
+  #
+  class ExpressionMap
+
+    def initialize (worker)
+
+      @map = {}
+      add(Ruote::Exp::RawExpression)
+      add(Ruote::Exp::DefineExpression)
+      add(Ruote::Exp::SequenceExpression)
+      add(Ruote::Exp::EchoExpression)
+      add(Ruote::Exp::ParticipantExpression)
+      add(Ruote::Exp::SetExpression)
+      add(Ruote::Exp::SubprocessExpression)
+      add(Ruote::Exp::ConcurrenceExpression)
+      add(Ruote::Exp::ConcurrentIteratorExpression)
+      add(Ruote::Exp::ForgetExpression)
+      add(Ruote::Exp::UndoExpression)
+      add(Ruote::Exp::RedoExpression)
+      add(Ruote::Exp::CancelProcessExpression)
+      add(Ruote::Exp::WaitExpression)
+      add(Ruote::Exp::ListenExpression)
+      add(Ruote::Exp::CommandExpression)
+      add(Ruote::Exp::IteratorExpression)
+      add(Ruote::Exp::CursorExpression)
+      add(Ruote::Exp::IfExpression)
+      add(Ruote::Exp::EqualsExpression)
+      add(Ruote::Exp::ReserveExpression)
+      add(Ruote::Exp::SaveExpression)
+      add(Ruote::Exp::RestoreExpression)
+      add(Ruote::Exp::NoOpExpression)
+      add(Ruote::Exp::ApplyExpression)
+      add(Ruote::Exp::AddBranchesExpression)
+      add(Ruote::Exp::ErrorExpression)
+      add(Ruote::Exp::IncExpression)
+      add(Ruote::Exp::WhenExpression)
+      add(Ruote::Exp::CronExpression)
+    end
+
+    # Returns the expression class for the given expression name
+    #
+    def expression_class (exp_name)
+
+      @map[exp_name]
+    end
+
+    protected
+
+    def add (exp_class)
+
+      exp_class.expression_names.each { |n| @map[n] = exp_class }
+    end
+  end
+end
+

data/lib/ruote/exp/fe_add_branches.rb

@@ -0,0 +1,138 @@
+#--
+# 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/iterator'
+
+
+module Ruote::Exp
+
+  #
+  # The 'add_branches'/'add_branch' expression can be used to add branches
+  # to a concurrent-iterator while it is running.
+  #
+  #   concurrent_iterator :on => 'a, b, c' do
+  #     sequence do
+  #       participant :ref => 'worker_${v:i}'
+  #       add_branches 'd, e', :if => '${v:/not_sufficient}'
+  #     end
+  #   end
+  #
+  # In this example, if the process level variable 'not_sufficient' is set to
+  # true, workers d and e will be added to the iterated elements.
+  #
+  # 'add_branches' understand comma-separated list of values or direcltly
+  # array of values, like the concurrent_iterator does. The :sep or :separator
+  # attribute can be used for custom separators :
+  #
+  #   add_branches 'd|e|f', :sep => '|'
+  #
+  #
+  # == :ref
+  #
+  # By default, add_branches looks up the first parent expression that is
+  # concurrent_iterator. This is all well, but what when you have nested
+  # concurrent_iterator and want to hit the enclosing one from inside the
+  # enclosed one ? Or when you want to add branches from somewhere else
+  # in the process instance, outside of the concurrent_iterator ?
+  #
+  #   concurrence do
+  #
+  #     concurrent_iterator :on => 'a, b, c', :tag => 'main' do
+  #       subprocess :ref => 'perform_work'
+  #     end
+  #
+  #     sequence do
+  #       subprocess :ref => 'supervise_work'
+  #       add_branches 'd, e', :ref => 'main', :if => '${f:more_cowbell}'
+  #       rewind :if => '${f:more_cowbell}'
+  #     end
+  #   end
+  #
+  # The add_branches expression refers to the 'main' concurrent_iterator via
+  # the :ref => 'main' attribute.
+  #
+  #
+  # == missing concurrent_iterator
+  #
+  # If :ref points to nothing or add_branch has no :ref and is not placed
+  # inside of a concurrent_iterator, the expression will silently have no
+  # effect.
+  #
+  class AddBranchesExpression < FlowExpression
+
+    include IteratorMixin
+
+    names :add_branches, :add_branch
+
+    def apply
+
+      list = split_list(lookup_val_prefix('on') || attribute_text)
+      it_fei = find_concurrent_iterator
+
+      if list && it_fei
+
+        wi = Ruote.fulldup(h.applied_workitem)
+        wi['fields'][ConcurrentIteratorExpression::ADD_BRANCHES_FIELD] = list
+
+        @context.storage.put_msg('reply', 'fei' => it_fei, 'workitem' => wi)
+      end
+
+      reply_to_parent(h.applied_workitem)
+    end
+
+    def reply (workitem)
+
+      # never called
+    end
+
+    protected
+
+    def find_concurrent_iterator
+
+      #
+      # ref ?
+
+      if ref = attribute(:ref)
+
+        return lookup_variable(ref)
+      end
+
+      #
+      # no :ref, lookup first parent that is a concurrent_iterator
+
+      exp = self.parent
+
+      loop do
+
+        break if exp.nil?
+        break if exp.is_a?(ConcurrentIteratorExpression)
+
+        exp = exp.parent
+      end
+
+      exp ? exp.h.fei : nil
+    end
+  end
+end
+

data/lib/ruote/exp/fe_apply.rb

@@ -0,0 +1,85 @@
+#--
+# 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 'apply' expression is an advanced expression.
+  #
+  # It takes as input an AST and applies it. The AST may be placed in a field
+  # or a variable or passed directly to the apply.
+  #
+  # These apply examples :
+  #
+  #   apply :tree => [ 'echo', { 'nada' => nil }, [] ]
+  #
+  #   sequence do
+  #     set :var => 'tree', :val => [ 'echo', { 'nada' => nil }, [] ]
+  #     apply # looks by default in variable 'tree'
+  #   end
+  #
+  #   sequence do
+  #     set :var => 't', :val => [ 'echo', { 'nada' => nil }, [] ]
+  #     apply :tree_var => 't'
+  #   end
+  #
+  #   sequence do
+  #     set :field => 't', :val => [ 'echo', { 'nada' => nil }, [] ]
+  #     apply :tree_field => 't'
+  #   end
+  #
+  # All are equivalent to
+  #
+  #   echo 'nada'
+  #
+  #
+  class ApplyExpression < FlowExpression
+
+    names :apply
+
+    # TODO : maybe accept directly ruby and xml (and json)
+    # TODO : _yield ?
+
+    def apply
+
+      #
+      # find 'tree'
+
+      tree =
+        lookup_val_prefix('tree', :escape => true) ||
+        lookup_variable('tree')
+
+      return reply_to_parent(h.applied_workitem) unless tree
+
+      #
+      # apply 'tree'
+
+      launch_sub(
+        "#{h.fei['expid']}_0", tree,
+        :variables => compile_atts(:escape => true))
+    end
+  end
+end
+