ruote 0.9.18 → 0.9.19

data/lib/openwfe/expressions/filter.rb

@@ -2,31 +2,31 @@
 #--
 # Copyright (c) 2007, John Mettraux, OpenWFE.org
 # All rights reserved.
-# 
-# Redistribution and use in source and binary forms, with or without 
+#
+# Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are met:
-# 
+#
 # . Redistributions of source code must retain the above copyright notice, this
-#   list of conditions and the following disclaimer.  
-# 
-# . Redistributions in binary form must reproduce the above copyright notice, 
-#   this list of conditions and the following disclaimer in the documentation 
+#   list of conditions and the following disclaimer.
+#
+# . Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
 #   and/or other materials provided with the distribution.
-# 
+#
 # . Neither the name of the "OpenWFE" nor the names of its contributors may be
 #   used to endorse or promote products derived from this software without
 #   specific prior written permission.
-# 
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
-# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
-# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
-# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
-# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
-# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 # POSSIBILITY OF SUCH DAMAGE.
 #++
 #
@@ -44,61 +44,61 @@
 
 module OpenWFE
 
-    #
-    # This mixin adds filtering capabilities to a FlowExpression.
-    #
-    # It's used by the 'participant' and 'filter' expressions.
-    #
-    module FilterMixin
+  #
+  # This mixin adds filtering capabilities to a FlowExpression.
+  #
+  # It's used by the 'participant' and 'filter' expressions.
+  #
+  module FilterMixin
 
-        attr_accessor :filter
+    attr_accessor :filter
 
-        #
-        # Used when the workitem enters the 'filtered zone'. Will replace
-        # the attributes of the workitem with filtered ones.
-        # Assumes the original workitem is kept under @applied_workitem.
-        #
-        def filter_in workitem, filter_attribute_name=:filter
+    #
+    # Used when the workitem enters the 'filtered zone'. Will replace
+    # the attributes of the workitem with filtered ones.
+    # Assumes the original workitem is kept under @applied_workitem.
+    #
+    def filter_in workitem, filter_attribute_name=:filter
 
-            @filter = get_filter filter_attribute_name, workitem
+      @filter = get_filter filter_attribute_name, workitem
 
-            return unless @filter
+      return unless @filter
 
-            workitem.attributes = @filter.filter_in workitem.attributes
-            workitem.filter = @filter.dup
-        end
+      workitem.attributes = @filter.filter_in workitem.attributes
+      workitem.filter = @filter.dup
+    end
 
-        #
-        # Prepares the workitem for leaving the 'filtered zone'. Makes sure
-        # hidden and unwritable fields haven't been tampered with. Enforces
-        # the 'add_ok', 'remove_ok', 'closed' filter directives.
-        # Assumes the original workitem is kept under @applied_workitem.
-        #
-        def filter_out incoming_workitem
+    #
+    # Prepares the workitem for leaving the 'filtered zone'. Makes sure
+    # hidden and unwritable fields haven't been tampered with. Enforces
+    # the 'add_ok', 'remove_ok', 'closed' filter directives.
+    # Assumes the original workitem is kept under @applied_workitem.
+    #
+    def filter_out incoming_workitem
 
-            return unless @filter
+      return unless @filter
 
-            incoming_workitem.filter = nil
+      incoming_workitem.filter = nil
 
-            incoming_workitem.attributes = @filter.filter_out(
-                @applied_workitem.attributes, incoming_workitem.attributes)
-        end
+      incoming_workitem.attributes = @filter.filter_out(
+        @applied_workitem.attributes, incoming_workitem.attributes)
+    end
 
-        protected
+    protected
 
-            #
-            # Fetches the filter pointed at via the 'filter' attribute
-            # of the including expression class.
-            #
-            def get_filter filter_attribute_name, workitem
+      #
+      # Fetches the filter pointed at via the 'filter' attribute
+      # of the including expression class.
+      #
+      def get_filter filter_attribute_name, workitem
 
-                filter_name = lookup_attribute filter_attribute_name, workitem
+        filter_name = lookup_attribute filter_attribute_name, workitem
 
-                return nil unless filter_name
+        return nil unless filter_name
 
-                lookup_variable filter_name
-            end
-    end
+        lookup_variable filter_name
+      end
+  end
 
 end
 

data/lib/openwfe/expressions/flowexpression.rb

@@ -47,801 +47,807 @@ require 'openwfe/util/dollar'
 
 module OpenWFE
 
+  #
+  # When this variable is set to true (at the process root),
+  # it means the process is paused.
+  #
+  VAR_PAUSED = '/__paused__'
+
+  #
+  # FlowExpression
+  #
+  # The base class for all OpenWFE flow expression classes.
+  # It gathers all the methods for attributes and variable lookup.
+  #
+  class FlowExpression < ObjectWithMeta
+    include Contextual, Logging, OwfeServiceLocator
+
     #
-    # When this variable is set to true (at the process root),
-    # it means the process is paused.
+    # The 'flow expression id' the unique identifier within a
+    # workflow instance for this expression instance.
     #
-    VAR_PAUSED = '/__paused__'
+    attr_accessor :fei
 
     #
-    # FlowExpression
+    # The 'flow expression id' of the parent expression.
+    # Will yield 'nil' if this expression is the root of its process
+    # instance.
+    #
+    attr_accessor :parent_id
+
     #
-    # The base class for all OpenWFE flow expression classes.
-    # It gathers all the methods for attributes and variable lookup.
+    # The 'flow expression id' of the environment this expression works
+    # with.
     #
-    class FlowExpression < ObjectWithMeta
-        include Contextual, Logging, OwfeServiceLocator
+    attr_accessor :environment_id
 
-        #
-        # The 'flow expression id' the unique identifier within a
-        # workflow instance for this expression instance.
-        #
-        attr_accessor :fei
+    #
+    # The attributes of the expression, as found in the process definition.
+    #
+    #   <participant ref='toto' timeout='1d10h' />
+    #
+    # The attributes will be ref => "toto" and timeout => "1d10h" (yes,
+    # 'attributes' contains a hash.
+    #
+    attr_accessor :attributes
 
-        #
-        # The 'flow expression id' of the parent expression.
-        # Will yield 'nil' if this expression is the root of its process
-        # instance.
-        #
-        attr_accessor :parent_id
+    #
+    # An array of 'flow expression id' instances. These are the ids of
+    # the expressions children to this one.
+    #
+    #   <sequence>
+    #     <participant ref="toto" />
+    #     <participant ref="bert" />
+    #   </sequence>
+    #
+    # The expression instance for 'sequence' will hold the feis of toto and
+    # bert in its children array.
+    #
+    attr_accessor :children
 
-        #
-        # The 'flow expression id' of the environment this expression works
-        # with.
-        #
-        attr_accessor :environment_id
+    #
+    # When the FlowExpression instance is applied, this time stamp is set
+    # to the current date.
+    #
+    attr_accessor :apply_time
 
-        #
-        # The attributes of the expression, as found in the process definition.
-        #
-        #     <participant ref='toto' timeout='1d10h' />
-        #
-        # The attributes will be ref => "toto" and timeout => "1d10h" (yes,
-        # 'attributes' contains a hash.
-        #
-        attr_accessor :attributes
+    #
+    # Used by raw expressions to store the not yet interpreted branches
+    # of a process, used by other expressions to store their
+    # representation at 'eval time'.
+    #
+    attr_accessor :raw_representation
 
-        #
-        # An array of 'flow expression id' instances. These are the ids of
-        # the expressions children to this one.
-        #
-        #     <sequence>
-        #         <participant ref="toto" />
-        #         <participant ref="bert" />
-        #     </sequence>
-        #
-        # The expression instance for 'sequence' will hold the feis of toto and
-        # bert in its children array.
-        #
-        attr_accessor :children
+    #
+    # Meant to contain a boolean value. If set to 'true' it means that
+    # this expression raw_representation has been modified after
+    # the expression instantiation.
+    #
+    # It's used to keep track effectively of in-flight modifications
+    # of process instances.
+    #
+    attr_accessor :raw_rep_updated
 
-        #
-        # When the FlowExpression instance is applied, this time stamp is set
-        # to the current date.
-        #
-        attr_accessor :apply_time
+    #
+    # When was this expression last updated ?
+    #
+    attr_accessor :updated_at
 
-        #
-        # Used by raw expressions to store the not yet interpreted branches
-        # of a process, used by other expressions to store their
-        # representation at 'eval time'.
-        #
-        attr_accessor :raw_representation
 
+    #
+    # The classical no-params constructors.
+    #
+    def initialize
+
+      super
         #
-        # Meant to contain a boolean value. If set to 'true' it means that
-        # this expression raw_representation has been modified after
-        # the expression instantiation.
-        #
-        # It's used to keep track effectively of in-flight modifications
-        # of process instances.
-        #
-        attr_accessor :raw_rep_updated
+        # very necessary as this class includes the MonitorMixin
+    end
 
+    #
+    # Builds a new instance of an expression
+    #
+    def self.new_exp (fei, parent_id, env_id, app_context, attributes)
 
-        #
-        # The classical no-params constructors.
-        #
-        def initialize
+      e = self.new
 
-            super
-                #
-                # very necessary as this class includes the MonitorMixin
-        end
+      e.fei = fei
+      e.parent_id = parent_id
+      e.environment_id = env_id
+      e.application_context = app_context
+      e.attributes = attributes
 
-        #
-        # Builds a new instance of an expression
-        #
-        def self.new_exp (fei, parent_id, env_id, app_context, attributes)
+      e.children = []
+      e.apply_time = nil
 
-            e = self.new
+      e
+    end
 
-            e.fei = fei
-            e.parent_id = parent_id
-            e.environment_id = env_id
-            e.application_context = app_context
-            e.attributes = attributes
+    #--
+    # the two most important methods for flow expressions
+    #++
 
-            e.children = []
-            e.apply_time = nil
+    #
+    # this default implementation immediately replies to the
+    # parent expression
+    #
+    def apply (workitem)
 
-            e
-        end
+      get_parent.reply(workitem) if @parent_id
+    end
 
-        #--
-        # the two most important methods for flow expressions
-        #++
+    #
+    # this default implementation immediately replies to the
+    # parent expression
+    #
+    def reply (workitem)
 
-        #
-        # this default implementation immediately replies to the
-        # parent expression
-        #
-        def apply (workitem)
+      reply_to_parent workitem
+    end
 
-            get_parent.reply(workitem) if @parent_id
-        end
+    #
+    # Triggers the reply to the parent expression (of course, via the
+    # expression pool).
+    # Expressions do call this method when their job is done and the flow
+    # should resume without them.
+    #
+    def reply_to_parent (workitem)
 
-        #
-        # this default implementation immediately replies to the
-        # parent expression
-        #
-        def reply (workitem)
+      get_expression_pool.reply_to_parent self, workitem
+    end
 
-            reply_to_parent workitem
-        end
+    #
+    # a default implementation for cancel :
+    # cancels all the children
+    # Attempts to return an InFlowWorkItem
+    #
+    def cancel
 
-        #
-        # Triggers the reply to the parent expression (of course, via the
-        # expression pool).
-        # Expressions do call this method when their job is done and the flow
-        # should resume without them.
-        #
-        def reply_to_parent (workitem)
+      return nil unless @children
 
-            get_expression_pool.reply_to_parent self, workitem
-        end
+      inflowitem = nil
 
-        #
-        # a default implementation for cancel :
-        # cancels all the children
-        # Attempts to return an InFlowWorkItem
-        #
-        def cancel
+      @children.each do |child|
 
-            return nil unless @children
+        next if child.is_a?(String)
 
-            inflowitem = nil
+        i = get_expression_pool.cancel child
+        inflowitem ||= i
+      end
 
-            @children.each do |child|
+      inflowitem
+    end
 
-                next if child.is_a?(String)
+    #
+    # some convenience methods
 
-                i = get_expression_pool.cancel child
-                inflowitem ||= i
-            end
+    #
+    # Returns the parent expression (not as a FlowExpressionId but directly
+    # as the FlowExpression instance it is).
+    #
+    def get_parent
 
-            inflowitem
-        end
+      get_expression_pool.fetch_expression @parent_id
+    end
 
-        #
-        # some convenience methods
+    #
+    # Stores itself in the expression pool.
+    # It's very important for expressions in persisted context to save
+    # themselves as soon as their state changed.
+    # Else this information would be lost at engine restart or
+    # simply if the expression got swapped out of memory and reloaded later.
+    #
+    def store_itself
 
-        #
-        # Returns the parent expression (not as a FlowExpressionId but directly
-        # as the FlowExpression instance it is).
-        #
-        def get_parent
+      ldebug { "store_itself() for  #{@fei.to_debug_s}" }
+      #ldebug { "store_itself() \n#{OpenWFE::caller_to_s(0, 6)}" }
 
-            get_expression_pool.fetch_expression @parent_id
-        end
+      get_expression_pool.update self
+    end
 
-        #
-        # Stores itself in the expression pool.
-        # It's very important for expressions in persisted context to save
-        # themselves as soon as their state changed.
-        # Else this information would be lost at engine restart or
-        # simply if the expression got swapped out of memory and reloaded later.
-        #
-        def store_itself
+    #
+    # Returns the environment instance this expression uses.
+    # An environment is a container (a scope) for variables in the process
+    # definition.
+    # Environments themselves are FlowExpression instances.
+    #
+    def get_environment
 
-            ldebug { "store_itself() for  #{@fei.to_debug_s}" }
-            #ldebug { "store_itself() \n#{OpenWFE::caller_to_s(0, 6)}" }
+      fetch_environment || get_expression_pool.fetch_engine_environment
+    end
 
-            get_expression_pool.update self
-        end
+    #
+    # A shortcut for fetch_environment.get_root_environment
+    #
+    # Returns the environment of the top process (the environement
+    # just before the engine environment in the hierarchy).
+    #
+    def get_root_environment
 
-        #
-        # Returns the environment instance this expression uses.
-        # An environment is a container (a scope) for variables in the process
-        # definition.
-        # Environments themselves are FlowExpression instances.
-        #
-        def get_environment
+      fetch_environment.get_root_environment
+    end
 
-            fetch_environment || get_expression_pool.fetch_engine_environment
-        end
+    #
+    # Just fetches the environment for this expression.
+    #
+    def fetch_environment
 
-        #
-        # A shortcut for fetch_environment.get_root_environment
-        #
-        # Returns the environment of the top process (the environement
-        # just before the engine environment in the hierarchy).
-        #
-        def get_root_environment
+      get_expression_pool.fetch_expression @environment_id
+    end
 
-            fetch_environment.get_root_environment
-        end
+    #
+    # Returns true if the expression's environment was generated
+    # for itself (usually DefineExpression do have such envs)
+    #
+    def owns_its_environment?
 
-        #
-        # Just fetches the environment for this expression.
-        #
-        def fetch_environment
+      #ldebug do
+      #  "owns_its_environment?()\n" +
+      #  "  #{@fei.to_debug_s}\n" +
+      #  "  #{@environment_id.to_debug_s}"
+      #end
 
-            get_expression_pool.fetch_expression @environment_id
-        end
+      return false if not @environment_id
 
-        #
-        # Returns true if the expression's environment was generated
-        # for itself (usually DefineExpression do have such envs)
-        #
-        def owns_its_environment?
+      ei = @fei.dup
+      vi = @environment_id.dup
 
-            #ldebug do
-            #    "owns_its_environment?()\n" +
-            #    "    #{@fei.to_debug_s}\n" +
-            #    "    #{@environment_id.to_debug_s}"
-            #end
+      ei.expression_name = "neutral"
+      vi.expression_name = "neutral"
 
-            return false if not @environment_id
+      #ldebug do
+      #  "owns_its_environment?()\n"+
+      #  "   exp  #{ei.to_debug_s}\n"+
+      #  "   env  #{vi.to_debug_s}"
+      #end
 
-            ei = @fei.dup
-            vi = @environment_id.dup
+      (ei == vi)
+    end
 
-            ei.expression_name = "neutral"
-            vi.expression_name = "neutral"
+    #
+    # Returns true if this expression belongs to a paused flow
+    #
+    def paused?
 
-            #ldebug do
-            #    "owns_its_environment?()\n"+
-            #    "   exp  #{ei.to_debug_s}\n"+
-            #    "   env  #{vi.to_debug_s}"
-            #end
+      #(lookup_variable(VAR_PAUSED) == true)
+      get_expression_pool.is_paused?(self)
+    end
 
-            (ei == vi)
-        end
+    #
+    # Sets a variable in the current environment. Is usually
+    # called by the 'set' expression.
+    #
+    # The variable name may be prefixed by / to indicate process level scope
+    # or by // to indicate engine level (global) scope.
+    #
+    def set_variable (varname, value)
 
-        #
-        # Returns true if this expression belongs to a paused flow
-        #
-        def paused?
+      env, var = lookup_environment varname
 
-            #(lookup_variable(VAR_PAUSED) == true)
-            get_expression_pool.is_paused?(self)
-        end
+      ldebug do
+        "set_variable() '#{varname}' to '#{value}' " +
+        "in  #{env.fei.to_debug_s}"
+      end
 
-        #
-        # Sets a variable in the current environment. Is usually
-        # called by the 'set' expression.
-        #
-        # The variable name may be prefixed by / to indicate process level scope
-        # or by // to indicate engine level (global) scope.
-        #
-        def set_variable (varname, value)
+      env[var] = value
+    end
 
-            env, var = lookup_environment(varname)
+    alias :sv :set_variable
 
-            ldebug do
-                "set_variable() '#{varname}' to '#{value}' " +
-                "in  #{env.fei.to_debug_s}"
-            end
+    #
+    # Looks up the value of a variable in the current environment.
+    # If not found locally will lookup at the process level and even
+    # further in the engine scope.
+    #
+    # The variable name may be prefixed by / to indicate process level scope
+    # or by // to indicate engine level (global) scope.
+    #
+    def lookup_variable (varname)
 
-            env[var] = value
-        end
+      env, var = lookup_environment varname
+      env[var]
+    end
 
-        #
-        # Looks up the value of a variable in the current environment.
-        # If not found locally will lookup at the process level and even
-        # further in the engine scope.
-        #
-        # The variable name may be prefixed by / to indicate process level scope
-        # or by // to indicate engine level (global) scope.
-        #
-        def lookup_variable (varname)
+    alias :lv :lookup_variable
 
-            #puts "lv : #{varname}"
-            #puts OpenWFE.caller_to_s(0, 5)
+    #
+    # Unsets a variable in the current environment.
+    #
+    # The variable name may be prefixed by / to indicate process level scope
+    # or by // to indicate engine level (global) scope.
+    #
+    def delete_variable (varname)
 
-            env, var = lookup_environment(varname)
-            env[var]
-        end
+      env, var = lookup_environment varname
+      env.delete var
+    end
 
-        #
-        # Unsets a variable in the current environment.
-        #
-        # The variable name may be prefixed by / to indicate process level scope
-        # or by // to indicate engine level (global) scope.
-        #
-        def delete_variable (varname)
+    alias :unset_variable :delete_variable
 
-            env, var = lookup_environment(varname)
-            env.delete var
-        end
+    #
+    # Looks up the value for an attribute of this expression.
+    #
+    # if the expression is
+    #
+    #   <participant ref="toto" />
+    #
+    # then
+    #
+    #   participant_expression.lookup_attribute("toto", wi)
+    #
+    # will yield "toto"
+    #
+    # The various methods for looking up attributes do perform dollar
+    # variable substitution.
+    # It's ok to pass a Symbol for the attribute name.
+    #
+    def lookup_attribute (attname, workitem, options={})
 
-        alias :unset_variable :delete_variable
+      default = options[:default]
+      escape = options[:escape]
+      tostring = options[:to_s]
 
-        #
-        # Looks up the value for an attribute of this expression.
-        #
-        # if the expression is
-        #
-        #     <participant ref="toto" />
-        #
-        # then
-        #
-        #     participant_expression.lookup_attribute("toto", wi)
-        #
-        # will yield "toto"
-        #
-        # The various methods for looking up attributes do perform dollar
-        # variable substitution.
-        # It's ok to pass a Symbol for the attribute name.
-        #
-        def lookup_attribute (attname, workitem, options={})
+      attname = OpenWFE::symbol_to_name(attname) \
+        if attname.kind_of?(Symbol)
 
-            default = options[:default]
-            escape = options[:escape]
-            tostring = options[:to_s]
+      #ldebug { "lookup_attribute() '#{attname}' in #{@fei.to_debug_s}" }
 
-            attname = OpenWFE::symbol_to_name(attname) \
-                if attname.kind_of?(Symbol)
+      text = @attributes[attname]
 
-            #ldebug { "lookup_attribute() '#{attname}' in #{@fei.to_debug_s}" }
+      text = if text == nil
 
-            text = @attributes[attname]
+        default
 
-            text = if text == nil
+      elsif escape == true
 
-                default
+        text
 
-            elsif escape == true
+      else
 
-                text
+        OpenWFE::dosub text, self, workitem
+      end
 
-            else
+      text = text.to_s if text and tostring
 
-                OpenWFE::dosub text, self, workitem
-            end
+      text
+    end
 
-            text = text.to_s if text and tostring
+    #
+    # Returns the attribute value as a String (or nil if it's not found).
+    #
+    def lookup_string_attribute (attname, workitem, options={})
 
-            text
-        end
+      result = lookup_attribute attname, workitem, options
+      result = result.to_s if result
+      result
+    end
 
-        #
-        # Returns the attribute value as a String (or nil if it's not found).
-        #
-        def lookup_string_attribute (attname, workitem, options={})
+    #
+    # Like lookup_attribute() but returns the value downcased [
+    # (and stripped).
+    # Returns nil if no such attribute was found.
+    #
+    def lookup_downcase_attribute (attname, workitem, options={})
 
-            result = lookup_attribute attname, workitem, options
-            result = result.to_s if result
-            result
-        end
+      result = lookup_string_attribute attname, workitem, options
+      result = result.strip.downcase if result
+      result
+    end
 
-        #
-        # Like lookup_attribute() but returns the value downcased [
-        # (and stripped).
-        # Returns nil if no such attribute was found.
-        #
-        def lookup_downcase_attribute (attname, workitem, options={})
+    #
+    # Returns the value of the attribute as a Symbol.
+    # Returns nil if there is no attribute under the given name.
+    #
+    def lookup_sym_attribute (attname, workitem, options={})
 
-            result = lookup_string_attribute attname, workitem, options
-            result = result.strip.downcase if result
-            result
-        end
+      result = lookup_downcase_attribute attname, workitem, options
+      result = result.to_sym if result
+      result
+    end
 
-        #
-        # Returns the value of the attribute as a Symbol.
-        # Returns nil if there is no attribute under the given name.
-        #
-        def lookup_sym_attribute (attname, workitem, options={})
+    #
+    # A convenience method for looking up a boolean value.
+    # It's ok to pass a Symbol for the attribute name.
+    #
+    def lookup_boolean_attribute (attname, workitem, default=false)
 
-            result = lookup_downcase_attribute attname, workitem, options
-            result = result.to_sym if result
-            result
-        end
+      result = lookup_downcase_attribute attname, workitem
+      return default if result == nil
 
-        #
-        # A convenience method for looking up a boolean value.
-        # It's ok to pass a Symbol for the attribute name.
-        #
-        def lookup_boolean_attribute (attname, workitem, default=false)
+      (result == 'true')
+    end
 
-            result = lookup_downcase_attribute attname, workitem
-            return default if result == nil
+    #
+    # looks up an attribute, if it's an array, returns it. Else
+    # (probably a string) will split it (comma) and return it
+    # (each element trimmed).
+    #
+    def lookup_array_attribute (attname, workitem, options={})
 
-            (result == 'true')
-        end
+      tostring = options.delete :to_s
 
-        #
-        # looks up an attribute, if it's an array, returns it. Else
-        # (probably a string) will split it (comma) and return it
-        # (each element trimmed).
-        #
-        def lookup_array_attribute (attname, workitem, options={})
+      v = lookup_attribute attname, workitem, options
 
-            tostring = options.delete :to_s
+      return nil unless v
 
-            v = lookup_attribute attname, workitem, options
+      v = v.to_s.split(",").collect { |e| e.strip } \
+        unless v.is_a?(Array)
 
-            return nil unless v
+      v = v.collect { |e| e.to_s } \
+        if tostring
 
-            v = v.to_s.split(",").collect { |e| e.strip } \
-                unless v.is_a?(Array)
+      v
+    end
 
-            v = v.collect { |e| e.to_s } \
-                if tostring
+    #
+    # Returns true if the expression has the given attribute.
+    # The attname parameter can be a String or a Symbol.
+    #
+    def has_attribute (attname)
 
-            v
-        end
+      attname = OpenWFE::symbol_to_name(attname) \
+        if attname.kind_of?(Symbol)
 
-        #
-        # Returns true if the expression has the given attribute.
-        # The attname parameter can be a String or a Symbol.
-        #
-        def has_attribute (attname)
+      (@attributes[attname] != nil)
+    end
 
-            attname = OpenWFE::symbol_to_name(attname) \
-                if attname.kind_of?(Symbol)
+    #
+    # Returns a hash of all the FlowExpression attributes with their
+    # values having undergone dollar variable substitution.
+    # If the _attributes parameter is set (to an Array instance) then
+    # only the attributes named in that list will be looked up.
+    #
+    # It's ok to pass an array of Symbol instances for the attributes
+    # parameter.
+    #
+    def lookup_attributes (workitem, _attributes=nil)
 
-            (@attributes[attname] != nil)
-        end
+      return {} unless @attributes
 
-        #
-        # Returns a hash of all the FlowExpression attributes with their
-        # values having undergone dollar variable substitution.
-        # If the _attributes parameter is set (to an Array instance) then
-        # only the attributes named in that list will be looked up.
-        #
-        # It's ok to pass an array of Symbol instances for the attributes
-        # parameter.
-        #
-        def lookup_attributes (workitem, _attributes=nil)
+      (_attributes || @attributes.keys).inject({}) do |r, k|
 
-            return {} unless @attributes
+        k = k.to_s
+        v = @attributes[k]
 
-            (_attributes || @attributes.keys).inject({}) do |r, k|
+        r[k] = OpenWFE::dosub v, self, workitem
 
-                k = k.to_s
-                v = @attributes[k]
+        r
+      end
+    end
 
-                r[k] = OpenWFE::dosub v, self, workitem
+    #
+    # creates a new environment just for this expression
+    #
+    def new_environment (initial_vars=nil)
 
-                r
-            end
-        end
+      ldebug { "new_environment() for #{@fei.to_debug_s}" }
 
-        #
-        # creates a new environment just for this expression
-        #
-        def new_environment (initial_vars=nil)
+      @environment_id = @fei.dup
+      @environment_id.expression_name = EN_ENVIRONMENT
 
-            ldebug { "new_environment() for #{@fei.to_debug_s}" }
+      parent_fei = nil
+      parent = nil
 
-            @environment_id = @fei.dup
-            @environment_id.expression_name = EN_ENVIRONMENT
+      parent, _fei = get_expression_pool.fetch(@parent_id) \
+        if @parent_id
 
-            parent_fei = nil
-            parent = nil
+      parent_fei = parent.environment_id if parent
 
-            parent, _fei = get_expression_pool.fetch(@parent_id) \
-                if @parent_id
+      env = Environment.new_env(
+        @environment_id, parent_fei, nil, @application_context, nil)
 
-            parent_fei = parent.environment_id if parent
+      env.variables.merge! initial_vars if initial_vars
 
-            env = Environment.new_env(
-                @environment_id, parent_fei, nil, @application_context, nil)
+      env[@fei.wfname] = self.raw_representation \
+        if (not @parent_id) and (self.is_a?(RawExpression))
+          #
+          # keeping track of the raw representation
+          # of the top expression (for top recursion)
 
-            env.variables.merge! initial_vars if initial_vars
+      ldebug { "new_environment() is #{env.fei.to_debug_s}" }
 
-            env[@fei.wfname] = self.raw_representation \
-                if (not @parent_id) and (self.is_a?(RawExpression))
-                    #
-                    # keeping track of the raw representation
-                    # of the top expression (for top recursion)
+      env.store_itself
 
-            ldebug { "new_environment() is #{env.fei.to_debug_s}" }
+      env
+    end
 
-            env.store_itself
+    #
+    # This method is called in expressionpool.forget(). It duplicates
+    # the expression's current environment (deep copy) and attaches
+    # it as the expression own environment.
+    # Returns the duplicated environment.
+    #
+    def dup_environment
 
-            env
-        end
+      env = fetch_environment
+      env = env.dup
+      env.fei = @fei.dup
+      env.fei.expression_name = EN_ENVIRONMENT
+      @environment_id = env.fei
 
-        #
-        # This method is called in expressionpool.forget(). It duplicates
-        # the expression's current environment (deep copy) and attaches
-        # it as the expression own environment.
-        # Returns the duplicated environment.
-        #
-        def dup_environment
+      env.store_itself
+    end
 
-            env = fetch_environment
-            env = env.dup
-            env.fei = @fei.dup
-            env.fei.expression_name = EN_ENVIRONMENT
-            @environment_id = env.fei
+    #
+    # Takes care of removing all the children of this expression, if any.
+    #
+    def clean_children
 
-            env.store_itself
-        end
+      return unless @children
 
-        #
-        # Takes care of removing all the children of this expression, if any.
-        #
-        def clean_children
+      @children.each do |child_fei|
+        get_expression_pool.remove(child_fei) \
+          if child_fei.kind_of?(FlowExpressionId)
+      end
+    end
 
-            return unless @children
+    #
+    # Removes a child from the expression children list.
+    #
+    def remove_child (child_fei)
 
-            @children.each do |child_fei|
-                get_expression_pool.remove(child_fei) \
-                    if child_fei.kind_of?(FlowExpressionId)
-            end
-        end
+      #fei = @children.delete child_fei
+      #store_itself if fei
 
-        #
-        # Removes a child from the expression children list.
-        #
-        def remove_child (child_fei)
+      i = @children.index child_fei
 
-            #fei = @children.delete child_fei
-            #store_itself if fei
+      return unless i
 
-            i = @children.index child_fei
+      @children.delete_at i
+      raw_children.delete_at i
+      @raw_rep_updated = true
 
-            return unless i
+      store_itself
+    end
 
-            @children.delete_at i
-            raw_children.delete_at i
-            @raw_rep_updated = true
+    #
+    # Currently only used by dollar.rb and its ${r:some_ruby_code},
+    # returns the binding in this flow expression.
+    #
+    def get_binding
 
-            store_itself
-        end
+      binding()
+    end
 
-        #
-        # Currently only used by dollar.rb and its ${r:some_ruby_code},
-        # returns the binding in this flow expression.
-        #
-        def get_binding
+    #--
+    # Used like the classical Ruby synchronize, but as the OpenWFE
+    # expression pool manages its own set of monitors, it's one of those
+    # monitors that is used. But the synchronize code looks like the class
+    # just included the MonitorMixin. No hassle.
+    #
+    #def synchronize
+    #  #ldebug { "synchronize() ---in--- for  #{@fei.to_debug_s}" }
+    #  get_expression_pool.get_monitor(@fei).synchronize do
+    #    yield
+    #  end
+    #  #ldebug { "synchronize() --out--  for  #{@fei.to_debug_s}" }
+    #end
+    #++
 
-            binding()
-        end
+    #
+    # Returns the text stored among the children
+    #
+    def fetch_text_content (workitem, escape=false)
 
-        #--
-        # Used like the classical Ruby synchronize, but as the OpenWFE
-        # expression pool manages its own set of monitors, it's one of those
-        # monitors that is used. But the synchronize code looks like the class
-        # just included the MonitorMixin. No hassle.
-        #
-        #def synchronize
-        #    #ldebug { "synchronize() ---in--- for  #{@fei.to_debug_s}" }
-        #    get_expression_pool.get_monitor(@fei).synchronize do
-        #        yield
-        #    end
-        #    #ldebug { "synchronize() --out--  for  #{@fei.to_debug_s}" }
-        #end
-        #++
+      cs = children || raw_children
 
-        #
-        # Returns the text stored as the children of the given expression
-        #
-        def fetch_text_content (workitem, escape=false)
+      text = cs.inject("") do |r, child|
 
-            text = ""
+        if child.is_a?(RawExpression)
 
-            children.each do |child|
+          r << child.fei.to_s
 
-                if child.is_a?(RawExpression)
+        elsif child.is_a?(FlowExpressionId)
 
-                    text << child.fei.to_s
+          r << get_expression_pool\
+            .fetch_expression(child).raw_representation.to_s
 
-                elsif child.is_a?(FlowExpressionId)
+        else
 
-                    text << get_expression_pool\
-                        .fetch_expression(child).raw_representation.to_s
+          r << child.to_s
+        end
+      end
 
-                else
+      return nil if text == ""
 
-                    text << child.to_s
-                end
-            end
+      text = OpenWFE::dosub(text, self, workitem) \
+        unless escape
 
-            return nil if text == ""
+      text
+    end
 
-            text = OpenWFE::dosub(text, self, workitem) \
-                unless escape
+    #
+    # looks up for 'value', 'variable-value' and then for 'field-value'
+    # if necessary.
+    #
+    def lookup_value (workitem, options={})
 
-            text
-        end
+      lookup_vf_attribute(workitem, 'value', options) ||
+      lookup_vf_attribute(workitem, 'val', options)
+    end
 
-        #
-        # looks up for 'value', 'variable-value' and then for 'field-value'
-        # if necessary.
-        #
-        def lookup_value (workitem, options={})
+    #
+    # looks up for 'ref', 'variable-ref' and then for 'field-ref'
+    # if necessary.
+    #
+    def lookup_ref (workitem, prefix='')
 
-            lookup_vf_attribute(workitem, 'value', options) ||
-            lookup_vf_attribute(workitem, 'val', options)
-        end
+      ref = lookup_vf_attribute workitem, 'ref', :prefix => prefix
+      return ref.to_s if ref
+      nil
+    end
 
-        #
-        # looks up for 'ref', 'variable-ref' and then for 'field-ref'
-        # if necessary.
-        #
-        def lookup_ref (workitem, prefix='')
+    #
+    # Looks up for value attributes like 'field-ref' or 'variable-value'
+    #
+    def lookup_vf_attribute (workitem, att_name, options={})
 
-            ref = lookup_vf_attribute workitem, 'ref', :prefix => prefix
-            return ref.to_s if ref
-            nil
-        end
+      att_name = att_name.to_s
 
-        #
-        # Looks up for value attributes like 'field-ref' or 'variable-value'
-        #
-        def lookup_vf_attribute (workitem, att_name, options={})
+      prefix = options[:prefix] || ''
+      prefix = prefix.to_s
 
-            att_name = att_name.to_s
+      dash = (att_name.size > 0 and prefix.size > 0) ? "-" : ""
 
-            prefix = options[:prefix] || ''
-            prefix = prefix.to_s
+      v = lookup_attribute(
+        "#{prefix}#{dash}#{att_name}", workitem, options)
 
-            dash = (att_name.size > 0 and prefix.size > 0) ? "-" : ""
+      att_name = "-#{att_name}" if att_name.size > 0
+      prefix = "#{prefix}-" if prefix.size > 0
 
-            v = lookup_attribute(
-                "#{prefix}#{dash}#{att_name}", workitem, options)
+      return v if v
 
-            att_name = "-#{att_name}" if att_name.size > 0
-            prefix = "#{prefix}-" if prefix.size > 0
+      v = lookup_attribute(
+        "#{prefix}variable#{att_name}", workitem, options) ||
+        lookup_attribute(
+        "#{prefix}var#{att_name}", workitem, options) ||
+        lookup_attribute(
+        "#{prefix}v#{att_name}", workitem, options)
 
-            return v if v
+      return lookup_variable(v) if v
 
-            v = lookup_attribute(
-                "#{prefix}variable#{att_name}", workitem, options) ||
-                lookup_attribute(
-                "#{prefix}var#{att_name}", workitem, options) ||
-                lookup_attribute(
-                "#{prefix}v#{att_name}", workitem, options)
+      f = lookup_attribute(
+        "#{prefix}field#{att_name}", workitem, options) ||
+        lookup_attribute(
+        "#{prefix}f#{att_name}", workitem, options)
 
-            return lookup_variable(v) if v
+      #return workitem.attributes[f] if f
+      return workitem.attributes[f.to_s] if f
 
-            f = lookup_attribute(
-                "#{prefix}field#{att_name}", workitem, options) ||
-                lookup_attribute(
-                "#{prefix}f#{att_name}", workitem, options)
+      nil
+    end
 
-            #return workitem.attributes[f] if f
-            return workitem.attributes[f.to_s] if f
+    #
+    # Since OpenWFEru 0.9.17, each expression keeps his @raw_representation
+    # this is a shortcut for exp.raw_representation[2]
+    #
+    def raw_children
 
-            nil
-        end
+      @raw_representation[2]
+    end
 
-        #
-        # Since OpenWFEru 0.9.17, each expression keeps his @raw_representation
-        # this is a shortcut for exp.raw_representation[2]
-        #
-        def raw_children
+    SUBIDMUTEX = Mutex.new
 
-            @raw_representation[2]
-        end
+    #
+    # Returns the next sub process id available (this counter
+    # is stored in the process environment under the key :next_sub_id)
+    #
+    def get_next_sub_id
 
-        SUBIDMUTEX = Mutex.new
+      #env = get_environment
+      env = get_root_environment
 
-        #
-        # Returns the next sub process id available (this counter
-        # is stored in the process environment under the key :next_sub_id)
-        #
-        def get_next_sub_id
+      c = nil
 
-            #env = get_environment
-            env = get_root_environment
+      #env.synchronize do
 
-            c = nil
+      c = env.variables[:next_sub_id]
+      n = if c
+        c + 1
+      else
+        c = 0
+        1
+      end
+      env.variables[:next_sub_id] = n
+      env.store_itself
+      #end
 
-            #env.synchronize do
+      c
+    end
 
-            c = env.variables[:next_sub_id]
-            n = if c
-                c + 1
-            else
-                c = 0
-                1
-            end
-            env.variables[:next_sub_id] = n
-            env.store_itself
-            #end
+    #
+    # Some eye candy
+    #
+    def to_s
 
-            c
-        end
+      s =  "* #{@fei.to_debug_s} [#{self.class.name}]"
 
-        #
-        # Some eye candy
-        #
-        def to_s
+      s << "\n   `--p--> #{@parent_id.to_debug_s}" \
+        if @parent_id
 
-            s =    "* #{@fei.to_debug_s} [#{self.class.name}]"
+      s << "\n   `--e--> #{@environment_id.to_debug_s}" \
+        if @environment_id
 
-            s << "\n   `--p--> #{@parent_id.to_debug_s}" \
-                if @parent_id
+      return s unless @children
 
-            s << "\n   `--e--> #{@environment_id.to_debug_s}" \
-                if @environment_id
+      @children.each do |c|
+        sc = if c.kind_of?(OpenWFE::FlowExpressionId)
+          c.to_debug_s
+        else
+          ">#{c.to_s}<"
+        end
+        s << "\n   `--c--> #{sc}"
+      end
 
-            return s unless @children
+      s
+    end
 
-            @children.each do |c|
-                sc = if c.kind_of?(OpenWFE::FlowExpressionId)
-                    c.to_debug_s
-                else
-                    ">#{c.to_s}<"
-                end
-                s << "\n   `--c--> #{sc}"
-            end
+    #
+    # a nice 'names' tag/method for registering the names of the
+    # Expression classes.
+    #
+    def self.names (*exp_names)
+
+      exp_names = exp_names.collect do |n|
+        n.to_s
+      end
+      meta_def :expression_names do
+        exp_names
+      end
+    end
 
-            s
-        end
+    #
+    # returns true if the expression class is a 'definition'.
+    #
+    def self.is_definition?
+      false
+    end
+    def self.is_definition
+      meta_def :is_definition? do
+        true
+      end
+    end
 
-        #
-        # a nice 'names' tag/method for registering the names of the
-        # Expression classes.
-        #
-        def self.names (*exp_names)
-
-            exp_names = exp_names.collect do |n|
-                n.to_s
-            end
-            meta_def :expression_names do
-                exp_names
-            end
-        end
+    #
+    # returns true if the expression class 'uses a template'
+    # (children will not immediately get expanded at 'parse' time)
+    #
+    def self.uses_template?
+      false
+    end
+    def self.uses_template
+      meta_def :uses_template? do
+        true
+      end
+    end
 
-        #
-        # returns true if the expression class is a 'definition'.
-        #
-        def self.is_definition?
-            false
-        end
-        def self.is_definition
-            meta_def :is_definition? do
-                true
-            end
-        end
+    protected
 
-        #
-        # returns true if the expression class 'uses a template'
-        # (children will not immediately get expanded at 'parse' time)
-        #
-        def self.uses_template?
-            false
+      #
+      # If the varname starts with '//' will return the engine
+      # environment and the truncated varname...
+      # If the varname starts with '/' will return the root environment
+      # for the current process instance and the truncated varname...
+      #
+      def lookup_environment (varname)
+
+        if varname[0, 2] == '//'
+          return [
+            get_expression_pool.fetch_engine_environment,
+            varname[2..-1]
+          ]
         end
-        def self.uses_template
-            meta_def :uses_template? do
-                true
-            end
+
+        if varname[0, 1] == '/'
+          return [
+            get_environment.get_root_environment,
+            varname[1..-1]
+          ]
         end
 
-        protected
-
-            #
-            # If the varname starts with '//' will return the engine
-            # environment and the truncated varname...
-            # If the varname starts with '/' will return the root environment
-            # for the current process instance and the truncated varname...
-            #
-            def lookup_environment (varname)
-
-                if varname[0, 2] == '//'
-                    return [
-                        get_expression_pool.fetch_engine_environment,
-                        varname[2..-1]
-                    ]
-                end
-
-                if varname[0, 1] == '/'
-                    return [
-                        get_environment.get_root_environment,
-                        varname[1..-1]
-                    ]
-                end
-
-                [ get_environment, varname ]
-            end
-    end
+        [ get_environment, varname ]
+      end
+  end
 
 end