messaging.rb in leandrosilva-sparrow-1.0.1

- old
+ new

@@ -1,25 +1,25 @@
 # Classes java usadas nesse arquivo
 import 'javax.jms.Session'
 import 'javax.jms.MessageListener'
 
 module Sparrow
-  module JMS
+  module JMSg
     module Messaging
 
       #
-      # Tempo padrão de timeout no recebimento de mensagens = 1 milesegundo.
+      # Tempo padrao de timeout no recebimento de mensagens = 1 milesegundo.
       #
       DEFAULT_RECEIVER_TIMEOUT = 1000
     
       #
       # Classe base para mensageiros, que enviam ou recebem mensagens, tanto
-      # para filas ou tópicos.
+      # para filas ou topicos.
       #
       class Base
         def initialize(connection_factory, destination)
-          # Fábrica de conexões JMS
+          # Fabrica de conexoes JMS
           @connection_factory = connection_factory
 
           # Destino JMS para envio ou recebimento de mensagens
           @destination = destination
         end
@@ -31,11 +31,10 @@
       class Sender < Base
         def send_text_message(text)
           send_message do |session|
             text_message = session.create_text_message(text)
             
-            # Se houver uma bloco para tratamento da mensagem
             if block_given?
               yield(text_message)
             end
             
             text_message
@@ -44,11 +43,10 @@
         
         def send_object_message(object)
           send_message do |session|
             object_message = session.create_object_message(object)
             
-            # Se houver uma bloco para tratamento da mensagem
             if block_given?
               yield(object_message)
             end
             
             object_message
@@ -57,112 +55,111 @@
         
         def send_map_message
           send_message do |session|
             map_message = session.create_map_message
             
-            # Se houver uma bloco para tratamento da mensagem
             if block_given?
               yield(map_message)
             end
             
             map_message
           end
         end
         
         def send_messages(&message_sender)
-          # Cria uma conexão, uma sessão e um emissor de qualquer tipo de mensagem
+          # Cria uma conexao, uma sessao e um emissor de qualquer tipo de mensagem
           connection = @connection_factory.create_connection
           session    = connection.create_session(true, Session::AUTO_ACKNOWLEDGE)
           producer   = session.create_producer(@destination)
           
-          # Passa o controle que trata a emissão de mensagens
+          # Passa o controle que trata a emissao de mensagens
           message_sender.call(session, producer)
 
-          # Fecha a conexão
+          # Fecha a conexao
           connection.close
         end
         
         # --- Private methods --- #
         private
         
         def send_message(&message_creator)
-          # Cria uma conexão, uma sessão e um emissor de qualquer tipo de mensagem
+          # Cria uma conexao, uma sessao e um emissor de qualquer tipo de mensagem
           connection = @connection_factory.create_connection
           session    = connection.create_session(true, Session::AUTO_ACKNOWLEDGE)
           producer   = session.create_producer(@destination)
           
           # Obtem uma mensagem (TextMessage, ObjectMessage ou MapMessage) do criador especifico
           message = message_creator.call(session)
           
           # Envia a mensagem
           producer.send(message)
           
-          # Commita a sessão e fecha a conexão
+          # Commita a sessao e fecha a conexao
           session.commit
           connection.close
         end
       end
       
       #
       # Receptor de mensagens.
       #
       class Receiver < Base    
         def receive_message(criteria_for_receiving = {:timeout => DEFAULT_RECEIVER_TIMEOUT, :selector => ''}, &message_handler)
-          # Cria uma conexão, uma sessão e um consumidor de qualquer tipo de mensagem
+          # Cria uma conexao, uma sessao e um consumidor de qualquer tipo de mensagem
           connection = @connection_factory.create_connection
           session    = connection.create_session(false, Session::AUTO_ACKNOWLEDGE)
           consumer   = session.create_consumer(@destination, criteria_for_receiving[:selector])
           
-          # Prepara a conexão para receber mensagens
+          # Prepara a conexao para receber mensagens
           connection.start
           
           # Inicia o recebimento de mensagens
           timeout = criteria_for_receiving[:timeout] || DEFAULT_RECEIVER_TIMEOUT
           
           while (received_message = consumer.receive(timeout))
-            # Inclui o modulo de identificação de mensagem, util para o message_handler
+            # Inclui o modulo de identificacao de mensagem, util para o message_handler
             class << received_message
               include MessageType
             end
           
             # Delega o tratamento da mensagem para o bloco recebido
             message_handler.call(received_message)
           end
           
-          # Fecha a conexão
+          # Fecha a conexao
           connection.close
         end
       end
       
       #
       # Ouvintes de mensagens.
       #
-      # TODO: Completar a implementação. Ainda não está legal.
+      # TODO: Completar a implementacao. Ainda nao esta legal.
       #
       class Listener < Base
         include MessageListener
         
         def initialize(connection_factory, destination)
           super(connection_factory, destination)
         end
         
         def criteria_for_receiving(criteria = {:timeout => DEFAULT_RECEIVER_TIMEOUT, :selector => ''})
-          # Valor default para timeout, caso não tenha sido informado
+          # Valor default para timeout, caso nao tenha sido informado
           @criteria_for_receiving[:timeout] = criteria[:timeout] || DEFAULT_RECEIVER_TIMEOUT
         end
         
         #
-        # Nome pelo qual este listener será conhecido.
+        # Nome pelo qual este listener sera conhecido.
         #
         # Invariavelmente deve ser re-implementado nas subclasses.
         #
         def name
           raise Utils::Exception::AbstractMethodError.new('name')
         end
         
         #
-        # Destino JMS que será escutado.
+        # Destino JMS que sera escutado.
         #
         # Invariavelmente deve ser re-implementado nas subclasses.
         #
         def destination_name
           raise Utils::Exception::AbstractMethodError.new('destination_name')
@@ -170,39 +167,39 @@
         
         #
         # Inicia a escuta de mensagens.
         #
         def start_listening
-          # Cria uma conexão, uma sessão e um consumidor de qualquer tipo de mensagem
+          # Cria uma conexao, uma sessao e um consumidor de qualquer tipo de mensagem
           connection = @connection_factory.create_connection
           session    = connection.create_session(false, Session::AUTO_ACKNOWLEDGE)
           consumer   = session.create_consumer(@destination, @criteria_for_receiving[:selector])
           
           # Registra-se como ouvinte
           consumer.message_listener = self
           
-          # inicia a escuta de mensagens
+          # Inicia a escuta de mensagens
           connection.start
         end
         
         #
-        # Faz o enriquecimento do objeto mensagem e delega para o método on_receive_message
+        # Faz o enriquecimento do objeto mensagem e delega para o metodo on_receive_message
         # que, implementado pelas subclasses, efetivamente trata a mensagem.
         #
-        # Não deve ser re-implementado por subclasses.
+        # Nao deve ser re-implementado por subclasses.
         #
         def on_message(received_message)
           class << received_message
             include MessageType
           end
           
           on_receive_message(received_message)
         end
         
         #
-        # É executado todas as vezes que chega uma mensagem que atenda aos critérios
-        # definido para este listener (na variável de instância @criteria).
+        # E executado todas as vezes que chega uma mensagem que atenda aos criterios
+        # definido para este listener (na variavel de instancia @criteria).
         #
         # Invariavelmente deve ser re-implementado nas subclasses.
         #
         def on_receive_message(received_message)
           raise Utils::Exception::AbstractMethodError.new('on_receive_message')
@@ -225,6 +222,6 @@
       def is_map_message?
         respond_to? :get_long
       end
     end
   end
-end
\ No newline at end of file
+end