pigeon 0.4.1 → 0.4.2

data/VERSION

@@ -1 +1 @@
-0.4.1
+0.4.2

data/lib/pigeon/scheduler.rb

@@ -30,6 +30,12 @@ class Pigeon::Scheduler
     end
   end
   
+  # Add a single task to the schedule. When subclassing, override the private
+  # enqueue_task method instead.
+  def <<(task)
+    enqueue_task(task)
+  end
+
   # Returns the default queue used for scheduling.
   def default_queue
     @queues[nil]
@@ -78,6 +84,11 @@ class Pigeon::Scheduler
     @state == :stopped
   end
   
+  # Returns true if there are no scheduled tasks, false otherwise.
+  def empty?
+    self.queue_size == 0
+  end
+  
   # Returns the number of tasks that have been queued up.
   def queue_length
     @queues.inject(0) do |length, (name, queue)|

data/pigeon.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{pigeon}
-  s.version = "0.4.1"
+  s.version = "0.4.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["tadman"]

data/test/unit/pigeon_processor_test.rb

@@ -4,8 +4,8 @@ class PigeonProcessorTest < Test::Unit::TestCase
   class TaggedTask < Pigeon::Task
     attr_accessor :tag
     
-    def initialize(engine, tag)
-      super(engine)
+    def initialize(tag, options = nil)
+      super(options)
       @tag = tag
     end
     
@@ -14,8 +14,14 @@ class PigeonProcessorTest < Test::Unit::TestCase
     end
   end
 
-  def engine
-    @engine ||= Pigeon::Engine.new
+  def setup
+    @engine = Pigeon::Engine.new
+
+    Pigeon::Engine.register_engine(@engine)
+  end
+  
+  def teardown
+    Pigeon::Engine.unregister_engine(@engine)
   end
 
   def test_empty_processor
@@ -25,7 +31,7 @@ class PigeonProcessorTest < Test::Unit::TestCase
     
     assert_equal false, processor.task?
     
-    assert_equal true, processor.accept?(Pigeon::Task.new(engine))
+    assert_equal true, processor.accept?(Pigeon::Task.new)
     
     assert processor.id
   end
@@ -39,12 +45,12 @@ class PigeonProcessorTest < Test::Unit::TestCase
     
     assert_equal false, processor.task?
     
-    queue << TaggedTask.new(engine, 0)
+    queue << TaggedTask.new(0)
     
     assert_equal false, processor.task?
     assert_equal 1, queue.length
 
-    queue << TaggedTask.new(engine, 1)
+    queue << TaggedTask.new(1)
     
     assert_equal true, processor.task?
     assert_equal 1, queue.length
@@ -60,7 +66,7 @@ class PigeonProcessorTest < Test::Unit::TestCase
     queue = Pigeon::Queue.new
     
     100.times do |n|
-      queue << TaggedTask.new(engine, n)
+      queue << TaggedTask.new(n)
     end
     
     processor = Pigeon::Processor.new(queue)
@@ -75,7 +81,7 @@ class PigeonProcessorTest < Test::Unit::TestCase
     count = 10000
     
     count.times do |n|
-      queue << TaggedTask.new(engine, n)
+      queue << TaggedTask.new(n)
     end
     
     assert_equal count, queue.length

data/test/unit/pigeon_queue_test.rb

@@ -4,8 +4,8 @@ class PigeonQueueTest < Test::Unit::TestCase
   class TaggedTask < Pigeon::Task
     attr_accessor :tag
     
-    def initialize(engine, tag)
-      super(engine)
+    def initialize(tag, options = nil)
+      super(options)
       @tag = tag
     end
     
@@ -14,8 +14,14 @@ class PigeonQueueTest < Test::Unit::TestCase
     end
   end
   
-  def engine
-    @engine ||= Pigeon::Engine.new
+  def setup
+    @engine = Pigeon::Engine.new
+
+    Pigeon::Engine.register_engine(@engine)
+  end
+  
+  def teardown
+    Pigeon::Engine.unregister_engine(@engine)
   end
 
   def test_empty_state
@@ -30,7 +36,7 @@ class PigeonQueueTest < Test::Unit::TestCase
   def test_cycling
     queue = Pigeon::Queue.new
     
-    task = Pigeon::Task.new(engine)
+    task = Pigeon::Task.new
     
     assert_equal task, queue << task
     
@@ -50,7 +56,7 @@ class PigeonQueueTest < Test::Unit::TestCase
     queue = Pigeon::Queue.new
 
     tasks = (0..9).to_a.collect do |n|
-      queue << TaggedTask.new(engine, n)
+      queue << TaggedTask.new(n)
     end
     
     assert_equal (0..9).to_a, tasks.to_a.collect(&:tag)
@@ -83,7 +89,7 @@ class PigeonQueueTest < Test::Unit::TestCase
     assert_equal 0, queue.length(:over_7)
     assert_equal true, queue.empty?(:over_7)
     
-    new_task = queue << TaggedTask.new(engine, 10)
+    new_task = queue << TaggedTask.new(10)
     
     assert_equal new_task, queue.peek(:over_7)
     assert_equal 1, queue.length(:over_7)
@@ -100,7 +106,7 @@ class PigeonQueueTest < Test::Unit::TestCase
     queue = Pigeon::Queue.new
     
     tasks = (0..9).to_a.collect do |n|
-      queue << TaggedTask.new(engine, n)
+      queue << TaggedTask.new(n)
     end
     
     queue.filter(:odd) do |task|
@@ -121,11 +127,11 @@ class PigeonQueueTest < Test::Unit::TestCase
       added_odd = task
     end
     
-    queue << TaggedTask.new(engine, 10)
+    queue << TaggedTask.new(10)
     
     assert_equal nil, added_odd
 
-    odd_1 = queue << TaggedTask.new(engine, 11)
+    odd_1 = queue << TaggedTask.new(11)
     
     assert_equal odd_1, added_odd
 
@@ -144,13 +150,13 @@ class PigeonQueueTest < Test::Unit::TestCase
     assert_equal 7, queue.length
     assert_equal 1, queue.length(:odd)
 
-    queue << TaggedTask.new(engine, 12)
+    queue << TaggedTask.new(12)
     
     assert_equal nil, claimed_task
     assert_equal 8, queue.length
     assert_equal 1, queue.length(:odd)
 
-    odd_2 = queue << TaggedTask.new(engine, 13)
+    odd_2 = queue << TaggedTask.new(13)
     
     # Adding a task that matches the filter triggers the callback.
     assert_equal odd_2, claimed_task
@@ -162,12 +168,12 @@ class PigeonQueueTest < Test::Unit::TestCase
     claimed_task = nil
     has_run = false
 
-    queue << TaggedTask.new(engine, 14)
+    queue << TaggedTask.new(14)
 
     assert_equal nil, claimed_task
     assert_equal false, has_run
 
-    odd_2 = queue << TaggedTask.new(engine, 15)
+    odd_2 = queue << TaggedTask.new(15)
     
     assert_equal odd_2, claimed_task
     assert_equal true, has_run
@@ -183,11 +189,11 @@ class PigeonQueueTest < Test::Unit::TestCase
       if (task.tag < 10)
         queue.claim(task)
 
-        queue << TaggedTask.new(engine, task.tag + 1)
+        queue << TaggedTask.new(task.tag + 1)
       end
     end
     
-    queue << TaggedTask.new(engine, 0)
+    queue << TaggedTask.new(0)
 
     assert queue.peek
     assert_equal 10, queue.peek.tag

data/test/unit/pigeon_scheduler_test.rb

@@ -4,8 +4,8 @@ class PigeonSchedulerTest < Test::Unit::TestCase
   class TaggedTask < Pigeon::Task
     attr_accessor :tag
     
-    def initialize(engine, tag)
-      super(engine)
+    def initialize(tag, options = nil)
+      super(options)
       @tag = tag
     end
     
@@ -14,14 +14,22 @@ class PigeonSchedulerTest < Test::Unit::TestCase
     end
   end
 
-  def engine
-    @engine ||= Pigeon::Engine.new
+  def setup
+    @engine = Pigeon::Engine.new
+
+    Pigeon::Engine.register_engine(@engine)
+  end
+  
+  def teardown
+    Pigeon::Engine.unregister_engine(@engine)
   end
   
   def test_defaults
     scheduler = Pigeon::Scheduler.new
     
     assert_equal true, scheduler.default_queue.empty?
+    assert_equal 0, scheduler.queue_size
+    assert_equal true, scheduler.empty?
   end
   
   def test_queued
@@ -32,7 +40,7 @@ class PigeonSchedulerTest < Test::Unit::TestCase
     count = 1000
     
     count.times do |n|
-      queue << TaggedTask.new(engine, n)
+      queue << TaggedTask.new(n)
     end
     
     assert_eventually(5) do
@@ -52,8 +60,8 @@ class PigeonSchedulerTest < Test::Unit::TestCase
     
     backlog = [ ]
     count.times do |n|
-      scheduler.add(TaggedTask.new(engine, n * 2 + 1))
-      backlog << TaggedTask.new(engine, n * 2)
+      scheduler.add(TaggedTask.new(n * 2 + 1))
+      backlog << TaggedTask.new(n * 2)
     end
     
     scheduler.add(backlog)

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 4
-  - 1
-  version: 0.4.1
+  - 2
+  version: 0.4.2
 platform: ruby
 authors: 
 - tadman