torquebox-messaging 2.1.2-java → 2.2.0-java

data/lib/gem_hook.rb

@@ -28,7 +28,7 @@ require 'torquebox/messaging/session'
 
 require 'torquebox/messaging/message'
 require 'torquebox/messaging/json_message'
-require 'torquebox/messaging/clojure_message'
+require 'torquebox/messaging/edn_message'
 require 'torquebox/messaging/text_message'
 require 'torquebox/messaging/marshal_base64_message'
 require 'torquebox/messaging/marshal_message'

data/lib/torquebox-messaging.rb

@@ -1,14 +1,14 @@
 module TorqueboxMessaging
-  VERSION = '2.1.2'
-  MAVEN_VERSION = '2.1.2'
+  VERSION = '2.2.0'
+  MAVEN_VERSION = '2.2.0'
 end
 begin
   require 'java'
   require File.dirname(__FILE__) + '/torquebox-messaging.jar'
   require File.dirname(__FILE__) + '/jboss-jms-api_1.1_spec-1.0.1.Final.jar'
   require File.dirname(__FILE__) + '/jboss-transaction-api_1.1_spec-1.0.1.Final.jar'
-  require File.dirname(__FILE__) + '/hornetq-core-2.2.18.Final.jar'
-  require File.dirname(__FILE__) + '/hornetq-jms-2.2.18.Final.jar'
+  require File.dirname(__FILE__) + '/hornetq-core-2.2.21.Final.jar'
+  require File.dirname(__FILE__) + '/hornetq-jms-2.2.21.Final.jar'
   require File.dirname(__FILE__) + '/netty-3.2.6.Final.jar'
 rescue LoadError
   puts 'JAR-based gems require JRuby to load. Please visit www.jruby.org.'

data/lib/torquebox/messaging/backgroundable.rb

@@ -20,6 +20,7 @@ require 'torquebox/messaging/future'
 require 'torquebox/messaging/task'
 require 'torquebox/messaging/future_status'
 require 'torquebox/injectors'
+require 'torquebox/logger'
 
 module TorqueBox
   module Messaging
@@ -64,22 +65,31 @@ module TorqueBox
             if !@__backgroundable_methods[method]
               @__backgroundable_methods[method] ||= { }
               @__backgroundable_methods[method][:options] = options
-              if Util.instance_methods_include?(self, method) ||
-                  Util.private_instance_methods_include?(self, method)
+              if Util.singleton_methods_include?(self, method) ||
+                  Util.instance_methods_include?(self, method)
                 __enable_backgrounding(method)
               end
             end
           end
         end
 
+        # Allows you to background any method that has not been marked
+        # as a backgrounded method via {ClassMethods#always_background}.
+        # @param [Hash] options that are passed through to
+        #   {TorqueBox::Messaging::Destination#publish}
+        # @return [Future]
+        def background(options = { })
+          BackgroundProxy.new(self, options)
+        end
+
         def method_added(method)
           super
-          method = method.to_s
-          if @__backgroundable_methods &&
-              @__backgroundable_methods[method] &&
-              !@__backgroundable_methods[method][:backgrounding]
-            __enable_backgrounding(method)
-          end
+          __method_added(method)
+        end
+
+        def singleton_method_added(method)
+          super
+          __method_added(method)
         end
 
         def __enable_backgroundable_newrelic_tracing(method)
@@ -102,28 +112,57 @@ module TorqueBox
         end
 
         private
+        
+        def __method_added(method)
+          method = method.to_s
+          if @__backgroundable_methods &&
+              @__backgroundable_methods[method] &&
+              !@__backgroundable_methods[method][:backgrounding]
+            __enable_backgrounding(method)
+          end
+        end
+
         def __enable_backgrounding(method)
-          privatize = Util.private_instance_methods_include?(self, method)
-          protect = Util.protected_instance_methods_include?(self, method) unless privatize
+          singleton_method = Util.singleton_methods_include?(self, method)
+          singleton = (class << self; self; end)
+
+          if singleton_method
+
+            TorqueBox::Logger.new( self ).
+              warn("always_background called for :#{method}, but :#{method} " +
+                   "exists as both a class and instance method. Only the " +
+                   "class method will be backgrounded.") if Util.instance_methods_include?(self, method)
+
+            privatize = Util.private_singleton_methods_include?(self, method)
+            protect = Util.protected_singleton_methods_include?(self, method) unless privatize
+          else
+            privatize = Util.private_instance_methods_include?(self, method)
+            protect = Util.protected_instance_methods_include?(self, method) unless privatize
+          end
+
           async_method = "__async_#{method}"
           sync_method = "__sync_#{method}"
 
           @__backgroundable_methods[method][:backgrounding] = true
           options = @__backgroundable_methods[method][:options]
-          class_eval do
 
+          (singleton_method ? singleton : self).class_eval do
             define_method async_method do |*args|
               Util.publish_message(self, sync_method, args, options)
             end
-
-            alias_method sync_method, method
-            alias_method method, async_method
-
-            if privatize || protect
-              send((privatize ? :private : :protected), method, sync_method, async_method)
-            end
-
           end
+          
+          code = singleton_method ? "class << self" : ""
+          code << %Q{
+            alias_method :#{sync_method}, :#{method}
+            alias_method :#{method}, :#{async_method}
+          }
+          code << %Q{
+            #{privatize ? "private" : "protected"} :#{method}, :#{sync_method}, :#{async_method}
+          } if privatize || protect
+          code << "end" if singleton_method
+
+          class_eval code          
         ensure
           @__backgroundable_methods[method][:backgrounding] = nil
         end
@@ -163,8 +202,22 @@ module TorqueBox
             raise RuntimeError.new("The Backgroundable queue is not available. Did you disable it by setting its concurrency to 0?")
           end
 
+          def singleton_methods_include?(klass, method)
+            methods_include?(klass.singleton_methods, method) ||
+              private_singleton_methods_include?(klass, method)
+          end
+
+          def private_singleton_methods_include?(klass, method)
+            methods_include?(klass.private_methods, method)
+          end
+
+          def protected_singleton_methods_include?(klass, method)
+            methods_include?(klass.protected_methods, method)
+          end
+
           def instance_methods_include?(klass, method)
-            methods_include?(klass.instance_methods, method)
+            methods_include?(klass.instance_methods, method) ||
+              private_instance_methods_include?(klass, method)
           end
 
           def private_instance_methods_include?(klass, method)

data/lib/torquebox/messaging/echo_processor.rb

@@ -1,7 +1,8 @@
-# A message processor that echos any messages sent to it back to
-# another queue specified by the response_queue configuration option
+# @api private
 module Torquebox
   module Messaging
+    # A message processor that echos any messages sent to it back to
+    # another queue specified by the response_queue configuration option
     class EchoProcessor < TorqueBox::Messaging::MessageProcessor
 
       def initialize(options={})

data/lib/torquebox/messaging/{clojure_message.rb → edn_message.rb}

@@ -15,23 +15,23 @@
 # Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 # 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 
-require 'clj'
+require 'edn'
 
 module TorqueBox
   module Messaging
-    class ClojureMessage < Message
-      ENCODING = :clojure
+    class EdnMessage < Message
+      ENCODING = :edn
       JMS_TYPE = :text
 
       def encode(message)
-        @jms_message.text = Clojure.dump(message)
+        @jms_message.text = message.to_edn
       end
 
       def decode
-        Clojure.parse(@jms_message.text) unless @jms_message.text.nil?
+        EDN.read(@jms_message.text) unless @jms_message.text.nil?
       end
     end
 
-    Message.register_encoding( ClojureMessage )
+    Message.register_encoding( EdnMessage )
   end
 end

data/spec/backgroundable_spec.rb

@@ -1,6 +1,7 @@
 require 'torquebox/messaging/backgroundable'
+require 'pp'
 
-class MyTestModel
+class InstanceMethodTestModel
   include TorqueBox::Messaging::Backgroundable
 
   def an_async_action(arg1, arg2)
@@ -15,45 +16,137 @@ class MyTestModel
   def redefine_me; end
 end
 
+class ClassMethodTestModel
+  include TorqueBox::Messaging::Backgroundable
+
+  def self.an_async_action(arg1, arg2)
+    a_sync_action
+  end
+  always_background :an_async_action
+
+  def self.a_sync_action;  end
+  def self.foo;  end
+  def self.bar;  end
+  def self.optioned; end
+  def self.redefine_me; end
+
+  def foo; end
+
+  class << self
+    def singleton_class
+      self
+    end
+  end
+end
+
 describe TorqueBox::Messaging::Backgroundable do
   before(:all) do
     @util = TorqueBox::Messaging::Backgroundable::Util
   end
 
   describe "always_background" do
-    it "should be able to handle mutliple methods" do
-      MyTestModel.always_background :foo, :bar
-      @util.instance_methods_include?(MyTestModel, '__async_foo').should be_true
-      @util.instance_methods_include?(MyTestModel, '__async_bar').should be_true
-    end
+    context "for instance methods" do
+      it "should be able to handle multiple methods" do
+        InstanceMethodTestModel.always_background :foo, :bar
+        @util.instance_methods_include?(InstanceMethodTestModel, '__async_foo').should be_true
+        @util.instance_methods_include?(InstanceMethodTestModel, '__async_bar').should be_true
+      end
 
-    it "should handle methods that are defined after the always_background call" do
-      MyTestModel.always_background :baz
-      @util.instance_methods_include?(MyTestModel, '__async_baz').should_not be_true
-      MyTestModel.class_eval('def baz;end')
-      @util.instance_methods_include?(MyTestModel, '__async_baz').should be_true
-    end
+      it "should handle methods that are defined after the always_background call" do
+        InstanceMethodTestModel.always_background :baz
+        @util.instance_methods_include?(InstanceMethodTestModel, '__async_baz').should_not be_true
+        InstanceMethodTestModel.class_eval('def baz;end')
+        @util.instance_methods_include?(InstanceMethodTestModel, '__async_baz').should be_true
+      end
 
-    it "should handle methods that are redefined after the always_background call" do
-      MyTestModel.always_background :redefine_me
-      MyTestModel.class_eval('def redefine_me; :xyz; end')
-      MyTestModel.new.__sync_redefine_me.should == :xyz
-    end
-    
-    it "should work for private methods, maintaining visibility" do
-      MyTestModel.class_eval('private; def no_peeking;end')
-      MyTestModel.always_background :no_peeking
-      @util.private_instance_methods_include?(MyTestModel, 'no_peeking').should be_true
-      @util.private_instance_methods_include?(MyTestModel, '__async_no_peeking').should be_true
-      @util.private_instance_methods_include?(MyTestModel, '__sync_no_peeking').should be_true
+      it "should handle methods that are redefined after the always_background call" do
+        InstanceMethodTestModel.always_background :redefine_me
+        InstanceMethodTestModel.class_eval('def redefine_me; :xyz; end')
+        InstanceMethodTestModel.new.__sync_redefine_me.should == :xyz
+      end
+
+      it "should work for private methods, maintaining visibility" do
+        InstanceMethodTestModel.class_eval('private; def no_peeking;end')
+        InstanceMethodTestModel.always_background :no_peeking
+        @util.private_instance_methods_include?(InstanceMethodTestModel, 'no_peeking').should be_true
+        @util.private_instance_methods_include?(InstanceMethodTestModel, '__async_no_peeking').should be_true
+        @util.private_instance_methods_include?(InstanceMethodTestModel, '__sync_no_peeking').should be_true
+      end
+
+      it "should work for protected methods, maintaining visibility" do
+        InstanceMethodTestModel.class_eval('protected; def some_peeking;end')
+        InstanceMethodTestModel.always_background :some_peeking
+        @util.protected_instance_methods_include?(InstanceMethodTestModel, 'some_peeking').should be_true
+        @util.protected_instance_methods_include?(InstanceMethodTestModel, '__async_some_peeking').should be_true
+        @util.protected_instance_methods_include?(InstanceMethodTestModel, '__sync_some_peeking').should be_true
+      end
     end
 
-    it "should work for protected methods, maintaining visibility" do
-      MyTestModel.class_eval('protected; def some_peeking;end')
-      MyTestModel.always_background :some_peeking
-      @util.protected_instance_methods_include?(MyTestModel, 'some_peeking').should be_true
-      @util.protected_instance_methods_include?(MyTestModel, '__async_some_peeking').should be_true
-      @util.protected_instance_methods_include?(MyTestModel, '__sync_some_peeking').should be_true
+    context "for class methods" do
+      it "should work when called after the method is defined" do
+        @util.singleton_methods_include?(ClassMethodTestModel, '__async_an_async_action').should be_true
+      end
+
+      it "should be able to handle multiple methods" do
+        ClassMethodTestModel.always_background :foo, :bar
+        @util.singleton_methods_include?(ClassMethodTestModel, '__async_foo').should be_true
+        @util.singleton_methods_include?(ClassMethodTestModel, '__async_bar').should be_true
+      end
+
+      it "class methods should win a tie" do
+        ClassMethodTestModel.always_background :foo
+        @util.singleton_methods_include?(ClassMethodTestModel, '__async_foo').should be_true
+        @util.instance_methods_include?(ClassMethodTestModel, '__async_foo').should_not be_true
+      end
+
+      it "should handle methods that are defined after the always_background call" do
+        ClassMethodTestModel.always_background :baz
+        @util.singleton_methods_include?(ClassMethodTestModel, '__async_baz').should_not be_true
+        ClassMethodTestModel.class_eval('def self.baz;end')
+        @util.singleton_methods_include?(ClassMethodTestModel, '__async_baz').should be_true
+      end
+
+      it "should handle methods that are redefined after the always_background call" do
+        ClassMethodTestModel.always_background :redefine_me
+        ClassMethodTestModel.class_eval('def self.redefine_me; :xyz; end')
+        ClassMethodTestModel.__sync_redefine_me.should == :xyz
+      end
+
+      it "should work for private methods, maintaining visibility" do
+        ClassMethodTestModel.class_eval do
+          class << self
+            private
+            def no_peeking;end
+          end
+        end
+
+        ClassMethodTestModel.always_background :no_peeking
+
+        @util.private_singleton_methods_include?(ClassMethodTestModel,
+                                                 'no_peeking').should be_true
+        @util.private_singleton_methods_include?(ClassMethodTestModel,
+                                                 '__async_no_peeking').should be_true
+        @util.private_singleton_methods_include?(ClassMethodTestModel,
+                                                 '__sync_no_peeking').should be_true
+      end
+
+      it "should work for protected methods, maintaining visibility" do
+        ClassMethodTestModel.class_eval do
+          class << self
+            protected
+            def some_peeking;end
+          end
+        end
+
+        ClassMethodTestModel.always_background :some_peeking
+
+        @util.protected_singleton_methods_include?(ClassMethodTestModel,
+                                                   'some_peeking').should be_true
+        @util.protected_singleton_methods_include?(ClassMethodTestModel,
+                                                   '__async_some_peeking').should be_true
+        @util.protected_singleton_methods_include?(ClassMethodTestModel,
+                                                   '__sync_some_peeking').should be_true
+      end
     end
 
   end
@@ -68,16 +161,16 @@ describe TorqueBox::Messaging::Backgroundable do
 
     it "should put a message on the queue" do
       @queue.should_receive(:publish)
-      MyTestModel.new.an_async_action(nil, nil)
+      InstanceMethodTestModel.new.an_async_action(nil, nil)
     end
 
     it "should return a future" do
-      result = MyTestModel.new.an_async_action(nil, nil)
+      result = InstanceMethodTestModel.new.an_async_action(nil, nil)
       result.is_a?(TorqueBox::Messaging::Future).should be_true
     end
-    
+
     it "should include the proper options in the message" do
-      object = MyTestModel.new
+      object = InstanceMethodTestModel.new
       @queue.should_receive(:publish).with({
                                              :receiver => object,
                                              :future_id => '1234',
@@ -86,70 +179,120 @@ describe TorqueBox::Messaging::Backgroundable do
                                              :args => [:a, :b]
                                            },
                                            anything)
-      object.an_async_action(:a, :b) 
+      object.an_async_action(:a, :b)
     end
-    
+
     it "should not call the action immediately" do
-      object = MyTestModel.new
+      object = InstanceMethodTestModel.new
       object.should_not_receive(:a_sync_action)
       object.an_async_action(nil, nil)
     end
 
     it "should pass through the options" do
-      MyTestModel.always_background :optioned, :priority => :low
+      InstanceMethodTestModel.always_background :optioned, :priority => :low
       @queue.should_receive(:publish).with(anything, hash_including(:priority => :low))
-      MyTestModel.new.optioned
+      InstanceMethodTestModel.new.optioned
     end
 
   end
 
   describe 'background' do
-    before(:each) do
-      @queue = mock('queue')
-      @queue.stub(:publish)
-      TorqueBox::Messaging::Queue.stub(:new).and_return(@queue)
-      @object = MyTestModel.new
-    end
+    context "for instance methods" do
+      before(:each) do
+        @queue = mock('queue')
+        @queue.stub(:publish)
+        TorqueBox::Messaging::Queue.stub(:new).and_return(@queue)
+        @object = InstanceMethodTestModel.new
+      end
 
-    it "should queue any method called on it" do
-      @queue.should_receive(:publish).with(hash_including(:method => :foo),
-                                           anything)
-      @object.background.foo 
-    end
+      it "should queue any method called on it" do
+        @queue.should_receive(:publish).with(hash_including(:method => :foo),
+                                             anything)
+        @object.background.foo
+      end
 
-    it "should queue the receiver" do
-      @queue.should_receive(:publish).with(hash_including(:receiver => @object), anything)
-      @object.background.foo 
-    end
+      it "should queue the receiver" do
+        @queue.should_receive(:publish).with(hash_including(:receiver => @object), anything)
+        @object.background.foo
+      end
 
-    it "should queue the args" do
-      @queue.should_receive(:publish).with(hash_including(:args => [1,2]), anything)
-      @object.background.foo(1,2) 
-    end
+      it "should queue the args" do
+        @queue.should_receive(:publish).with(hash_including(:args => [1,2]), anything)
+        @object.background.foo(1,2)
+      end
 
-    it "should raise when given a block" do
-      lambda { 
-        @object.background.foo { }
-      }.should raise_error(ArgumentError)
-    end
+      it "should raise when given a block" do
+        lambda {
+          @object.background.foo { }
+        }.should raise_error(ArgumentError)
+      end
 
-    it "should handle missing methods" do
-      @object.should_receive(:method_missing)
-      @object.background.no_method
-    end
+      it "should handle missing methods" do
+        @object.should_receive(:method_missing)
+        @object.background.no_method
+      end
 
-    it "should pass through any options" do
-      @queue.should_receive(:publish).with(anything,
-                                           hash_including(:ttl => 1))
-      @object.background(:ttl => 1).foo
-    end
+      it "should pass through any options" do
+        @queue.should_receive(:publish).with(anything,
+                                             hash_including(:ttl => 1))
+        @object.background(:ttl => 1).foo
+      end
+
+      it "should always use the :marshal encoding" do
+        @queue.should_receive(:publish).with(anything,
+                                             hash_including(:encoding => :marshal))
+        @object.background.foo
+      end
 
-    it "should always use the :marshal encoding" do
-      @queue.should_receive(:publish).with(anything,
-                                           hash_including(:encoding => :marshal))
-      @object.background.foo
     end
 
+    context "for class methods" do
+      before(:each) do
+        @queue = mock('queue')
+        @queue.stub(:publish)
+        TorqueBox::Messaging::Queue.stub(:new).and_return(@queue)
+        @object = ClassMethodTestModel
+      end
+
+      it "should queue any method called on it" do
+        @queue.should_receive(:publish).with(hash_including(:method => :foo),
+                                             anything)
+        @object.background.foo
+      end
+
+      it "should queue the receiver" do
+        @queue.should_receive(:publish).with(hash_including(:receiver => @object), anything)
+        @object.background.foo
+      end
+
+      it "should queue the args" do
+        @queue.should_receive(:publish).with(hash_including(:args => [1,2]), anything)
+        @object.background.foo(1,2)
+      end
+
+      it "should raise when given a block" do
+        lambda {
+          @object.background.foo { }
+        }.should raise_error(ArgumentError)
+      end
+
+      it "should handle missing methods" do
+        @object.should_receive(:method_missing)
+        @object.background.no_method
+      end
+
+      it "should pass through any options" do
+        @queue.should_receive(:publish).with(anything,
+                                             hash_including(:ttl => 1))
+        @object.background(:ttl => 1).foo
+      end
+
+      it "should always use the :marshal encoding" do
+        @queue.should_receive(:publish).with(anything,
+                                             hash_including(:encoding => :marshal))
+        @object.background.foo
+      end
+    end
   end
-  
+
 end

metadata

@@ -1,170 +1,191 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: torquebox-messaging
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 2.1.2
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: 2.2.0
 platform: java
-authors: 
-  - The TorqueBox Team
-autorequire: 
+authors:
+- The TorqueBox Team
+autorequire:
 bindir: bin
 cert_chain: []
-
-date: 2012-09-24 00:00:00 Z
-dependencies: 
-  - !ruby/object:Gem::Dependency 
-    name: torquebox-core
-    prerelease: false
-    requirement: &id001 !ruby/object:Gem::Requirement 
-      none: false
-      requirements: 
-        - - "="
-          - !ruby/object:Gem::Version 
-            version: 2.1.2
-    type: :runtime
-    version_requirements: *id001
-  - !ruby/object:Gem::Dependency 
-    name: torquebox-transactions
-    prerelease: false
-    requirement: &id002 !ruby/object:Gem::Requirement 
-      none: false
-      requirements: 
-        - - "="
-          - !ruby/object:Gem::Version 
-            version: 2.1.2
-    type: :runtime
-    version_requirements: *id002
-  - !ruby/object:Gem::Dependency 
-    name: clj
-    prerelease: false
-    requirement: &id003 !ruby/object:Gem::Requirement 
-      none: false
-      requirements: 
-        - - "="
-          - !ruby/object:Gem::Version 
-            version: 0.0.5.6
-    type: :runtime
-    version_requirements: *id003
-  - !ruby/object:Gem::Dependency 
-    name: rspec
-    prerelease: false
-    requirement: &id004 !ruby/object:Gem::Requirement 
-      none: false
-      requirements: 
-        - - "="
-          - !ruby/object:Gem::Version 
-            version: 2.7.0
-    type: :development
-    version_requirements: *id004
-  - !ruby/object:Gem::Dependency 
-    name: newrelic_rpm
-    prerelease: false
-    requirement: &id005 !ruby/object:Gem::Requirement 
-      none: false
-      requirements: 
-        - - "="
-          - !ruby/object:Gem::Version 
-            version: 3.3.2
-    type: :development
-    version_requirements: *id005
-description: ""
-email: 
-  - torquebox-dev@torquebox.org
+date: 2012-12-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: torquebox-core
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+    none: false
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: torquebox-transactions
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+    none: false
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: edn
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+    none: false
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.7.0
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.7.0
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: newrelic_rpm
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.3.2
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.3.2
+    none: false
+  prerelease: false
+  type: :development
+description: ''
+email:
+- torquebox-dev@torquebox.org
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-  - licenses/lgpl-2.1.txt
-  - lib/torquebox-messaging.jar
-  - lib/torquebox-messaging.rb
-  - lib/jboss-jms-api_1.1_spec-1.0.1.Final.jar
-  - lib/jboss-transaction-api_1.1_spec-1.0.1.Final.jar
-  - lib/hornetq-core-2.2.18.Final.jar
-  - lib/hornetq-jms-2.2.18.Final.jar
-  - lib/netty-3.2.6.Final.jar
-  - lib/org.torquebox.messaging-client.rb
-  - lib/gem_hook.rb
-  - lib/torquebox/messaging.rb
-  - lib/torquebox/messaging/clojure_message.rb
-  - lib/torquebox/messaging/message_processor.rb
-  - lib/torquebox/messaging/backgroundable.rb
-  - lib/torquebox/messaging/xa_session.rb
-  - lib/torquebox/messaging/backgroundable_processor.rb
-  - lib/torquebox/messaging/session.rb
-  - lib/torquebox/messaging/marshal_base64_message.rb
-  - lib/torquebox/messaging/const_missing.rb
-  - lib/torquebox/messaging/topic.rb
-  - lib/torquebox/messaging/connection_factory.rb
-  - lib/torquebox/messaging/datamapper_marshaling.rb
-  - lib/torquebox/messaging/future_status.rb
-  - lib/torquebox/messaging/future_responder.rb
-  - lib/torquebox/messaging/marshal_message.rb
-  - lib/torquebox/messaging/message.rb
-  - lib/torquebox/messaging/xa_connection.rb
-  - lib/torquebox/messaging/echo_processor.rb
-  - lib/torquebox/messaging/connection.rb
-  - lib/torquebox/messaging/task.rb
-  - lib/torquebox/messaging/queue.rb
-  - lib/torquebox/messaging/core.rb
-  - lib/torquebox/messaging/future.rb
-  - lib/torquebox/messaging/text_message.rb
-  - lib/torquebox/messaging/xa_connection_factory.rb
-  - lib/torquebox/messaging/json_message.rb
-  - lib/torquebox/messaging/destination.rb
-  - lib/torquebox/messaging/processor_middleware/with_transaction.rb
-  - lib/torquebox/messaging/processor_middleware/default_middleware.rb
-  - lib/torquebox/messaging/processor_middleware/chain.rb
-  - lib/torquebox/messaging/ext/javax_jms_queue_browser.rb
-  - spec/message_spec.rb
-  - spec/default_middleware_spec.rb
-  - spec/task_spec.rb
-  - spec/message_processor_spec.rb
-  - spec/future_spec.rb
-  - spec/chain_spec.rb
-  - spec/future_responder_spec.rb
-  - spec/backgroundable_spec.rb
-  - spec/destination_spec.rb
-  - spec/json_message_spec.rb
-  - spec/datamapper_marshaling_spec.rb
+files:
+- licenses/lgpl-2.1.txt
+- lib/torquebox-messaging.jar
+- lib/torquebox-messaging.rb
+- lib/jboss-jms-api_1.1_spec-1.0.1.Final.jar
+- lib/jboss-transaction-api_1.1_spec-1.0.1.Final.jar
+- lib/hornetq-core-2.2.21.Final.jar
+- lib/hornetq-jms-2.2.21.Final.jar
+- lib/netty-3.2.6.Final.jar
+- lib/gem_hook.rb
+- lib/org.torquebox.messaging-client.rb
+- lib/torquebox/messaging.rb
+- lib/torquebox/messaging/session.rb
+- lib/torquebox/messaging/connection.rb
+- lib/torquebox/messaging/datamapper_marshaling.rb
+- lib/torquebox/messaging/backgroundable.rb
+- lib/torquebox/messaging/marshal_message.rb
+- lib/torquebox/messaging/echo_processor.rb
+- lib/torquebox/messaging/xa_connection_factory.rb
+- lib/torquebox/messaging/message_processor.rb
+- lib/torquebox/messaging/json_message.rb
+- lib/torquebox/messaging/xa_session.rb
+- lib/torquebox/messaging/message.rb
+- lib/torquebox/messaging/edn_message.rb
+- lib/torquebox/messaging/task.rb
+- lib/torquebox/messaging/connection_factory.rb
+- lib/torquebox/messaging/marshal_base64_message.rb
+- lib/torquebox/messaging/queue.rb
+- lib/torquebox/messaging/xa_connection.rb
+- lib/torquebox/messaging/backgroundable_processor.rb
+- lib/torquebox/messaging/future.rb
+- lib/torquebox/messaging/future_status.rb
+- lib/torquebox/messaging/text_message.rb
+- lib/torquebox/messaging/const_missing.rb
+- lib/torquebox/messaging/destination.rb
+- lib/torquebox/messaging/topic.rb
+- lib/torquebox/messaging/future_responder.rb
+- lib/torquebox/messaging/core.rb
+- lib/torquebox/messaging/ext/javax_jms_queue_browser.rb
+- lib/torquebox/messaging/processor_middleware/with_transaction.rb
+- lib/torquebox/messaging/processor_middleware/chain.rb
+- lib/torquebox/messaging/processor_middleware/default_middleware.rb
+- spec/task_spec.rb
+- spec/backgroundable_spec.rb
+- spec/future_spec.rb
+- spec/default_middleware_spec.rb
+- spec/destination_spec.rb
+- spec/message_spec.rb
+- spec/message_processor_spec.rb
+- spec/chain_spec.rb
+- spec/json_message_spec.rb
+- spec/future_responder_spec.rb
+- spec/datamapper_marshaling_spec.rb
 homepage: http://torquebox.org/
-licenses: 
-  - lgpl
-post_install_message: 
+licenses:
+- lgpl
+post_install_message:
 rdoc_options: []
-
-require_paths: 
-  - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
   none: false
-  requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
   none: false
-  requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
 requirements: []
-
-rubyforge_project: 
+rubyforge_project:
 rubygems_version: 1.8.24
-signing_key: 
+signing_key:
 specification_version: 3
 summary: TorqueBox Messaging Client
-test_files: 
-  - spec/message_spec.rb
-  - spec/default_middleware_spec.rb
-  - spec/task_spec.rb
-  - spec/message_processor_spec.rb
-  - spec/future_spec.rb
-  - spec/chain_spec.rb
-  - spec/future_responder_spec.rb
-  - spec/backgroundable_spec.rb
-  - spec/destination_spec.rb
-  - spec/json_message_spec.rb
-  - spec/datamapper_marshaling_spec.rb
+test_files:
+- spec/task_spec.rb
+- spec/backgroundable_spec.rb
+- spec/future_spec.rb
+- spec/default_middleware_spec.rb
+- spec/destination_spec.rb
+- spec/message_spec.rb
+- spec/message_processor_spec.rb
+- spec/chain_spec.rb
+- spec/json_message_spec.rb
+- spec/future_responder_spec.rb
+- spec/datamapper_marshaling_spec.rb