openwferu 0.9.7 → 0.9.8

data/lib/openwfe/expressions/flowexpression.rb

@@ -61,11 +61,11 @@ module OpenWFE
         include Contextual, Logging, OwfeServiceLocator
 
         attr_accessor \
-            :fei, \
-            :parent_id, \
-            :environment_id, \
-            :attributes, \
-            :children, \
+            :fei,
+            :parent_id,
+            :environment_id,
+            :attributes,
+            :children,
             :apply_time 
 
 
@@ -124,7 +124,7 @@ module OpenWFE
         # cancels all the children
         # Attempts to return an InFlowWorkItem
         #
-        def cancel ()
+        def cancel
 
             return nil if not @children
 
@@ -138,7 +138,7 @@ module OpenWFE
                 inflowitem = i if not inflowitem
             end
 
-            return inflowitem
+            inflowitem
         end
 
         #
@@ -150,7 +150,7 @@ module OpenWFE
         #
         def get_parent ()
             parent, parent_fei = get_expression_pool().fetch(@parent_id)
-            return parent
+            parent
         end
 
         #
@@ -163,7 +163,7 @@ module OpenWFE
         def store_itself ()
             ldebug { "store_itself() for  #{@fei.to_debug_s}" }
             #ldebug { "store_itself() \n#{OpenWFE::caller_to_s(0, 6)}" }
-            return get_expression_pool().update(self)
+            get_expression_pool().update(self)
         end
 
         #
@@ -175,7 +175,7 @@ module OpenWFE
         def get_environment ()
             return nil if not @environment_id
             env, fei = get_expression_pool().fetch(@environment_id)
-            return env
+            env
         end
 
         #
@@ -282,7 +282,19 @@ module OpenWFE
 
             return default if not text
 
-            return OpenWFE::dosub(text, self, workitem)
+            OpenWFE::dosub(text, self, workitem)
+        end
+
+        #
+        # Returns true if the expression has the given attribute.
+        # The attname parameter can be a String or a Symbol.
+        #
+        def has_attribute (attname)
+
+            attname = OpenWFE::symbol_to_name(attname) \
+                if attname.kind_of? Symbol
+
+            @attributes[attname] != nil
         end
 
         #
@@ -322,7 +334,7 @@ module OpenWFE
                 #end
             end
 
-            return result
+            result
         end
 
         #
@@ -419,6 +431,69 @@ module OpenWFE
             #ldebug { "synchronize() --out--  for  #{@fei.to_debug_s}" }
         end
 
+        #
+        # Returns the text stored as the children of the given expression
+        # 
+        def fetch_text_content (workitem, escape=false)
+
+            text = ""
+
+            children.each do |child|
+                if child.kind_of?(RawExpression)
+                    text << child.fei.to_s
+                else
+                    text << child.to_s
+                end
+            end
+
+            return nil if text == ""
+
+            text = OpenWFE::dosub(text, self, workitem) \
+                unless escape
+
+            text
+        end
+
+        #
+        # looks up for 'value', 'variable-value' and then for 'field-value'
+        # if necessary.
+        #
+        def lookup_value (workitem, prefix='')
+
+            lookup_vf_attribute(workitem, 'value', prefix)
+        end
+
+        #
+        # looks up for 'ref', 'variable-ref' and then for 'field-ref'
+        # if necessary.
+        #
+        def lookup_ref (workitem, prefix='')
+
+            lookup_vf_attribute(workitem, 'ref', prefix)
+        end
+
+        #
+        # Looks up for value attributes like 'field-ref' or 'variable-value'
+        #
+        def lookup_vf_attribute (workitem, att_name, prefix='')
+
+            prefix = "#{prefix.to_s}-" if prefix != ''
+
+            v = lookup_attribute("#{prefix}#{att_name}", workitem)
+
+            return v if v
+
+            v = lookup_attribute("#{prefix}variable-#{att_name}", workitem)
+
+            return lookup_variable(v) if v
+
+            v = lookup_attribute("#{prefix}field-#{att_name}", workitem)
+
+            return workitem.attributes[v] if v
+
+            nil
+        end
+
         #
         # Some eye candy
         #
@@ -461,13 +536,6 @@ module OpenWFE
             end
         end
 
-        #def self.sync_expression (bool)
-        #    meta_def :is_sync_expression? do
-        #        bool
-        #    end
-        #end
-        #sync_expression false
-
         protected
 
             #
@@ -494,6 +562,31 @@ module OpenWFE
 
                 return [ get_environment, varname]
             end
+
+            #
+            # Returns the next sub process id available (this counter
+            # is stored in the local environment under the key :next_sub_id)
+            #
+            def get_next_sub_id
+
+                env = get_environment
+
+                c = nil
+
+                env.synchronize do
+                    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
+
+                c
+            end
     end
 
 end

data/lib/openwfe/expressions/raw_prog.rb

@@ -43,119 +43,11 @@ require 'rexml/document'
 
 require 'openwfe/utils'
 require 'openwfe/expressions/fe_raw'
-require 'openwfe/expressions/fe_utils'
+require 'openwfe/expressions/simplerep'
 
 
 module OpenWFE
 
-    #
-    # A raw representation for a process definition, programmatic
-    # process definitions are turned into trees of instances of this class.
-    #
-    class ProgExpRepresentation
-
-        attr_reader \
-            :name, 
-            :attributes
-
-        attr_accessor \
-            :children
-
-        def initialize (name, attributes)
-            super()
-            @name = name
-            @attributes = attributes
-            @children = []
-        end
-
-        #
-        # Adds a child to this expression representation.
-        #
-        def << (child)
-            @children << child
-        end
-
-        #
-        # Always return the ProgRawExpression class.
-        #
-        def raw_expression_class
-            return ProgRawExpression
-        end
-
-        #
-        # Returns an XML string, containing the equivalent process definition
-        # in the classical OpenWFE process definition language.
-        #
-        def to_s
-            doc = REXML::Document.new()
-            doc << to_xml
-            s = ""
-            doc.write(s, 0)
-            return s
-        end
-
-        #
-        # Returns this representation tree as an XML element (and its children).
-        #
-        def to_xml
-
-            elt = REXML::Element.new(@name)
-
-            #elt.attributes.update(@attributes)
-            @attributes.each do |k, v|
-                elt.attributes[k] = v
-            end
-
-            @children.each do |child|
-                if child.kind_of? ProgExpRepresentation
-                    elt << child.to_xml
-                else
-                    elt << REXML::Text.new(child.to_s)
-                end
-            end
-
-            return elt
-        end
-
-        #
-        # Returns a string containing the ruby code that generated this
-        # raw representation tree.
-        #
-        def to_code_s (indentation = 0)
-
-            s = ""
-            tab = "    "
-            ind = tab * indentation
-
-            s << ind
-            s << OpenWFE::make_safe(@name)
-
-            sa = ""
-            @attributes.each do |k, v|
-                sa << ", :#{OpenWFE::to_underscore(k)} => '#{v}'"
-            end
-            s << sa[1..-1] if sa.length > 0
-
-            if @children.length > 0
-                s << " do\n"
-                @children.each do |child|
-                    if child.respond_to? :to_code_s
-                        s << child.to_code_s(indentation + 1)
-                    else
-                        s << ind
-                        s << tab
-                        s << "'#{child.to_s}'"
-                    end
-                    s << "\n"
-                end
-                s << ind
-                s << "end"
-            end
-
-            return s
-        end
-    end
-
     #
     # This is the class to extend to create a programmatic process definition.
     #
@@ -235,7 +127,7 @@ module OpenWFE
                 string_child = params.to_s
             end
 
-            exp = ProgExpRepresentation.new(exp_name, attributes)
+            exp = SimpleExpRepresentation.new(exp_name, attributes)
 
             exp.children << string_child \
                 if string_child
@@ -293,7 +185,7 @@ module OpenWFE
             attributes["name"] = name
             attributes["revision"] = revision
 
-            top_expression = ProgExpRepresentation.new(
+            top_expression = SimpleExpRepresentation.new(
                 "process-definition", attributes)
 
             top_expression.children = context.top_expressions
@@ -384,7 +276,7 @@ module OpenWFE
 
     #
     # The actual 'programmatic' raw expression.
-    # Its raw_representation being an instance of ProgExpRepresentation.
+    # Its raw_representation being an instance of SimpleExpRepresentation.
     #
     class ProgRawExpression < RawExpression
 
@@ -413,7 +305,7 @@ module OpenWFE
                 result = []
                 raw_representation.children.each do |child|
 
-                    next unless child.is_a?(ProgExpRepresentation)
+                    next unless child.is_a?(SimpleExpRepresentation)
                     next if child.name.intern != :description
 
                     lang = child.attributes[:language]
@@ -431,7 +323,7 @@ module OpenWFE
                 result = []
                 raw_representation.children.each do |child|
 
-                    if child.kind_of? ProgExpRepresentation
+                    if child.kind_of? SimpleExpRepresentation
 
                         cname = child.name.intern
 
@@ -463,7 +355,7 @@ module OpenWFE
 
             def extract_text_children ()
                 raw_representation.children.collect do |child|
-                    next if child.is_a? ProgExpRepresentation
+                    next if child.is_a? SimpleExpRepresentation
                     child.to_s
                 end
             end
@@ -473,7 +365,7 @@ module OpenWFE
                 r = []
                 raw_representation.children.each do |child|
 
-                    next unless child.is_a? ProgExpRepresentation
+                    next unless child.is_a? SimpleExpRepresentation
 
                     name = child.name.intern
                     next unless (name == :parameter or name == :param)

data/lib/openwfe/expressions/simplerep.rb

@@ -0,0 +1,197 @@
+#
+#--
+# Copyright (c) 2007, 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.
+#++
+#
+# $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+require 'rexml/document'
+
+require 'openwfe/expressions/raw_prog'
+
+
+module OpenWFE
+
+    #
+    # A raw representation for a process definition, programmatic
+    # process definitions are turned into trees of instances of this class.
+    #
+    class SimpleExpRepresentation
+
+        attr_reader \
+            :name, 
+            :attributes
+
+        attr_accessor \
+            :children
+
+        def initialize (name, attributes)
+            super()
+            @name = name
+            @attributes = attributes
+            @children = []
+        end
+
+        #
+        # Adds a child to this expression representation.
+        #
+        def << (child)
+            @children << child
+        end
+
+        #
+        # Always return the ProgRawExpression class.
+        #
+        def raw_expression_class
+            return ProgRawExpression
+        end
+
+        #
+        # Returns an XML string, containing the equivalent process definition
+        # in the classical OpenWFE process definition language.
+        #
+        def to_s
+            doc = REXML::Document.new()
+            doc << to_xml
+            s = ""
+            doc.write(s, 0)
+            return s
+        end
+
+        #
+        # Returns this representation tree as an XML element (and its children).
+        #
+        def to_xml
+
+            elt = REXML::Element.new(@name)
+
+            #elt.attributes.update(@attributes)
+            @attributes.each do |k, v|
+                elt.attributes[k] = v
+            end
+
+            @children.each do |child|
+                if child.kind_of? SimpleExpRepresentation
+                    elt << child.to_xml
+                else
+                    elt << REXML::Text.new(child.to_s)
+                end
+            end
+
+            return elt
+        end
+
+        #
+        # Turns an XML tree into a simple representation
+        # (beware embedded XML, should do something to stop that,
+        # CDATA is perhaps sufficient).
+        #
+        def self.from_xml (xml)
+
+            xml = REXML::Document.new(xml) \
+                if xml.is_a? String
+
+            xml = xml.root \
+                if xml.is_a? REXML::Document
+
+            if xml.is_a? REXML::Text
+                s = xml.to_s
+                return s if s.strip.length > 1
+                return nil
+            end
+
+            # xml element thus...
+
+            name = xml.name
+
+            attributes = {}
+
+            xml.attributes.each do |k, v|
+                attributes[k] = v
+            end
+
+            rep = SimpleExpRepresentation.new(name, attributes)
+
+            xml.children.each do |c|
+                r = from_xml(c)
+                rep << r if r
+            end
+
+            rep
+        end
+
+        #
+        # Returns a string containing the ruby code that generated this
+        # raw representation tree.
+        #
+        def to_code_s (indentation = 0)
+
+            s = ""
+            tab = "    "
+            ind = tab * indentation
+
+            s << ind
+            s << OpenWFE::make_safe(@name)
+
+            sa = ""
+            @attributes.each do |k, v|
+                sa << ", :#{OpenWFE::to_underscore(k)} => '#{v}'"
+            end
+            s << sa[1..-1] if sa.length > 0
+
+            if @children.length > 0
+                s << " do\n"
+                @children.each do |child|
+                    if child.respond_to? :to_code_s
+                        s << child.to_code_s(indentation + 1)
+                    else
+                        s << ind
+                        s << tab
+                        s << "'#{child.to_s}'"
+                    end
+                    s << "\n"
+                end
+                s << ind
+                s << "end"
+            end
+
+            return s
+        end
+    end
+
+end
+