splib 1.4.2 → 1.4.3

data/CHANGELOG

@@ -1,3 +1,10 @@
+1.4.3
+    * Added new Splib.sleep to return actual sleep times that are useful
+    * Added Monitor#try_lock
+    * Modify locking behavior on Monitor#signal and Monitor#broadcast
+    * Updates to Monitor#wait when used with a timeout
+    * Added some simple checking to remove dead threads that fail to release their lock
+    * CodeReloader.reload_code returns new holder instead of gutted holder
 1.4.2
     * Modify Float#within_delta? to use #between? like any
         reasonable person would

data/README.rdoc

@@ -21,14 +21,14 @@ The Spox Library is collection of helper methods and classes.
 
 This library has been tested on:
 
-* Ruby 1.8.6-p376
-* Ruby 1.8.7-p248
-* Ruby 1.9.1-p383
-* JRuby 1.4
+* Ruby 1.8.6-p399
+* Ruby 1.8.7-p249
+* Ruby 1.9.1-p378
+* JRuby 1.4.0
 
 === Usage
 
-The Spox Library has various things located within it. The Splib#load method will allow you to load individual parts of the library, or the entire thing into your program. Lets take a quick look at some of the things available from this library.
+The Spox Library has various things located within it. The Splib#load method will allow you to load individual parts of the library, or the entire thing, into your program. Lets take a quick look at some of the things available from this library.
 
 ==== URL Shorteners
 
@@ -185,7 +185,75 @@ monitor does its best to ensure your threads stay where they are supposed.
     [:foobar, :foo]
     [:foobar, :foo, :bar]
 
-==== TODO: Write examples for CodeReloader and RandomIterator
+The monitor also provides simple wait timers. See the following code:
+
+    require 'splib'
+    Splib.load :Monitor
+
+    monitor = Splib::Monitor.new
+    a = Queue.new
+    5.times{ Thread.new{ monitor.wait(0.1); a << 1; } }
+    sleep(0.2)
+    puts "Size: #{a.size}"
+
+Here we have five threads waiting with a timeout. Nicely, the monitor only uses
+a single thread for timing, instead of generating a new thread for each timeout.
+
+==== Sleep
+
+Make getting an actual amount of sleeping a bit easier:
+
+    require 'splib'
+    Splib.load :Sleep
+
+    puts Kernel.sleep(0.01)
+    puts Splib.sleep(0.01)
+
+    =>
+        0
+        0.00228595733642578
+
+==== CodeReloader
+
+Easily reload code into a module:
+
+First, assume that file.rb starts out with the following contents:
+
+    class Foo
+        def test
+            puts 'Test'
+        end
+    end
+
+Then, after the Splib.load_code call, we modify the file to contain:
+
+    class Foo
+        def untest
+            puts 'UnTest'
+        end
+    end
+
+Okay, now we proceed:
+
+    require 'splib'
+    Splib.load :CodeReloader, :Constants
+
+    mod = Splib.load_code('file.rb')
+    foo = Splib.find_const('Foo', [mod]).new
+    p foo.respond_to?(:test)
+    puts foo.test
+    mod = Splib.reload_code(mod)
+    foo = Splib.find_const('Foo', [mod]).new
+    p foo.respond_to?(:test)
+    p foo.respond_to?(:untest)
+    puts foo.untest
+
+    =>
+        true
+        Test
+        false
+        true
+        UnTest
 
 == Last remarks
 

data/Rakefile

@@ -15,7 +15,7 @@ spec = Gem::Specification.new do |s|
     s.name              = 'splib'
     s.author            = 'spox'
     s.email             = 'spox@modspox.com'
-    s.version           = '1.4.2'
+    s.version           = '1.4.3'
     s.summary           = 'Spox Library'
     s.platform          = Gem::Platform::RUBY
     s.files             = %w(LICENSE README.rdoc CHANGELOG Rakefile) + Dir.glob("{bin,lib,spec,test}/**/*")

data/lib/splib.rb

@@ -8,6 +8,7 @@ module Splib
             :HumanIdealRandomIterator,
             :Monitor,
             :PriorityQueue,
+            :Sleep,
             :UrlShorteners
            ]
     # args:: name of library to load

data/lib/splib/CodeReloader.rb

@@ -43,10 +43,7 @@ module Splib
     # Reload the code within the module
     def self.reload_code(holder)
         raise ArgumentError.new('Expecting a module containing loaded code') unless holder.respond_to?(:path)
-        holder.constants.each do |const|
-            holder.send(:remove_const, const)
-        end
-        self.load_code(holder.path, holder)
+        self.load_code(holder.path)
     end
 
     # path:: path to ruby code

data/lib/splib/Exec.rb

@@ -3,7 +3,12 @@ require 'timeout'
 module Splib
 
     @@processes = []
-    Kernel.at_exit{@@processes.each{|p| Process.kill('KILL', pro.pid) }}
+    @@owner ||= Thread.current
+    Kernel.at_exit do
+        if(Thread.current == @@owner)
+            @@processes.each{|pro| Process.kill('KILL', pro.pid) }
+        end
+    end
 
     # Returns current array of running Processes
     def self.running_procs

data/lib/splib/Monitor.rb

@@ -1,37 +1,42 @@
 require 'thread'
 
 module Splib
-    
+    Splib.load :Sleep
+    # Basic exception to wakeup a monitor timer
+    class Wakeup < Exception
+    end
     class Monitor
+        # Create a new Monitor
         def initialize
             @threads = []
             @locks = []
             @lock_owner = nil
             @timers = {}
+            @timer = start_timer
+            @stop = false
+            Kernel.at_exit do
+                if(@timer)
+                    @stop = true
+                    @timer.raise Wakeup.new
+                end
+            end
         end
+
         # timeout:: Wait for given amount of time
         # Park a thread here
         def wait(timeout=nil)
+            raise 'This thread is already a registered sleeper' if @threads.include?(Thread.current)
+            Thread.exclusive{ @threads << Thread.current }
             if(timeout)
-                timout = timeout.to_f
-                @timers[Thread.current] = Thread.new(Thread.current) do |t|
-                    time = 0.0
-                    until(time >= timeout) do
-                        s = Time.now.to_f
-                        sleep(timeout - time)
-                        time += Time.now.to_f - s
-                    end
-                    t.wakeup
-                end
+                timeout = timeout.to_f
+                Thread.exclusive{ @timers[Thread.current] = timeout }
+                @timer.raise Wakeup.new
             end
-            @threads << Thread.current
             Thread.stop
-            @threads.delete(Thread.current)
-            if(timeout)
-                if(@timers[Thread.current].alive?)
-                    @timers[Thread.current].kill
-                end
-                @timers.delete(Thread.current)
+            Thread.exclusive{ @threads.delete(Thread.current) }
+            if(timeout && @timers.has_key?(Thread.current))
+                Thread.exclusive{ @timers.delete(Thread.current) }
+                @timer.raise Wakeup.new
             end
             true
         end
@@ -50,17 +55,22 @@ module Splib
         # Wake up earliest thread
         def signal
             synchronize do
-                t = @threads.shift
-                t.wakeup if t && t.alive?
+                while(t = @threads.shift)
+                    if(t && t.alive? && t.stop?)
+                        t.wakeup
+                        break
+                    else
+                        next
+                    end
+                end
             end
         end
         # Wake up all threads
         def broadcast
             synchronize do
-                @threads.each do |t|
-                    t.wakeup if t.alive?
+                @threads.dup.each do |t|
+                    t.wakeup if t.alive? && t.stop?
                 end
-                @threads.clear
             end
         end
         # Number of threads waiting
@@ -69,58 +79,135 @@ module Splib
         end
         # Lock the monitor
         def lock
-            if(Thread.exclusive{do_lock})
-                until(owner?(Thread.current)) do
-                    Thread.stop
-                end
+            Thread.exclusive{ do_lock }
+            until(owner?(Thread.current)) do
+                Thread.stop
             end
         end
         # Unlock the monitor
         def unlock
-            Thread.exclusive{ do_unlock }
+            do_unlock
+        end
+        # Attempt to lock. Returns true if lock is aquired and false if not.
+        def try_lock
+            locked = false
+            Thread.exclusive do
+                clean
+                unless(locked?(false))
+                    do_lock
+                    locked = true
+                else
+                    locked = owner?(Thread.current)
+                end
+            end
+            locked
         end
+        # cln:: Clean dead threads
         # Is monitor locked
-        def locked?
-            @locks.size > 0
+        def locked?(cln=true)
+            Thread.exclusive{clean} if cln
+            @locks.size > 0 || @lock_owner
         end
         # Lock the monitor, execute block and unlock the monitor
         def synchronize
             result = nil
-            Thread.exclusive do
-                do_lock
-                result = yield
-                do_unlock
-            end
+            lock
+            result = yield
+            do_unlock
             result
         end
 
         private
 
+
+        # This is a simple helper method to help keep threads from ending
+        # up stuck waiting for a lock when a thread locks the monitor and
+        # then decides to die without unlocking. It is only called when
+        # new locks are attempted or a check is made if the monitor is
+        # currently locked.
+        def clean
+            @locks.delete_if{|t|!t.alive?}
+            if(@lock_owner && !@lock_owner.alive?)
+                @lock_owner = @locks.empty? ? nil : @locks.shift
+                @lock_owner.wakeup if @lock_owner && !owner?(Thread.current)
+            end
+        end
+
+        # Check if the givin thread is the current owner
         def owner?(t)
             @lock_owner == t
         end
 
+        # Aquire monitor lock or be queued for lock
+        # NOTE: To make this method more generic and useful, it does
+        # not perform a Thread.exclusive, and as such this method should
+        # only be called from within a Thread.exclusive{}
         def do_lock
-            stop = false
+            clean
             if(@lock_owner)
-                @locks << Thread.current
-                stop = true
+                if(owner?(Thread.current))
+                    @locks.unshift(Thread.current)
+                else
+                    @locks << Thread.current
+                end
             else
                 @lock_owner = Thread.current
             end
-            stop
+            true
         end
 
+        # Unlock the monitor
         def do_unlock
             unless(owner?(Thread.current))
                 raise ThreadError.new("Thread #{Thread.current} is not the current owner: #{@lock_owner}")
             end
-            unless(@locks.empty?)
+            Thread.exclusive do
                 @locks.delete_if{|t|!t.alive?}
-                @lock_owner = @locks.shift
-                @lock_owner.wakeup
-            else
-                @lock_owner = nil
+                unless(@locks.empty?)
+                    old_owner = @lock_owner
+                    @lock_owner = @locks.shift
+                    @lock_owner.wakeup unless old_owner == @lock_owner
+                else
+                    @lock_owner = nil
+                end
+            end
+        end
+
+        # Starts the timer for waiting threads with a timeout
+        def start_timer
+            @timer = Thread.new do
+                begin
+                    until(@stop) do
+                        cur = []
+                        t = 0
+                        Thread.exclusive do
+                            t = @timers.values.min
+                            cur = @timers.dup
+                        end
+                        t = 0 if !t.nil? && t < 0
+                        a = 0
+                        begin
+                            a = Splib.sleep(t)
+                        rescue Wakeup
+                            # do nothing of importance
+                        ensure
+                            next if t.nil?
+                            Thread.exclusive do
+                                cur.each_pair do |thread, value|
+                                    value -= a
+                                    if(value <= 0)
+                                        thread.wakeup
+                                        @timers.delete(thread)
+                                    else
+                                        @timers[thread] = value
+                                    end
+                                end
+                            end
+                        end
+                    end
+                rescue
+                    retry
+                end
             end
         end
     end

data/lib/splib/PriorityQueue.rb

@@ -1,7 +1,8 @@
-require 'thread'
+Splib.load :Monitor
+
 module Splib
     # Exception raised when queue is empty
-    class EmptyQueue < Exception
+    class EmptyQueue < RuntimeError
     end
     # This class provides some simple logic for item output. It is
     # basically a priority based queue with some round robin thrown
@@ -19,7 +20,7 @@ module Splib
             @whocares = whocares
             @target_queues = {}
             @queues = {:PRIORITY => [], :NEW => [], :NORMAL => [], :WHOCARES => []}
-            @lock = Mutex.new
+            @lock = Splib::Monitor.new
         end
         
         # target:: target queue
@@ -42,6 +43,7 @@ module Splib
                         add_queue(:NORMAL, @target_queues[target])
                     end
                 end
+                @lock.signal
             end
             item
         end
@@ -54,6 +56,7 @@ module Splib
                 @target_queues[:internal_prio] = [] unless @target_queues[:internal_prio]
                 @target_queues[:internal_prio] << message
                 add_queue(:PRIORITY, @target_queues[:internal_prio])
+                @lock.signal
             end
             message
         end
@@ -77,8 +80,15 @@ module Splib
                     end
                 end
             end
-            raise EmptyQueue.new('Queue is currently empty') if m.nil? && @raise
-            return m
+            unless(m)
+                if(@raise)
+                    raise EmptyQueue.new('Queue is currently empty')
+                else
+                    @lock.wait_while{ empty? }
+                    m = pop
+                end
+            end
+            m
         end
 
         # Returns true if queue is empty
@@ -87,6 +97,7 @@ module Splib
         end
 
         alias :push :prioritized_queue
+        alias :<< :direct_queue
 
         private
         

data/lib/splib/Sleep.rb

@@ -0,0 +1,10 @@
+module Splib
+class << self
+    # secs:: Number of seconds to sleep (Use float to provide better actual sleep time)
+    def sleep(secs=nil)
+        start = Time.now.to_f
+        secs.nil? ? Kernel.sleep : Kernel.sleep(secs)
+        Time.now.to_f - start
+    end
+end
+end

data/test/cases/CodeReloader.rb

@@ -28,7 +28,7 @@ class CodeReloaderTest < Test::Unit::TestCase
         assert(!obj.respond_to?(:feebar))
         assert_equal('hello world', obj.foobar)
         FileUtils.cp @s2, @s
-        Splib.reload_code(holder)
+        holder = Splib.reload_code(holder)
         klass = Splib.find_const('Fu::Bar', [holder])
         obj = klass.new
         assert(obj.respond_to?(:feebar))

data/test/cases/Exec.rb

@@ -4,26 +4,27 @@ require 'test/unit'
 class ExecTest < Test::Unit::TestCase
     def setup
         Splib.load :Exec
+        Splib.load :Sleep
     end
 
     def test_exec
         assert_raise(IOError) do
-            Splib.exec('echo test', 10, 1)
+            Splib.exec('/bin/sh -c "echo test"', 10, 1)
         end
         assert_raise(Timeout::Error) do
-            Splib.exec('while [ true ]; do true; done;', 1)
+            Splib.exec('/bin/sh -c "while [ true ]; do true; done;"', 1)
         end
-        assert_equal("test\n", Splib.exec('echo test'))
+        assert_equal("test\n", Splib.exec('/bin/sh -c "echo test"'))
     end
 
     def test_running
         output = nil
         Thread.new do
-            output = Splib.exec('ruby -e \'sleep(0.4); puts "done"\'')
+            output = Splib.exec('/bin/sh -c "sleep 0.4; echo done"')
         end
-        sleep(0.1)
+        Kernel.sleep(0.1)
         assert_equal(1, Splib.running_procs.size)
-        sleep(0.5)
+        Kernel.sleep(0.5)
         assert_equal("done\n", output)
         assert_equal(0, Splib.running_procs.size)
     end

data/test/cases/Monitor.rb

@@ -2,15 +2,16 @@ require 'splib'
 require 'test/unit'
 
 class MonitorTest < Test::Unit::TestCase
+    Splib.load :Monitor
+    Splib.load :Sleep
     def setup
-        Splib.load :Monitor
         @monitor = Splib::Monitor.new
     end
 
     def test_wait
         t = []
         5.times{ t << Thread.new{ @monitor.wait } }
-        sleep(0.01) # give threads a chance to wait
+        Splib.sleep(0.1) # give threads a chance to wait
         t.each do |thread|
             assert(thread.alive?)
             assert(thread.stop?)
@@ -19,139 +20,174 @@ class MonitorTest < Test::Unit::TestCase
 
     def test_wait_timeout
         t = []
-        o = []
-        5.times{|i| t << Thread.new{ @monitor.wait((i+1)/100.0); o << 1 } }
-        sleep(0.011)
-        Thread.pass
-        assert(!t.shift.alive?)
-        assert_equal(1, o.size)
-        sleep(0.1)
+        o = Queue.new
+        5.times{ t << Thread.new{ @monitor.wait(0.1); o << 1 } }
+        Splib.sleep(0.3)
         assert_equal(5, o.size)
-        t.each do |th|
-            assert(!th.alive?)
-        end
     end
 
     def test_signal
-        output = []
+        output = Queue.new
         t = []
         5.times{ t << Thread.new{ @monitor.wait; output << 1 } }
-        sleep(0.01)
+        Splib.sleep(0.01)
         t.each do |thread|
             assert(thread.alive?)
             assert(thread.stop?)
         end
         assert(output.empty?)
         @monitor.signal
-        sleep(0.01)
+        Splib.sleep(0.01)
         assert_equal(4, t.select{|th|th.alive?}.size)
         assert_equal(1, output.size)
         assert_equal(1, output.pop)
     end
 
     def test_broadcast
-        output = []
+        output = Queue.new
         t = []
         5.times{ t << Thread.new{ @monitor.wait; output << 1 } }
-        sleep(0.01)
+        Splib.sleep(0.01)
         t.each do |thread|
             assert(thread.alive?)
             assert(thread.stop?)
         end
+        assert_equal(5, t.size)
         assert(output.empty?)
         @monitor.broadcast
-        sleep(0.01)
+        Splib.sleep(0.1)
         assert_equal(5, output.size)
         5.times{ assert_equal(1, output.pop) }
         assert_equal(5, t.select{|th|!th.alive?}.size)
     end
 
+    def test_synchronize_broadcast
+        output = Queue.new
+        t = []
+        5.times{ t << Thread.new{ @monitor.wait; output << 1 } }
+        Splib.sleep(0.01)
+        t.each do |thread|
+            assert(thread.alive?)
+            assert(thread.stop?)
+        end
+        assert_equal(5, t.size)
+        assert(output.empty?)
+        @monitor.synchronize{ @monitor.broadcast }
+        Splib.sleep(0.1)
+        assert_equal(5, output.size)
+        5.times{ assert_equal(1, output.pop) }
+        assert_equal(5, t.select{|th|!th.alive?}.size)
+    end
+    
+    def test_multi_lock
+        @monitor.synchronize do
+            @monitor.synchronize do
+                @monitor.lock
+                @monitor.synchronize do
+                    true
+                end
+                @monitor.unlock
+            end
+        end
+    end
+
     def test_wait_while
         stop = true
         t = Thread.new{ @monitor.wait_while{ stop } }
-        sleep(0.01)
+        Splib.sleep(0.01)
         assert(t.alive?)
         assert(t.stop?)
         @monitor.signal
-        sleep(0.01)
+        Splib.sleep(0.01)
         assert(t.alive?)
         assert(t.stop?)
         @monitor.broadcast
-        sleep(0.01)
+        Splib.sleep(0.01)
         assert(t.alive?)
         assert(t.stop?)
         stop = false
         @monitor.signal
-        sleep(0.01)
+        Splib.sleep(0.01)
         assert(!t.alive?)
         assert(t.stop?)
     end
 
     def test_wait_until
         stop = false
-        t = Thread.new{ @monitor.wait_until{ stop } }
-        sleep(0.01)
+        done = false
+        t = Thread.new{ @monitor.wait_until{ stop }; done = true; }
+        Splib.sleep(0.01)
         assert(t.alive?)
         assert(t.stop?)
         @monitor.signal
-        sleep(0.01)
+        Splib.sleep(0.01)
         assert(t.alive?)
         assert(t.stop?)
         @monitor.broadcast
-        sleep(0.01)
+        Splib.sleep(0.01)
         assert(t.alive?)
         assert(t.stop?)
         stop = true
         @monitor.signal
-        sleep(0.01)
-        assert(!t.alive?)
-        assert(t.stop?)
+        Splib.sleep(0.1)
+        assert(done)
     end
 
     def test_waiters
         t = []
         (rand(20)+1).times{ t << Thread.new{ @monitor.wait } }
-        sleep(0.01)
+        Splib.sleep(0.1)
         assert_equal(t.size, @monitor.waiters)
         @monitor.broadcast
-        sleep(0.01)
+        Splib.sleep(0.1)
         assert_equal(0, @monitor.waiters)
     end
 
     def test_lock_unlock
         t = []
         output = []
-        3.times{|i| t << Thread.new{ @monitor.lock; sleep((i+1)/100.0); output << i; @monitor.unlock;}}
-        sleep(0.011)
+        3.times{|i| t << Thread.new{ @monitor.lock; Splib.sleep(0.1); output << i; @monitor.unlock;}}
+        Splib.sleep(0.12)
         assert_equal(1, output.size)
-        sleep(0.021)
+        Splib.sleep(0.12)
         assert_equal(2, output.size)
-        sleep(0.031)
+        Splib.sleep(0.12)
         assert_equal(3, output.size)
         assert(!t.any?{|th|th.alive?})
         3.times{|i|assert_equal(i, output.shift)}
     end
-    
+
     def test_lock_unlock_wakeup
         complete = false
-        t1 = Thread.new{@monitor.lock; sleep(0.1); @monitor.unlock}
+        t1 = Thread.new{@monitor.lock; Splib.sleep(0.1); @monitor.unlock}
+        Splib.sleep(0.01)
         t2 = Thread.new{@monitor.lock; complete = true; @monitor.unlock}
         assert(!complete)
         assert(t1.alive?)
         t2.wakeup
         Thread.pass
         assert(!complete)
-        sleep(0.11)
+        Splib.sleep(0.15)
         assert(complete)
     end
 
     def synchronize
         t = []
         output = []
-        5.times{|i| t << Thread.new{ @monitor.lock; sleep(i/100.0); output << i; @monitor.unlock;}}
+        5.times{|i| t << Thread.new{ @monitor.lock; Splib.sleep(i/100.0); output << i; @monitor.unlock;}}
         @monitor.synchronize{ output << :done }
-        sleep(0.5)
+        Splib.sleep(0.5)
         assert_equal(6, output.size)
     end
 
+    def test_try_lock
+        assert(@monitor.try_lock)
+        assert(@monitor.locked?)
+        assert(@monitor.try_lock)
+        Thread.new{ assert(!@monitor.try_lock) }
+        @monitor.unlock
+        assert(!@monitor.locked?)
+        Thread.new{ assert(@monitor.try_lock); @monitor.unlock }
+    end
+
 end

data/test/cases/PriorityQueue.rb

@@ -42,4 +42,32 @@ class PriorityQueueTest < Test::Unit::TestCase
         assert_equal('last', queue.pop)
         assert(queue.empty?)
     end
+
+    def test_raise
+        queue = Splib::PriorityQueue.new(:raise_on_empty)
+        assert_raise(Splib::EmptyQueue){ queue.pop }
+    end
+
+    def test_waiters
+        queue = Splib::PriorityQueue.new
+        q = Queue.new
+        t = Thread.new{ q << queue.pop; }
+        assert(t.alive?)
+        queue << :item1
+        sleep(0.1)
+        assert_equal(:item1, q.pop)
+        t = []
+        5.times{ t << Thread.new{ q << queue.pop } }
+        sleep(0.1)
+        assert_equal(5, t.find_all{|x|x.alive?}.size)
+        queue << :item2
+        sleep(0.1)
+        assert_equal(1, q.size)
+        queue.push(:foo, :item3)
+        sleep(0.1)
+        assert_equal(2, q.size)
+        3.times{ queue << :item4 }
+        sleep(0.1)
+        assert_equal(5, q.size)
+    end
 end

data/test/cases/Sleep.rb

@@ -0,0 +1,24 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'splib'
+
+class SleepTest < Test::Unit::TestCase
+    def setup
+        Splib.load :Sleep
+    end
+    
+    def test_sleep_valid
+        assert(Splib.sleep(0.5).between?(0.45, 0.55))
+        assert(Splib.sleep(0.05).between?(0.04, 0.06))
+    end
+
+    def test_sleep_invalid
+        assert_raise(TypeError) do
+            Splib.sleep(:foo)
+        end
+        assert_raise(ArgumentError) do
+            Splib.sleep(-1)
+        end
+    end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: splib
 version: !ruby/object:Gem::Version 
-  version: 1.4.2
+  version: 1.4.3
 platform: ruby
 authors: 
 - spox
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-29 00:00:00 -08:00
+date: 2010-04-06 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -27,7 +27,7 @@ files:
 - README.rdoc
 - CHANGELOG
 - Rakefile
-- lib/splib.rb
+- lib/splib
 - lib/splib/Array.rb
 - lib/splib/PriorityQueue.rb
 - lib/splib/UrlShorteners.rb
@@ -38,7 +38,10 @@ files:
 - lib/splib/HumanIdealRandomIterator.rb
 - lib/splib/Monitor.rb
 - lib/splib/Conversions.rb
+- lib/splib/Sleep.rb
+- lib/splib.rb
 - spec/dummy.rb
+- test/cases
 - test/cases/Array.rb
 - test/cases/PriorityQueue.rb
 - test/cases/UrlShorteners.rb
@@ -49,13 +52,12 @@ files:
 - test/cases/HumanIdealRandomIterator.rb
 - test/cases/Monitor.rb
 - test/cases/Conversions.rb
+- test/cases/Sleep.rb
 - test/run_tests.rb
 - test/samplecode2.rb
 - test/samplecode1.rb
-has_rdoc: true
+has_rdoc: false
 homepage: http://github.com/spox/splib
-licenses: []
-
 post_install_message: 
 rdoc_options: 
 - --title
@@ -80,9 +82,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.1
 signing_key: 
-specification_version: 3
+specification_version: 2
 summary: Spox Library
 test_files: []