ruote 0.9.18

data/lib/openwfe/expressions/iterator.rb

@@ -0,0 +1,221 @@
+#
+#--
+# Copyright (c) 2007-2008, John Mettraux, OpenWFE.org
+# All rights reserved.
+# 
+# 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 
+#   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 
+# POSSIBILITY OF SUCH DAMAGE.
+#++
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+
+module OpenWFE
+
+    #
+    # Iterator instances keep track of the position of an iteration.
+    # This class is meant to be used both by <iterator> and 
+    # <concurrent-iterator>.
+    #
+    class Iterator
+
+        ITERATOR_COUNT = "__ic__"
+        ITERATOR_POSITION = "__ip__"
+
+        attr_accessor :iteration_index
+        attr_accessor :iteration_list
+        attr_accessor :to_field
+        attr_accessor :to_variable
+        attr_accessor :value_separator
+
+        #
+        # Builds a new iterator, serving a given iterator_expression. 
+        # The second parameter is the workitem (as applied to the iterator
+        # expression).
+        #
+        def initialize (iterator_expression, workitem)
+
+            @to_field = iterator_expression\
+                .lookup_attribute(:to_field, workitem)
+            @to_variable = iterator_expression\
+                .lookup_attribute(:to_variable, workitem)
+
+            @value_separator = iterator_expression\
+                .lookup_attribute(:value_separator, workitem)
+
+            @value_separator = /,\s*/ unless @value_separator
+
+            @iteration_index = 0
+
+            #raw_list = iterator_expression.lookup_vf_attribute(
+            #    workitem, :value, :prefix => :on)
+            #raw_list ||= iterator_expression.lookup_attribute(:on, workitem)
+
+            raw_list = 
+                iterator_expression.lookup_vf_attribute(
+                    workitem, :value, :prefix => :on) ||
+                iterator_expression.lookup_vf_attribute(
+                    workitem, nil, :prefix => :on)
+
+            @iteration_list = extract_iteration_list raw_list
+
+            workitem.attributes[ITERATOR_COUNT] = @iteration_list.length
+        end
+
+        #
+        # Has the iteration a next element ?
+        #
+        def has_next?
+
+            @iteration_index < @iteration_list.size
+        end
+
+        #
+        # Returns the size of this iterator, or rather, the size of the
+        # underlying iteration list.
+        #
+        def size
+
+            @iteration_list.size
+        end
+
+        #
+        # Prepares the iterator expression and the workitem for the next 
+        # iteration.
+        #
+        def next (workitem)
+
+            position_at workitem, @iteration_index
+        end
+
+        #
+        # Positions the iterator back at position 0.
+        #
+        def rewind (workitem)
+
+            position_at workitem, 0
+        end
+
+        #
+        # Jumps to a given position in the iterator
+        #
+        def jump (workitem, index)
+
+            index = if index < 0
+                0
+            elsif index >= @iteration_list.size
+                @iteration_list.size
+            else
+                index
+            end
+
+            position_at workitem, index
+        end
+
+        #
+        # Jumps a certain number of positions in the iterator.
+        #
+        def skip (workitem, offset)
+
+            jump workitem, @iteration_index + offset
+        end
+
+        #
+        # The current index (whereas @iteration_index already points to
+        # the next element).
+        #
+        def index
+
+            @iteration_index - 1
+        end
+
+        protected
+
+            #
+            # Positions the iterator absolutely.
+            #
+            def position_at (workitem, position)
+
+                result = {}
+
+                value = @iteration_list[position]
+
+                return nil unless value
+
+                if @to_field
+                    workitem.attributes[@to_field] = value
+                else
+                    result[@to_variable] = value
+                end
+
+                workitem.attributes[ITERATOR_POSITION] = position
+                result[ITERATOR_POSITION] = position
+
+                @iteration_index = position + 1
+
+                result
+            end
+
+            #
+            # Extracts the iteration list from any value.
+            #
+            def extract_iteration_list (raw_list)
+
+                if is_suitable_list?(raw_list)
+                    raw_list
+                else
+                    extract_list_from_string raw_list.to_s
+                end
+            end
+
+            #
+            # Returns true if the given instance can be directly
+            # used as a list.
+            #
+            def is_suitable_list? (instance)
+
+                (not instance.is_a?(String)) and \
+                instance.respond_to? :[] and \
+                instance.respond_to? :length
+            end
+
+            #
+            # Extracts the list from the string (comma separated list
+            # usually).
+            #
+            def extract_list_from_string (s)
+
+                s.split @value_separator
+            end
+    end
+
+end
+

data/lib/openwfe/expressions/merge.rb

@@ -0,0 +1,84 @@
+#
+#--
+# Copyright (c) 2007-2008, John Mettraux, OpenWFE.org
+# All rights reserved.
+# 
+# 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 
+#   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 
+# POSSIBILITY OF SUCH DAMAGE.
+#++
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+require 'openwfe/utils'
+
+
+module OpenWFE
+
+    #
+    # Gathering methods for mixing (merging) workitems.
+    #
+    module MergeMixin
+
+        #
+        # Merges a source workitem into a target workitem (the fields
+        # of the source will overwrite the fields in the target).
+        #
+        # Returns the resulting (merged) workitem.
+        #
+        def merge_workitems (wiTarget, wiSource, override=false)
+        
+            return wiSource unless wiTarget
+            return wiTarget unless wiSource
+
+            return wiSource if override
+
+            #puts "merge()"
+            #puts "merge() source : " + wiSource.attributes.inspect
+            #puts "merge() target : " + wiTarget.attributes.inspect
+        
+            wiSource.attributes.each do |k, v|
+        
+                #puts "merge() '#{k}' => '#{v}'"
+        
+                nk = OpenWFE::fulldup k
+                nv = OpenWFE::fulldup v
+        
+                wiTarget.attributes[nk] = nv
+            end
+
+            #puts "merge() target after : " + wiTarget.attributes.inspect
+        
+            wiTarget
+        end
+    end
+
+end
+

data/lib/openwfe/expressions/raw.rb

@@ -0,0 +1,547 @@
+#
+#--
+# Copyright (c) 2006-2008, John Mettraux, OpenWFE.org
+# All rights reserved.
+#
+# 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
+#   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
+# POSSIBILITY OF SUCH DAMAGE.
+#++
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+require 'openwfe/exceptions'
+require 'openwfe/expressions/flowexpression'
+require 'openwfe/rudefinitions'
+
+
+module OpenWFE
+
+    #
+    # A class storing bits (trees) of process definitions just
+    # parsed. Upon application (apply()) these raw expressions get turned
+    # into real expressions.
+    #
+    class RawExpression < FlowExpression
+
+        #
+        # A [static] method for creating new RawExpression instances.
+        #
+        def self.new_raw (
+            fei, parent_id, env_id, app_context, raw_representation)
+
+            re = self.new
+
+            re.fei = fei
+            re.parent_id = parent_id
+            re.environment_id = env_id
+            re.application_context = app_context
+            re.attributes = nil
+            re.children = []
+            re.apply_time = nil
+
+            re.raw_representation = raw_representation
+            re
+        end
+
+        #--
+        # A duplication method that duplicates everything, except
+        # the application context
+        #
+        #def dup
+        #    self.class.new_raw(
+        #        @fei.dup,
+        #        @parent_id ? @parent_id.dup : nil,
+        #        @environment_id ? @environment_id.dup : nil,
+        #        @application_context,
+        #        raw_representation)
+        #end
+        #alias :fulldup :dup
+        #++
+
+        def instantiate_real_expression (
+            workitem, exp_name=nil, exp_class=nil, attributes=nil)
+
+            exp_name ||= expression_name
+            exp_class ||= expression_class
+
+            raise "unknown expression '#{exp_name}'" \
+                unless exp_class
+
+            #ldebug do
+            #    "instantiate_real_expression() exp_class is #{exp_class}"
+            #end
+
+            attributes ||= raw_representation[1]
+
+            exp = exp_class.new
+            exp.fei = @fei
+            exp.parent_id = @parent_id
+            exp.environment_id = @environment_id
+            exp.application_context = @application_context
+            exp.attributes = attributes
+
+            exp.raw_representation = raw_representation
+            exp.raw_rep_updated = raw_rep_updated
+                #
+                # keeping track of how the expression look at apply /
+                # instantiation time
+
+            consider_tag workitem, exp
+
+            exp.children = extract_children \
+                unless exp_class.uses_template?
+
+            exp
+        end
+
+        #
+        # When a raw expression is applied, it gets turned into the
+        # real expression which then gets applied.
+        #
+        def apply (workitem)
+
+            exp_name, exp_class, attributes = determine_real_expression
+
+            expression = instantiate_real_expression(
+                workitem, exp_name, exp_class, attributes)
+
+            expression.apply_time = Time.now
+            expression.store_itself
+
+            expression.apply workitem
+        end
+
+        #
+        # This method is called by the expression pool when it is about
+        # to launch a process, it will interpret the 'parameter' statements
+        # in the process definition and raise an exception if the requirements
+        # are not met.
+        #
+        def check_parameters (workitem)
+
+            extract_parameters.each do |param|
+                param.check(workitem)
+            end
+        end
+
+        #--
+        #def reply (workitem)
+        # no implementation necessary
+        #end
+        #++
+
+        def is_definition?
+
+            get_expression_map.is_definition?(expression_name())
+        end
+
+        def expression_class
+
+            get_expression_map.get_class(expression_name())
+        end
+
+        def definition_name
+
+            (raw_representation[1]['name'] || raw_children.first).to_s
+        end
+
+        def expression_name
+
+            raw_representation.first
+        end
+
+        #
+        # Forces the raw expression to load the attributes and set them
+        # in its @attributes instance variable.
+        # Currently only used by FilterDefinitionExpression.
+        #
+        def load_attributes
+
+            @attributes = raw_representation[1]
+        end
+
+        #
+        # This method has been made public in order to have quick look
+        # at the attributes of an expression before it's really
+        # 'instantiated'.
+        #
+        def extract_attributes
+
+            raw_representation[1]
+        end
+
+        protected
+
+            #
+            # looks up a participant in the participant map, considers
+            # "my-participant" and "my_participant" as the same
+            # (by doing two lookups).
+            #
+            def lookup_participant (name)
+
+                p = get_participant_map.lookup_participant(name)
+
+                unless p
+                    name = OpenWFE::to_underscore(name)
+                    p = get_participant_map.lookup_participant(name)
+                end
+
+                return name if p
+
+                nil
+            end
+
+            #
+            # Determines if this raw expression points to a classical
+            # expression, a participant or a subprocess, or nothing at all...
+            #
+            def determine_real_expression
+
+                exp_name = expression_name()
+                exp_class = expression_class()
+                var_value = lookup_variable exp_name
+                attributes = extract_attributes
+
+                unless var_value
+                    #
+                    # accomodating "sub_process_name" and "sub-process-name"
+                    #
+                    alt = OpenWFE::to_underscore exp_name
+                    var_value = lookup_variable(alt) if alt != exp_name
+
+                    exp_name = alt if var_value
+                end
+
+                var_value = exp_name \
+                    if (not exp_class and not var_value)
+
+                if var_value.is_a?(String)
+
+                    participant_name = lookup_participant var_value
+
+                    if participant_name
+                        exp_name = participant_name
+                        exp_class = ParticipantExpression
+                        attributes['ref'] = participant_name
+                    end
+
+                elsif var_value.is_a?(FlowExpressionId) \
+                    or var_value.is_a?(RawExpression)
+
+                    exp_class = SubProcessRefExpression
+                    attributes['ref'] = exp_name
+                end
+                # else, it's a standard expression
+
+                [ exp_name, exp_class, attributes ]
+            end
+
+            def extract_children
+
+                i = 0
+                result = []
+                raw_representation.last.each do |child|
+
+                    if is_not_a_node?(child)
+
+                        result << child
+                    else
+
+                        cname = child.first.intern
+
+                        next if cname == :param
+                        next if cname == :parameter
+                        #next if cname == :description
+
+                        cfei = @fei.dup
+                        cfei.expression_name = child.first
+                        cfei.expression_id = "#{cfei.expression_id}.#{i}"
+
+                        efei = @environment_id
+
+                        rawexp = RawExpression.new_raw(
+                            cfei, @fei, efei, @application_context, child)
+
+                        get_expression_pool.update rawexp
+
+                        i = i + 1
+
+                        result << rawexp.fei
+                    end
+                end
+                result
+            end
+
+            def extract_parameters
+
+                r = []
+                raw_representation.last.each do |child|
+
+                    #next unless child.is_a?(SimpleExpRepresentation)
+                    #next unless child.is_a?(Array)
+                    next if is_not_a_node?(child)
+
+                    name = child.first.to_sym
+                    next unless (name == :parameter or name == :param)
+
+                    attributes = child[1]
+
+                    r << Parameter.new(
+                        attributes['field'],
+                        attributes['match'],
+                        attributes['default'],
+                        attributes['type'])
+                end
+                r
+            end
+
+            def is_not_a_node? (child)
+
+                (( ! child.is_a?(Array)) ||
+                 child.size != 3 ||
+                 ( ! child.first.is_a?(String)))
+            end
+
+            #
+            # Expressions can get tagged. Tagged expressions can easily
+            # be cancelled (undone) or redone.
+            #
+            def consider_tag (workitem, new_expression)
+
+                tagname = new_expression.lookup_string_attribute :tag, workitem
+
+                return unless tagname
+
+                ldebug { "consider_tag() tag is '#{tagname}'" }
+
+                set_variable tagname, Tag.new(self, workitem)
+                    #
+                    # keep copy of raw expression and workitem as applied
+
+                new_expression.attributes["tag"] = tagname
+                    #
+                    # making sure that the value of tag doesn't change anymore
+            end
+
+            #
+            # A small class wrapping a tag (a raw expression and the workitem
+            # it received at apply time.
+            #
+            class Tag
+
+                attr_reader \
+                    :raw_expression,
+                    :workitem
+
+                def flow_expression_id
+                    @raw_expression.fei
+                end
+                alias :fei :flow_expression_id
+
+                def initialize (raw_expression, workitem)
+
+                    @raw_expression = raw_expression.dup
+                    @workitem = workitem.dup
+                end
+            end
+
+            #
+            # Encapsulating
+            #     <parameter field="x" default="y" type="z" match="m" />
+            #
+            # Somehow I have that : OpenWFEru is not a strongly typed language
+            # ... Anyway I implemented that to please Pat.
+            #
+            class Parameter
+
+                def initialize (field, match, default, type)
+
+                    @field = to_s field
+                    @match = to_s match
+                    @default = to_s default
+                    @type = to_s type
+                end
+
+                #
+                # Will raise an exception if this param requirement is not
+                # met by the workitem.
+                #
+                def check (workitem)
+
+                    unless @field
+                        raise \
+                            OpenWFE::ParameterException,
+                            "'parameter'/'param' without a 'field' attribute"
+                    end
+
+                    field_value = workitem.attributes[@field]
+                    field_value = @default unless field_value
+
+                    unless field_value
+                        raise \
+                            OpenWFE::ParameterException,
+                            "field '#{@field}' is missing" \
+                    end
+
+                    check_match(field_value)
+
+                    enforce_type(workitem, field_value)
+                end
+
+                protected
+
+                    #
+                    # Used in the constructor to flatten everything to strings.
+                    #
+                    def to_s (o)
+                        return nil unless o
+                        o.to_s
+                    end
+
+                    #
+                    # Will raise an exception if it cannot coerce the type
+                    # of the value to the one desired.
+                    #
+                    def enforce_type (workitem, value)
+
+                        value = if not @type
+                            value
+                        elsif @type == "string"
+                            value.to_s
+                        elsif @type == "int" or @type == "integer"
+                            Integer(value)
+                        elsif @type == "float"
+                            Float(value)
+                        else
+                            raise
+                                "unknown type '#{@type}' for field '#{@field}'"
+                        end
+
+                        workitem.attributes[@field] = value
+                    end
+
+                    def check_match (value)
+
+                        return unless @match
+
+                        unless value.to_s.match(@match)
+                            raise \
+                                OpenWFE::ParameterException,
+                                "value of field '#{@field}' doesn't match"
+                        end
+                    end
+            end
+    end
+
+    #
+    # This class is only present to ensure that OpenWFEru 0.9.17 can read
+    # previous (<= 0.9.16) expools.
+    #
+    class ProgRawExpression < RawExpression
+
+        def raw_representation
+
+            @raw_representation.to_a
+        end
+    end
+
+    #
+    # This class is only present to ensure that OpenWFEru 0.9.17 can read
+    # previous (<= 0.9.16) expools.
+    #
+    class XmlRawExpression < RawExpression
+
+        def raw_representation
+
+            #SimpleExpRepresentation.from_xml @raw_representation_s
+            DefParser.parse_xml @raw_representation_s
+        end
+    end
+
+    #
+    # This class is only present to ensure that OpenWFEru 0.9.17 can read
+    # previous (<= 0.9.16) expools.
+    #
+    class SimpleExpRepresentation
+
+        def to_a
+
+            children = @children.collect do |c|
+                if c.is_a?(SimpleExpRepresentation)
+                    c.to_a
+                else
+                    c
+                end
+            end
+
+            a = [ @name, @attributes, children ]
+        end
+    end
+
+    private
+
+        #
+        # OpenWFE process definitions do use some
+        # Ruby keywords... The workaround is to put an underscore
+        # just before the name to 'escape' it.
+        #
+        # 'undo' isn't reserved by Ruby, but lets keep it in line
+        # with 'do' and 'redo' that are.
+        #
+        KEYWORDS = [
+            :if, :do, :redo, :undo, :print, :sleep, :loop, :break, :when
+            #:until, :while
+        ]
+
+        #
+        # Ensures the method name is not conflicting with Ruby keywords
+        # and turn dashes to underscores.
+        #
+        def OpenWFE.make_safe (method_name)
+
+            method_name = OpenWFE::to_underscore(method_name)
+
+            return "_" + method_name \
+                if KEYWORDS.include? eval(":"+method_name)
+
+            method_name
+        end
+
+        def OpenWFE.to_expression_name (method_name)
+
+            method_name = method_name.to_s
+            method_name = method_name[1..-1] if method_name[0, 1] == "_"
+            method_name = OpenWFE::to_dash(method_name)
+            method_name
+        end
+
+end
+