ruote-maestrodev 2.2.1

data/lib/ruote/exp/iterator.rb

@@ -0,0 +1,81 @@
+#--
+# Copyright (c) 2005-2011, 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
+
+  #
+  # A Mixin shared by Ruote::IteratorExpression and
+  # Ruote::ConcurrentIteratorExpression
+  #
+  module IteratorMixin
+
+    protected
+
+    def determine_list
+
+      h.times_iterator = false
+
+      #
+      # :times or :branches
+
+      if count = attribute(:times) || attribute(:branches)
+
+        list = ((1..count.to_i).to_a rescue nil)
+
+        if list
+          h.times_iterator = true
+          return list
+        end
+      end
+
+      #
+      # :on{_...}
+
+      split_list(lookup_val_prefix('on'))
+    end
+
+    def split_list(list)
+
+      if list.is_a?(String)
+
+        sep = attribute(:separator) || attribute(:sep) || ','
+        list.split(sep).collect { |e| e.strip }
+
+      elsif list.respond_to?(:to_a)
+
+        list.to_a
+
+      elsif list.respond_to?(:[]) and list.respond_to?(:length)
+
+        list
+
+      else
+
+        []
+      end
+    end
+  end
+end
+

data/lib/ruote/exp/merge.rb

@@ -0,0 +1,118 @@
+#--
+# Copyright (c) 2005-2011, 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
+
+  #
+  # Gathering methods for merging workitems.
+  #
+  module MergeMixin
+
+    # Given a list of workitems and a merge_type, will merge according to
+    # the merge type.
+    #
+    # The return value is the merged workitem.
+    #
+    def merge_workitems(workitems, merge_type)
+
+      rworkitems = workitems.reverse
+
+      workitems.inject(nil) do |t, wi|
+        merge_workitem(workitems.index(wi), t, wi, merge_type)
+      end
+    end
+
+    # Merge workitem 'source' into workitem 'target'.
+    #
+    # If type is 'override', the source will prevail and be returned.
+    #
+    # If type is 'mix', the source fields will be merge into the target fields.
+    #
+    # If type is 'isolate', the source fields will be placed in a separte field
+    # in the target workitem. The name of this field is the child_id of the
+    # source workitem (a string from '0' to '99999' and beyond)
+    #
+    def merge_workitem(index, target, source, merge_type)
+
+      return source if merge_type == 'override'
+
+      if target == nil
+
+        case merge_type
+
+          #when 'mix'
+             # do nothing
+
+          when 'stack'
+            source['fields'] = { 'stack' => [ source['fields'] ] }
+
+          when 'isolate'
+            source['fields'] = { index.to_s => source['fields'] }
+
+          #when 'union'
+             # do nothing
+        end
+
+        source
+
+      else
+
+        case merge_type
+
+          when 'mix'
+
+            target['fields'].merge!(source['fields'])
+
+          when 'stack'
+
+            target['fields']['stack'] << source['fields']
+            target['fields']['stack_attributes'] = expand_atts
+
+          when 'isolate'
+
+            target['fields'][index.to_s] = source['fields']
+
+          when 'union'
+
+            source['fields'].each do |k, sv|
+
+              tv = target['fields'][k]
+
+              if sv.is_a?(Array) and tv.is_a?(Array)
+                tv.concat(sv)
+              elsif sv.is_a?(Hash) and tv.is_a?(Hash)
+                tv.merge!(sv)
+              else
+                target['fields'][k] = sv
+              end
+            end
+        end
+
+        target
+      end
+    end
+  end
+end
+

data/lib/ruote/exp/ro_attributes.rb

@@ -0,0 +1,212 @@
+#--
+# Copyright (c) 2005-2011, 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
+
+  #
+  # Those methods are added in FlowExpression. They were put here to offload
+  # FlowExpression and especially, to gather them around their attribute topic.
+  #
+  class FlowExpression
+
+    # Given a list of attribute names, returns the first attribute name for
+    # which there is a value.
+    #
+    def has_attribute(*args)
+
+      args.each { |a| a = a.to_s; return a if attributes[a] != nil }
+
+      nil
+    end
+
+    alias :has_att :has_attribute
+
+    # Looks up the value for attribute n.
+    #
+    def attribute(n, workitem=h.applied_workitem, options={})
+
+      n = n.to_s
+
+      default = options[:default]
+      escape = options[:escape]
+      string = options[:to_s] || options[:string]
+
+      v = attributes[n]
+
+      v = if v == nil
+        default
+      elsif escape
+        v
+      else
+        @context.dollar_sub.s(v, self, workitem)
+      end
+
+      v = v.to_s if v and string
+
+      v
+    end
+
+    # Returns the value for attribute 'key', this value should be present
+    # in the array list 'values'. If not, the default value is returned.
+    # By default, the default value is the first element of 'values'.
+    #
+    def att(key, values, opts={})
+
+      default = opts[:default] || values.first
+
+      val = attribute(key)
+      val = val.to_s if val
+
+      #raise(
+      #  ArgumentError.new("attribute '#{key}' missing in #{tree}")
+      #) if opts[:mandatory] && val == nil
+      #raise(
+      #  ArgumentError.new("attribute '#{key}' has invalid value in #{tree}")
+      #) if opts[:enforce] && (not values.include?(val))
+
+      values.include?(val) ? val : default
+    end
+
+    # prefix = 'on' => will lookup on, on_val, on_value, on_v, on_var,
+    # on_variable, on_f, on_fld, on_field...
+    #
+    def lookup_val_prefix(prefix, att_options={})
+
+      lval(
+        [ prefix ] + [ 'val', 'value' ].map { |s| "#{prefix}_#{s}" },
+        %w[ v var variable ].map { |s| "#{prefix}_#{s}" },
+        %w[ f fld field ].map { |s| "#{prefix}_#{s}" },
+        att_options)
+    end
+
+    def lookup_val(att_options={})
+
+      lval(
+        VV,
+        s_cartesian(%w[ v var variable ], VV),
+        s_cartesian(%w[ f fld field ], VV),
+        att_options)
+    end
+
+    # Returns a Hash containing all attributes set for an expression with
+    # their values resolved.
+    #
+    def compile_atts(opts={})
+
+      attributes.keys.inject({}) { |r, k|
+        r[k] = attribute(k, h.applied_workitem, opts)
+        r
+      }
+    end
+
+    # Like compile_atts, but the keys are expanded as well.
+    #
+    # Useful for things like
+    #
+    #   set "f:${v:field_name}" => "${v:that_variable}"
+    #
+    def expand_atts(opts={})
+
+      attributes.keys.inject({}) { |r, k|
+        kk = @context.dollar_sub.s(k, self, h.applied_workitem)
+        r[kk] = attribute(k, h.applied_workitem, opts)
+        r
+      }
+    end
+
+    # Given something like
+    #
+    #   sequence do
+    #     participant 'alpha'
+    #   end
+    #
+    # in the context of the participant expression
+    #
+    #   attribute_text()
+    #
+    # will yield 'alpha'.
+    #
+    # Note : an empty text returns '', not the nil value.
+    #
+    def attribute_text(workitem=h.applied_workitem)
+
+      text = attributes.keys.find { |k| attributes[k] == nil }
+
+      @context.dollar_sub.s(text.to_s, self, workitem)
+    end
+
+    protected
+
+    def determine_tos
+
+      to_v = attribute(:to_v) || attribute(:to_var) || attribute(:to_variable)
+      to_f = attribute(:to_f) || attribute(:to_fld) || attribute(:to_field)
+
+      if to = attribute(:to)
+        pre, key = to.split(':')
+        pre, key = [ 'f', pre ] if key == nil
+        if pre.match(/^f/)
+          to_f = key
+        else
+          to_v = key
+        end
+      end
+
+      [ to_v, to_f ]
+    end
+
+    # Val and Value (Sense and Sensibility ?)
+    #
+    VV = %w[ val value ]
+
+    def s_cartesian(a0, a1)
+
+      a0.inject([]) { |a, e0| a + a1.collect { |e1| "#{e0}_#{e1}" } }
+    end
+
+    def lval(vals, vars, flds, att_options)
+
+      if k = has_att(*vals)
+
+        attribute(k, h.applied_workitem, att_options)
+
+      elsif k = has_att(*vars)
+
+        k = attribute(k, h.applied_workitem, att_options)
+        lookup_variable(k)
+
+      elsif k = has_att(*flds)
+
+        k = attribute(k, h.applied_workitem, att_options)
+        Ruote.lookup(h.applied_workitem['fields'], k)
+
+      else
+
+        nil
+      end
+    end
+  end
+end
+

data/lib/ruote/exp/ro_filters.rb

@@ -0,0 +1,136 @@
+#--
+# Copyright (c) 2005-2011, 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 methods about the :filter attribute are placed in FlowExpression
+  # from here.
+  #
+  class FlowExpression
+
+    protected
+
+    # The :filter attribute work is done here, at apply (in) and at reply (out).
+    #
+    def filter(workitem=nil)
+
+      filter = lookup_filter(workitem)
+
+      return unless filter
+
+      unless filter.is_a?(Array)
+        #
+        # filter is a participant
+
+        def filter.receive(wi); end
+          # making sure the participant never replies to the engine
+
+        hwi = workitem || h.applied_workitem
+
+        if filter.respond_to?(:filter)
+          hwi['fields'] = filter.filter(hwi['fields'], workitem ? 'out' : 'in')
+        else
+          hwi['fields']['__filter_direction__'] = workitem ? 'out' : 'in'
+          filter.consume(Ruote::Workitem.new(hwi))
+        end
+
+        hwi['fields'].delete('__filter_direction__')
+
+        return
+      end
+
+      #
+      # filter is a not a participnat
+
+      unless workitem # in
+
+        h.fields_pre_filter =
+          Rufus::Json.dup(h.applied_workitem['fields'])
+        h.applied_workitem['fields'] =
+          Ruote.filter(filter, h.applied_workitem['fields'], {})
+
+      else # out
+
+        workitem['fields'] =
+          Ruote.filter(
+            filter, workitem['fields'], :double_tilde => h.fields_pre_filter)
+      end
+    end
+
+    # Used by #filter, deals with the various ways to pass filters
+    # (directly, via a variable, via a participant, in and out, ...)
+    #
+    # Returns nil, if there is no filter. Raises an ArgumentError if the
+    # filter is not usable. Returns the instantiated participant if the
+    # filter points to one.
+    #
+    def lookup_filter(workitem)
+
+      f = attribute(:filter)
+
+      return nil unless f
+
+      3.times { f = narrow_filter(f, workitem) }
+
+      raise ArgumentError.new(
+        "found no filter corresponding to '#{f}'"
+      ) unless f
+
+      f
+    end
+
+    # Called successively to dig for the filter (Array or Participant).
+    #
+    def narrow_filter(fi, workitem)
+
+      if fi.is_a?(Array) or fi.respond_to?(:consume) or fi.respond_to?(:filter)
+
+        fi
+
+      elsif fi.is_a?(Hash)
+
+        workitem ? fi['out'] || fi['reply'] : fi['in'] || fi['apply']
+
+      elsif fi.is_a?(String)
+
+        filter =
+          lookup_variable(fi) ||
+          @context.plist.lookup(fi, workitem || h.applied_workitem)
+
+        if filter.respond_to?(:consume) or filter.respond_to?(:filter)
+          (workitem || h.applied_workitem)['participant_name'] = fi
+        end
+
+        filter
+
+      else
+
+        nil
+      end
+    end
+  end
+end
+