jsparrow 1.1.0 → 1.1.1

data/README.rdoc

@@ -10,16 +10,16 @@ Make gem install:
 
 === Example
 
-===== Six steps to send and receive JMS messages to/from a JMS middleware.
+===== Five steps to send and receive JMS messages to/from a JMS provider.
 
-WARNING: OpenJMS will be used as JMS middleware, but any other could be used with no problems.
+WARNING: OpenJMS will be used as JMS provider, but any other could be used with no problems.
 
 1) Create my_jsparrow_test.rb file and require the gems
 
   require 'rubygems'
   require 'jsparrow'
 
-2) Setup indispensable informations to connect your JMS middleware
+2) Setup indispensable informations to connect your JMS provider
 
   JSparrow::Connection.configure do |connection|
     connection.use_jms_client_jar '/opt/openjms/lib/openjms-0.7.7-beta-1.jar'
@@ -29,20 +29,17 @@ WARNING: OpenJMS will be used as JMS middleware, but any other could be used wit
                                  # :security_principal      => 'user',
                                  # :security_credentials    => 'password'
 
-    connection.enable_connection_factories :queue_connection_factory => 'ConnectionFactory', 
-                                           :topic_connection_factory => 'ConnectionFactory'
+    connection.enable_connection_factories :queue_connection_factory => 'ConnectionFactory'
+    
+    connection.enable_queues :my_queue => 'MyQueue'
   end
 
-3) Create the client and setup a queue
+3) Create the client and start it
 
   jms_client = JSparrow::Connection.new_client
-  jms_client.enable_queues :my_queue => 'MyQueue'
-  
-4) After appropriate setup, start the client
-
   jms_client.start
 
-5) OK! Now you can send and receive messages right now!
+4) OK! Now you can send and receive messages right now!
 
   jms_client.queue_sender(:my_queue).send_text_message('jsparrow rocks!') do |msg|
     msg.set_string_property('recipient', 'jsparrow-example')
@@ -57,17 +54,19 @@ WARNING: OpenJMS will be used as JMS middleware, but any other could be used wit
     puts "message: #{msg.text}"                        # message: jsparrow rocks!
   end
 
-6) After you receive your amazing messages, stop the client
+5) After you receive your amazing messages, stop the client
 
   jms_client.stop
 
-So, now that you did code and save it, start the OpenJMS server, create the queue (MyQueue), and run above script:
+So, now that you wrote code and save it, start the OpenJMS server, create the queue (MyQueue), and run above script:
 
   jruby my_jsparrow_test.rb
 
 jsparrow rocks! =)
 
-===== Sample code
+=== Sample
+
+===== A very simple sample code
 
 Or, if you don't want write code, only do it:
 

data/VERSION.yml

@@ -1,5 +1,5 @@
 --- 
-:patch: 0
+:patch: 1
 :major: 1
 :build: 
 :minor: 1

data/lib/client.rb

@@ -0,0 +1,161 @@
+# Classes Java usadas nesse arquivo
+import 'javax.naming.InitialContext'
+
+module JSparrow
+  module Connection
+
+    #
+    # Cliente JMS que possibilita a conexao com o servidor de aplicacoes Java EE
+    # que prove o servico JMS.
+    #
+    class Client
+      def initialize(connection_config, jndi_context_builder)
+        @connection_config    = connection_config
+        @jndi_context_builder = jndi_context_builder
+    
+        # Conexoes, filas, topicos, senders e receivers que serao habilitados
+        @connection_factories = {}
+        @queues               = {}
+        @queue_senders        = {}
+        @queue_receivers      = {}
+        @topics               = {}
+        @topic_senders        = {}
+        @topic_receivers      = {}
+
+        # Foi iniciado?
+        @started = false
+      end
+  
+      def is_started?
+        @started
+      end
+  
+      def start
+        raise InvalidClientStateError.new('started', 'start') if is_started?
+    
+        begin
+          @jndi_context = @jndi_context_builder.build
+        rescue => cause
+          raise ClientInitializationError.new(@connection_config, cause)
+        end
+    
+        @connection_factories, @queues, @topics = lookup_resources
+    
+        @started = true
+      end
+  
+      def is_stoped?
+        !@started
+      end
+  
+      def stop
+        raise InvalidClientStateError.new('stoped', 'stop') if is_stoped?
+    
+        @jndi_context.close
+    
+        @started = false  
+      end
+
+      def queue_connection_factory_enabled?
+        @connection_config.enabled_connection_factories.include?(:queue_connection_factory)
+      end
+
+      def queue_connection_factory
+        @connection_factories[:queue_connection_factory]
+      end
+  
+      def queue_enabled?(queue_name)
+        @connection_config.enabled_queues.include?(queue_name)
+      end
+  
+      def queue(queue_name)
+        raise NameError, "Queue '#{queue_name}' does not exist." unless queue_enabled?(queue_name)
+    
+        @queues[queue_name]
+      end
+
+      def queue_sender(queue_name)
+        @queue_senders[queue_name] ||=
+            Messaging::Sender.new(queue_connection_factory, queue(queue_name))
+      end
+
+      def queue_receiver(queue_name)
+        @queue_receivers[queue_name] ||=
+            Messaging::Receiver.new(queue_connection_factory, queue(queue_name))
+      end
+
+      def topic_connection_factory_enabled?
+        @connection_config.enabled_connection_factories.include?(:topic_connection_factory)
+      end
+
+      def topic_connection_factory
+        @connection_factories[:topic_connection_factory]
+      end
+  
+      def topic_enabled?(topic_name)
+        @connection_config.enabled_topics.include?(topic_name)
+      end
+  
+      def topic(topic_name)
+        raise NameError, "Topic '#{topic_name}' does not exist." unless topic_enabled?(topic_name)
+    
+        @topics[topic_name]
+      end
+
+      def topic_sender(topic_name)
+        @topic_senders[topic_name] ||=
+            Messaging::Sender.new(topic_connection_factory, topic(topic_name))
+      end
+
+      def topic_receiver(topic_name)
+        @topic_receivers[topic_name] ||=
+            Messaging::Receiver.new(topic_connection_factory, topic(topic_name))
+      end
+  
+      # -- Private methods -- #
+      private
+
+        def lookup_resources
+          @lookuped_connection_factories = lookup_resource(@connection_config.enabled_connection_factories)
+          @lookuped_queues               = lookup_resource(@connection_config.enabled_queues)
+          @lookuped_topic                = lookup_resource(@connection_config.enabled_topics)
+          
+          return @lookuped_connection_factories, @lookuped_queues, @lookuped_topic
+        end
+  
+        def lookup_resource(jndi_names = {})
+          lookuped = {}
+      
+          return lookuped unless jndi_names
+          
+          jndi_names.each do |key, jndi_name|
+            lookuped[key] = @jndi_context.lookup(jndi_name)
+          end
+      
+          lookuped
+        end
+    end
+
+    class ClientInitializationError < StandardError
+      attr_reader :config, :cause
+  
+      def initialize(config, cause)
+        super("Could not open connection to server. Verify the config's config.")
+    
+        @config = config
+        @cause  = cause
+      end
+    end
+
+    class InvalidClientStateError < StandardError
+      attr_reader :state, :operation
+  
+      def initialize(state, operation)
+        super("Could not did #{operation} because client is #{state}.")
+    
+        @state     = state
+        @operation = operation
+      end
+    end
+  end
+end

data/lib/connection.rb

@@ -6,35 +6,37 @@ module JSparrow
   module Connection
 
     #
-    # Metodo usado para configurar a conexao com o middleware de JMS.
+    # Metodo usado para configurar a conexao com o provedor de JMS.
     #
     def self.configure
-      @@properties = ConnectionProperties.new
+      @@config = Configuration.new
       
-      yield @@properties
+      yield @@config
+      
+      @@config
     end
     
     #
-    # Metodo usado para obter a configuracao para conexao com o middleware de JMS.
+    # Metodo usado para obter a configuracao para conexao com o provedor de JMS.
     #
-    def self.connection_properties
-      @@properties
+    def self.configuration
+      @@config
     end
     
     #
     # Metodo usado para criar um novo Client JMS.
     #
     def self.new_client
-      jndi_context_builder = JNDI::ContextBuilder.new(@@properties.jms_client_jar, @@properties.jndi_properties)
+      jndi_context_builder = JNDI::ContextBuilder.new(@@config.jms_client_jar, @@config.jndi_properties)
       
-      Client.new(@@properties, jndi_context_builder)
+      Client.new(@@config, jndi_context_builder)
     end
 
     #
     # Configuracoes necessarias para que clientes JMS se conetem
-    # ao middleware de mensageria via contexto JNDI.
+    # ao provedor de mensageria via contexto JNDI.
     #
-    class ConnectionProperties
+    class Configuration
       attr_reader :jms_client_jar, :jndi_properties,
                   :enabled_connection_factories, :enabled_queues, :enabled_topics
       
@@ -58,182 +60,20 @@ module JSparrow
         @enabled_topics = jndi_names
       end
     end
-
-    #
-    # Cliente JMS que possibilita a conexao com o servidor de aplicacoes Java EE
-    # que prove o servico JMS.
-    #
-    class Client
-      def initialize(connection_properties, jndi_context_builder)
-        @connection_properties = connection_properties
-        @jndi_context_builder  = jndi_context_builder
-        
-        @jndi_name_of_enabled_connection_factories = @connection_properties.enabled_connection_factories
-        @jndi_name_of_enabled_queues               = {}
-        @jndi_name_of_enabled_topics               = {}
-
-        # Conexoes, filas, topicos, senders e receivers que serao habilitados
-        @connection_factories               = {}
-        @queues                             = {}
-        @queue_senders                      = {}
-        @queue_receivers                    = {}
-        @topics                             = {}
-        @topic_senders                      = {}
-        @topic_receivers                    = {}
-
-        # Foi startado?
-        @started = false
-      end
-      
-      def is_started?
-        @started
-      end
-      
-      def start
-        raise InvalidClientStateError.new('started', 'start') if is_started?
-        
-        begin
-          @jndi_context = @jndi_context_builder.build
-        rescue => cause
-          raise ClientInitializationError.new(@connection_properties, cause)
-        end
-        
-        @connection_factories = lookup_resource(@jndi_name_of_enabled_connection_factories)
-        @queues               = lookup_resource(@jndi_name_of_enabled_queues)
-        @topics               = lookup_resource(@jndi_name_of_enabled_topics)
-        
-        @started = true
-      end
-      
-      def is_stoped?
-        !@started
-      end
-      
-      def stop
-        raise InvalidClientStateError.new('stoped', 'stop') if is_stoped?
-        
-        @jndi_context.close
-        
-        @started = false  
-      end
-
-      def queue_connection_factory_enabled?
-        @jndi_name_of_enabled_connection_factories.include?(:queue_connection_factory)
-      end
-
-      def queue_connection_factory
-        @connection_factories[:queue_connection_factory]
-      end
-
-      def topic_connection_factory_enabled?
-        @jndi_name_of_enabled_connection_factories.include?(:topic_connection_factory)
-      end
-
-      def topic_connection_factory
-        @connection_factories[:topic_connection_factory]
-      end
-
-      def enable_queues(jndi_names = {})
-        raise InvalidClientStateError.new('started', 'enable_queues') if is_started?
-        
-        @jndi_name_of_enabled_queues = jndi_names
-      end
-      
-      def queue_enabled?(queue_name)
-        @jndi_name_of_enabled_queues.include?(queue_name)
-      end
-      
-      def queue(queue_name)
-        raise NameError, "Queue '#{queue_name}' does not exist." unless queue_enabled?(queue_name)
-        
-        @queues[queue_name]
-      end
-
-      def queue_sender(queue_name)
-        @queue_senders[queue_name] ||=
-            Messaging::Sender.new(queue_connection_factory, queue(queue_name))
-      end
-
-      def queue_receiver(queue_name)
-        @queue_receivers[queue_name] ||=
-            Messaging::Receiver.new(queue_connection_factory, queue(queue_name))
-      end
-
-      def enable_topics(jndi_names = {})
-        raise InvalidClientStateError.new('started', 'enable_topics') if is_started?
-        
-        @jndi_name_of_enabled_topics = jndi_names
-      end
-      
-      def topic_enabled?(topic_name)
-        @jndi_name_of_enabled_topics.include?(topic_name)
-      end
-      
-      def topic(topic_name)
-        raise NameError, "Topic '#{topic_name}' does not exist." unless topic_enabled?(topic_name)
-        
-        @topics[topic_name]
-      end
-
-      def topic_sender(topic_name)
-        @topic_senders[topic_name] ||=
-            Messaging::Sender.new(topic_connection_factory, topic(topic_name))
-      end
-
-      def topic_receiver(topic_name)
-        @topic_receivers[topic_name] ||=
-            Messaging::Receiver.new(topic_connection_factory, topic(topic_name))
-      end
-      
-      # -- Private methods -- #
-      private
-      
-        def lookup_resource(jndi_names = {})
-          lookuped = {}
-          
-          jndi_names.each do |key, jndi_name|
-            lookuped[key] = @jndi_context.lookup(jndi_name)
-          end
-          
-          lookuped
-        end
-    end
-    
-    class ClientInitializationError < StandardError
-      attr_reader :properties, :cause
-      
-      def initialize(properties, cause)
-        super("Could not open connection to server. Verify the properties's properties.")
-        
-        @properties = properties
-        @cause      = cause
-      end
-    end
-
-    class InvalidClientStateError < StandardError
-      attr_reader :state, :operation
-      
-      def initialize(state, operation)
-        super("Could not did #{operation} because client is #{state}.")
-        
-        @state     = state
-        @operation = operation
-      end
-    end
   end
   
   module JNDI
     
     #
-    # Builder para construcao de contexto JNDI para conexao com o middleware
+    # Builder para construcao de contexto JNDI para conexao com o provedor
     # de JMS.
     #
     class ContextBuilder
       attr_accessor :jms_client_jar, :jndi_properties
       
       def initialize(jms_client_jar, jndi_properties)
-        @jms_client_jar = jms_client_jar
-        @jndi_properties   = jndi_properties
+        @jms_client_jar  = jms_client_jar
+        @jndi_properties = jndi_properties
       end
       
       #

data/lib/jsparrow.rb

@@ -5,5 +5,6 @@ require 'jms.rb'
 
 # Bibliotecas do JSparrow
 require 'connection.rb'
+require 'client.rb'
 require 'messaging.rb'
 require 'error.rb'

data/sample/sample.rb

@@ -9,20 +9,19 @@ JSparrow::Connection.configure do |connection|
                                # :security_principal      => 'user',
                                # :security_credentials    => 'password'
 
-  connection.enable_connection_factories :queue_connection_factory => 'ConnectionFactory', 
-                                         :topic_connection_factory => 'ConnectionFactory'
+  connection.enable_connection_factories :queue_connection_factory => 'ConnectionFactory'
+  
+  connection.enable_queues :test_queue => 'TestQueue'
 end
 
 jms_client = JSparrow::Connection.new_client
-jms_client.enable_queues :pardal_queue => 'PardalQueue'
-
 jms_client.start
 
-jms_client.queue_sender(:pardal_queue).send_text_message('jsparrow rocks!') do |msg|
+jms_client.queue_sender(:test_queue).send_text_message('jsparrow rocks!') do |msg|
   msg.set_string_property('recipient', 'jsparrow-example')
 end
 
-jms_client.queue_receiver(:pardal_queue).receive_message(
+jms_client.queue_receiver(:test_queue).receive_message(
     :timeout  => 5000,
     :selector => "recipient = 'jsparrow-example'"
   ) do |msg|

data/spec/client_spec.rb

@@ -0,0 +1,86 @@
+require File.dirname(File.expand_path(__FILE__)) + '/spec_helper.rb'
+
+#
+# Cenario que testa o start e stop do cliente JMS.
+#
+describe JSparrow::Connection::Client, ', quando criado,' do
+
+  before(:all) do
+    @jms_client = create_jms_client
+  end
+  
+  it 'deveria permitir ser iniciado e parado' do
+    @jms_client.start
+    
+    @jms_client.is_started?.should be true
+    @jms_client.is_stoped?.should be false
+    
+    @jms_client.stop
+    
+    @jms_client.is_started?.should be false
+    @jms_client.is_stoped?.should be true
+  end
+end
+
+#
+# Cenario de configuracao do cliente JMS, quando sao informadas as propriedades de ambiente
+# para conexao com o servidor de aplicacoes e a inicializacao do contexto JNDI inicial,
+# onde estao criadas as connection factories, queues e topics.
+#
+# Importante: nesse momento o cliente JMS ainda nao sera iniciado, ja que nao deve haver
+#             configuracao depois inicia-lo.
+#
+describe JSparrow::Connection::Client, ', quando esta sendo configurado, mas ainda nao iniciado,' do
+
+  before(:all) do
+    @jms_client = create_jms_client
+  end
+  
+  it 'deveria ter uma connection factory especifica para queues' do
+    @jms_client.queue_connection_factory_enabled?.should be true
+  end
+  
+  it 'deveria ter uma connection factory especifica para topics' do
+    @jms_client.topic_connection_factory_enabled?.should be true
+  end
+  
+  it 'deveria ter uma Queue especifica' do
+    @jms_client.queue_enabled?(:test_queue).should eql true
+  end
+  
+  it 'deveria ter um Topic especifico' do
+    @jms_client.topic_enabled?(:test_topic).should eql true
+  end  
+end
+
+#
+# Cenario pos-configuracao do cliente JMS, quando as queues e os topicos ja devem estar
+# disponiveis, e entao e possivel obter sender/receiver para elas.
+#
+describe JSparrow::Connection::Client, ', depois de ter sido configurado,' do
+
+  before(:all) do
+    @jms_client = create_jms_client
+    @jms_client.start
+  end
+  
+  after(:all) do
+    @jms_client.stop
+  end
+  
+  it 'deveria possibilitar obter um Sender para uma Queue especifica' do
+    @jms_client.queue_sender(:test_queue).should_not be nil
+  end
+  
+  it 'deveria possibilitar obter um Receiver para uma Queue especifica' do
+    @jms_client.queue_receiver(:test_queue).should_not be nil
+  end
+  
+  it 'deveria possibilitar obter um Sender para um Topic especifico' do
+    @jms_client.topic_sender(:test_topic).should_not be nil
+  end
+  
+  it 'deveria possibilitar obter um Receiver para um Topic especifico' do
+    @jms_client.topic_receiver(:test_topic).should_not be nil
+  end
+end

data/spec/connection_spec.rb

@@ -1,120 +1,31 @@
 require File.dirname(File.expand_path(__FILE__)) + '/spec_helper.rb'
 
 #
-# Cenario que testa o start e stop do cliente JMS.
+# Cenario que testa a configuracao a conexao com o provedor de JMS.
 #
-describe JSparrow::Connection::Client, ', quando criado,' do
+describe JSparrow::Connection, ', quando configurado,' do
 
   before(:all) do
-    @jms_client = create_jms_client
+    @config = configure_connection
   end
   
-  it 'deveria permitir ser iniciado e parado' do
-    @jms_client.start
-    
-    @jms_client.is_started?.should be true
-    @jms_client.is_stoped?.should be false
-    
-    @jms_client.stop
-    
-    @jms_client.is_started?.should be false
-    @jms_client.is_stoped?.should be true
+  it 'deveria ter jms_client_jar' do
+    @config.jms_client_jar.should_not be nil
   end
-end
-
-#
-# Cenario de configuracao do cliente JMS, quando sao informadas as propriedades de ambiente
-# para conexao com o servidor de aplicacoes e a inicializacao do contexto JNDI inicial,
-# onde estao criadas as connection factories, queues e topics.
-#
-# Importante: nesse momento o cliente JMS ainda nao sera iniciado, ja que nao deve haver
-#             configuracao depois inicia-lo.
-#
-describe JSparrow::Connection::Client, ', quando esta sendo configurado, mas ainda nao iniciado,' do
 
-  before(:all) do
-    @jms_client = create_jms_client
-  end
-  
-  it 'deveria ter uma connection factory especifica para queues' do
-    @jms_client.queue_connection_factory_enabled?.should be true
-  end
-  
-  it 'deveria ter uma connection factory especifica para topics' do
-    @jms_client.topic_connection_factory_enabled?.should be true
+  it 'deveria ter jndi_properties' do
+    @config.jndi_properties.should_not be nil
   end
-  
-  it 'deveria permitir habilitar uma Queue especifica' do
-    @jms_client.enable_queues :pardal_queue => 'PardalQueue'
 
-    @jms_client.queue_enabled?(:pardal_queue).should eql true
+  it 'deveria ter enabled_connection_factories' do
+    @config.enabled_connection_factories.should_not be nil
   end
-  
-  it 'deveria permitir habilitar um Topic especifico' do
-    @jms_client.enable_topics :pardal_topic => 'PardalTopic'
-
-    @jms_client.topic_enabled?(:pardal_topic).should eql true
-  end  
-end
-
-#
-# Cenario de configuracao do cliente JMS apos ter sido iniciado.
-#
-# Importante: Como o cliente JMS ja esta iniciado, deve lancar erro, nao permitindo
-#             qualquer configuracao.
-#
-describe JSparrow::Connection::Client, ', quando esta sendo configurado, apos iniciado,' do
 
-  before(:all) do
-    @jms_client = create_jms_client
-    @jms_client.start
+  it 'deveria ter enabled_queues' do
+    @config.enabled_queues.should_not be nil
   end
-  
-  after(:all) do
-    @jms_client.stop
-  end
-  
-  it 'nao deveria permitir habilitar uma Queue especifica' do
-    lambda {
-        @jms_client.enable_queues(:pardal_queue => 'PardalQueue')
-      }.should raise_error JSparrow::Connection::InvalidClientStateError
-  end
-  
-  it 'nao deveria permitir habilitar um Topic especifico' do
-    lambda {
-        @jms_client.enable_topics(:pardal_topic => 'PardalTopic')
-      }.should raise_error JSparrow::Connection::InvalidClientStateError
-  end  
-end
 
-#
-# Cenario pos-configuracao do cliente JMS, quando as queues e os topicos ja devem estar
-# disponiveis, e entao e possivel obter sender/receiver para elas.
-#
-describe JSparrow::Connection::Client, ', depois de ter sido configurado,' do
-
-  before(:all) do
-    @jms_client = create_and_setup_jms_client
-    @jms_client.start
-  end
-  
-  after(:all) do
-    @jms_client.stop
-  end
-  
-  it 'deveria possibilitar obter um Sender para uma Queue especifica' do
-    @jms_client.queue_sender(:pardal_queue).should_not be nil
-  end
-  
-  it 'deveria possibilitar obter um Receiver para uma Queue especifica' do
-    @jms_client.queue_receiver(:pardal_queue).should_not be nil
-  end
-  
-  it 'deveria possibilitar obter um Sender para um Topic especifico' do
-    @jms_client.topic_sender(:pardal_topic).should_not be nil
-  end
-  
-  it 'deveria possibilitar obter um Receiver para um Topic especifico' do
-    @jms_client.topic_receiver(:pardal_topic).should_not be nil
+  it 'deveria ter enabled_topics' do
+    @config.enabled_topics.should_not be nil
   end
 end

data/spec/messaging_spec.rb

@@ -8,11 +8,11 @@ require File.dirname(File.expand_path(__FILE__)) + '/spec_helper.rb'
 describe JSparrow::Messaging, ', quando tem um Sender e um Receiver para uma Queue especifica,' do
   
   before(:all) do
-    @jms_client = create_and_setup_jms_client
+    @jms_client = create_jms_client
     @jms_client.start
     
-    @sender   = @jms_client.queue_sender(:pardal_queue)
-    @receiver = @jms_client.queue_receiver(:pardal_queue)
+    @sender   = @jms_client.queue_sender(:test_queue)
+    @receiver = @jms_client.queue_receiver(:test_queue)
   end
   
   after(:all) do

data/spec/spec_helper.rb

@@ -17,32 +17,23 @@ module JSparrowHelperMethods
     JSparrow::Connection.new_client
   end
   
-  def create_and_setup_jms_client
-    configure_connection
-    
-    jms_client = JSparrow::Connection.new_client
-    jms_client.enable_queues :pardal_queue => 'PardalQueue'
-    jms_client.enable_topics :pardal_topic => 'PardalTopic'
-
-    jms_client
-  end
-  
-  # --- Private methods --- #
-  private
-    
-    def configure_connection
-      JSparrow::Connection.configure do |connection|
-        connection.use_jms_client_jar '/opt/openjms/lib/openjms-0.7.7-beta-1.jar'
+  def configure_connection
+    JSparrow::Connection.configure do |connection|
+      connection.use_jms_client_jar '/opt/openjms/lib/openjms-0.7.7-beta-1.jar'
 
-        connection.use_jndi_properties :initial_context_factory => 'org.exolab.jms.jndi.InitialContextFactory',
-                                       :provider_url            => 'tcp://localhost:3035'
-                                     # :security_principal      => 'user',
-                                     # :security_credentials    => 'password'
-
-        connection.enable_connection_factories :queue_connection_factory => 'ConnectionFactory', 
-                                               :topic_connection_factory => 'ConnectionFactory'
-      end
+      connection.use_jndi_properties :initial_context_factory => 'org.exolab.jms.jndi.InitialContextFactory',
+                                     :provider_url            => 'tcp://localhost:3035'
+                                   # :security_principal      => 'user',
+                                   # :security_credentials    => 'password'
+      
+      connection.enable_connection_factories :queue_connection_factory => 'ConnectionFactory', 
+                                             :topic_connection_factory => 'ConnectionFactory'
+      
+      connection.enable_queues :test_queue => 'TestQueue'
+      
+      connection.enable_topics :test_topic => 'TestTopic'
     end
+  end
 end
 
 #

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jsparrow
 version: !ruby/object:Gem::Version 
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors: 
 - Leandro Silva
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-15 00:00:00 -08:00
+date: 2010-02-16 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -27,6 +27,7 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION.yml
+- lib/client.rb
 - lib/connection.rb
 - lib/error.rb
 - lib/jms.rb
@@ -36,6 +37,7 @@ files:
 - lib/jsparrow.rb
 - lib/messaging.rb
 - sample/sample.rb
+- spec/client_spec.rb
 - spec/connection_spec.rb
 - spec/messaging_spec.rb
 - spec/spec_helper.rb
@@ -68,6 +70,7 @@ signing_key:
 specification_version: 3
 summary: JSparrow is a JMS client based on JRuby
 test_files: 
+- spec/client_spec.rb
 - spec/connection_spec.rb
 - spec/messaging_spec.rb
 - spec/spec_helper.rb