jruby-jms 1.1.0-java → 1.2.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 601d2d745dab0bb052eaf0516faabda7afcc4ef3
-  data.tar.gz: 66a1ea9158a02a782acb728c890c4654c48cb67c
+  metadata.gz: c58dfbbab766a5b4ad1f7f383e256294e658089f
+  data.tar.gz: 7ec282e9a6f7b9ab24fa9502be32c7a16f66a2ea
 SHA512:
-  metadata.gz: b0a7f76e0fc27018d8de20761f57be8f181a5c3aac528e657df4cfe8943db3ad0efaa5485c79a5d5d911495229090fd2088dd530091f3d81fd8dd12f03aa3eeb
-  data.tar.gz: 1970f9dabe77b456b70e1cd8ed519db44d827a6b9e245fc04e143b6f631344869bfc6d9f5db9d8bd1ccff223258e0cb195369ca32d4a6f914437eaa369a85981
+  metadata.gz: 7099c5bc513f3616e5a01073671a2e40cc33b7a697e6807cf7c4ada87d76ae61a8c0056397e5bc72bfb6aeeac5df58f448c2c9946d20fc64580884b7b6db2c77
+  data.tar.gz: bda4d42a7fa8f4f299e9120042caf7e707117fe755628edd7ad167ec4ba65a9a0c1f053be5ff4de54b8a2f3f99a8b7e4ad8dceacb6f47ea1aa11c692c3abe636

data/HISTORY.md

@@ -1,3 +1,20 @@
+## 1.2.0 (2015-08-29)
+
+* Tested against JRuby 9.0.0.0
+* Drop support for JRuby 1.5 and 1.6
+* Tested against ActiveMQ 5.11, and HornetQ 2.4
+* Raises ArgumentError instead of RuntimeError for missing arguments
+* Update tests
+* Upgrade to Minitest 5.8
+* Switch to Ruby 1.9 hash syntax
+* Reformat code
+
+## 1.1.0 (2014-04-10)
+
+* Support Oracle AQ 11gR2
+* Tibco EMS Examples
+* Add .gemspec file
+
 ## 1.0.0 (2012-10-21)
 
 * Issue #10 Support WebSphereMQ V7
@@ -18,16 +35,16 @@
 
 * Compatibility with JRuby 1.6
 * I hate doing this, but unfortunately there is a small breaking change in this release:
-** We can no longer pass symbols into the following methods:
-*** jms_delivery_mode
-*** jms_delivery_mode=
-** Just rename existing uses of the above methods to:
-*** jms_delivery_mode_sym
-*** jms_delivery_mode_sym=
+    * We can no longer pass symbols into the following methods:
+        * jms_delivery_mode
+        * jms_delivery_mode=
+    * Just rename existing uses of the above methods to:
+        * jms_delivery_mode_sym
+        * jms_delivery_mode_sym=
 * Added Session Pool - requires GenePool as a dependency if used
 * Generate warning log entry for any parameters not known to the ConnectionFactory
 * Use java_import for all javax.jms classes
-** Rename all Java source files to match new names
+    * Rename all Java source files to match new names
 
 ## 0.10.1 (2011-02-21)
 

data/README.md

@@ -2,14 +2,18 @@
 
 * http://github.com/reidmorrison/jruby-jms
 
-### Introduction
+jruby-jms is a complete JRuby API into Java Messaging Specification (JMS) V1.1.
+
+Note: jruby-jms is for JRuby only.
+
+### Design
 
 jruby-jms attempts to "rubify" the Java JMS API without
 compromising performance. It does this by sprinkling "Ruby-goodness" into the
 existing JMS Java interfaces, I.e. By adding Ruby methods to the existing
 classes and interfaces. Since jruby-jms exposes the JMS
 Java classes directly there is no performance impact that would have been
-introduced had the entire API been wrapped in a Ruby layer.
+introduced had the entire API been wrapped with an extra Ruby layer.
 
 In this way, using regular Ruby constructs a Ruby program can easily
 interact with JMS in a highly performant way. Also, in this way you are not
@@ -18,7 +22,23 @@ API is available to you at any time.
 
 ### Install
 
-    jgem install jruby-jms
+Add to Gemfile if using bundler:
+
+```ruby
+gem 'jruby-jms'
+```
+
+Install using bundler:
+
+    bundle
+
+If not using Bundler:
+
+    gem install jruby-jms
+
+### Documentation
+
+* [API Reference](http://www.rubydoc.info/gems/jruby-jms)
 
 ### Simplification
 
@@ -56,7 +76,7 @@ for passing messages between threads in the same JVM.
 
 In order to connect to any broker the Client JMS application must create a
 connection. In traditional JMS a ConnectionFactory is used to create connections.
-In jruby-jms the JMS::Connection takes care of the complexities of dealing with
+In jruby-jms the `JMS::Connection` takes care of the complexities of dealing with
 the factory class, just pass the required parameters to Connection.new and
 jruby-jms takes care of the rest.
 
@@ -79,23 +99,21 @@ Producers write messages to queues or topics
 ActiveMQ Example:
 
 ```ruby
-require 'rubygems'
 require 'jms'
 
 # Connect to ActiveMQ
 config = {
-    :factory => 'org.apache.activemq.ActiveMQConnectionFactory',
-    :broker_url => 'tcp://localhost:61616',
-    :require_jars => [
-      "~/Applications/apache-activemq-5.7.0/activemq-all-5.7.0.jar",
-      "~/Applications/apache-activemq-5.5.0/lib/optional/log4j-1.2.17.jar"
-    ]
+  :factory: org.apache.activemq.ActiveMQConnectionFactory
+  :broker_url: tcp://localhost:61616
+  :require_jars:
+    - /usr/local/Cellar/activemq/5.11.1/libexec/activemq-all-5.11.1.jar
+    - /usr/local/Cellar/activemq/5.11.1/libexec/lib/optional/log4j-1.2.17.jar
 }
 
 JMS::Connection.session(config) do |session|
-    session.producer(:queue_name => 'ExampleQueue') do |producer|
+  session.producer(queue_name: 'ExampleQueue') do |producer|
     producer.send(session.message("Hello World"))
-    end
+  end
 end
 ```
 
@@ -111,34 +129,32 @@ require 'jms'
 
 # Connect to ActiveMQ
 config = {
-    :factory => 'org.apache.activemq.ActiveMQConnectionFactory',
-    :broker_url => 'tcp://localhost:61616',
-    :require_jars => [
-      "~/Applications/apache-activemq-5.7.0/activemq-all-5.7.0.jar",
-      "~/Applications/apache-activemq-5.5.0/lib/optional/log4j-1.2.17.jar"
-    ]
+  :factory: org.apache.activemq.ActiveMQConnectionFactory
+  :broker_url: tcp://localhost:61616
+  :require_jars:
+    - /usr/local/Cellar/activemq/5.11.1/libexec/activemq-all-5.11.1.jar
+    - /usr/local/Cellar/activemq/5.11.1/libexec/lib/optional/log4j-1.2.17.jar
 }
 
 JMS::Connection.session(config) do |session|
-    session.consume(:queue_name => 'ExampleQueue', :timeout=>1000) do |message|
+  session.consume(queue_name: 'ExampleQueue', timeout: 1000) do |message|
     p message
-    end
+  end
 end
 ```
 
-## Overview
+## More Examples
 
-jruby-jms is a complete JRuby API into the Java Messaging Specification (JMS) V1.1
-followed by several JMS Providers.
+There are several more examples available at https://github.com/reidmorrison/jruby-jms/tree/master/examples
 
 ## Threading
 
-A JMS::Connection instance can be shared between threads, whereas a session,
+A `JMS::Connection` instance can be shared between threads, whereas a session,
 consumer, producer, and any artifacts created by the session should only be
 used by one thread at a time.
 
 For consumers, it is recommended to create a session for each thread and leave
-that thread blocked on Consumer.receive. Or, even better use Connection.on_message
+that thread blocked on `Consumer#receive`. Or, even better use `Connection#on_message`
 which will create a session, within which any message received from the specified
 queue or topic will be passed to the block.
 
@@ -146,7 +162,7 @@ queue or topic will be passed to the block.
 
 jruby-jms detects the logging available in the current environment.
 When running under Rails it will use the Rails logger, otherwise it will use the
-standard Ruby logger. The logger can also be replaced by calling Connection.logger=
+standard Ruby logger. The logger can also be replaced by calling `JMS.logger=`
 
 ## Dependencies
 
@@ -154,35 +170,19 @@ standard Ruby logger. The logger can also be replaced by calling Connection.logg
 
 In order to communicate with a JMS V 1.1 provider jruby-jms needs the jar files supplied
 by the JMS provider. As in the examples above the jar files can be specified in
-the configuration element :require_jars. Otherwise, the jars must be explicitly
+the configuration element `:require_jars`. Otherwise, the jars must be explicitly
 required in the Ruby code:
 
 ```ruby
-require "~/Applications/apache-activemq-5.7.0/activemq-all-5.7.0.jar"
+require '/usr/local/Cellar/activemq/5.11.1/libexec/activemq-all-5.11.1.jar'
+require '/usr/local/Cellar/activemq/5.11.1/libexec/lib/optional/log4j-1.2.17.jar'
 ```
 
 ### JRuby
 
-jruby-jms has been tested against JRuby 1.5.1, 1.6.1, and 1.7.0 RC2
-
-## Contributing
-
-Once you've made your great commits:
-
-1. [Fork](http://help.github.com/forking/) jruby-jms
-2. Create a topic branch - `git checkout -b my_branch`
-3. Push to your branch - `git push origin my_branch`
-4. Create an [Issue](http://github.com/reidmorrison/jruby-jms/issues) with a link to your branch
-5. That's it!
-
-## Meta
-
-* Code: `git clone git://github.com/reidmorrison/jruby-jms.git`
-* Home: <http://github.com/reidmorrison/jruby-jms>
-* Bugs: <http://github.com/reidmorrison/jruby-jms/issues>
-* Gems: <http://rubygems.org/gems/jruby-jms>
+jruby-jms has been tested against JRuby 1.7, and JRuby 9.0.0.0
 
-This project uses [Semantic Versioning](http://semver.org/).
+## Versioning
 
 ## Author
 
@@ -190,7 +190,7 @@ Reid Morrison :: reidmo@gmail.com :: @reidmorrison
 
 ## License
 
-Copyright 2008 - 2012  J. Reid Morrison
+Copyright 2008 - 2015  J. Reid Morrison
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

data/Rakefile

@@ -1,20 +1,23 @@
-lib = File.expand_path('../lib/', __FILE__)
-$:.unshift lib unless $:.include?(lib)
-
-raise "jruby-jms must be built with JRuby: try again with `jruby -S rake'" unless defined?(JRUBY_VERSION)
-
-require 'rubygems'
-require 'rubygems/package'
 require 'rake/clean'
 require 'rake/testtask'
+
+raise 'jruby-jms must be built with JRuby' unless defined?(JRUBY_VERSION)
+
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
 require 'jms/version'
 
-desc "Build gem"
-task :gem  do |t|
-  Gem::Package.build(Gem::Specification.load('parallel_minion.gemspec'))
+task :gem do
+  system 'gem build jruby-jms.gemspec'
 end
 
-desc "Run Test Suite"
+task :publish => :gem do
+  system "git tag -a v#{JMS::VERSION} -m 'Tagging #{JMS::VERSION}'"
+  system 'git push --tags'
+  system "gem push jruby-jms-#{JMS::VERSION}-java.gem"
+  system "rm jruby-jms-#{JMS::VERSION}-java.gem"
+end
+
+desc 'Run Test Suite'
 task :test do
   Rake::TestTask.new(:functional) do |t|
     t.test_files = FileList['test/*_test.rb']
@@ -24,7 +27,9 @@ task :test do
   Rake::Task['functional'].invoke
 end
 
-desc "Generate RDOC documentation"
+task :default => :test
+
+desc 'Generate RDOC documentation'
 task :doc do
   system "rdoc --main README.md --inline-source --quiet README.md `find lib -name '*.rb'`"
 end

data/lib/jms.rb

@@ -1,20 +1,11 @@
-################################################################################
-#  Copyright 2008, 2009, 2010, 2011  J. Reid Morrison
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-################################################################################
-
 require 'java'
 require 'jms/version'
-require 'jms/logging'
 require 'jms/connection'
+require 'semantic_logger'
+
+module JMS
+  # Add Logging capabilities
+  include SemanticLogger::Loggable
+
+  autoload :SessionPool, 'jms/session_pool'
+end

data/lib/jms/bytes_message.rb

@@ -1,20 +1,4 @@
-################################################################################
-#  Copyright 2008, 2009, 2010, 2011  J. Reid Morrison
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-################################################################################
-
-#Interface javax.jms.BytesMessage
+# Interface javax.jms.BytesMessage
 module JMS::BytesMessage
   def data
     # Puts the message body in read-only mode and repositions the stream of
@@ -25,9 +9,9 @@ module JMS::BytesMessage
 
     return nil if available == 0
 
-    result = ""
+    result     = ''
     bytes_size = 1024
-    bytes = Java::byte[bytes_size].new
+    bytes      = Java::byte[bytes_size].new
 
     while (n = available < bytes_size ? available : bytes_size) > 0
       self.read_bytes(bytes, n)

data/lib/jms/connection.rb

@@ -1,19 +1,4 @@
-################################################################################
-#  Copyright 2008, 2009, 2010, 2011  J. Reid Morrison
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-################################################################################
-
+require 'semantic_logger'
 # Module: Java Messaging System (JMS) Interface
 module JMS
   # Every JMS session must have at least one Connection instance
@@ -32,12 +17,11 @@ module JMS
   #  require 'jms'
   #
   #  JMS::Connection.create_session(
-  #    :factory => 'org.apache.activemq.ActiveMQConnectionFactory',
-  #    :broker_url => 'tcp://localhost:61616',
-  #    :require_jars => [
-  #      '~/Applications/apache-activemq-5.5.0/activemq-all-5.5.0.jar',
-  #      '~/Applications/apache-activemq-5.5.0/lib/optional/slf4j-log4j12-1.5.11.jar',
-  #      '~/Applications/apache-activemq-5.5.0/lib/optional/log4j-1.2.14.jar',
+  #    factory:      'org.apache.activemq.ActiveMQConnectionFactory',
+  #    broker_url:   'tcp://localhost:61616',
+  #    require_jars: [
+  #      '/usr/local/Cellar/activemq/5.11.1/libexec/activemq-all-5.11.1.jar',
+  #      '/usr/local/Cellar/activemq/5.11.1/libexec/lib/optional/log4j-1.2.17.jar'
   #    ]
   #  ) do |session|
   #    session.consumer(:queue_name=>'TEST') do |consumer|
@@ -55,16 +39,18 @@ module JMS
   # See: http://download.oracle.com/javaee/6/api/javax/jms/Connection.html
   #
   class Connection
+    include SemanticLogger::Loggable
+
     # Create a connection to the JMS provider, start the connection,
     # call the supplied code block, then close the connection upon completion
     #
     # Returns the result of the supplied block
-    def self.start(params = {}, &proc)
-      raise "Missing mandatory Block when calling JMS::Connection.start" unless proc
+    def self.start(params = {}, &block)
+      raise(ArgumentError, 'Missing mandatory Block when calling JMS::Connection.start') unless block
       connection = Connection.new(params)
       connection.start
       begin
-        proc.call(connection)
+        block.call(connection)
       ensure
         connection.close
       end
@@ -80,9 +66,9 @@ module JMS
     # Note: It is important that each thread have its own session to support transactions
     #       This method will also start the session immediately so that any
     #       consumers using this session will start immediately
-    def self.session(params = {}, &proc)
+    def self.session(params = {}, &block)
       self.start(params) do |connection|
-        connection.session(params, &proc)
+        connection.session(params, &block)
       end
     end
 
@@ -100,15 +86,13 @@ module JMS
     #                     to load for this JMS Provider
     #
     # Returns nil
-    #
-    # TODO make this a class method
     def fetch_dependencies(jar_list)
       jar_list.each do |jar|
-        JMS::logger.debug "Loading Jar File:#{jar}"
+        logger.debug "Loading Jar File:#{jar}"
         begin
           require jar
         rescue Exception => exc
-          JMS::logger.error "Failed to Load Jar File:#{jar}. #{exc.to_s}"
+          logger.error "Failed to Load Jar File:#{jar}", exc
         end
       end if jar_list
 
@@ -139,21 +123,21 @@ module JMS
     #   2. Supply an instance of the JMS Provider class itself
     #   3. Use a JNDI lookup to return the JMS Provider Factory class
     # Parameters:
-    #   :factory   => String: Name of JMS Provider Factory class
-    #              => Class: JMS Provider Factory class itself
+    #   factory:   [String] Name of JMS Provider Factory class
+    #              [Class]  JMS Provider Factory class itself
     #
-    #   :jndi_name    => String: Name of JNDI entry at which the Factory can be found
-    #   :jndi_context => Mandatory if jndi lookup is being used, contains details
-    #                    on how to connect to JNDI server etc.
+    #   jndi_name:    [String] Name of JNDI entry at which the Factory can be found
+    #   jndi_context: Mandatory if jndi lookup is being used, contains details
+    #                 on how to connect to JNDI server etc.
     #
-    #   :require_jars => An optional array of Jar file names to load for the specified
-    #                    JMS provider. By using this option it is not necessary
-    #                    to put all the JMS Provider specific jar files into the
-    #                    environment variable CLASSPATH prior to starting JRuby
+    #   require_jars: [Array<String>] An optional array of Jar file names to load for the specified
+    #                 JMS provider. By using this option it is not necessary
+    #                 to put all the JMS Provider specific jar files into the
+    #                 environment variable CLASSPATH prior to starting JRuby
     #
-    #   :username  => Username to connect to JMS provider with
-    #   :password  => Password to use when to connecting to the JMS provider
-    #                 Note: :password is ignored if :username is not supplied
+    #   username:  [String] Username to connect to JMS provider with
+    #   password:  [String] Password to use when to connecting to the JMS provider
+    #              Note: :password is ignored if :username is not supplied
     #
     # :factory and :jndi_name are mutually exclusive, both cannot be supplied at the
     # same time. :factory takes precedence over :jndi_name
@@ -162,10 +146,9 @@ module JMS
     # has setters for those properties.
     #
     # For some known examples, see: [Example jms.yml](https://github.com/reidmorrison/jruby-jms/blob/master/examples/jms.yml)
-    #
     def initialize(params = {})
-      # Used by ::on_message
-      @sessions = []
+      # Used by #on_message
+      @sessions  = []
       @consumers = []
 
       options = params.dup
@@ -175,19 +158,17 @@ module JMS
       fetch_dependencies(options.delete(:require_jars))
 
       connection_factory = nil
-      factory = options.delete(:factory)
+      factory            = options.delete(:factory)
       if factory
         # If factory check if oracle is needed.
-        if (factory.include? 'AQjmsFactory')
-          require 'jms/oracle_a_q_connection_factory'
-        end
+        require('jms/oracle_a_q_connection_factory') if factory.include?('AQjmsFactory')
 
         # If factory is a string, then it is the name of a class, not the class itself
-        factory = eval(factory) if factory.respond_to? :to_str
+        factory            = eval(factory) if factory.respond_to?(:to_str)
         connection_factory = factory.new
       elsif jndi_name = options[:jndi_name]
-        raise "Missing mandatory parameter :jndi_context missing in call to Connection::connect" unless jndi_context = options[:jndi_context]
-        if jndi_context['java.naming.factory.initial'].include? 'AQjmsInitialContextFactory'
+        raise(ArgumentError, 'Missing mandatory parameter :jndi_context in call to Connection::connect') unless jndi_context = options[:jndi_context]
+        if jndi_context['java.naming.factory.initial'].include?('AQjmsInitialContextFactory')
           require 'jms/oracle_a_q_connection_factory'
         end
 
@@ -198,21 +179,21 @@ module JMS
           jndi.close
         end
       else
-        raise "Missing mandatory parameter :factory or :jndi_name missing in call to Connection::connect"
+        raise(ArgumentError, 'Missing mandatory parameter :factory or :jndi_name missing in call to Connection::connect')
       end
       options.delete(:jndi_name)
       options.delete(:jndi_context)
 
-      JMS::logger.debug "Using Factory: #{connection_factory.java_class}" if connection_factory.respond_to? :java_class
+      logger.debug "Using Factory: #{connection_factory.java_class}" if connection_factory.respond_to? :java_class
       options.each_pair do |key, val|
         next if [:username, :password].include?(key)
 
         method = key.to_s+'='
         if connection_factory.respond_to? method
           connection_factory.send method, val
-          JMS::logger.debug "   #{key} = #{connection_factory.send key.to_sym}" if connection_factory.respond_to? key.to_sym
+          logger.debug "   #{key} = #{connection_factory.send key.to_sym}" if connection_factory.respond_to? key.to_sym
         else
-          JMS::logger.warn "#{connection_factory.java_class} does not understand option: :#{key}=#{val}, ignoring :#{key}" if connection_factory.respond_to? :java_class
+          logger.warn "#{connection_factory.java_class} does not understand option: :#{key}=#{val}, ignoring :#{key}" if connection_factory.respond_to? :java_class
         end
       end
 
@@ -246,14 +227,14 @@ module JMS
     # closed on completion of the code block
     #
     # Parameters:
-    #  :transacted => true or false
+    #  transacted: [true|false]
     #      Determines whether transactions are supported within this session.
     #      I.e. Whether commit or rollback can be called
     #      Default: false
     #      Note: :options below are ignored if this value is set to :true
     #
-    #  :options => any of the JMS::Session constants:
-    #     Note: :options are ignored if :transacted => true
+    #  options: any of the JMS::Session constants:
+    #     Note: :options are ignored if transacted: true
     #     JMS::Session::AUTO_ACKNOWLEDGE
     #        With this acknowledgment mode, the session automatically acknowledges
     #        a client's receipt of a message either when the session has successfully
@@ -270,11 +251,11 @@ module JMS
     #        session is transacted.
     #     Default: JMS::Session::AUTO_ACKNOWLEDGE
     #
-    def session(params={}, &proc)
-      raise "Missing mandatory Block when calling JMS::Connection#session" unless proc
+    def session(params={}, &block)
+      raise(ArgumentError, 'Missing mandatory Block when calling JMS::Connection#session') unless block
       session = self.create_session(params)
       begin
-        proc.call(session)
+        block.call(session)
       ensure
         session.close
       end
@@ -288,14 +269,14 @@ module JMS
     #       possible
     #
     # Parameters:
-    #  :transacted => true or false
+    #  transacted: true or false
     #      Determines whether transactions are supported within this session.
     #      I.e. Whether commit or rollback can be called
     #      Default: false
     #      Note: :options below are ignored if this value is set to :true
     #
-    #  :options => any of the JMS::Session constants:
-    #     Note: :options are ignored if :transacted => true
+    #  options: any of the JMS::Session constants:
+    #     Note: :options are ignored if transacted: true
     #     JMS::Session::AUTO_ACKNOWLEDGE
     #        With this acknowledgment mode, the session automatically acknowledges
     #        a client's receipt of a message either when the session has successfully
@@ -314,17 +295,17 @@ module JMS
     #
     def create_session(params={})
       transacted = params[:transacted] || false
-      options = params[:options] || JMS::Session::AUTO_ACKNOWLEDGE
+      options    = params[:options] || JMS::Session::AUTO_ACKNOWLEDGE
       @jms_connection.create_session(transacted, options)
     end
 
     # Close connection with the JMS Provider
     # First close any consumers or sessions that are active as a result of JMS::Connection::on_message
     def close
-      @consumers.each {|consumer| consumer.close } if @consumers
+      @consumers.each { |consumer| consumer.close } if @consumers
       @consumers = []
 
-      @sessions.each {|session| session.close} if @sessions
+      @sessions.each { |session| session.close } if @sessions
       @session=[]
 
       @jms_connection.close if @jms_connection
@@ -390,14 +371,14 @@ module JMS
     # can then be processed.
     #
     # Session Parameters:
-    #  :transacted => true or false
+    #  transacted: true or false
     #      Determines whether transactions are supported within this session.
     #      I.e. Whether commit or rollback can be called
     #      Default: false
     #      Note: :options below are ignored if this value is set to :true
     #
-    #  :options => any of the JMS::Session constants:
-    #     Note: :options are ignored if :transacted => true
+    #  options: any of the JMS::Session constants:
+    #     Note: :options are ignored if transacted: true
     #     JMS::Session::AUTO_ACKNOWLEDGE
     #        With this acknowledgment mode, the session automatically acknowledges
     #        a client's receipt of a message either when the session has successfully
@@ -423,20 +404,20 @@ module JMS
     #                    Default: 1
     #
     # Consumer Parameters:
-    #   :queue_name => String: Name of the Queue to return
-    #                  Symbol: :temporary => Create temporary queue
+    #   queue_name: String: Name of the Queue to return
+    #                  Symbol: temporary: Create temporary queue
     #                  Mandatory unless :topic_name is supplied
     #     Or,
-    #   :topic_name => String: Name of the Topic to write to or subscribe to
-    #                  Symbol: :temporary => Create temporary topic
+    #   topic_name: String: Name of the Topic to write to or subscribe to
+    #                  Symbol: temporary: Create temporary topic
     #                  Mandatory unless :queue_name is supplied
     #     Or,
-    #   :destination=> Explicit javaxJms::Destination to use
+    #   destination:Explicit javaxJms::Destination to use
     #
-    #   :selector   => Filter which messages should be returned from the queue
+    #   selector:   Filter which messages should be returned from the queue
     #                  Default: All messages
     #
-    #   :no_local   => Determine whether messages published by its own connection
+    #   no_local:   Determine whether messages published by its own connection
     #                  should be delivered to the supplied block
     #                  Default: false
     #
@@ -447,7 +428,7 @@ module JMS
     #              or when Destination::statistics is called. In this case MessageConsumer::statistics
     #              can be called several times during processing without affecting the end time.
     #              Also, the start time and message count is not reset until MessageConsumer::each
-    #              is called again with :statistics => true
+    #              is called again with statistics: true
     #
     # Usage: For transacted sessions the block supplied must return either true or false:
     #          true => The session is committed
@@ -458,11 +439,11 @@ module JMS
     #       since on_message will Not be called if the connection is lost
     #
     def on_message(params, &block)
-      raise "JMS::Connection must be connected prior to calling JMS::Connection::on_message" unless @sessions && @consumers
+      raise 'JMS::Connection must be connected prior to calling JMS::Connection::on_message' unless @sessions && @consumers
 
       consumer_count = params[:session_count] || 1
       consumer_count.times do
-        session = self.create_session(params)
+        session  = self.create_session(params)
         consumer = session.consumer(params)
         if session.transacted?
           consumer.on_message(params) do |message|
@@ -520,7 +501,6 @@ module JMS
     #      producer.send(session.message("Hello World"))
     #   end
     def create_session_pool(params={})
-      require 'jms/session_pool' unless defined? JMS::SessionPool
       JMS::SessionPool.new(self, params)
     end