Use explicit method to clear event handlers.

Author: jemc

lib/rabbitmq/channel.rb

@@ -67,6 +67,11 @@ def on_event(*args, &block)
     end
     alias_method :on, :on_event
 
+    # @see {Client#clear_event_handler}
+    def clear_event_handler(*args)
+      @client.clear_event_handler(@id, *args)
+    end
+    
     # @see {Client#run_loop!}
     # The block will be yielded all non-exception events *for any channel*.
     def run_loop!(*args, &block)

lib/rabbitmq/client.rb

@@ -142,12 +142,22 @@ def fetch_response(channel_id, method, timeout: protocol_timeout)
     def on_event(channel_id, method, callable=nil, &block)
       handler = block || callable
       raise ArgumentError, "expected block or callable as the event handler" \
-        unless handler.nil? or handler.respond_to?(:call)
+        unless handler.respond_to?(:call)
 
       @event_handlers[Integer(channel_id)][method.to_sym] = handler
       handler
     end
 
+    # Unregister the event handler associated with the given channel and method.
+    #
+    # @param channel_id [Integer] The channel number to watch for.
+    # @param method [Symbol] The type of protocol method to watch for.
+    # @return [Proc,nil] This removed handler, if any.
+    #
+    def clear_event_handler(channel_id, method)
+      @event_handlers[Integer(channel_id)].delete(method.to_sym)
+    end
+    
     # Fetch and handle events in a loop that blocks the calling thread.
     # The loop will continue until the {#break!} method is called from within
     # an event handler, or until the given timeout duration has elapsed.

spec/channel_spec.rb

@@ -69,6 +69,11 @@
       subject.on(*a, &b).should eq res
     end
 
+    specify "#clear_event_handler" do
+      client.should_receive(:clear_event_handler).with(id, *a) { res }
+      subject.clear_event_handler(*a).should eq res
+    end
+    
     specify "#send_request" do
       client.should_receive(:send_request).with(id, *a) { res }
       subject.send_request(*a).should eq res

spec/client_spec.rb

@@ -119,14 +119,10 @@
     let(:other_bucket) { [] }
 
     it "requires a block or callable object to be given as the handler" do
-      expect { subject.on_event(11, :channel_open_ok, :neither) }.to \
+      expect { subject.on_event(11, :channel_open_ok) }.to \
         raise_error ArgumentError, /block or callable/
     end
 
-    it "allows nil to clear the handler" do
-      subject.on_event(11, :channel_open_ok, nil)
-    end
-    
     shared_examples "handling events" do
       it "calls the handler for uncaught events" do
         subject.send_request(11, :channel_open)
@@ -172,15 +168,22 @@
         other_bucket.should be_empty
       end
 
-      it "clears the handler when nil is registered" do
-        subject.on_event(11, :channel_open_ok, nil)
+      it "clears the handler when explicitly unregistered" do
+        subject.clear_event_handler(11, :channel_open_ok).should respond_to :call
 
         subject.send_request(11, :channel_open)
         subject.fetch_response(11, :channel_open_ok)
 
         bucket.should be_empty
       end
 
+      it "clears the handler and returns nil when already cleared" do
+        subject.clear_event_handler(11, :channel_close_ok).should eq nil
+        
+        subject.clear_event_handler(11, :channel_open_ok).should respond_to :call
+        subject.clear_event_handler(11, :channel_open_ok).should eq nil
+      end
+      
       it "calls the block passed to run_loop! for handler-matching events" do
         subject.send_request(11, :channel_open)
         subject.run_loop! do |event|