pigeon 0.4.4 → 0.4.6

data/VERSION

@@ -1 +1 @@
-0.4.4
+0.4.6

data/lib/pigeon/processor.rb

@@ -5,6 +5,8 @@ class Pigeon::Processor
 
   # == Properties ===========================================================
   
+  attr_accessor :context
+  attr_reader :queue
   attr_reader :task
   attr_reader :id
 
@@ -15,10 +17,11 @@ class Pigeon::Processor
   # Creates a new processor. An optional queue can be specified in which case
   # the processor will register itself as an observer of that queue. A block
   # can be given to filter the tasks contained in the associated queue.
-  def initialize(queue = nil, &filter)
+  def initialize(queue = nil, context = nil, &filter)
     @id = Pigeon::Support.unique_id
     @lock = Mutex.new
     @filter = filter || lambda { |task| true }
+    @context = context
     
     if (queue)
       self.queue = queue
@@ -31,24 +34,24 @@ class Pigeon::Processor
   # then the observer callback for that queue will be removed.
   def queue=(queue)
     if (@queue)
-      @queue.remove_observer(&@claim)
+      @queue.remove_processor(self, &@claim)
     end
     
-    @queue = queue
-
-    @claim = lambda do |task|
-      @lock.synchronize do
-        if (!@task and @filter.call(task))
-          @task = queue.claim(task)
+    if (@queue = queue)
+      @claim = lambda do |task|
+        @lock.synchronize do
+          if (!@task and @filter.call(task))
+            @task = queue.claim(task)
       
-          @task.run! do
-            switch_to_next_task!
+            @task.run!(self) do
+              switch_to_next_task!
+            end
           end
         end
       end
+
+      @queue.add_processor(self, &@claim)
     end
-    
-    @queue.observe(&@claim)
   end
   
   # Returns true if the given task would be accepted by the filter defined
@@ -62,13 +65,17 @@ class Pigeon::Processor
     !!@task
   end
   
+  def inspect
+    "<#{self.class}\##{@id} queue=#{@queue.inspect} task=#{@task} context=#{@context}>"
+  end
+  
 protected
   def switch_to_next_task!
     @lock.synchronize do
       @task = nil
 
       if (@task = @queue.pop(&@filter))
-        @task.run! do
+        @task.run!(self) do
           switch_to_next_task!
         end
       end

data/lib/pigeon/queue.rb

@@ -17,15 +17,9 @@ class Pigeon::Queue
     alias_method :to_s, :inspect
   end
 
-  # == Extensions ===========================================================
-
-  # == Relationships ========================================================
-
-  # == Scopes ===============================================================
-
-  # == Callbacks ============================================================
-
-  # == Validations ==========================================================
+  # == Properties ===========================================================
+  
+  attr_reader :processors
 
   # == Class Methods ========================================================
   
@@ -56,6 +50,7 @@ class Pigeon::Queue
     @claimable_task = { }
     @filters = self.class.filters.dup
     @observers = { }
+    @processors = [ ]
     @next_task = { }
     @insert_backlog = [ ]
     
@@ -107,6 +102,24 @@ class Pigeon::Queue
     end
   end
   
+  # Adds a processor to the queue and adds an observer claim method.
+  def add_processor(processor, &claim)
+    @observer_lock.synchronize do
+      @processors << processor
+    end
+
+    observe(&claim) if (claim)
+  end
+  
+  # Removes a processor from the queue and removes an observer claim method.
+  def remove_processor(processor, &claim)
+    @observer_lock.synchronize do
+      @processors.delete(processor)
+    end
+
+    remove_observer(&claim) if (claim)
+  end
+  
   # Creates a named filter for the queue using the provided block to select
   # the tasks which should match.
   def filter(filter_name, &block)

data/lib/pigeon/task.rb

@@ -38,14 +38,16 @@ class Pigeon::Task
     after_initialized
   end
   
-  # Kicks off the task. An optional callback is executed just before each
+  # Kicks off the task. The processor execurting the task should be supplied
+  # as the first argument. An optional callback is executed just before each
   # state is excuted and is passed the state name as a symbol.
-  def run!(initial_state = nil, &callback)
+  def run!(processor = nil, initial_state = nil, &callback)
     @callback = callback if (block_given?)
     
     @state = initial_state || self.class.initial_state
     @started_at = Time.now
 
+    @processor = processor
     run_state!(@state)
   end
 

data/pigeon.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{pigeon}
-  s.version = "0.4.4"
+  s.version = "0.4.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["tadman"]
-  s.date = %q{2010-12-15}
+  s.date = %q{2010-12-17}
   s.default_executable = %q{launcher.example}
   s.description = %q{Pigeon is a simple way to get started building an EventMachine engine that's intended to run as a background job.}
   s.email = %q{github@tadman.ca}

data/test/unit/pigeon_processor_test.rb

@@ -110,6 +110,19 @@ class PigeonProcessorTest < Test::Unit::TestCase
     
     assert_equal false, task_c.finished?
   end
+  
+  def test_can_unassign_queue_from_processor
+    queue = Pigeon::Queue.new
+    processor = Pigeon::Processor.new(queue)
+    
+    assert_equal queue, processor.queue
+    assert_equal [ processor ], queue.processors
+    
+    processor.queue = nil
+    
+    assert_equal nil, processor.queue
+    assert_equal [ ], queue.processors
+  end
 
   def test_multiple_processors
     queue = Pigeon::Queue.new

data/test/unit/pigeon_queue_test.rb

@@ -31,6 +31,8 @@ class PigeonQueueTest < Test::Unit::TestCase
     assert_equal true, queue.empty?
     
     assert_equal nil, queue.pop
+    
+    assert_equal [ ], queue.processors
   end
   
   def test_cycling

data/test/unit/pigeon_task_test.rb

@@ -140,7 +140,7 @@ class PigeonTaskTest < Test::Unit::TestCase
     assert task.exception?
   end
   
-  def test_arbitrary_options
+  def test_with_context
     options = {
       :example => 'example1',
       :optional => 1
@@ -149,6 +149,10 @@ class PigeonTaskTest < Test::Unit::TestCase
     task = Pigeon::Task.new(options)
     
     assert_equal options, task.context
+    
+    task.context = 'test'
+    
+    assert_equal 'test', task.context
   end
 
   def test_block_notification

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 4
-  - 4
-  version: 0.4.4
+  - 6
+  version: 0.4.6
 platform: ruby
 authors: 
 - tadman
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-15 00:00:00 -05:00
+date: 2010-12-17 00:00:00 -05:00
 default_executable: launcher.example
 dependencies: 
 - !ruby/object:Gem::Dependency