simple_queues 1.2.2 → 1.3.0

data/README.textile

@@ -62,6 +62,48 @@ while $running do
 end
 </code></pre>
 
+Alternatively, the block you provide to #on_dequeue can accept two parameters and will be provided with the queue name:
+
+<pre><code>require "simple_queues"
+# Provides #underscore, #classify, #constantize and friends
+require "active_support/inflector"
+
+# Provides #seconds, #minutes and friends
+require "active_support/core_ext/numeric/time"
+
+Queues = SimpleQueues::Redis.new
+
+class BaseWorker
+  def initialize(message)
+    @message = message
+  end
+end
+
+class CrawlerControlWorker < BaseWorker
+  def run
+    $running = false
+  end
+end
+
+class PagesToCrawlWorker < BaseWorker
+  def run
+    # Crawl, do your own stuff here
+  end
+end
+
+def handler(queue_name, message)
+  klass = (queue_name.to_s << "_worker").classify.constantize
+  klass.new(message).run
+end
+
+Queues.on_dequeue :crawler_controls, &method(:handler)
+Queues.on_dequeue :pages_to_crawl,   &method(:handler)
+
+while $running
+  Queues.dequeue_with_timeout(30.seconds)
+end
+</code></pre>
+
 h2. LICENSE
 
 (The MIT License)

data/lib/simple_queues/redis.rb

@@ -29,7 +29,13 @@ module SimpleQueues
       @queues = Hash.new
     end
 
+    # Saves a block for later execution from #dequeue_with_timeout or #dequeue.
+    #
+    # When the block's arity is 1, only the message will be passed.
+    # When the block's arity is 2, the queue's name and the message will be passed along, in that order.
+    # When the block's arity is negative (accepts a variable number of arguments), SimpleQueues::Redis behaves as if the block's arity was 2.
     def on_dequeue(queue_name, &block)
+      raise ArgumentError, "The provided block must accept at least one argument - #{block.inspect} accepts no arguments" if block.arity.zero?
       @queues[q_name(queue_name)] = block
     end
 
@@ -86,7 +92,16 @@ module SimpleQueues
         raise ArgumentError, "Timeout must not be nil" if timeout.nil? || timeout.to_s.empty?
 
         queue, result = @redis.blpop(*[@queues.keys, timeout.to_i].flatten)
-        @queues.fetch(queue).call(decode(result)) if queue
+        if queue then
+          block = @queues.fetch(queue)
+          message = decode(result)
+
+          if block.arity == 1 then
+            block.call(message)
+          else
+            block.call(queue, message)
+          end
+        end
         queue
       when 2
         queue_name, timeout = args.shift, args.shift

data/lib/simple_queues/version.rb

@@ -1,3 +1,3 @@
 module SimpleQueues
-  VERSION = "1.2.2"
+  VERSION = "1.3.0"
 end

data/spec/dequeueing_spec.rb

@@ -23,6 +23,14 @@ describe SimpleQueues::Redis, "dequeue_blocking" do
     lambda { queue.dequeue_blocking(nil) }.should raise_error(ArgumentError)
     lambda { queue.dequeue_blocking("") }.should raise_error(ArgumentError)
   end
+
+  it "should reraise underlying connection errors"
+  # Errno::ECONNREFUSED
+  # Errno::EAGAIN
+
+  context "given #exception_handler= is set with a block" do
+    it "should call the block to handle underlying connection exceptions"
+  end
 end
 
 describe SimpleQueues::Redis, "dequeue_with_timeout" do

data/spec/multi_dequeue_spec.rb

@@ -13,17 +13,23 @@ describe SimpleQueues::Redis, "multiple dequeue" do
     redis.flushdb
   end
 
-  it "should accept setting up a dequeue block" do
-    lambda do
-      queue.on_dequeue(:pages_to_crawl) {|message| message}
-    end.should_not raise_error
-  end
+  context "#on_dequeue" do
+    it "should accept setting up a dequeue block" do
+      lambda do
+        queue.on_dequeue(:pages_to_crawl) {|message| message}
+      end.should_not raise_error
+    end
 
-  it "should accept setting up multiple dequeue block" do
-    lambda do
-      queue.on_dequeue(:pages_to_crawl)   {|message| message}
-      queue.on_dequeue(:pages_to_analyze) {|message| message}
-    end.should_not raise_error
+    it "should accept setting up multiple dequeue block" do
+      lambda do
+        queue.on_dequeue(:pages_to_crawl)   {|message| message}
+        queue.on_dequeue(:pages_to_analyze) {|message| message}
+      end.should_not raise_error
+    end
+
+    it "should raise an ArgumentError when the block accepts no arguments" do
+      lambda { queue.on_dequeue(:a) { fail } }.should raise_error(ArgumentError)
+    end
   end
 
   context "#dequeue_with_timeout" do
@@ -39,7 +45,7 @@ describe SimpleQueues::Redis, "multiple dequeue" do
       queue.dequeue_with_timeout(1).should be_nil
     end
 
-    it "should call into the correct block" do
+    it "should send only the message when the block has an arity of 1" do
       a, b = [], []
       queue.on_dequeue(:a) {|message| a << message}
       queue.on_dequeue(:b) {|message| b << message}
@@ -53,5 +59,44 @@ describe SimpleQueues::Redis, "multiple dequeue" do
       a.should == [{"sent_to" => "a", "serial" => 1}, {"sent_to" => "a", "serial" => 2}]
       b.should == [{"sent_to" => "b", "serial" => 1}]
     end
+
+    it "should send the queue name and the message when the block has an arity of 2" do
+      received = []
+      queue.on_dequeue(:a) {|queue, message| received << [queue, message]}
+      queue.on_dequeue(:b) {|queue, message| received << [queue, message]}
+
+      queue.enqueue(:a, "a" => 1)
+      queue.enqueue(:b, "b" => 2)
+
+      2.times { queue.dequeue_with_timeout(1) }
+
+      received.should == [["a", {"a" => 1}], ["b", {"b" => 2}]]
+    end
+
+    it "should send the queue name and the message when the block has an arity of -1" do
+      received = []
+      queue.on_dequeue(:a) {|*args| received << args}
+      queue.on_dequeue(:b) {|*args| received << args}
+
+      queue.enqueue(:a, "a" => 1)
+      queue.enqueue(:b, "b" => 2)
+
+      2.times { queue.dequeue_with_timeout(1) }
+
+      received.should == [["a", {"a" => 1}], ["b", {"b" => 2}]]
+    end
+
+    it "should send the queue name and the message when the block has an arity of -2" do
+      received = []
+      queue.on_dequeue(:a) {|queue, *args| received << [queue, args]}
+      queue.on_dequeue(:b) {|queue, *args| received << [queue, args]}
+
+      queue.enqueue(:a, "a" => 1)
+      queue.enqueue(:b, "b" => 2)
+
+      2.times { queue.dequeue_with_timeout(1) }
+
+      received.should == [["a", [{"a" => 1}]], ["b", [{"b" => 2}]]]
+    end
   end
 end

metadata

@@ -2,7 +2,7 @@
 name: simple_queues
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.2.2
+  version: 1.3.0
 platform: ruby
 authors: 
 - "Fran\xC3\xA7ois Beausoleil"
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-30 00:00:00 -04:00
+date: 2011-05-31 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency