openwferu 0.9.1 → 0.9.2

data/lib/{ru/fe_misc.rb → openwfe/expressions/fe_losfor.rb}

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2006, John Mettraux, OpenWFE.org
+# Copyright (c) 2006-2007, John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -39,60 +39,11 @@
 # John Mettraux at openwfe.org
 #
 
-require 'ru/flowexpression'
-require 'ru/fe_utils'
+require 'openwfe/expressions/flowexpression'
+require 'openwfe/expressions/fe_utils'
 
 
-module OpenWFEru
-
-    class PrintExpression < FlowExpression
-
-        #
-        # apply / reply
-
-        def apply (workitem)
-
-            escape = lookup_boolean_attribute('escape', workitem, false)
-
-            text = OpenWFEru::fetch_text_content(self, workitem, escape)
-            tracer = @application_context['__tracer']
-
-            if tracer
-                tracer << text
-            else
-                puts text
-            end
-
-            reply_to_parent(workitem)
-        end
-
-        #def reply (workitem)
-        #end
-
-    end
-
-    #
-    # Evals some Ruby code contained within the process definition 
-    # or within the workitem
-    #
-    class RevalExpression < FlowExpression
-
-        def apply (workitem)
-
-            escape = lookup_boolean_attribute('escape', workitem, false)
-
-            code = OpenWFEru::lookup_vf_attribute(self, workitem, 'code')
-
-            code = OpenWFEru::fetch_text_content(self, workitem, escape) \
-                if not code
-
-            result = eval(code.to_s)
-
-            OpenWFEru::set_result(workitem, result) if result != nil
-
-            reply_to_parent(workitem)
-        end
-    end
+module OpenWFE
 
     #
     # Triggers the first (and supposedly unique child of this expression)
@@ -107,7 +58,7 @@ module OpenWFEru
         end
 
         def reply (workitem)
-            # does nothing at all
+            get_expression_pool.remove(self)
         end
     end
 
@@ -115,7 +66,7 @@ module OpenWFEru
     # This method triggers its child (in its own thread) and then
     # forgets about it. It immediately replies to its parent expression.
     #
-    class ForgetExpression < LoseExpression
+    class ForgetExpression < FlowExpression
 
         def apply (workitem)
 
@@ -125,11 +76,14 @@ module OpenWFEru
 
                 Thread.new do
                     begin
+                        #child = get_expression_pool.fetch(@children[0])
+                        #child.parent_id = nil
+                        get_expression_pool.forget(@children[0])
                         get_expression_pool.apply(@children[0], wi)
                     rescue Exception => e
                         lwarn do
                             "apply() failed to apply child to forget "+
-                            OpenWFEru::exception_to_s(e)
+                            OpenWFE::exception_to_s(e)
                         end
                     end
                 end
@@ -137,6 +91,10 @@ module OpenWFEru
 
             reply_to_parent(wi)
         end
+
+        def reply (workitem)
+            # never gets called
+        end
     end
 
 end

data/lib/openwfe/expressions/fe_misc.rb

@@ -0,0 +1,102 @@
+#
+#--
+# Copyright (c) 2006-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 'openwfe/expressions/flowexpression'
+require 'openwfe/expressions/fe_utils'
+
+
+module OpenWFE
+
+    class PrintExpression < FlowExpression
+
+        #
+        # apply / reply
+
+        def apply (workitem)
+
+            escape = lookup_boolean_attribute('escape', workitem, false)
+
+            text = OpenWFE::fetch_text_content(self, workitem, escape)
+            text << "\n"
+
+            tracer = @application_context['__tracer']
+
+            if tracer
+                tracer << text
+            else
+                puts text
+            end
+
+            reply_to_parent(workitem)
+        end
+
+        #def reply (workitem)
+        #end
+
+    end
+
+    #
+    # <reval/>
+    #
+    # Evals some Ruby code contained within the process definition 
+    # or within the workitem
+    #
+    class RevalExpression < FlowExpression
+
+        def apply (workitem)
+
+            escape = lookup_boolean_attribute('escape', workitem, false)
+
+            code = OpenWFE::lookup_vf_attribute(self, workitem, 'code')
+
+            code = OpenWFE::fetch_text_content(self, workitem, escape) \
+                if not code
+
+            result = eval(code.to_s)
+
+            OpenWFE::set_result(workitem, result) if result != nil
+
+            reply_to_parent(workitem)
+        end
+    end
+
+end
+

data/lib/{ru → openwfe/expressions}/fe_participant.rb

@@ -1,6 +1,6 @@
 #
-#<tt>
-# Copyright (c) 2006, John Mettraux, OpenWFE.org
+#--
+# Copyright (c) 2006-2007, John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -28,7 +28,7 @@
 # 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.
-#</tt>
+#++
 #
 # $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
 #
@@ -39,34 +39,45 @@
 # John Mettraux at openwfe.org
 #
 
-#require 'workitem'
-require 'ru/rudefinitions'
-require 'ru/fe_utils'
+require 'openwfe/rudefinitions'
+require 'openwfe/expressions/fe_utils'
 
 
 #
 # The participant expression, in its own file
 #
 
-module OpenWFEru
+module OpenWFE
 
+    #
+    # Participants sit at the edge between the engine and the external
+    # world. The participant expression transmit the workitem applied
+    # to it to the Participant instance it looks up in the participant map
+    # tied to the engine.
+    #
     class ParticipantExpression < FlowExpression
 
-        #attr_accessor \
-        #    :applied_workitem
+        attr_accessor \
+            :participant_name,
+            :applied_workitem
 
         #
         # apply / reply
 
         def apply (workitem)
 
-            #@applied_workitem = workitem
+            @applied_workitem = workitem
+            #puts  "apply() \n#{@applied_workitem}"
+            #ldebug { "apply() \n#{@applied_workitem}" }
 
-            participant_name = \
-                OpenWFEru::lookup_vf_attribute(self, workitem, 'ref')
+            @participant_name = OpenWFE::lookup_ref(self, workitem)
 
-            @application_context[S_PARTICIPANT_MAP]\
-                .dispatch(participant_name, workitem)
+            @participant_name = OpenWFE::fetch_text_content(self, workitem) \
+                unless @participant_name
+
+            store_itself()
+
+            get_participant_map.dispatch(participant_name, workitem)
         end
 
         #def reply (workitem)

data/lib/{ru → openwfe/expressions}/fe_raw.rb

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2006, John Mettraux, OpenWFE.org
+# Copyright (c) 2006-2007, John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -39,29 +39,31 @@
 # John Mettraux at openwfe.org
 #
 
-require 'rexml/document'
+#require 'rexml/document'
 
-require 'otime'
-require 'workitem'
-require 'ru/engine'
-require 'ru/rudefinitions'
-require 'ru/flowexpression'
-require 'ru/fe_base'
+require 'openwfe/rudefinitions'
+require 'openwfe/expressions/flowexpression'
 
 
-module OpenWFEru
+module OpenWFE
 
+    #
+    # An 'abstract' class storing bits (trees) of process definitions just
+    # parsed. Upon application (apply()) these raw expressions get turned
+    # into real expressions.
+    # The first and classical extension of this class is XmlRawExpression.
+    #
     class RawExpression < FlowExpression
 
-        attr_accessor \
-            :xml_element
+        #attr_accessor \
+        #    :raw_representation
 
         def initialize \
-            (fei, parent_id, environment_id, application_context, xml_element)
+            (fei, parent_id, env_id, application_context, raw_representation)
 
-            super(fei, parent_id, environment_id, application_context, nil)
+            super(fei, parent_id, env_id, application_context, nil)
 
-            @xml_element = xml_element
+            @raw_representation = raw_representation
 
             new_environment() if not @environment_id
         end
@@ -74,6 +76,8 @@ module OpenWFEru
 
             raise "unknown expression '#{expression_name}'" if not eclass
 
+            ldebug { "instantiate_real_expression() eclass is #{eclass}" }
+
             expression = eclass.new(
                 @fei, 
                 @parent_id, 
@@ -101,89 +105,49 @@ module OpenWFEru
         end
 
         #def reply (workitem)
+        # no implementation necessary
         #end
 
-        def is_expression? ()
-            return false if not @xml_element.kind_of?(REXML::XMLElement)
-            return expression_class() != nil
-        end
-
         def is_definition? ()
             return get_expression_map.is_definition?(expression_name())
         end
 
-        def expression_name ()
-            return @xml_element.name
-        end
-
         def expression_class ()
             return get_expression_map().get_class(expression_name())
         end
-        
+
         def definition_name ()
-            return @xml_element.attributes['name'].to_s
+            return raw_representation.attributes['name'].to_s
         end
 
+        def expression_name ()
+            return raw_representation.name
+        end
+        
         protected
 
             def launch_template (template, workitem)
 
-                attributes = extract_attributes()
+                @attributes = extract_attributes()
+
+                #require 'pp'
+                #pp attributes
+                #pp lookup_attributes(workitem, attributes)
 
-                get_expression_pool().launch_template(\
+                get_expression_pool().launch_template(
                     self, 
                     template, 
                     workitem, 
-                    lookup_attributes(attributes, workitem))
+                    lookup_attributes(workitem))
             end
 
-            def extract_attributes ()
-                result = {}
-                @xml_element.attributes.each_attribute do |a|
-                    result[a.name] = a.value
-                end
-                return result
-            end
-
-            def extract_children ()
-
-                c = []
-                i = 0
-
-                @xml_element.each_child do |elt|
-
-                    if elt.kind_of?(REXML::Element)
-
-                        cfei = @fei.dup
-                        pfei = @fei
-
-                        efei = @environment_id
-
-                        cfei.expressionName = elt.name
-                        cfei.expressionId = "#{cfei.expressionId}.#{i}"
-
-                        rawchild = RawExpression\
-                            .new(cfei, pfei, efei, @application_context, elt)
-
-                        get_expression_pool().update(rawchild)
-                        c << rawchild.fei
-
-                        i = i+1
-
-                    elsif elt.kind_of?(REXML::Comment)
-
-                        next
-
-                    else
-
-                        s = elt.to_s.strip
-                        c << s if s.length > 0
-
-                    end
-                end
-
-                return c
-            end
+            #def extract_attributes ()
+            #    raise "abstract method : not implemented here"
+            #end
+            #def extract_children ()
+            #    raise "abstract method : not implemented here"
+            #end
     end
+
 end