openwferu 0.9.6 → 0.9.7

data/lib/openwfe/expressions/flowexpression.rb

@@ -43,6 +43,7 @@ require 'openwfe/utils'
 require 'openwfe/logging'
 require 'openwfe/contextual'
 require 'openwfe/rudefinitions'
+require 'openwfe/util/ometa'
 require 'openwfe/util/dollar'
 
 
@@ -56,7 +57,7 @@ module OpenWFE
     # The base class for all OpenWFE flow expression classes.
     # It gathers all the methods for attributes and variable lookup.
     #
-    class FlowExpression
+    class FlowExpression < ObjectWithMeta
         include Contextual, Logging, OwfeServiceLocator
 
         attr_accessor \
@@ -214,7 +215,11 @@ module OpenWFE
         # or by // to indicate engine level (global) scope.
         #
         def set_variable (varname, value)
-            get_environment()[varname] = value
+
+            #get_environment()[varname] = value
+
+            env, var = lookup_environment(varname)
+            env[var] = value
         end
 
         #
@@ -226,7 +231,11 @@ module OpenWFE
         # or by // to indicate engine level (global) scope.
         #
         def lookup_variable (varname)
-            get_environment()[varname]
+
+            #get_environment()[varname]
+
+            env, var = lookup_environment(varname)
+            env[var]
         end
 
         #
@@ -236,7 +245,11 @@ module OpenWFE
         # or by // to indicate engine level (global) scope.
         #
         def delete_variable (varname)
-            get_environment().delete(varname)
+
+            #get_environment().delete(varname)
+
+            env, var = lookup_environment(varname)
+            env.delete var
         end
 
         #
@@ -258,7 +271,7 @@ module OpenWFE
         #
         def lookup_attribute (attname, workitem, default=nil)
 
-            attname = symbol_to_attname(attname) \
+            attname = OpenWFE::symbol_to_name(attname) \
                 if attname.kind_of? Symbol
 
             #ldebug { "lookup_attribute() '#{attname}' in #{@fei.to_debug_s}" }
@@ -277,6 +290,7 @@ module OpenWFE
         # It's ok to pass a Symbol for the attribute name.
         #
         def lookup_boolean_attribute (attname, workitem, default=false)
+
             value = lookup_attribute(attname, workitem)
             return default if not value
             return value.downcase == 'true'
@@ -434,12 +448,51 @@ module OpenWFE
             return s
         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
+
+        #def self.sync_expression (bool)
+        #    meta_def :is_sync_expression? do
+        #        bool
+        #    end
+        #end
+        #sync_expression false
+
         protected
 
-            def symbol_to_attname (s)
-                attname = s.to_s
-                attname = OpenWFE::to_dash(attname)
-                return attname
+            #
+            # 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
+
+                return [ get_environment, varname]
             end
     end
 

data/lib/openwfe/expressions/raw_prog.rb

@@ -41,6 +41,7 @@
 
 require 'rexml/document'
 
+require 'openwfe/utils'
 require 'openwfe/expressions/fe_raw'
 require 'openwfe/expressions/fe_utils'
 
@@ -177,26 +178,37 @@ module OpenWFE
     #
     class ProcessDefinition
 
-        attr_reader :top_expressions
+        def self.metaclass; class << self; self; end; end
 
-        #def initialize (exp_names=nil)
-        def initialize ()
+        attr_reader :context
 
+        def initialize ()
             super()
-
-            @top_expressions = []
-            @previous_parent_expression = []
+            @context = Context.new
         end
 
         def method_missing (m, *args, &block)
 
-            methodname = m.to_s
+            #puts "__i_method_missing >>>#{m}<<<<"
+
+            ProcessDefinition.make_expression(
+                @context, 
+                OpenWFE::to_expression_name(m),
+                ProcessDefinition.pack_args(args), 
+                &block)
+        end
+
+        def self.method_missing (m, *args, &block)
 
-            expname = OpenWFE.to_expression_name(methodname)
+            #puts "__c_method_missing >>>#{m}<<<<"
 
-            args = pack_args(args)
+            @ccontext = Context.new() unless @ccontext
 
-            make_expression(expname, args, &block)
+            ProcessDefinition.make_expression(
+                @ccontext, 
+                OpenWFE::to_expression_name(m),
+                ProcessDefinition.pack_args(args), 
+                &block)
         end
 
         #
@@ -207,19 +219,17 @@ module OpenWFE
             raise "make() implementation is missing, please provide one"
         end
 
-        def make_expression (exp_name, params, &block)
-
-            exp_name = exp_name.to_s
+        def self.make_expression (context, exp_name, params, &block)
 
             string_child = nil
-            attributes = {}
+            attributes = OpenWFE::SymbolHash.new
 
             #puts " ... params.class is #{params.class}"
 
             if params.kind_of? Hash 
                 params.each do |k, v|
                     #attributes[k.to_s] = v.to_s
-                    attributes[OpenWFE.to_dash(k.to_s)] = v.to_s
+                    attributes[OpenWFE::symbol_to_name(k.to_s)] = v.to_s
                 end
             elsif params
                 string_child = params.to_s
@@ -230,30 +240,28 @@ module OpenWFE
             exp.children << string_child \
                 if string_child
 
-            if @parent_expression
-                @parent_expression << exp
+            if context.parent_expression
+                #
+                # adding this new expression to its parent
+                #
+                context.parent_expression << exp
             else
-                @top_expressions << exp
+                #
+                # an orphan, a top expression
+                #
+                context.top_expressions << exp
             end
 
             return exp if not block
 
-            @previous_parent_expression.push(@parent_expression) \
-                if @parent_expression
-
-            @parent_expression = exp
+            context.push_parent_expression(exp)
 
             result = block.call
-            #if result and result.kind_of? String and result.length > 0
-            #    puts " ... child is >#{result}<"
-            #    exp.children << result
-            #end
-            #exp.children << result \
-            #    if result and not result.kind_of? ProgExpRepresentation
+
             exp.children << result \
                 if result and result.kind_of? String
 
-            @parent_expression = @previous_parent_expression.pop
+            context.pop_parent_expression
 
             return exp
         end
@@ -264,16 +272,23 @@ module OpenWFE
         #
         def ProcessDefinition.do_make ()
 
-            pdef = self.new
-            exp = pdef.make
-
-            if pdef.top_expressions.size == 1 and \
-                exp.name == "process-definition"
+            context = nil
 
-                return exp 
+            if @ccontext
+                context = @ccontext
+            else
+                pdef = self.new
+                pdef.make
+                context = pdef.context
             end
 
-            name, revision = extract_name_and_revision(pdef.class.name)
+            exp = context.top_expression
+
+            return exp if exp
+
+            name, revision = 
+                extract_name_and_revision(self.metaclass.to_s[8..-2])
+
             attributes = {}
             attributes["name"] = name
             attributes["revision"] = revision
@@ -281,14 +296,14 @@ module OpenWFE
             top_expression = ProgExpRepresentation.new(
                 "process-definition", attributes)
 
-            top_expression.children = pdef.top_expressions
+            top_expression.children = context.top_expressions
 
-            top_expression
+            return top_expression
         end
 
         protected
 
-            def pack_args (args)
+            def ProcessDefinition.pack_args (args)
                 return args[0] if args.length == 1
                 a = {}
                 args.each_with_index do |arg, index|
@@ -323,6 +338,48 @@ module OpenWFE
             def ProcessDefinition.as_revision (s)
                 s.gsub("_", ".")
             end
+
+            class Context
+
+                attr_accessor :parent_expression
+                attr_reader :top_expressions, :previous_parent_expressions
+
+                def initialize
+                    @parent_expression = nil
+                    @top_expressions = []
+                    @previous_parent_expressions = []
+                end
+
+                #
+                # puts the current parent expression on top of the 'previous
+                # parent expressions' stack, the current parent expression
+                # is replaced with the supplied parent expression.
+                #
+                def push_parent_expression (exp)
+                    @previous_parent_expressions.push(@parent_expression) \
+                        if @parent_expression
+                    @parent_expression = exp
+                end
+
+                #
+                # Replaces the current parent expression with the one found
+                # on the top of the previous parent expression stack (pop).
+                #
+                def pop_parent_expression
+                    @parent_expression = @previous_parent_expressions.pop
+                end
+
+                #
+                # This method returns the top expression among the 
+                # top expressions...
+                #
+                def top_expression
+                    return nil if @top_expressions.size > 1
+                    exp = @top_expressions[0]
+                    return exp if exp.name == "process-definition"
+                    return nil
+                end
+            end
     end
 
     #
@@ -348,16 +405,40 @@ module OpenWFE
         protected 
 
             def extract_attributes ()
-                return raw_representation.attributes
+                raw_representation.attributes
+            end
+
+            def extract_descriptions ()
+
+                result = []
+                raw_representation.children.each do |child|
+
+                    next unless child.is_a?(ProgExpRepresentation)
+                    next if child.name.intern != :description
+
+                    lang = child.attributes[:language]
+                    lang = child.attributes[:lang] unless lang
+                    lang = "default" unless lang
+
+                    result << [ lang, child.children[0] ]
+                end
+                result
             end
 
             def extract_children ()
 
                 i = 0
-                raw_representation.children.collect do |child|
+                result = []
+                raw_representation.children.each do |child|
 
                     if child.kind_of? ProgExpRepresentation
 
+                        cname = child.name.intern
+
+                        next if cname == :param
+                        next if cname == :parameter
+                        next if cname == :description
+
                         cfei = @fei.dup
                         cfei.expression_name = child.name
                         cfei.expression_id = "#{cfei.expression_id}.#{i}"
@@ -371,12 +452,13 @@ module OpenWFE
 
                         i = i + 1
 
-                        rawexp.fei
+                        result << rawexp.fei
                     else
 
-                        child
+                        result << child
                     end
                 end
+                result
             end
 
             def extract_text_children ()
@@ -385,6 +467,25 @@ module OpenWFE
                     child.to_s
                 end
             end
+
+            def extract_parameters ()
+
+                r = []
+                raw_representation.children.each do |child|
+
+                    next unless child.is_a? ProgExpRepresentation
+
+                    name = child.name.intern
+                    next unless (name == :parameter or name == :param)
+
+                    r << Parameter.new(
+                        child.attributes[:field],
+                        child.attributes[:match],
+                        child.attributes[:default],
+                        child.attributes[:type])
+                end
+                r
+            end
     end
 
     private
@@ -406,15 +507,16 @@ module OpenWFE
         # and turn dashes to underscores.
         #
         def OpenWFE.make_safe (method_name)
-            method_name = to_underscore(method_name)
+            method_name = OpenWFE::to_underscore(method_name)
             return "_" + method_name \
                 if KEYWORDS.include? eval(":"+method_name)
             return 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 = to_dash(method_name)
+            method_name = OpenWFE::to_dash(method_name)
             return method_name
         end
 

data/lib/openwfe/expressions/raw_xml.rb

@@ -66,13 +66,14 @@ module OpenWFE
         end
 
         def raw_representation
-            #synchronize do
-            if not @raw_representation
+
+            unless @raw_representation
+
                 @raw_representation = \
                     REXML::Document.new(@raw_representation_s).root
             end
-            return @raw_representation
-            #end
+
+            @raw_representation
         end
 
         protected
@@ -85,6 +86,23 @@ module OpenWFE
                 return result
             end
 
+            def extract_descriptions ()
+
+                result = []
+                raw_representation.each_child do |child|
+
+                    next unless child.is_a?(REXML::Element)
+                    next if child.name.intern != :description
+
+                    lang = child.attributes["language"]
+                    lang = child.attributes["lang"] unless lang
+                    lang = "default" unless lang
+
+                    result << [ lang, child.children[0] ]
+                end
+                result
+            end
+
             def extract_children ()
 
                 c = []
@@ -94,6 +112,12 @@ module OpenWFE
 
                     if elt.kind_of?(REXML::Element)
 
+                        ename = elt.name.intern
+
+                        next if ename == :param
+                        next if ename == :parameter
+                        next if ename == :description
+
                         cfei = @fei.dup
 
                         efei = @environment_id
@@ -121,11 +145,13 @@ module OpenWFE
                     end
                 end
 
-                return c
+                c
             end
 
             def extract_text_children ()
+
                 raw_representation.children.collect do |elt|
+
                     next if elt.is_a? REXML::Element
                     next if elt.is_a? REXML::Comment
                     s = elt.to_s.strip
@@ -133,6 +159,25 @@ module OpenWFE
                     s
                 end
             end
+
+            def extract_parameters ()
+
+                r = []
+                raw_representation.children.each do |child|
+
+                    next unless child.is_a? REXML::Element
+
+                    cname = child.name.intern
+                    next unless (cname == :param or cname == :parameter)
+
+                    r << Parameter.new(
+                        child.attributes["field"],
+                        child.attributes["match"],
+                        child.attributes["default"],
+                        child.attributes["type"])
+                end
+                r
+            end
     end
 end
 

data/lib/openwfe/expressions/timeout.rb

@@ -49,7 +49,6 @@ require 'openwfe/util/scheduler'
 
 module OpenWFE
 
-
     #
     # The timeout behaviour is implemented here, making it easy
     # to mix it in into ParticipantExpression and WhenExpression.
@@ -61,6 +60,10 @@ module OpenWFE
             :timeout_at,
             :timeout_job_id
         
+        #
+        # Looks for the "timeout" attribute in its process definition
+        # and then sets the @timeout_at field (if there is a timeout).
+        #
         def determine_timeout
 
             #@timeout_at = nil
@@ -73,6 +76,11 @@ module OpenWFE
             @timeout_at = Time.new.to_f + timeout
         end
 
+        #
+        # Providing a default reschedule() implementation for the expressions
+        # that use this mixin.
+        # This default implementation just reschedules the timeout.
+        #
         def reschedule (scheduler)
             to_reschedule(scheduler)
         end
@@ -81,15 +89,24 @@ module OpenWFE
         # Overrides the parent method to make sure a potential
         # timeout schedules gets removed.
         #
-        def reply_to_parent (workitem)
-            unschedule_timeout()
-            super(workitem)
-        end
+        # Well... Leave that to classes that mix this in...
+        # No method override in a mixin...
+        #
+        #def reply_to_parent (workitem)
+        #    unschedule_timeout()
+        #    super(workitem)
+        #end
 
+        #
+        # Places a "__timed_out__" field in the workitem.
+        #
         def set_timedout_flag (workitem)
             workitem.attributes["__timed_out__"] = "true"
         end
 
+        #
+        # Removes any "__timed_out__" field in the workitem.
+        #
         def remove_timedout_flag (workitem)
             workitem.attributes.delete("__timed_out__")
         end
@@ -122,8 +139,18 @@ module OpenWFE
                     # done in the including expression
             end
 
+            #
+            # Unschedules the timeout
+            #
             def unschedule_timeout ()
 
+                ldebug do 
+                    "unschedule_timeout() " +
+                    "@timeout_job_id is #{@timeout_job_id}" 
+                end
+
+                #ldebug_callstack "unschedule_timeout()"
+
                 get_scheduler.unschedule(@timeout_job_id) \
                     if @timeout_job_id
             end

data/lib/openwfe/flowexpressionid.rb

@@ -125,6 +125,10 @@ module OpenWFE
             "(fei #{@workflow_definition_name} #{@workflow_definition_revision} #{@workflow_instance_id} #{@expression_id} #{@expression_name})"
         end
 
+        def to_short_s
+            "(fei #{@workflow_instance_id} #{@expression_id} #{@expression_name})"
+        end
+
         #
         # Returns the workflow instance id without any subflow indices.
         # For example, if the wfid is "1234.0.1", this method will
@@ -148,9 +152,7 @@ module OpenWFE
 
             ss = string.split(" ")
 
-            #require 'pp'
-            #puts
-            #pp ss
+            #require 'pp'; puts; pp ss
 
             ss = ss[1..-1] if ss[0] == "("
 
@@ -170,7 +172,7 @@ module OpenWFE
             fei.expression_id = fei.expression_id[0..-2] \
                 if fei.expression_id[-1, 1] == ")"
 
-            return fei
+            fei
         end
     end
 

data/lib/openwfe/listeners/listeners.rb

@@ -77,9 +77,10 @@ module OpenWFE
         def initialize (service_name, application_context)
             super
 
-            @workdir = application_context[:work_directory]
-            @workdir = OpenWFE::DEFAULT_WORK_DIRECTORY unless @workdir
-            @workdir += "/in/"
+            #@workdir = application_context[:work_directory]
+            #@workdir = OpenWFE::DEFAULT_WORK_DIRECTORY unless @workdir
+            #@workdir += "/in/"
+            @workdir = OpenWFE::get_work_directory + "/in/"
 
             linfo { "new() workdir is '#{@workdir}'" }
         end