nebulous_stomp 1.1.5

data/spec/stomp_handler_spec.rb

@@ -0,0 +1,446 @@
+require 'time'
+require 'spec_helper'
+
+require 'nebulous/stomp_handler'
+require 'nebulous/message'
+
+require_relative 'helpers'
+
+include Nebulous
+
+
+RSpec.configure do |c|
+  c.include Helpers
+end
+
+
+describe StompHandler do
+
+  # Actually these are the real connection params, but we are going to stub, so
+  # hopefully it doesn't matter.
+  let(:stomp_hash) do
+    { hosts: [{ login:    'guest',
+                 passcode: 'guest',
+                 host:     '10.0.0.150',
+                 port:     61613,
+                 ssl:      false }],
+       reliable: false }
+  end
+
+  let(:client) { double( Stomp::Client ).as_null_object }
+
+  let(:handler) do
+    sh = StompHandler.new(stomp_hash, client)
+    
+    # Attempt to duplicate anything in Stomp::Client that we might need.
+    # This does the opposite of making me happy -- it's hella fragile, and
+    # we're dealing with implementation details, in code we don't even
+    # maintain! 
+    # But. I don't know of another way to do this. And we only do it here, in
+    # the test for StompHandler. Everything else can mock StompHandler or use
+    # StompHandlerNull.
+    conn = double("connection frame").as_null_object
+
+    allow(client).to receive(:connection_frame).and_return(conn)
+    allow(client).to receive_message_chain("connection_frame.headers").
+       and_return({"session" => "123"})
+
+    sh
+  end
+
+  let(:msg1) do
+    stomp_message('application/text', 'verb:Foo', client.calc_reply_id)
+  end
+
+  let(:msg2) do
+    stomp_message('application/text', 'verb:Bar', client.calc_reply_id)
+  end
+
+
+  describe 'StompHandler.body_to_hash' do
+
+    it "raises an error unless headers is a hash" do
+      expect{ StompHandler.body_to_hash() }.to raise_exception ArgumentError
+
+      expect{ StompHandler.body_to_hash('foo') }.
+        to raise_exception ArgumentError
+
+      expect{ StompHandler.body_to_hash('foo', 'bar') }.
+        to raise_exception ArgumentError
+
+      expect{ StompHandler.body_to_hash({}, 'baz') }.not_to raise_exception
+    end
+
+    context "when the content type is JSON" do
+
+      it "parses the json" do
+        body = {'one' => 'two', 'three' => [4,5]}
+        msg = stomp_message('application/json', body.to_json)
+        expect( StompHandler.body_to_hash(msg.headers, msg.body) ).to eq body
+
+        body = [ {'one' => 2, 'three' => 4}, {'five' => 6} ]
+        msg = stomp_message('application/json', body.to_json)
+        expect( StompHandler.body_to_hash(msg.headers, msg.body) ).to eq body
+      end
+
+    end
+
+    context "when the content type is not JSON" do
+
+      it "assumes text lines in key:value format" do
+        # Note that all values will be strings, and we can't support arrays.
+        result = {'one' => 'two', 'three' => '4'}
+        body = result.map{|k,v| "#{k}:#{v}" }.join("\n")
+        msg = stomp_message('application/text', body )
+
+        expect( StompHandler.body_to_hash(msg.headers, msg.body) ).to eq result
+      end
+
+    end
+
+    it "allows the caller to override the content type" do
+      result = {'one' => 'two', 'three' => '4'}
+      body = result.map{|k,v| "#{k}:#{v}" }.join("\n")
+      msg = stomp_message('application/json', body )
+
+      expect( StompHandler.body_to_hash( msg.headers, 
+                                         msg.body, 
+                                         'application/text') ).to eq result
+
+    end
+
+    it "returns a hash or an array of hashes" do
+      # lets check some corner cases to ensure this
+      msg = stomp_message('appplication/json', ''.to_json)
+      expect( StompHandler.body_to_hash(msg.headers, msg.body) ).to eq({})
+
+      msg = stomp_message('appplication/json', nil.to_json)
+      expect( StompHandler.body_to_hash(msg.headers, msg.body) ).to eq({})
+
+      msg = stomp_message('appplication/text', '')
+      expect( StompHandler.body_to_hash(msg.headers, msg.body) ).to eq({})
+
+      msg = stomp_message('appplication/text', nil)
+      expect( StompHandler.body_to_hash(msg.headers, msg.body) ).to eq({})
+    end
+
+
+  end
+  ##
+
+
+  describe "StompHandler.with_timeout" do
+
+    it "should hang for the given timeout period" do
+      start = Time.now
+      StompHandler.with_timeout(2) do |r|
+      end
+      stop = Time.now
+
+      expect(stop - start).to be_within(0.5).of(2)
+    end
+
+    it "should drop out of the block when given the signal" do
+      start = Time.now
+      StompHandler.with_timeout(2) do |r|
+        r.signal
+      end
+      stop = Time.now
+
+      expect(stop - start).to be < 0.5
+    end
+
+  end
+  ##
+
+
+  describe "#initialize" do
+
+    it "takes an initialization hash" do
+      expect{ StompHandler.new(foo: 'bar') }.not_to raise_exception
+      expect{ StompHandler.new }.to raise_exception ArgumentError
+    end
+
+  end
+  ##
+
+
+  describe "#stomp_connect" do
+
+    it "raises ConnectionError if it cannot connect to the STOMP server" do
+      hash = stomp_hash.merge( hosts: {passcode:'flurb'} )
+      sh = StompHandler.new(hash)
+
+      expect{sh.stomp_connect}.to raise_exception Nebulous::ConnectionError
+    end
+
+    it "returns self" do
+      expect(handler.stomp_connect).to eq handler
+    end
+
+    it "sets client to an instance of STOMP::Client" do
+      # Weeeeelllll -- actually... it isn't. It's the double.
+      handler.stomp_connect
+      expect(handler.client).to eq client
+    end
+
+    it "connects to the STOMP server" do
+      # in passing we test #connected? -- there doesn't seem to be a way to (or
+      # a point in) test(ing) it seperately.
+      handler.stomp_connect
+      expect( handler ).to be_connected
+    end
+
+    it 'doesn''t freak out if Nebulous is not "on"' do
+      sh = StompHandler.new({})
+      expect{ sh.stomp_connect }.not_to raise_exception
+      expect( sh.stomp_connect ).to eq sh
+    end
+
+  end
+  ##
+
+  
+  describe '#nebulous_on?' do
+
+    it 'should be true if there is anything in the stomp hash' do
+      sh = StompHandler.new(foo: 'bar')
+      expect( sh.nebulous_on? ).to be_truthy
+    end
+
+    it 'should be false if the stomp hash is nil' do
+      sh = StompHandler.new(nil)
+      expect( sh.nebulous_on? ).to be_falsy
+    end
+
+  end
+  ##
+
+
+  describe "#stomp_disconnect" do
+    it "disconnects!" do
+      handler.stomp_connect
+      handler.stomp_disconnect
+
+      expect( handler ).not_to be_connected
+    end
+
+    it 'doesn''t freak out if Nebulous is not "on"' do
+      sh = StompHandler.new({}).stomp_connect
+      expect{ sh.stomp_disconnect }.not_to raise_exception
+      expect( sh.stomp_disconnect ).to eq sh
+    end
+
+  end
+  ##
+
+
+  describe "#calc_reply_id" do
+
+    it "raises an error if the client is not connected" do
+      handler.stomp_disconnect
+
+      expect{ handler.calc_reply_id }.
+        to raise_exception Nebulous::ConnectionError
+
+    end
+
+    it "returns a unique string" do
+      # I can't actually check that the string is unique, so this is kinda weak
+      handler.stomp_connect
+      expect( handler.calc_reply_id ).to respond_to :upcase
+      expect( handler.calc_reply_id.size ).to be > 12
+    end
+
+    it 'doesn''t freak out if Nebulous is not "on"' do
+      sh = StompHandler.new({}).stomp_connect
+      expect{ sh.calc_reply_id }.not_to raise_exception
+      expect( sh.calc_reply_id ).to eq nil
+    end
+
+  end
+  ##
+
+
+  describe "send_message" do
+    # We're kind of navel gazing here because send_message is just one line: a
+    # call to client.publish. Still, call it a warming up exercise....
+    
+    let(:mess) { Nebulous::Message.from_parts(nil, nil, 'foo', nil, nil) }
+
+    before do
+      handler.stomp_connect
+    end
+
+    it "accepts a queue name and a Message" do
+      expect{ handler.send_message        }.to raise_exception ArgumentError
+      expect{ handler.send_message('foo') }.to raise_exception ArgumentError
+      expect{ handler.send_message(1,2,3) }.to raise_exception ArgumentError
+      expect{ handler.send_message('foo', 12) }.
+        to raise_exception Nebulous::NebulousError
+
+      expect{ handler.send_message('foo', mess) }.not_to raise_exception
+    end
+
+    it "returns the message" do
+      expect( handler.send_message('foo', mess) ).to eq mess
+    end
+
+    it "tries to publish the message" do
+      expect(client).to receive(:publish)
+      handler.send_message('foo', mess)
+    end
+
+    it "tries to reconnect if the client is not connected" do
+      handler.stomp_disconnect
+      expect(client).to receive(:publish)
+
+      handler.send_message('foo', mess)
+      expect{ handler.send_message('foo', mess) }.not_to raise_exception
+    end
+
+    it 'doesn''t freak out if Nebulous is not "on"' do
+      sh = StompHandler.new({}).stomp_connect
+      expect{ sh.send_message('foo', mess) }.not_to raise_exception
+      expect( sh.send_message('foo', mess) ).to eq nil
+    end
+
+
+  end
+  ##
+
+
+  describe "#listen" do
+
+    def run_listen(secs)
+      got = nil
+
+      handler.listen('/queue/foo') do |m|
+        got = m
+      end
+      sleep secs
+
+      got
+    end
+
+
+    before do
+      handler.stomp_connect
+    end
+
+    it "tries to reconnect if the client is not connected" do
+      handler.stomp_disconnect
+      expect(client).to receive(:publish)
+      expect{ handler.listen('foo') }.not_to raise_exception
+    end
+
+    it "yields a Message if it gets a response on the given queue" do
+      allow(client).to receive(:subscribe).and_yield(msg1)
+      gotMessage = run_listen(1)
+
+      expect(gotMessage).not_to be_nil
+      expect(gotMessage).to be_a_kind_of Nebulous::Message
+      expect( gotMessage.verb ).to eq 'Foo'
+    end
+
+    it "continues blocking after receiving a message" do
+      # If it's still blocking, it should receive a second message
+      allow(client).to receive(:subscribe).
+        and_yield(msg1).
+        and_yield(msg2)
+
+      gotMessage = run_listen(2)
+
+      expect(gotMessage).not_to be_nil
+      expect(gotMessage).to be_a_kind_of Nebulous::Message
+      expect( gotMessage.verb ).to eq 'Bar'
+    end
+
+    it 'doesn''t freak out if Nebulous is not "on"' do
+      sh = StompHandler.new({}).stomp_connect
+      expect{ sh.listen('/queue/x') }.not_to raise_exception
+      expect{|y| sh.listen('/queue/x', &y) }.not_to yield_control
+    end
+
+
+  end
+  ##
+
+
+  describe "listen_with_timeout" do
+
+    def run_listen_with_timeout(secs)
+      got = nil
+      handler.listen_with_timeout('/queue/foo', secs) do |m|
+        got = m
+      end
+
+      got
+    end
+
+    before do
+      handler.stomp_connect
+    end
+
+    it "tries to reconnect if the client is not connected" do
+      handler.stomp_disconnect
+
+      expect(client).to receive(:publish)
+      expect{ handler.listen_with_timeout('foo', 1) }.
+        to raise_exception NebulousTimeout #as opposed to something nastier
+
+    end
+
+    it "yields a Message if it gets a response on the given queue" do
+      allow(client).to receive(:subscribe).and_yield(msg1)
+
+      start = Time.now
+      gotMessage = run_listen_with_timeout(2)
+      stop = Time.now
+
+      expect( gotMessage ).not_to be_nil
+      expect( gotMessage ).to be_a_kind_of Nebulous::Message
+      expect( gotMessage.verb ).to eq 'Foo'
+      expect(stop - start).to be < 0.5
+    end
+
+    it "stops after the first message" do
+      # The opposite of listen. We yield twice but expect the *first* message.
+      allow(client).to receive(:subscribe).
+        and_yield(msg1).
+        and_yield(msg2)
+
+      gotMessage = run_listen_with_timeout(2)
+
+      expect( gotMessage ).not_to be_nil
+      expect( gotMessage ).to be_a_kind_of Nebulous::Message
+      expect( gotMessage.verb ).to eq 'Foo'
+    end
+
+    it "stops after a timeout" do
+      start = Time.now
+      run_listen_with_timeout(2) rescue nil #probably raises NebulousTimeout
+      stop = Time.now
+
+      expect(stop - start).to be_within(0.5).of(2)
+    end
+
+    it "raises NebulousTimeout after a timeout" do
+      expect{ run_listen_with_timeout(1) }.to raise_exception NebulousTimeout
+    end
+
+    it 'doesn''t freak out if Nebulous is not "on"'do
+      sh = StompHandler.new({}).stomp_connect
+      expect{ sh.listen_with_timeout('/queue/x', 1) }.not_to raise_exception
+      expect{|y| sh.listen_with_timeout('/queue/x', 1, &y) }.
+        not_to yield_control
+
+    end
+
+
+  end
+  ##
+
+
+end 
+

data/tags

@@ -0,0 +1,134 @@
+!_TAG_FILE_FORMAT	2	/extended format; --format=1 will not append ;" to lines/
+!_TAG_FILE_SORTED	1	/0=unsorted, 1=sorted, 2=foldcase/
+ConnectionError	lib/nebulous.rb	/^  class ConnectionError < NebulousError; end$/;"	c	class:Nebulous	inherits:NebulousError
+DocNoPending	spec/doc_no_pending.rb	/^class DocNoPending < RSpec::Core::Formatters::DocumentationFormatter$/;"	c	inherits:RSpec.Core.Formatters.DocumentationFormatter
+Helpers	spec/helpers.rb	/^module Helpers$/;"	m
+Message	lib/nebulous/message.rb	/^  class Message$/;"	c	class:Nebulous
+NebRequest	lib/nebulous/nebrequest.rb	/^  class NebRequest$/;"	c	class:Nebulous
+NebRequestNull	lib/nebulous/nebrequest_null.rb	/^  class NebRequestNull < NebRequest$/;"	c	class:Nebulous	inherits:NebRequest
+Nebulous	lib/nebulous.rb	/^module Nebulous$/;"	m
+Nebulous	lib/nebulous/message.rb	/^module Nebulous$/;"	m
+Nebulous	lib/nebulous/nebrequest.rb	/^module Nebulous$/;"	m
+Nebulous	lib/nebulous/nebrequest_null.rb	/^module Nebulous$/;"	m
+Nebulous	lib/nebulous/param.rb	/^module Nebulous$/;"	m
+Nebulous	lib/nebulous/redis_handler.rb	/^module Nebulous$/;"	m
+Nebulous	lib/nebulous/redis_handler_null.rb	/^module Nebulous$/;"	m
+Nebulous	lib/nebulous/stomp_handler.rb	/^module Nebulous$/;"	m
+Nebulous	lib/nebulous/stomp_handler_null.rb	/^module Nebulous$/;"	m
+Nebulous	lib/nebulous/version.rb	/^module Nebulous$/;"	m
+NebulousError	lib/nebulous.rb	/^  class NebulousError < StandardError; end$/;"	c	class:Nebulous	inherits:StandardError
+NebulousTimeout	lib/nebulous.rb	/^  class NebulousTimeout < StandardError; end$/;"	c	class:Nebulous	inherits:StandardError
+Param	lib/nebulous/param.rb	/^  module Param$/;"	m	class:Nebulous
+ParamDefaults	lib/nebulous/param.rb	/^    ParamDefaults = { stompConnectHash: {},$/;"	C	class:Nebulous.Param
+RedisHandler	lib/nebulous/redis_handler.rb	/^  class RedisHandler$/;"	c	class:Nebulous
+RedisHandlerNull	lib/nebulous/redis_handler_null.rb	/^  class RedisHandlerNull < RedisHandler$/;"	c	class:Nebulous	inherits:RedisHandler
+StompHandler	lib/nebulous/stomp_handler.rb	/^  class StompHandler$/;"	c	class:Nebulous
+StompHandlerNull	lib/nebulous/stomp_handler_null.rb	/^  class StompHandlerNull < StompHandler$/;"	c	class:Nebulous	inherits:StompHandler
+TargetDefaults	lib/nebulous/param.rb	/^    TargetDefaults = { sendQueue:      nil,$/;"	C	class:Nebulous.Param
+VERSION	lib/nebulous/version.rb	/^  VERSION = "1.1.5"$/;"	C	class:Nebulous
+add_target	lib/nebulous.rb	/^  def self.add_target(name, targetHash) # -> nil$/;"	F	class:Nebulous
+add_target	lib/nebulous/param.rb	/^    def add_target(n, t)$/;"	f	class:Nebulous.Param
+body_for_stomp	lib/nebulous/message.rb	/^    def body_for_stomp$/;"	f	class:Nebulous.Message
+body_to_h	lib/nebulous/message.rb	/^    def body_to_h$/;"	f	class:Nebulous.Message
+body_to_hash	lib/nebulous/stomp_handler.rb	/^      def body_to_hash(headers, body, contentType=nil)$/;"	F	class:Nebulous.StompHandler
+cTimeout	lib/nebulous/nebrequest.rb	/^    attr_reader :cTimeout$/;"	f	class:Nebulous.NebRequest
+calc_reply_id	lib/nebulous/stomp_handler.rb	/^    def calc_reply_id$/;"	f	class:Nebulous.StompHandler
+calc_reply_id	lib/nebulous/stomp_handler_null.rb	/^    def calc_reply_id; 'ABCD123456789'; end$/;"	f	class:Nebulous.StompHandlerNull
+clear_cache	lib/nebulous/nebrequest.rb	/^    def clear_cache$/;"	f	class:Nebulous.NebRequest
+client	lib/nebulous/stomp_handler.rb	/^    attr_reader :client$/;"	f	class:Nebulous.StompHandler
+connect	lib/nebulous/redis_handler.rb	/^    def connect$/;"	f	class:Nebulous.RedisHandler
+connect	lib/nebulous/redis_handler_null.rb	/^    def connect$/;"	f	class:Nebulous.RedisHandlerNull
+connected?	lib/nebulous/redis_handler.rb	/^    def connected?$/;"	f	class:Nebulous.RedisHandler
+connected?	lib/nebulous/redis_handler_null.rb	/^    def connected?$/;"	f	class:Nebulous.RedisHandlerNull
+connected?	lib/nebulous/stomp_handler.rb	/^    def connected?$/;"	f	class:Nebulous.StompHandler
+connected?	lib/nebulous/stomp_handler_null.rb	/^    def connected? $/;"	f	class:Nebulous.StompHandlerNull
+content_is_json?	lib/nebulous/message.rb	/^    def content_is_json?$/;"	f	class:Nebulous.Message
+content_type	lib/nebulous/message.rb	/^    attr_reader :content_type$/;"	f	class:Nebulous.Message
+del	lib/nebulous/redis_handler_null.rb	/^    def del(key); @fake_pair = {}; end$/;"	f	class:Nebulous.RedisHandlerNull
+desc	lib/nebulous/message.rb	/^    attr_reader :verb, :params, :desc$/;"	f	class:Nebulous.Message
+desc	lib/nebulous/nebrequest.rb	/^    attr_reader :desc$/;"	f	class:Nebulous.NebRequest
+description	lib/nebulous/message.rb	/^    alias :description :desc$/;"	a	class:Nebulous.Message
+example_pending	spec/doc_no_pending.rb	/^  def example_pending(notifications); end$/;"	f	class:DocNoPending
+fake_mess	lib/nebulous/stomp_handler_null.rb	/^    attr_reader :fake_mess$/;"	f	class:Nebulous.StompHandlerNull
+fake_pair	lib/nebulous/redis_handler_null.rb	/^    attr_reader :fake_pair$/;"	f	class:Nebulous.RedisHandlerNull
+fill_from_message	lib/nebulous/message.rb	/^    def fill_from_message$/;"	f	class:Nebulous.Message
+from_cache	lib/nebulous/message.rb	/^      def from_cache(json)$/;"	F	class:Nebulous.Message
+from_parts	lib/nebulous/message.rb	/^      def from_parts(replyTo, inReplyTo, verb, params, desc)$/;"	F	class:Nebulous.Message
+from_stomp	lib/nebulous/message.rb	/^      def from_stomp(stompMsg)$/;"	F	class:Nebulous.Message
+get	lib/nebulous/param.rb	/^    def get(p)$/;"	f	class:Nebulous.Param
+get	lib/nebulous/redis_handler_null.rb	/^    def get(key); @fake_pair.values.first; end$/;"	f	class:Nebulous.RedisHandlerNull
+get_all	lib/nebulous/param.rb	/^    def get_all()$/;"	f	class:Nebulous.Param
+get_logger	lib/nebulous/param.rb	/^    def get_logger; @logger; end$/;"	f	class:Nebulous.Param
+get_target	lib/nebulous/param.rb	/^    def get_target(name)$/;"	f	class:Nebulous.Param
+headers_for_stomp	lib/nebulous/message.rb	/^    def headers_for_stomp$/;"	f	class:Nebulous.Message
+in_reply_to	lib/nebulous/message.rb	/^      def in_reply_to(msg, verb, params=nil, desc=nil, replyTo=nil)$/;"	F	class:Nebulous.Message
+in_reply_to	lib/nebulous/message.rb	/^    attr_reader :reply_to, :in_reply_to $/;"	f	class:Nebulous.Message
+init	lib/nebulous.rb	/^  def self.init(paramHash={}) $/;"	F	class:Nebulous
+initialize	lib/nebulous/message.rb	/^    def initialize(hash)$/;"	f	class:Nebulous.Message
+initialize	lib/nebulous/nebrequest.rb	/^    def initialize( target, $/;"	f	class:Nebulous.NebRequest
+initialize	lib/nebulous/nebrequest_null.rb	/^    def initialize( target, verb, params=nil, desc=nil )$/;"	f	class:Nebulous.NebRequestNull
+initialize	lib/nebulous/redis_handler.rb	/^    def initialize(connectHash, testRedis=nil)$/;"	f	class:Nebulous.RedisHandler
+initialize	lib/nebulous/redis_handler_null.rb	/^    def initialize(connectHash={})$/;"	f	class:Nebulous.RedisHandlerNull
+initialize	lib/nebulous/stomp_handler.rb	/^    def initialize(connectHash, testClient=nil)$/;"	f	class:Nebulous.StompHandler
+initialize	lib/nebulous/stomp_handler_null.rb	/^    def initialize(hash={})$/;"	f	class:Nebulous.StompHandlerNull
+insert_fake	lib/nebulous/redis_handler_null.rb	/^    def insert_fake(key, value)$/;"	f	class:Nebulous.RedisHandlerNull
+insert_fake	lib/nebulous/stomp_handler_null.rb	/^    def insert_fake(message)$/;"	f	class:Nebulous.StompHandlerNull
+insert_fake_redis	lib/nebulous/nebrequest_null.rb	/^    def insert_fake_redis(key, value)$/;"	f	class:Nebulous.NebRequestNull
+insert_fake_stomp	lib/nebulous/nebrequest_null.rb	/^    def insert_fake_stomp(message)$/;"	f	class:Nebulous.NebRequestNull
+listen	lib/nebulous/stomp_handler.rb	/^    def listen(queue)$/;"	f	class:Nebulous.StompHandler
+listen	lib/nebulous/stomp_handler_null.rb	/^    def listen(queue)$/;"	f	class:Nebulous.StompHandlerNull
+listen_with_timeout	lib/nebulous/stomp_handler.rb	/^    def listen_with_timeout(queue, timeout)$/;"	f	class:Nebulous.StompHandler
+listen_with_timeout	lib/nebulous/stomp_handler_null.rb	/^    def listen_with_timeout(queue, timeout)$/;"	f	class:Nebulous.StompHandlerNull
+logger	lib/nebulous.rb	/^  def self.logger$/;"	F	class:Nebulous
+mTimeout	lib/nebulous/nebrequest.rb	/^    attr_reader :mTimeout$/;"	f	class:Nebulous.NebRequest
+message	lib/nebulous/nebrequest.rb	/^    attr_reader :message$/;"	f	class:Nebulous.NebRequest
+method_missing	lib/nebulous/redis_handler.rb	/^    def method_missing(meth, *args)$/;"	f	class:Nebulous.RedisHandler
+neb_connect	lib/nebulous/nebrequest.rb	/^    def neb_connect$/;"	f	class:Nebulous.NebRequest
+neb_qna	lib/nebulous/nebrequest.rb	/^    def neb_qna(mTimeout)$/;"	f	class:Nebulous.NebRequest
+nebulous_on?	lib/nebulous/nebrequest.rb	/^    def nebulous_on?$/;"	f	class:Nebulous.NebRequest
+nebulous_on?	lib/nebulous/stomp_handler.rb	/^    def nebulous_on?$/;"	f	class:Nebulous.StompHandler
+on?	lib/nebulous.rb	/^  def self.on?$/;"	F	class:Nebulous
+parameters	lib/nebulous/message.rb	/^    alias :parameters  :params$/;"	a	class:Nebulous.Message
+params	lib/nebulous/message.rb	/^    attr_reader :verb, :params, :desc$/;"	f	class:Nebulous.Message
+params	lib/nebulous/nebrequest.rb	/^    attr_reader :params    $/;"	f	class:Nebulous.NebRequest
+protocol_hash	lib/nebulous/message.rb	/^    def protocol_hash$/;"	f	class:Nebulous.Message
+protocol_json	lib/nebulous/message.rb	/^    def protocol_json$/;"	f	class:Nebulous.Message
+quit	lib/nebulous/redis_handler.rb	/^    def quit$/;"	f	class:Nebulous.RedisHandler
+quit	lib/nebulous/redis_handler_null.rb	/^    def quit$/;"	f	class:Nebulous.RedisHandlerNull
+redis	lib/nebulous/redis_handler.rb	/^    attr_reader :redis$/;"	f	class:Nebulous.RedisHandler
+redis_on?	lib/nebulous.rb	/^  def self.redis_on?$/;"	F	class:Nebulous
+redis_on?	lib/nebulous/nebrequest.rb	/^    def redis_on?$/;"	f	class:Nebulous.NebRequest
+redis_on?	lib/nebulous/redis_handler.rb	/^    def redis_on?$/;"	f	class:Nebulous.RedisHandler
+replyID	lib/nebulous/nebrequest.rb	/^    attr_reader :replyID$/;"	f	class:Nebulous.NebRequest
+reply_id	lib/nebulous/message.rb	/^    attr_accessor :reply_id$/;"	f	class:Nebulous.Message
+reply_id=	lib/nebulous/message.rb	/^    attr_accessor :reply_id$/;"	f	class:Nebulous.Message
+reply_to	lib/nebulous/message.rb	/^    attr_reader :reply_to, :in_reply_to $/;"	f	class:Nebulous.Message
+requestQ	lib/nebulous/nebrequest.rb	/^    attr_reader :requestQ$/;"	f	class:Nebulous.NebRequest
+reset	lib/nebulous/param.rb	/^    def reset$/;"	f	class:Nebulous.Param
+respond_error	lib/nebulous/message.rb	/^    def respond_error(err,fields=[])$/;"	f	class:Nebulous.Message
+respond_error	lib/nebulous/stomp_handler_null.rb	/^    def respond_error(nebMess,err,fields=[])$/;"	f	class:Nebulous.StompHandlerNull
+respond_success	lib/nebulous/message.rb	/^    def respond_success$/;"	f	class:Nebulous.Message
+respond_success	lib/nebulous/stomp_handler_null.rb	/^    def respond_success(nebMess)$/;"	f	class:Nebulous.StompHandlerNull
+responseQ	lib/nebulous/nebrequest.rb	/^    attr_reader :responseQ$/;"	f	class:Nebulous.NebRequest
+send	lib/nebulous/nebrequest.rb	/^    def send(mTimeout=@mTimeout, cTimeout=@cTimeout)$/;"	f	class:Nebulous.NebRequest
+send_message	lib/nebulous/stomp_handler.rb	/^    def send_message(queue, mess)$/;"	f	class:Nebulous.StompHandler
+send_message	lib/nebulous/stomp_handler_null.rb	/^    def send_message(queue, nebMess)$/;"	f	class:Nebulous.StompHandlerNull
+send_no_cache	lib/nebulous/nebrequest.rb	/^    def send_no_cache(mTimeout=@mTimeout)$/;"	f	class:Nebulous.NebRequest
+set	lib/nebulous/param.rb	/^    def set(p={})$/;"	f	class:Nebulous.Param
+set	lib/nebulous/redis_handler_null.rb	/^    def set(key, value, hash=nil); insert_fake(key, value); end$/;"	f	class:Nebulous.RedisHandlerNull
+set_logger	lib/nebulous.rb	/^  def self.set_logger(logger)$/;"	F	class:Nebulous
+set_logger	lib/nebulous/param.rb	/^    def set_logger(lg)$/;"	f	class:Nebulous.Param
+stomp_body	lib/nebulous/message.rb	/^    attr_reader :stomp_headers, :stomp_body$/;"	f	class:Nebulous.Message
+stomp_connect	lib/nebulous/stomp_handler.rb	/^    def stomp_connect$/;"	f	class:Nebulous.StompHandler
+stomp_connect	lib/nebulous/stomp_handler_null.rb	/^    def stomp_connect$/;"	f	class:Nebulous.StompHandlerNull
+stomp_disconnect	lib/nebulous/stomp_handler.rb	/^    def stomp_disconnect$/;"	f	class:Nebulous.StompHandler
+stomp_disconnect	lib/nebulous/stomp_handler_null.rb	/^    def stomp_disconnect$/;"	f	class:Nebulous.StompHandlerNull
+stomp_headers	lib/nebulous/message.rb	/^    attr_reader :stomp_headers, :stomp_body$/;"	f	class:Nebulous.Message
+stomp_message	spec/helpers.rb	/^  def stomp_message(contentType, body, inReplyTo=nil)$/;"	f	class:Helpers
+target	lib/nebulous/nebrequest.rb	/^    attr_reader :target$/;"	f	class:Nebulous.NebRequest
+to_cache	lib/nebulous/message.rb	/^    def to_cache$/;"	f	class:Nebulous.Message
+to_s	lib/nebulous/message.rb	/^    def to_s$/;"	f	class:Nebulous.Message
+validate	lib/nebulous/param.rb	/^    def validate(exemplar, hash, message)$/;"	f	class:Nebulous.Param
+verb	lib/nebulous/message.rb	/^    attr_reader :verb, :params, :desc$/;"	f	class:Nebulous.Message
+verb	lib/nebulous/nebrequest.rb	/^    attr_reader :verb      $/;"	f	class:Nebulous.NebRequest
+with_timeout	lib/nebulous/stomp_handler.rb	/^      def with_timeout(secs)$/;"	F	class:Nebulous.StompHandler