openwferu 0.9.16 → 0.9.17

data/lib/openwfe/expressions/{raw_prog.rb → rprocdef.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 
@@ -37,11 +37,10 @@
 # John Mettraux at openwfe.org
 #
 
-require 'rexml/document'
+require 'rufus/eval' # gem 'rufus-eval'
 
 require 'openwfe/utils'
 require 'openwfe/expressions/raw'
-require 'openwfe/expressions/simplerep'
 
 
 module OpenWFE
@@ -72,7 +71,8 @@ module OpenWFE
 
         attr_reader :context
 
-        def initialize ()
+        def initialize
+
             super()
             @context = Context.new
         end
@@ -90,7 +90,7 @@ module OpenWFE
 
         def self.method_missing (m, *args, &block)
 
-            @ccontext = Context.new() \
+            @ccontext = Context.new \
                 if (not @ccontext) or @ccontext.discarded?
 
             ProcessDefinition.make_expression(
@@ -100,15 +100,22 @@ module OpenWFE
                 &block)
         end
 
+        #
+        # builds an actual expression representation (a node in the
+        # process definition tree).
+        #
         def self.make_expression (context, exp_name, params, &block)
 
             string_child = nil
-            attributes = OpenWFE::SymbolHash.new
+            #attributes = OpenWFE::SymbolHash.new
+            attributes = Hash.new
 
             #puts " ... params.class is #{params.class}"
 
             if params.kind_of?(Hash)
+
                 params.each do |k, v|
+
                     if k == '0'
                         string_child = v.to_s
                     else
@@ -116,20 +123,22 @@ module OpenWFE
                         attributes[OpenWFE::symbol_to_name(k.to_s)] = v
                     end
                 end
+
             elsif params
+
                 string_child = params.to_s
             end
 
-            exp = SimpleExpRepresentation.new(exp_name, attributes)
+            exp = [ exp_name, attributes, [] ]
 
-            exp.children << string_child \
+            exp.last << string_child \
                 if string_child
 
             if context.parent_expression
                 #
                 # adding this new expression to its parent
                 #
-                context.parent_expression << exp
+                context.parent_expression.last << exp
             else
                 #
                 # an orphan, a top expression
@@ -137,14 +146,14 @@ module OpenWFE
                 context.top_expressions << exp
             end
 
-            return exp if not block
+            return exp unless block
 
-            context.push_parent_expression(exp)
+            context.push_parent_expression exp
 
             result = block.call
 
-            exp.children << result \
-                if result and result.kind_of? String
+            exp.last << result \
+                if result and result.kind_of?(String)
 
             context.pop_parent_expression
 
@@ -152,23 +161,28 @@ module OpenWFE
         end
 
         def do_make
-            ProcessDefinition.do_make(self)
+
+            ProcessDefinition.do_make self
         end
 
         #
         # A class method for actually "making" the process 
         # segment raw representation
         #
-        def ProcessDefinition.do_make (instance=nil)
+        def self.do_make (instance=nil)
 
             context = if @ccontext
+
                 @ccontext.discard
                     # preventing further additions in case of reevaluation
                 @ccontext
+
             elsif instance
+
                 instance.make
                 instance.context
             else    
+
                 pdef = self.new
                 pdef.make
                 pdef.context
@@ -179,14 +193,11 @@ module OpenWFE
             name, revision = 
                 extract_name_and_revision(self.metaclass.to_s[8..-2])
 
-            attributes = {}
-            attributes["name"] = name
-            attributes["revision"] = revision
-
-            top_expression = SimpleExpRepresentation.new(
-                "process-definition", attributes)
-
-            top_expression.children = context.top_expressions
+            top_expression = [ 
+                "process-definition", 
+                { "name" => name, "revision" => revision }, 
+                context.top_expressions 
+            ]
 
             top_expression
         end
@@ -199,7 +210,8 @@ module OpenWFE
 
             ruby_proc_def_string.each_line do |l|
 
-                m = l.match " *class *([a-zA-Z0-9]*) *< .*ProcessDefinition"
+                m = ClassNameRex.match l
+
                 return eval(m[1]) if m
             end
 
@@ -211,20 +223,57 @@ module OpenWFE
         #
         def self.eval_ruby_process_definition (code, safety_level=2)
 
-            o = OpenWFE::eval_safely(code, safety_level)
+            #puts "\nin:\n#{code}\n"
+
+            code, is_wrapped = wrap_code code
+
+            o = Rufus::eval_safely code, safety_level, binding()
 
             o = extract_class(code) \
-                if (o == nil) or o.is_a?(SimpleExpRepresentation)
+                if (o == nil) or o.is_a?(Array)
+                #if (o == nil) or o.is_a?(SimpleExpRepresentation)
+                    #
+                    # grab the first process definition class found
+                    # in the given code
 
-            return o.do_make \
-                if o.is_a?(ProcessDefinition) or o.is_a?(Class)
+            #return o.do_make \
+            #    if o.is_a?(ProcessDefinition) or o.is_a?(Class)
+            #o
 
-            o
+            result = o.do_make
+
+            #return result.first_child if is_wrapped
+            return result.last.first if is_wrapped
+
+            result
         end
 
         protected
 
-            def ProcessDefinition.pack_args (args)
+            ClassNameRex = Regexp.compile(
+                " *class *([a-zA-Z0-9]*) *< .*ProcessDefinition")
+            ProcessDefinitionRex = Regexp.compile(
+                "^class *[a-zA-Z0-9]* *< .*ProcessDefinition")
+            ProcessNameAndDefRex = Regexp.compile(
+                "([^0-9_]*)_*([0-9].*)$")
+            ProcessNameRex = Regexp.compile(
+                "(.*$)")
+            EndsInDefinitionRex = Regexp.compile(
+                ".*Definition$")
+
+            def self.wrap_code (code)
+
+                return [ code, false ] if ProcessDefinitionRex.match(code)
+
+                s =  "class NoName0 < ProcessDefinition"
+                s << "\n"
+                s << code
+                s << "\nend"
+
+                [ s, true ]
+            end
+
+            def self.pack_args (args)
 
                 return args[0] if args.length == 1
 
@@ -239,26 +288,27 @@ module OpenWFE
                 a
             end
 
-            def ProcessDefinition.extract_name_and_revision (s)
+            def self.extract_name_and_revision (s)
 
-                #puts "s is >#{s}<"
+                i = s.rindex("::")
+                s = s[i+2..-1] if i
 
-                m = Regexp.compile(".*::([^0-9_]*)_*([0-9][0-9_]*)$").match(s)
+                m = ProcessNameAndDefRex.match s
                 return [ as_name(m[1]), as_revision(m[2]) ] if m
 
-                m = Regexp.compile(".*::(.*$)").match(s)
+                m = ProcessNameRex.match s
                 return [ as_name(m[1]), '0' ] if m
 
                 [ as_name(s), '0' ]
             end
 
-            def ProcessDefinition.as_name (s)
+            def self.as_name (s)
 
-                return s[0..-11] if s.match(".*Definition$")
+                return s[0..-11] if EndsInDefinitionRex.match(s)
                 s
             end
 
-            def ProcessDefinition.as_revision (s)
+            def self.as_revision (s)
 
                 s.gsub("_", ".")
             end
@@ -287,8 +337,10 @@ module OpenWFE
                 # 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
 
@@ -297,6 +349,7 @@ module OpenWFE
                 # on the top of the previous parent expression stack (pop).
                 #
                 def pop_parent_expression
+
                     @parent_expression = @previous_parent_expressions.pop
                 end
 
@@ -305,154 +358,16 @@ module OpenWFE
                 # top expressions...
                 #
                 def top_expression
-                    return nil if @top_expressions.size > 1
-                    exp = @top_expressions[0]
-                    return exp if exp.name == "process-definition"
-                    nil
-                end
-            end
-    end
-
-    #
-    # The actual 'programmatic' raw expression.
-    # Its raw_representation being an instance of SimpleExpRepresentation.
-    #
-    class ProgRawExpression < RawExpression
-
-        attr_accessor \
-            :raw_representation
-
-        def initialize \
-            (fei, parent_id, env_id, application_context, raw_representation)
-
-            super(
-                fei, 
-                parent_id, 
-                env_id, 
-                application_context, 
-                raw_representation)
-        end
-
-        protected 
-
-            def extract_attributes ()
-
-                raw_representation.attributes
-            end
-
-            def extract_descriptions ()
-
-                result = []
-                raw_representation.children.each do |child|
-
-                    next unless child.is_a?(SimpleExpRepresentation)
-                    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
-                result = []
-                raw_representation.children.each do |child|
-
-                    if child.kind_of?(SimpleExpRepresentation)
 
-                        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}"
-
-                        efei = @environment_id
-
-                        rawexp = ProgRawExpression\
-                            .new(cfei, @fei, efei, @application_context, child)
-
-                        get_expression_pool.update rawexp
-
-                        i = i + 1
-
-                        result << rawexp.fei
-                    else
-
-                        result << child
-                    end
-                end
-                result
-            end
-
-            def extract_text_children ()
-
-                raw_representation.children.collect do |child|
-                    next if child.is_a?(SimpleExpRepresentation)
-                    child.to_s
-                end
-            end
-
-            def extract_parameters ()
-
-                r = []
-                raw_representation.children.each do |child|
-
-                    next unless child.is_a?(SimpleExpRepresentation)
+                    return nil if @top_expressions.size > 1
 
-                    name = child.name.to_sym
-                    next unless (name == :parameter or name == :param)
+                    exp = @top_expressions.first
 
-                    r << Parameter.new(
-                        child.attributes[:field],
-                        child.attributes[:match],
-                        child.attributes[:default],
-                        child.attributes[:type])
+                    return exp if exp.first == "process-definition"
+                    nil
                 end
-                r
             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
 

data/lib/openwfe/expressions/time.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 
@@ -37,8 +37,7 @@
 # John Mettraux at openwfe.org
 #
 
-require 'openwfe/util/otime'
-require 'openwfe/util/scheduler'
+require 'rufus/otime'
 require 'openwfe/expressions/timeout'
 
 
@@ -51,7 +50,7 @@ module OpenWFE
     # localization for <sleep/> and <cron/>.
     #
     class TimeExpression < FlowExpression
-        include Schedulable
+        include Rufus::Schedulable
 
         #
         # The workitem received at apply time
@@ -93,12 +92,21 @@ module OpenWFE
 
             ldebug { "unschedule() @scheduler_job_id is #{@scheduler_job_id}" }
 
+            sleep get_scheduler.precision + 0.001
+                #
+                # make sure not to unschedule before the actual scheduling
+                # got done.
+
             get_scheduler.unschedule(@scheduler_job_id) \
                 if @scheduler_job_id
         end
 
         protected
 
+            #
+            # looks up potential scheduler tags in the expression
+            # attributes
+            #
             def determine_scheduler_tags
 
                 st = lookup_attribute :scheduler_tags, @applied_workitem
@@ -130,11 +138,17 @@ module OpenWFE
         #
         DEFAULT_FREQUENCY = "10s"
 
+        #
+        # Don't go under 300 milliseconds.
+        #
+        MIN_FREQUENCY = 0.300
+
         #
         # Classes extending this WaitingExpression have a 'conditions' class
         # method (like 'attr_accessor').
         #
         def self.conditions (*attnames)
+
             attnames = attnames.collect do |n|
                 n.to_s.intern
             end
@@ -151,8 +165,10 @@ module OpenWFE
 
             @frequency = lookup_attribute(
                 :frequency, workitem, :default => DEFAULT_FREQUENCY)
-            @frequency = OpenWFE::parse_time_string(
+            @frequency = Rufus::parse_time_string(
                 @frequency)
+            @frequency = MIN_FREQUENCY \
+                if @frequency < MIN_FREQUENCY
 
             determine_timeout
             determine_scheduler_tags
@@ -173,15 +189,19 @@ module OpenWFE
             end
         end
 
-        def cancel ()
+        #
+        # Cancels this expression (takes care of unscheduling a timeout
+        # if there is one).
+        #
+        def cancel
 
-            to_unschedule()
+            unschedule_timeout
             super()
         end
 
         def trigger (params={})
 
-            ldebug { "trigger() #{@fei.to_debug_s} params is #{params}" }
+            ldebug { "trigger() #{@fei.to_debug_s} params : #{params.inspect}" }
 
             if params[:do_timeout!]
                 #
@@ -215,10 +235,10 @@ module OpenWFE
 
         def reply_to_parent (workitem)
 
-            unschedule()
-            unschedule_timeout()
+            unschedule
+            unschedule_timeout
 
-            super(workitem)
+            super workitem
         end
 
         protected
@@ -255,7 +275,11 @@ module OpenWFE
                 # trigger the first child (the condition child)
 
                 get_expression_pool.launch_template(
-                    self, @condition_sub_id, @children[0], @applied_workitem)
+                    self, 
+                    @environment_id,
+                    @condition_sub_id, 
+                    @children[0], 
+                    @applied_workitem)
             end
 
             #