openwferu 0.9.16 → 0.9.17

data/lib/openwfe/expressions/merge.rb

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2007, John Mettraux, OpenWFE.org
+# Copyright (c) 2007-2008, John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -59,6 +59,10 @@ module OpenWFE
             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|
         
@@ -69,6 +73,8 @@ module OpenWFE
         
                 wiTarget.attributes[nk] = nv
             end
+
+            #puts "merge() target after : " + wiTarget.attributes.inspect
         
             wiTarget
         end

data/lib/openwfe/expressions/raw.rb

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2006-2007, John Mettraux, OpenWFE.org
+# Copyright (c) 2006-2008, John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -45,32 +45,50 @@ require 'openwfe/rudefinitions'
 module OpenWFE
 
     #
-    # An 'abstract' class storing bits (trees) of process definitions just
+    # A 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
 
-        def initialize (
-            fei, parent_id, env_id, application_context, raw_representation)
 
-            super(fei, parent_id, env_id, application_context, nil)
+        def self.new_raw (
+            fei, parent_id, env_id, app_context, raw_representation)
 
-            #linfo { "initialize() '#{fei.expression_name}'" }
+            re = self.new
 
-            @raw_representation = raw_representation
+            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
 
-            #new_environment() if not @environment_id
-                #
-                # now done in the launch methods of the expression pool
+            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() unless exp_name
-            exp_class = expression_class() unless exp_class
+            exp_name ||= expression_name
+            exp_class ||= expression_class
 
             raise "unknown expression '#{exp_name}'" \
                 unless exp_class
@@ -79,22 +97,27 @@ module OpenWFE
             #    "instantiate_real_expression() exp_class is #{exp_class}"
             #end
 
-            attributes = extract_attributes() unless attributes
+            attributes ||= raw_representation[1]
 
-            expression = exp_class.new(
-                @fei, 
-                @parent_id, 
-                @environment_id, 
-                @application_context, 
-                attributes)
+            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
 
-            consider_tag(workitem, expression)
+            exp.raw_representation = raw_representation
+                #
+                # keeping track of how the expression look at apply / 
+                # instantiation time
+
+            consider_tag workitem, exp
             
-            handle_descriptions()
+            handle_descriptions
 
-            expression.children = extract_children()
+            exp.children = extract_children
 
-            expression
+            exp
         end
 
         #
@@ -127,24 +150,30 @@ module OpenWFE
             end
         end
 
+        #--
         #def reply (workitem)
         # no implementation necessary
         #end
+        #++
+
+        def is_definition?
 
-        def is_definition? ()
             get_expression_map.is_definition?(expression_name())
         end
 
-        def expression_class ()
+        def expression_class
+
             get_expression_map.get_class(expression_name())
         end
 
-        def definition_name ()
-            raw_representation.attributes['name'].to_s
+        def definition_name
+
+            raw_representation[1]['name'].to_s
         end
 
-        def expression_name ()
-            raw_representation.name
+        def expression_name
+
+            raw_representation.first
         end
 
         #
@@ -153,7 +182,18 @@ module OpenWFE
         # Currently only used by FilterDefinitionExpression.
         #
         def load_attributes
-            @attributes = extract_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
@@ -172,35 +212,38 @@ module OpenWFE
                     p = get_participant_map.lookup_participant(name)
                 end
 
-                if p 
-                    name
-                else
-                    nil
-                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 ()
+            def determine_real_expression
 
                 exp_name = expression_name()
-
                 exp_class = expression_class()
-                attributes = nil
+                var_value = lookup_variable exp_name
+                attributes = extract_attributes
 
-                var_value = lookup_variable(exp_name)
-
-                var_value = exp_name if (not exp_class and not var_value)
+                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
 
-                if var_value
-                    attributes = extract_attributes()
+                    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)
+                    participant_name = lookup_participant var_value
 
                     if participant_name
                         exp_name = participant_name
@@ -245,23 +288,93 @@ module OpenWFE
                     unless default
             end
 
-            #--
-            #def extract_attributes ()
-            #    raise NotImplementedError.new("'abstract method' sorry")
-            #end
-            #def extract_children ()
-            #    raise NotImplementedError.new("'abstract method' sorry")
-            #end
-            #def extract_descriptions ()
-            #    raise NotImplementedError.new("'abstract method' sorry")
-            #end
-            #def extract_parameters ()
-            #    raise NotImplementedError.new("'abstract method' sorry")
-            #end
-            #def extract_text_children ()
-            #    raise NotImplementedError.new("'abstract method' sorry")
-            #end
-            #++
+            def extract_descriptions
+
+                result = []
+                raw_representation.last.each do |child|
+
+                    #next unless child.is_a?(SimpleExpRepresentation)
+                    next if is_not_a_node?(child)
+                    next if child.first.intern != :description
+
+                    attributes = child[1]
+
+                    lang = attributes[:language]
+                    lang = attributes[:lang] unless lang
+                    lang = "default" unless lang
+
+                    result << [ lang, child.last.first ]
+                end
+                result
+            end
+
+            def extract_children
+
+                i = 0
+                result = []
+                raw_representation.last.each do |child|
+
+                    #if child.kind_of?(SimpleExpRepresentation)
+                    #if child.kind_of?(Array)
+                    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
@@ -275,7 +388,7 @@ module OpenWFE
 
                 ldebug { "consider_tag() tag is '#{tagname}'" }
 
-                set_variable(tagname, Tag.new(self, workitem))
+                set_variable tagname, Tag.new(self, workitem)
                     #
                     # keep copy of raw expression and workitem as applied
 
@@ -310,6 +423,9 @@ module OpenWFE
             # 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)
@@ -391,5 +507,87 @@ module OpenWFE
             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