openwferu 0.9.15 → 0.9.16

data/lib/openwfe/utils.rb

@@ -108,6 +108,9 @@ module OpenWFE
             return d.root
         end
 
+        return Rational(object.denominator, object.numerator) \
+            if object.kind_of?(Rational)
+
         o = nil
 
         begin
@@ -153,20 +156,24 @@ module OpenWFE
     end
 
     def OpenWFE.to_underscore (string)
+
         string.gsub("-", "_")
     end
 
     def OpenWFE.to_dash (string)
+
         string.gsub("_", "-")
     end
 
     def OpenWFE.symbol_to_name (symbol)
+
         to_dash(symbol.to_s)
     end
 
     def OpenWFE.name_to_symbol (name)
+
         return name if name.is_a?(Symbol)
-        return to_underscore(name).intern
+        to_underscore(name).intern
     end
 
     #
@@ -174,6 +181,7 @@ module OpenWFE
     # Returns the new String.
     #
     def OpenWFE.stu (s)
+
         s.gsub("\s", "_")
     end
 
@@ -336,7 +344,7 @@ module OpenWFE
         # instantiated.
         #
         def duration
-            return (Time.now.to_f - @start) * 1000
+            (Time.now.to_f - @start) * 1000
         end
     end
 
@@ -355,6 +363,7 @@ module OpenWFE
     # (removes for examples things like '/' or '\'...)
     #
     def OpenWFE.ensure_for_filename (s)
+
         s = s.gsub(" ", "_")
         s = s.gsub("/", "_")
         s = s.gsub(":", "_")
@@ -363,7 +372,8 @@ module OpenWFE
         s = s.gsub("\\", "_")
         s = s.gsub("\+", "_")
         s = s.gsub("\?", "_")
-        return s
+
+        s
     end
 
     #
@@ -379,7 +389,14 @@ module OpenWFE
     def OpenWFE.lookup_attribute (container, key)
 
         key, rest = pop_key(key)
-        value = container[key]
+
+        #value = nil
+        #begin
+        #    value = container[key]
+        #rescue Exception => e
+        #end
+
+        value = flex_lookup(container, key)
 
         return value unless rest
 
@@ -393,17 +410,22 @@ module OpenWFE
     #
     def OpenWFE.has_attribute? (container, key)
 
-        key, rest = pop_key(key)
+        key, last_key = pop_last_key(key)
 
-        unless rest
+        container = lookup_attribute(container, key) if key
 
-            return container.has_key?(key) \
-                if container.respond_to?(:has_key?)
+        if container.respond_to?(:has_key?)
 
-            return false
-        end
+            (container.has_key?(last_key) or container.has_key?(last_key.to_s))
 
-        has_attribute?(rest, key)
+        elsif container.is_a?(Array) and last_key.is_a?(Fixnum)
+
+            (last_key < container.length)
+
+        else
+
+            false
+        end
     end
 
     #
@@ -415,6 +437,8 @@ module OpenWFE
     #         puts " - '#{line.downcase}'"
     #     end
     #
+    # TODO : find a ruby library and use it instead of that code
+    #
     def OpenWFE.grep (pattern, filepath, &block)
 
         result = []
@@ -468,18 +492,48 @@ module OpenWFE
 
     protected
 
-        def pop_key (key)
+        def OpenWFE.pop_key (key)
             i = key.index(".")
             return narrow(key), nil unless i
             [ narrow(key[0..i-1]), key[i+1..-1] ]
         end
 
-        def narrow (key)
+        def OpenWFE.pop_last_key (key)
+            i = key.rindex(".")
+            return nil, narrow(key) unless i
+            [ key[0..i-1], narrow(key[i+1..-1]) ]
+        end
+
+        def OpenWFE.narrow (key)
             return 0 if key == "0"
             i = key.to_i
             return i if i != 0
             key
         end
+
+        #
+        # looks up in a container (something that has a [] method)  with a key,
+        # if nothing has been found and the key is a number, turns the
+        # the number into a String a does a last lookup.
+        #
+        def OpenWFE.flex_lookup (container, key)
+
+            value = nil
+
+            begin
+                value = container[key]
+            rescue Exception => e
+            end
+
+            if value == nil and key.kind_of?(Fixnum)
+                begin
+                    value = container[key.to_s]
+                rescue Exception => e
+                end
+            end
+
+            value
+        end
     
 end
 

data/lib/openwfe/version.rb

@@ -32,5 +32,5 @@
 #
 
 module OpenWFE
-    OPENWFERU_VERSION = '0.9.15'
+    OPENWFERU_VERSION = '0.9.16'
 end

data/lib/openwfe/workitem.rb

@@ -33,17 +33,13 @@
 
 #
 # "hecho en Costa Rica"
+# and "made in Japan"
 #
 # john.mettraux@openwfe.org
 #
 
-require 'base64'
-
 require 'openwfe/utils'
 
-require 'openwfe/rest/definitions'
-    # hmmm, only used for MAP_TYPE
-
 
 module OpenWFE
 
@@ -53,9 +49,9 @@ module OpenWFE
     #
     FIELD_RESULT = "__result__"
 
-    #
+    #--
     # WORKITEMS
-    #
+    #++
 
     #
     # The base class for all the workitems.
@@ -64,17 +60,21 @@ module OpenWFE
 
         attr_accessor :last_modified, :attributes
 
-        def initialize ()
-
+        def initialize
             @last_modified = nil
-
             @attributes = {}
-            @attributes[MAP_TYPE] = E_SMAP
         end
 
         alias :fields :attributes
         alias :fields= :attributes=
 
+        #
+        # Sets the last_modified field to now
+        #
+        def touch
+            @last_modified = Time.now
+        end
+
         def to_h
             h = {}
             h[:type] = self.class.name
@@ -248,17 +248,21 @@ module OpenWFE
         # Outputting the workitem in a human readable format
         #
         def to_s
+
             s = ""
-            s << "  >>>#{self.class}>>>\n"
+            s << "  #{self.class} :\n"
             s << "  - flow_expression_id : #{@flow_expression_id}\n"
             s << "  - participant_name :   #{@participant_name}\n"
             s << "  - last_modified :      #{@last_modified}\n"
             s << "  - dispatch_time :      #{@dispatch_time}\n"
             s << "  - attributes :\n"
-            @attributes.each do |k, v|
-                s << "    * '#{k}' --> '#{v}'\n"
+
+            s << "    {\n"
+            @attributes.keys.sort.each do |k|
+                v = @attributes[k]
+            s << "      #{k.inspect} => #{v.inspect},\n"
             end
-            s << "  <<<#{self.class}<<<"
+            s << "    }"
             s
         end
 
@@ -267,6 +271,7 @@ module OpenWFE
         # (Any YAML-enabled platform can thus read it).
         #
         def to_h
+
             h = super
             h[:dispatch_time] = @dispatch_time
             h[:history] = @history
@@ -374,13 +379,13 @@ module OpenWFE
         #
         #   # Load an XML process definition from a local file
         #   require 'uri'
-        #   LaunchItem.new(URI.new("file:///tmp/my_process_definition.xml"))
+        #   LaunchItem.new(URI.parse("file:///tmp/my_process_definition.xml"))
         #
         #   # If you initialized your engine with 
         #   # {:remote_definitions_allowed => true}, then you can also load an
         #   # XML process definition from a remote url
         #   require 'uri'
-        #   LaunchItem.new(URI.new("http://foo.bar/my_process_definition.xml"))
+        #   LaunchItem.new(URI.parse("http://foo.bar/my_process_definition.xml"))
         #
         def initialize (process_definition=nil)
 
@@ -419,153 +424,5 @@ module OpenWFE
         wi_class.from_h(h)
     end
 
-    #
-    # HISTORY ITEM
-    #
-
-    #
-    # HistoryItem instances are used to keep track of what happened to
-    # a workitem.
-    #
-    class HistoryItem
-
-        attr_accessor \
-            :date, \
-            :author, \
-            :host, \
-            :text, \
-            :wfd_name, \
-            :wfd_revision, \
-            :wf_instance_id, \
-            :expression_id
-        
-        def dup
-            return OpenWFE::fulldup(self)
-        end
-    end
-
-
-    #
-    # STORES
-    #
-
-    #
-    # Models the information about a store as viewed by the current user 
-    # (upon calling the listStores or getStoreNames methods)
-    #
-    class Store
-
-        attr_accessor :name, :workitem_count, :permissions
-
-        def initialize ()
-            super()
-            #@name = nil
-            #@workitem_count = nil
-            #@permissions = nil
-        end
-
-        #
-        # Returns true if the current user may read headers and workitems
-        # from this store
-        #
-        def may_read? ()
-            return @permissions.index('r') > -1
-        end
-
-        #
-        # Returns true if the current user may modify workitems (and at least
-        # proceed/forward them) in this store
-        #
-        def may_write? ()
-            return @permissions.index('w') > -1
-        end
-
-        #
-        # Returns true if the current user may browse the headers of this
-        # store
-        #
-        def may_browse? ()
-            return @permissions.index('b') > -1
-        end
-
-        #
-        # Returns true if the current user may delegate workitems to this store
-        #
-        def may_delegate? ()
-            return @permissions.index('d') > -1
-        end
-    end
-
-    #
-    # A header is a summary of a workitem, returned by the getHeader
-    # worklist method.
-    #
-    class Header < InFlowWorkItem
-
-        attr_accessor :locked
-    end
-
-
-    #
-    # MISC ATTRIBUTES
-    #
-    # in openwfe-ruby, OpenWFE attributes are immediately mapped to
-    # Ruby instances, but some attributes still deserve their own class
-    #
-
-    #
-    # a wrapper for some binary content
-    #
-    class Base64Attribute
-
-        attr_accessor :content
-
-        def initialize (base64content)
-
-            @content = base64content
-        end
-
-        #
-        # dewraps (decode) the current content and returns it
-        #
-        def dewrap ()
-
-            return Base64.decode64(@content)
-        end
-
-        #
-        # wraps some binary content and stores it in this attribute
-        # (class method)
-        #
-        def Base64Attribute.wrap (binaryData)
-
-            return Base64Attribute.new(Base64.encode64(binaryData))
-        end
-    end
-
-
-    #
-    # LAUNCHABLE
-    # 
-
-    #
-    # A worklist will return list of Launchable instances indicating
-    # what processes (URL) a user may launch on which engine.
-    #
-    class Launchable
-
-        attr_accessor :url, :engine_id
-    end
-
-
-    #
-    # Expression, somehow equivalent to FlowExpression, but only used 
-    # by the control interface.
-    #
-    class Expression
-
-        attr_accessor :id, :apply_time, :state, :state_since
-    end
-
 end
 

data/lib/openwfe/worklist/oldrest.rb

@@ -38,8 +38,8 @@
 #
 
 require 'rexml/element'
-require 'openwfe/rest/xmlcodec'
-require 'openwfe/rest/oldrestservlet'
+require 'openwfe/orest/xmlcodec'
+require 'openwfe/orest/oldrestservlet'
 
 
 module OpenWFE

data/test/bm/bm_1_xml_vs_prog.rb

@@ -0,0 +1,56 @@
+
+#
+# a bit of benchmark
+#
+# Thu Nov  8 21:48:20 JST 2007
+#
+
+require 'benchmark'
+
+require 'openwfe/def'
+#require 'openwfe/engine/engine'
+require 'openwfe/engine/file_persisted_engine'
+
+
+class ProgDef < OpenWFE::ProcessDefinition
+    sequence do
+        toto
+        toto
+        toto
+        toto
+        toto
+    end
+end
+
+xml = <<END
+<process-definition name="x" revision="y">
+    <sequence>
+        <toto/>
+        <toto/>
+        <toto/>
+        <toto/>
+        <toto/>
+    </sequence>
+</process-definition>
+END
+
+#$engine = OpenWFE::Engine.new
+$engine = OpenWFE::FilePersistedEngine.new
+
+$engine.register_participant "toto" do |workitem|
+    # do nothing
+end
+
+N = 500
+
+def test (proc_def)
+    N.times do 
+        fei = $engine.launch proc_def
+        $engine.wait_for fei
+    end
+end
+
+Benchmark.bm do |x|
+    x.report("prog :") { test ProgDef }
+    x.report("xml :") { test xml.strip }
+end

data/test/{ft_26c_load.rb → bm/ft_26c_load.rb}

@@ -28,7 +28,7 @@ class FlowTest26c < Test::Unit::TestCase
     # Test 0
     #
 
-    N = 10000
+    N = 10_000
 
     class TestDefinition0 < ProcessDefinition
         sequence do
@@ -38,9 +38,10 @@ class FlowTest26c < Test::Unit::TestCase
         end
     end
 
-    #def xxxx_load_0
     def test_load_0
 
+        #log_level_to_debug
+
         #@engine.get_scheduler.sstop
             #
             # JRuby is no friend of the Scheduler
@@ -55,10 +56,11 @@ class FlowTest26c < Test::Unit::TestCase
         fei = @engine.launch(LaunchItem.new(TestDefinition0))
         puts "launched #{fei}"
 
+        #log_level_to_debug
+
         @engine.wait_for fei
-        #sleep 60
 
-        assert_equal $count, N
+        assert_equal N, $count
     end
 
     #
@@ -80,5 +82,15 @@ class FlowTest26c < Test::Unit::TestCase
     #
     # 10_000 in 42.616s
 
+    #
+    # Thu Nov  8 21:36:02 JST 2007
+    #
+    # ruby 1.8.6 (2007-06-07 patchlevel 36) [universal-darwin9.0]
+    #
+    # 10_000 in 39.089
+    #
+    # ?
+    #
+
 end
 

data/test/clone_test.rb

@@ -6,8 +6,10 @@
 #
 
 require 'test/unit'
+require 'rexml/document'
 
 require 'openwfe/utils'
+require 'openwfe/workitem'
 
 
 class FullDupTest < Test::Unit::TestCase
@@ -48,4 +50,64 @@ class FullDupTest < Test::Unit::TestCase
         assert_equal o0.name, o1.name
     end
 
+    def test_dup_0
+        a0 = A.new
+        a0.a = 1
+        a0.b = 2
+        a1 = OpenWFE::fulldup(a0)
+
+        #puts a0
+        #puts a1
+        
+        assert_equal a0, a1, "dup() utility not working"
+    end
+
+    def test_dup_1
+        d = REXML::Document.new("<document/>")
+        d1 = OpenWFE::fulldup(d)
+        assert d.object_id != d1.object_id
+    end
+
+    def test_dup_2
+        d = REXML::Document.new("<document>text</document>")
+        d1 = OpenWFE::fulldup(d)
+        assert d.object_id != d1.object_id
+    end
+
+    def test_dup_3
+        d = REXML::Text.new "toto"
+        d1 = OpenWFE::fulldup(d)
+        assert d.object_id != d1.object_id
+    end
+
+    def test_dup_4
+        wi = OpenWFE::InFlowWorkItem.new
+        wi.xml_stuff = REXML::Text.new "whatever"
+        wi1 = wi.dup
+        assert wi.object_id != wi1.object_id
+        assert wi.xml_stuff.object_id != wi1.xml_stuff.object_id
+        assert_equal wi.xml_stuff, wi1.xml_stuff
+    end
+
+    def test_dup_5
+        require 'date'
+        d = DateTime.now()
+        d1 = OpenWFE::fulldup(d)
+        assert d.object_id != d1.object_id
+    end
+
+    private
+    
+        class A
+            attr_accessor :a, :b
+
+            def == (other)
+                return false if not other.kind_of?(A)
+                (self.a == other.a and self.b == other.b)
+            end
+
+            def to_s
+                "A : a='#{a}', b='#{b}'"
+            end
+        end
 end

data/test/cron_test.rb

@@ -24,7 +24,7 @@ class CronTest < Test::Unit::TestCase
     #def teardown
     #end
 
-    def test_cron_0
+    def test_0
 
         $var = 0
 
@@ -45,6 +45,61 @@ class CronTest < Test::Unit::TestCase
         assert_equal $var, 2, "$var should be at 2, it's at #{$var}"
     end
 
+    def test_1
+
+        scheduler = OpenWFE::Scheduler.new
+        scheduler.start
+
+        sec = nil
+        has_gone_wrong = false
+        counter = 0
+
+        scheduler.schedule "* * * * * *" do
+            t = Time.new
+            if (t.sec == sec)
+                has_gone_wrong = true
+                #print "x"
+            else
+                #print "."
+            end
+            #STDOUT.flush
+            sec = t.sec
+            counter = counter + 1
+        end
+
+        sleep 10
+        scheduler.stop
+
+        assert_equal 10, counter
+        assert (not has_gone_wrong)
+    end
+
+    def test_2
+
+        scheduler = OpenWFE::Scheduler.new
+        scheduler.start
+
+        seen = false
+        has_gone_wrong = false
+
+        scheduler.schedule "7 * * * * *" do
+            if seen
+                has_gone_wrong = true
+                #print "x"
+            else
+                seen = true
+                #print "."
+            end
+            #STDOUT.flush
+        end
+
+        sleep 61
+        scheduler.stop
+
+        assert seen
+        assert (not has_gone_wrong)
+    end
+
     protected
 
         class CounterSchedulable