work_queue 0.1.2 → 1.0.0

data/Rakefile

@@ -1,6 +1,7 @@
 require 'rubygems'
 require 'rake'
 require 'rake/clean'
+require 'lib/work_queue'
 
 # Load all rakefile extensions
 Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].each { |ext| load ext }

data/lib/work_queue.rb

@@ -6,7 +6,7 @@
 # This file contains an implementation of a work queue structure.
 #
 # == Version
-# 0.1.2
+# 1.0.0
 #
 # == Author
 # Miguel Fonseca <fmmfonseca@gmail.com>
@@ -33,211 +33,211 @@ require 'timeout'
 #  wq.join
 #
 class WorkQueue
-	
-	VERSION = "0.1.2"
-	
-	##
-	# Creates a new work queue with the desired parameters.
-	#	
-	#  wq = WorkQueue.new(5,10,20)
-	#
-	def initialize(max_threads=nil, max_tasks=nil, keep_alive=60)
-		self.max_threads = max_threads
-		self.max_tasks = max_tasks
-		self.keep_alive = keep_alive
-		@threads = []
-		@threads_lock = Mutex.new
-		@tasks = max_tasks ? SizedQueue.new(max_tasks) : Queue.new
-		@threads.taint
-		@tasks.taint
-		self.taint
-	end
-	
-	##
-	# Returns the maximum number of worker threads.
-	# This value is set upon initialization and cannot be changed afterwards.
-	#
-	#  wq = WorkQueue.new()
-	#  wq.max_threads		#=> Infinity
-	#  wq = WorkQueue.new(1)
-	#  wq.max_threads		#=> 1
-	#
-	def max_threads
-		@max_threads
-	end
-	
-	##
-	# Returns the current number of worker threads.
-	# This value is just a snapshot, and may change immediately upon returning.
-	#
-	#  wq = WorkQueue.new(10)
-	#  wq.cur_threads		#=> 0
-	#  wq.enqueue_b {}
-	#  wq.cur_threads		#=> 1
-	#
-	def cur_threads
-		@threads.size
-	end
-	
-	##
-	# Returns the maximum number of queued tasks.
-	# This value is set upon initialization and cannot be changed afterwards.
-	#
-	#  wq = WorkQueue.new()
-	#  wq.max_tasks		#=> Infinity
-	#  wq = WorkQueue.new(nil,1)
-	#  wq.max_tasks		#=> 1
-	#
-	def max_tasks
-		@max_tasks
-	end
-	
-	##
-	# Returns the current number of queued tasks.
-	# This value is just a snapshot, and may change immediately upon returning.
-	#
-	#  wq = WorkQueue.new(1)
-	#  wq.enqueue_b { sleep(1) }
-	#  wq.cur_tasks		#=> 0
-	#  wq.enqueue_b {}
-	#  wq.cur_tasks		#=> 1
-	#
-	def cur_tasks
-		@tasks.size
-	end
-	
-	##
-	# Returns the number of seconds to keep worker threads alive waiting for new tasks.
-	# This value is set upon initialization and cannot be changed afterwards.
-	#
-	#  wq = WorkQueue.new()
-	#  wq.keep_alive		#=> 60
-	#  wq = WorkQueue.new(nil,nil,1)
-	#  wq.keep_alive		#=> 1
-	#
-	def keep_alive
-		@keep_alive
-	end
-	
-	##
-	# Schedules the given Proc for future execution by a worker thread.
-	# If there is no space left in the queue, waits until space becomes available.
-	#
-	#  wq = WorkQueue.new(1)
-	#  wq.enqueue_p(Proc.new {})
-	#
-	def enqueue_p(proc, *args)
-		@tasks << [proc,args]
-		spawn_thread
-		self
-	end
-	
-	##
-	# Schedules the given Block for future execution by a worker thread.
-	# If there is no space left in the queue, waits until space becomes available.
-	#
-	#  wq = WorkQueue.new(1)
-	#  wq.enqueue_b {}
-	#
-	def enqueue_b(*args, &block)
-		@tasks << [block,args]
-		spawn_thread
-		self
-	end
-	
-	##
-	# Waits until the tasks queue is empty and all worker threads have finished.
-	#
-	#  wq = WorkQueue.new(1)
-	#  wq.enqueue_b { sleep(1) }
-	#  wq.join
-	#
-	def join
-		cur_threads.times { dismiss_thread }
-		@threads.dup.each { |thread| thread.join }
-		self
-	end
-	
-	##
-	# Stops all worker threads immediately, aborting any ongoing tasks.
-	#
-	#  wq = WorkQueue.new(1)
-	#  wq.enqueue_b { sleep(1) }
-	#  wq.stop
-	#
-	def stop
-		@threads.dup.each { |thread| thread.exit.join }
-		@tasks.clear
-		self
-	end
-	
-	private
-	
-	##
-	# Sets the maximum number of worker threads.
-	#
-	def max_threads=(value)
-		raise ArgumentError, "the maximum number of threads must be positive" if value and value <= 0
-		@max_threads = value || 1.0/0
-	end
-	
-	##
-	# Sets the maximum number of queued tasks.
-	#
-	def max_tasks=(value)
-		raise ArgumentError, "the maximum number of tasks must be positive" if value and value <= 0
-		@max_tasks = value || 1.0/0
-	end
-	
-	##
-	# Sets the maximum time to keep worker threads alive waiting for new tasks.
-	#
-	def keep_alive=(value)
-		raise ArgumentError, "the keep-alive time must be positive" if value and value <= 0
-		@keep_alive = value || 1.0/0
-	end
-	
-	##
-	# Enrolls a new worker thread.
-	# The request is only carried out if necessary.
-	#
-	def spawn_thread
-		if cur_threads < max_threads and @tasks.num_waiting <= 0 and cur_tasks > 0
-			@threads_lock.synchronize { 
-				@threads << Thread.new do
-					begin
-						work()
-					ensure
-						@threads_lock.synchronize { @threads.delete(Thread.current) }
-					end
-				end
-			}
-		end
-	end
-	
-	##
-	# Instructs an idle worker thread to exit.
-	# The request is only carried out if necessary.
-	#
-	def dismiss_thread
-		@tasks << [Proc.new { Thread.exit }, nil] if cur_threads > 0
-	end
-	
-	##
-	# Repeatedly process the tasks queue.
-	#
-	def work
-		loop do
-			begin
-				proc, args = timeout(keep_alive) { @tasks.pop }
-				proc.call(*args)
-			rescue Timeout::Error
-				break
-			rescue Exception
-				# suppress exception
-			end
-			break if cur_threads > max_threads
-		end
-	end
-	
+
+  VERSION = "1.0.0"
+
+  ##
+  # Creates a new work queue with the desired parameters.
+  #
+  #  wq = WorkQueue.new(5,10,20)
+  #
+  def initialize(max_threads=nil, max_tasks=nil, keep_alive=60)
+    self.max_threads = max_threads
+    self.max_tasks = max_tasks
+    self.keep_alive = keep_alive
+    @threads = []
+    @threads_lock = Mutex.new
+    @tasks = max_tasks ? SizedQueue.new(max_tasks) : Queue.new
+    @threads.taint
+    @tasks.taint
+    self.taint
+  end
+
+  ##
+  # Returns the maximum number of worker threads.
+  # This value is set upon initialization and cannot be changed afterwards.
+  #
+  #  wq = WorkQueue.new()
+  #  wq.max_threads		#=> Infinity
+  #  wq = WorkQueue.new(1)
+  #  wq.max_threads		#=> 1
+  #
+  def max_threads
+    @max_threads
+  end
+
+  ##
+  # Returns the current number of worker threads.
+  # This value is just a snapshot, and may change immediately upon returning.
+  #
+  #  wq = WorkQueue.new(10)
+  #  wq.cur_threads		#=> 0
+  #  wq.enqueue_b {}
+  #  wq.cur_threads		#=> 1
+  #
+  def cur_threads
+    @threads.size
+  end
+
+  ##
+  # Returns the maximum number of queued tasks.
+  # This value is set upon initialization and cannot be changed afterwards.
+  #
+  #  wq = WorkQueue.new()
+  #  wq.max_tasks		#=> Infinity
+  #  wq = WorkQueue.new(nil,1)
+  #  wq.max_tasks		#=> 1
+  #
+  def max_tasks
+    @max_tasks
+  end
+
+  ##
+  # Returns the current number of queued tasks.
+  # This value is just a snapshot, and may change immediately upon returning.
+  #
+  #  wq = WorkQueue.new(1)
+  #  wq.enqueue_b { sleep(1) }
+  #  wq.cur_tasks		#=> 0
+  #  wq.enqueue_b {}
+  #  wq.cur_tasks		#=> 1
+  #
+  def cur_tasks
+    @tasks.size
+  end
+
+  ##
+  # Returns the number of seconds to keep worker threads alive waiting for new tasks.
+  # This value is set upon initialization and cannot be changed afterwards.
+  #
+  #  wq = WorkQueue.new()
+  #  wq.keep_alive		#=> 60
+  #  wq = WorkQueue.new(nil,nil,1)
+  #  wq.keep_alive		#=> 1
+  #
+  def keep_alive
+    @keep_alive
+  end
+
+  ##
+  # Schedules the given Proc for future execution by a worker thread.
+  # If there is no space left in the queue, waits until space becomes available.
+  #
+  #  wq = WorkQueue.new(1)
+  #  wq.enqueue_p(Proc.new {})
+  #
+  def enqueue_p(proc, *args)
+    @tasks << [proc,args]
+    spawn_thread
+    self
+  end
+
+  ##
+  # Schedules the given Block for future execution by a worker thread.
+  # If there is no space left in the queue, waits until space becomes available.
+  #
+  #  wq = WorkQueue.new(1)
+  #  wq.enqueue_b {}
+  #
+  def enqueue_b(*args, &block)
+    @tasks << [block,args]
+    spawn_thread
+    self
+  end
+
+  ##
+  # Waits until the tasks queue is empty and all worker threads have finished.
+  #
+  #  wq = WorkQueue.new(1)
+  #  wq.enqueue_b { sleep(1) }
+  #  wq.join
+  #
+  def join
+    cur_threads.times { dismiss_thread }
+    @threads.dup.each { |thread| thread.join }
+    self
+  end
+
+  ##
+  # Stops all worker threads immediately, aborting any ongoing tasks.
+  #
+  #  wq = WorkQueue.new(1)
+  #  wq.enqueue_b { sleep(1) }
+  #  wq.stop
+  #
+  def stop
+    @threads.dup.each { |thread| thread.exit.join }
+    @tasks.clear
+    self
+  end
+
+  private
+
+  ##
+  # Sets the maximum number of worker threads.
+  #
+  def max_threads=(value)
+    raise ArgumentError, "the maximum number of threads must be positive" if value and value <= 0
+    @max_threads = value || 1.0/0
+  end
+
+  ##
+  # Sets the maximum number of queued tasks.
+  #
+  def max_tasks=(value)
+    raise ArgumentError, "the maximum number of tasks must be positive" if value and value <= 0
+    @max_tasks = value || 1.0/0
+  end
+
+  ##
+  # Sets the maximum time to keep worker threads alive waiting for new tasks.
+  #
+  def keep_alive=(value)
+    raise ArgumentError, "the keep-alive time must be positive" if value and value <= 0
+    @keep_alive = value || 1.0/0
+  end
+
+  ##
+  # Enrolls a new worker thread.
+  # The request is only carried out if necessary.
+  #
+  def spawn_thread
+    if cur_threads < max_threads and @tasks.num_waiting <= 0 and cur_tasks > 0
+      @threads_lock.synchronize {
+        @threads << Thread.new do
+          begin
+            work()
+          ensure
+            @threads_lock.synchronize { @threads.delete(Thread.current) }
+          end
+        end
+      }
+    end
+  end
+
+  ##
+  # Instructs an idle worker thread to exit.
+  # The request is only carried out if necessary.
+  #
+  def dismiss_thread
+    @tasks << [Proc.new { Thread.exit }, nil] if cur_threads > 0
+  end
+
+  ##
+  # Repeatedly process the tasks queue.
+  #
+  def work
+    loop do
+      begin
+        proc, args = timeout(keep_alive) { @tasks.pop }
+        proc.call(*args)
+      rescue Timeout::Error
+        break
+      rescue Exception
+        # suppress exception
+      end
+      break if cur_threads > max_threads
+    end
+  end
+
 end

data/tasks/test.rake

@@ -2,21 +2,21 @@ require 'rake/testtask'
 
 namespace(:test) do
 
-	# For a list of all attributes refer to http://rake.rubyforge.org/classes/Rake/TestTask.html
-	Rake::TestTask.new(:unit) do |t|
-		t.libs << "test"
-		t.test_files = FileList['test/tc_*.rb']
-		t.verbose = true
-		t.warning = true
-	end
+  # For a list of all attributes refer to http://rake.rubyforge.org/classes/Rake/TestTask.html
+  Rake::TestTask.new(:unit) do |t|
+    t.libs << "test"
+    t.test_files = FileList['test/tc_*.rb']
+    t.verbose = true
+    t.warning = true
+  end
 
-	desc "Run tests on multiple ruby versions"
-	task(:compatibility) do
-		versions = %w[1.8.6 1.8.7 1.9.1 jruby]
-		system <<-CMD
-			bash -c 'source ~/.rvm/scripts/rvm;
-					 rvm #{versions.join(',')} rake test:unit'
-		CMD
-	end
+  desc "Run tests on multiple ruby versions"
+  task(:compatibility) do
+    versions = %w[1.8.6 1.8.7 1.9.1 jruby]
+    system <<-CMD
+  bash -c 'source ~/.rvm/scripts/rvm;
+       rvm #{versions.join(',')} rake test:unit'
+    CMD
+  end
 
 end

data/test/tc_work_queue.rb

@@ -18,75 +18,75 @@ require 'test/unit'
 require 'lib/work_queue'
 
 class TC_WorkQueue < Test::Unit::TestCase
-	
-	# def setup
-	# end
-	
-	# def teardown
-	# end
-	
-	def test_enqueue
-		s = String.new
-		wq = WorkQueue.new
-		# using proc
-		wq.enqueue_p(Proc.new { |str| str.replace("Hello #1") }, s)
-		wq.join
-		assert_equal(s, "Hello #1")
-		# using block
-		wq.enqueue_b(s) { |str| str.replace("Hello #2") }
-		wq.join
-		assert_equal(s, "Hello #2")
-	end
-	
-	def test_max_threads
-		assert_raise(ArgumentError) { WorkQueue.new(0) }
-		assert_raise(ArgumentError) { WorkQueue.new(-1) }
-		wq = WorkQueue.new(1)
-		assert_equal(wq.cur_threads, 0)
-		wq.enqueue_b { sleep(0.01) }
-		assert_equal(wq.cur_threads, 1)
-		wq.enqueue_b { sleep(0.01) }
-		assert_equal(wq.cur_threads, 1)
-		sleep(0.1)
-		assert_equal(wq.cur_threads, 1)
-		wq.join
-	end
-	
-	def test_max_tasks
-		assert_raise(ArgumentError) { WorkQueue.new(nil,0) }
-		assert_raise(ArgumentError) { WorkQueue.new(nil,-1) }
-		wq = WorkQueue.new(1,1)
-		wq.enqueue_b { sleep(0.01) }
-		wq.enqueue_b { sleep(0.01) }
-		assert_equal(wq.cur_tasks, 1)
-		wq.enqueue_b { sleep(0.01) }
-		assert_equal(wq.cur_tasks, 1)
-		wq.join
-	end
-	
-	def test_keep_alive
-		assert_raise(ArgumentError) { WorkQueue.new(nil,nil,0) }
-		assert_raise(ArgumentError) { WorkQueue.new(nil,nil,-1) }
-		wq = WorkQueue.new(1,1,0.01)
-		wq.enqueue_b { sleep(0.01) }
-		assert_equal(wq.cur_threads, 1)
-		sleep(0.1)
-		assert_equal(wq.cur_threads, 0)
-		wq.join
-	end
-	
-	def test_stress
-		a = []
-		m = Mutex.new
-		wq = WorkQueue.new(100,200,0.1)
-		(1..1000).each do
-			wq.enqueue_b(a,m) { |str,mut| 
-				sleep(0.01)
-				mut.synchronize { a.push nil }
-			}
-		end
-		wq.join
-		assert_equal(a.size, 1000)
-	end
-	
+
+  # def setup
+  # end
+
+  # def teardown
+  # end
+
+  def test_enqueue
+    s = String.new
+    wq = WorkQueue.new
+    # using proc
+    wq.enqueue_p(Proc.new { |str| str.replace("Hello #1") }, s)
+    wq.join
+    assert_equal(s, "Hello #1")
+    # using block
+    wq.enqueue_b(s) { |str| str.replace("Hello #2") }
+    wq.join
+    assert_equal(s, "Hello #2")
+  end
+
+  def test_max_threads
+    assert_raise(ArgumentError) { WorkQueue.new(0) }
+    assert_raise(ArgumentError) { WorkQueue.new(-1) }
+    wq = WorkQueue.new(1)
+    assert_equal(wq.cur_threads, 0)
+    wq.enqueue_b { sleep(0.01) }
+    assert_equal(wq.cur_threads, 1)
+    wq.enqueue_b { sleep(0.01) }
+    assert_equal(wq.cur_threads, 1)
+    sleep(0.1)
+    assert_equal(wq.cur_threads, 1)
+    wq.join
+  end
+
+  def test_max_tasks
+    assert_raise(ArgumentError) { WorkQueue.new(nil,0) }
+    assert_raise(ArgumentError) { WorkQueue.new(nil,-1) }
+    wq = WorkQueue.new(1,1)
+    wq.enqueue_b { sleep(0.01) }
+    wq.enqueue_b { sleep(0.01) }
+    assert_equal(wq.cur_tasks, 1)
+    wq.enqueue_b { sleep(0.01) }
+    assert_equal(wq.cur_tasks, 1)
+    wq.join
+  end
+
+  def test_keep_alive
+    assert_raise(ArgumentError) { WorkQueue.new(nil,nil,0) }
+    assert_raise(ArgumentError) { WorkQueue.new(nil,nil,-1) }
+    wq = WorkQueue.new(1,1,0.01)
+    wq.enqueue_b { sleep(0.01) }
+    assert_equal(wq.cur_threads, 1)
+    sleep(0.1)
+    assert_equal(wq.cur_threads, 0)
+    wq.join
+  end
+
+  def test_stress
+    a = []
+    m = Mutex.new
+    wq = WorkQueue.new(100,200,0.1)
+    (1..1000).each do
+      wq.enqueue_b(a,m) { |str,mut|
+        sleep(0.01)
+        mut.synchronize { a.push nil }
+      }
+    end
+    wq.join
+    assert_equal(a.size, 1000)
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: work_queue
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 1.0.0
 platform: ruby
 authors: 
 - Miguel Fonseca
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-28 00:00:00 +00:00
+date: 2010-02-17 00:00:00 +00:00
 default_executable: 
 dependencies: []
 
@@ -21,13 +21,11 @@ extensions: []
 
 extra_rdoc_files: 
 - README.rdoc
+- LICENSE
 files: 
 - LICENSE
 - Rakefile
 - README.rdoc
-- tasks/ftp.rake
-- tasks/gem.rake
-- tasks/rdoc.rake
 - tasks/test.rake
 - lib/work_queue.rb
 - test/tc_work_queue.rb
@@ -39,8 +37,6 @@ post_install_message:
 rdoc_options: 
 - --line-numbers
 - --inline-source
-- --title
-- WorkQueue
 - --main
 - README.rdoc
 require_paths: 

data/tasks/ftp.rake

@@ -1,177 +0,0 @@
-require 'net/ftp'
-require 'pathname'
-require 'yaml'
-require 'rubygems'
-require 'rake'
-require 'rake/tasklib'
-
-module Rake
-	
-	# = FTPTask
-	#
-	# == Description
-	# A Rake task that transfers local files to an FTP server.
-	#
-	# == Usage
-	#  Rake::FTPTask.new do |t|
-	#   t.host = "ftp.example.com"
-	#   t.user_name = "user"
-	#   t.password = "pass"
-	#   t.path = "public_html/"
-	#   t.upload_files = FileList["doc/**/*"].to_a
-	#  end
-	#
-	# To avoid hard-coding the connection configuration into the source code, the task can obtain that data from a YAML file.
-	#
-	#  Rake::FTPTask.new("ftp.yml") do |t|
-	#   t.path = "public_html/"
-	#   t.upload_files = FileList["doc/**/*"].to_a
-	#  end
-	#
-	#  # ftp.yml
-	#  host = ftp.example.com
-	#  user_name = user
-	#  password = pass
-	#  path = public_html/ 
-	#
-	class FTPTask < TaskLib
-		
-		##
-		# The address of the server (default is nil).
-		#
-		attr_accessor :host
-		
-		##
-		# The user name required to log into the server (default is "anonymous").
-		#
-		attr_accessor :user_name
-		
-		##
-		# The password required for the selected user name (default is nil).
-		#
-		attr_accessor :password
-		
-		##
-		# The (remote) base directory (default is "").
-		#
-		attr_accessor :path
-		
-		##
-		# The array of files to be included in the FTP upload (default is []).
-		#
-		attr_accessor :upload_files
-		
-		##
-		# The boolean to enable progress messages when true (default is false).
-		#
-		attr_accessor :verbose
-		
-		##
-		# Creates a new FTP task.
-		#
-		def initialize(config_file=nil)
-			@host = nil
-			@user_name = "anonymous"
-			@password = nil
-			@path = ""
-			@upload_files = []
-			@verbose = false
-			@ftp = nil
-			@history = {}
-			load_config(config_file) unless config_file.nil?
-			yield self if block_given?
-			define
-		end
-		
-		##
-		# Creates the tasks defined by this task lib.
-		#
-		def define
-			desc "Upload files to an FTP account"
-			task(:upload) do
-				connect
-				upload
-				disconnect
-			end
-		end
-		
-		private
-		
-		##
-		# Reads configuration values from a YAML file.
-		#
-		def load_config(file)
-			config = YAML::load_file(file)
-			@host = config["host"] || @host
-			@user_name = config["user_name"] || @user_name
-			@password = config["password"] || @password
-			@path = config["path"] || @path
-		end
-		
-		##
-		# Establishes the FTP connection.
-		#
-		def connect
-			@ftp = Net::FTP.new(@host, @user_name, @password)
-			puts "Connected to #{@host}" if @verbose
-			puts "Using #{@ftp.binary ? "binary" : "text"} mode to transfer files" if @verbose
-			unless @path.nil? or @path.empty?
-				make_dirs(@path)
-				@ftp.chdir(@path)
-				puts "The working directory is now #{@ftp.getdir}" if @verbose
-			end
-		end
-		
-		##
-		# Closes the FTP connection. Further remote operations are impossible. 
-		#
-		def disconnect
-			@ftp.close
-			puts "Disconnected" if @verbose
-		end
-		
-		##
-		# Iterates through the array of files.
-		#
-		def upload
-			puts "Uploading #{@upload_files.length} files..." if @verbose
-			@upload_files.each do |entry|
-				if File.directory?(entry)
-					make_dirs(entry)
-				else
-					put_file(entry)
-				end
-			end
-		end
-		
-		##
-		# Transfers a local file to the server, relative to the current working directory.
-		#
-		def put_file(name)
-			puts "Uploading file #{name}" if @verbose
-			path = File.dirname(name)
-			make_dirs(path)
-			@ftp.put(name,name)
-		end
-		
-		##
-		# Creates a directory and all its parent directories in the server, relative to the current working directory.
-		#
-		def make_dirs(name)
-			Pathname.new(name).descend do |dir|
-				if @history[dir].nil?
-					@history[dir] = true
-					puts "Creating directory #{dir}" if @verbose
-					@ftp.mkdir(dir) rescue nil
-				end
-			end
-		end
-		
-	end
-	
-end
-
-Rake::FTPTask.new("config/ftp.yml") do |ftp|
-	ftp.upload_files = FileList["doc/**/*"].to_a
-	ftp.verbose = true
-end

data/tasks/gem.rake

@@ -1,26 +0,0 @@
-require 'rake/gempackagetask'
-require 'lib/work_queue'
-
-CLEAN.include("pkg")
-
-# For a list of all attributes refer to http://docs.rubygems.org/read/chapter/20
-spec = Gem::Specification.new do |s|
-	s.name = "work_queue"
-	s.version = WorkQueue::VERSION
-	s.summary = "A tunable work queue, designed to coordinate work between a producer and a pool of worker threads."
-	s.homepage = "http://github.com/fmmfonseca/work_queue"
-	s.author = "Miguel Fonseca"
-	s.email = "fmmfonseca@gmail.com"
-	
-	s.required_ruby_version = ">= 1.8.6"
-	s.files = FileList["LICENSE", "Rakefile", "README.rdoc", "tasks/*.rake", "lib/**/*.rb", "test/tc_*.rb"].to_a
-	s.test_files = Dir.glob("test/tc_*.rb")
-	s.has_rdoc = true
-	s.extra_rdoc_files = %w[README.rdoc]
-	s.rdoc_options = %w[--line-numbers --inline-source --title WorkQueue --main README.rdoc]
-end
-
-# For a list of all attributes refer to http://rake.rubyforge.org/classes/Rake/PackageTask.html
-Rake::GemPackageTask.new(spec) do |p|
-	p.need_zip = true
-end

data/tasks/rdoc.rake

@@ -1,11 +0,0 @@
-require 'rake/rdoctask'
-
-CLEAN.include("doc")
-
-# For a list of all attributes refer to http://rake.rubyforge.org/classes/Rake/RDocTask.html
-Rake::RDocTask.new do |rd|
-	rd.title = "WorkQueue"
-	rd.main = "README.rdoc"
-	rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
-	rd.rdoc_dir = "doc"
-end