stomper 1.0.0 → 2.0.0

data/lib/stomper/frames/commit.rb

@@ -1,10 +0,0 @@
-module Stomper
-  module Frames
-    # Encapsulates a "COMMIT" frame from the Stomp Protocol.
-    class Commit < Stomper::Frames::ClientFrame
-      def initialize(transaction_id, headers={})
-        super(headers.merge({ :transaction => transaction_id }))
-      end
-    end
-  end
-end

data/lib/stomper/frames/connect.rb

@@ -1,10 +0,0 @@
-module Stomper
-  module Frames
-    # Encapsulates a "CONNECT" frame from the Stomp Protocol.
-    class Connect < Stomper::Frames::ClientFrame
-      def initialize(login='', passcode='', headers={})
-        super(headers.merge({ :login => login, :passcode => passcode }))
-      end
-    end
-  end
-end

data/lib/stomper/frames/connected.rb

@@ -1,30 +0,0 @@
-module Stomper
-  module Frames
-    # Encapsulates a "CONNECTED" server side frame for the Stomp Protocol.
-    class Connected < Stomper::Frames::ServerFrame
-
-      # Builds a Connected frame instance with the supplied
-      # +headers+ and +body+
-      def initialize(headers, body)
-        super(headers, body)
-      end
-
-      # A convenience method that returns the value of
-      # the session header, if it is set.
-      #
-      # This value can also be accessed as:
-      # frame.headers[:session]
-      def session
-        @headers[:session]
-      end
-
-      def perform
-        # TODO: I want the frames, particularly the server frames, to know
-        # 'what to do' when they are received.  For instance, when a CONNECTED
-        # frame is received, the connection it is received on should be marked
-        # as being "connected".  This way we can get rid of the various conditional
-        # behavior based on Frame classes in connection and client.
-      end
-    end
-  end
-end

data/lib/stomper/frames/disconnect.rb

@@ -1,10 +0,0 @@
-module Stomper
-  module Frames
-    # Encapsulates a "DISCONNECT" frame from the Stomp Protocol.
-    class Disconnect < Stomper::Frames::ClientFrame
-      def initialize(headers={})
-        super(headers)
-      end
-    end
-  end
-end

data/lib/stomper/frames/error.rb

@@ -1,21 +0,0 @@
-module Stomper
-  module Frames
-    # Encapsulates an "ERROR" server side frame for the Stomp Protocol.
-    class Error < Stomper::Frames::ServerFrame
-
-      # Creates a new Error frame with the supplied +headers+ and +body+
-      def initialize(headers, body)
-        super(headers, body)
-      end
-
-      # Returns the message responsible for the generation of this Error frame,
-      # if applicable.
-      #
-      # This is a convenience method for:
-      # frame.headers[:message]
-      def message
-        @headers[:message]
-      end
-    end
-  end
-end

data/lib/stomper/frames/message.rb

@@ -1,48 +0,0 @@
-module Stomper
-  module Frames
-    # Encapsulates a "MESSAGE" server side frame for the Stomp Protocol.
-    class Message < Stomper::Frames::ServerFrame
-
-      # Creates a new message frame with the given +headers+ and +body+
-      def initialize(headers, body)
-        super(headers, body)
-      end
-
-      # Returns the message id generated by the stomp broker.
-      #
-      # This is a convenience method for:
-      # frame.headers[:'message-id']
-      def id
-        @headers[:'message-id']
-      end
-
-      # Returns the destination from which this message was delivered.
-      #
-      # This is a convenience method for:
-      # frame.headers[:destination]
-      def destination
-        @headers[:destination]
-      end
-
-      # Returns the name of the subscription which is responsible for the
-      # client having received this message.
-      #
-      # This is a convenience method for:
-      # frame.headers[:subscription]
-      def subscription
-        @headers[:subscription]
-      end
-
-      def perform
-        # TODO: I want the frames, particularly the server frames, to know
-        # 'what to do' when they are received.  For instance, when a MESSAGE
-        # frame is received, the message should be applied to all
-        # stored subscriptions on the receiving connection.  This will
-        # remove the conditional branching in the Client class, and provide
-        # a more flexible means of adding additional behaviors, instead of
-        # relying on what is sure to become a giant case statement in Client
-        # if we must change state on other Frames later.
-      end
-    end
-  end
-end

data/lib/stomper/frames/receipt.rb

@@ -1,19 +0,0 @@
-module Stomper
-  module Frames
-    # Encapsulates a "RECEIPT" server side frame for the Stomp Protocol.
-    class Receipt < Stomper::Frames::ServerFrame
-
-      # Creates a new Receipt frame with the supplied +headers+ and +body+
-      def initialize(headers, body)
-        super(headers, body)
-      end
-
-      # Returns the 'receipt-id' header of the frame, which
-      # will correspond to the 'receipt' header of the message
-      # that caused this receipt to be sent by the stomp broker.
-      def for
-        @headers[:'receipt-id']
-      end
-    end
-  end
-end

data/lib/stomper/frames/send.rb

@@ -1,10 +0,0 @@
-module Stomper
-  module Frames
-    # Encapsulates a "SEND" frame from the Stomp Protocol.
-    class Send < Stomper::Frames::ClientFrame
-      def initialize(destination, body, headers={})
-        super(headers.merge({ :destination => destination }), body)
-      end
-    end
-  end
-end

data/lib/stomper/frames/server_frame.rb

@@ -1,38 +0,0 @@
-module Stomper
-  module Frames
-    # Encapsulates a server side frame for the Stomp Protocol.
-    class ServerFrame < IndirectFrame
-
-      # Creates a new server frame corresponding to the
-      # supplied +command+ with the given +headers+ and +body+.
-      def initialize(headers={}, body=nil, command = nil)
-        super
-      end
-
-      class << self
-        def inherited(server_frame) #:nodoc:
-          declared_frames << { :class => server_frame, :command => server_frame.name.split("::").last.downcase.to_sym }
-        end
-
-        def declared_frames
-          @declared_frames ||= []
-        end
-
-        # Builds a new ServerFrame instance by first checking to
-        # see if some subclass of ServerFrame has registered itself
-        # as a builder of the particular command.  If so, a new
-        # instance of that subclass is created, otherwise a generic
-        # ServerFrame instance is created with its +command+ attribute
-        # set appropriately.
-        def build(command, headers, body)
-          com_sym = command.downcase.to_sym
-          if klass = declared_frames.detect { |frame| com_sym == frame[:command] }
-            klass[:class].new(headers, body)
-          else
-            ServerFrame.new(headers, body, command)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/stomper/frames/subscribe.rb

@@ -1,42 +0,0 @@
-module Stomper
-  module Frames
-    # Encapsulates a "SUBSCRIBE" frame from the Stomp Protocol.
-    class Subscribe < Stomper::Frames::ClientFrame
-      def initialize(destination, headers={})
-        super({ :ack => 'auto' }.merge(headers).merge({ :destination => destination }))
-      end
-
-      # Returns the ack mode of this subscription. (defaults to 'auto')
-      #
-      # This is a convenience method, and may also be accessed through
-      # frame.headers[:ack]
-      def ack
-        @headers[:ack]
-      end
-
-      # Returns the destination to which we are subscribing.
-      #
-      # This is a convenience method, and may also be accessed through
-      # frame.headers[:destination]
-      def destination
-        @headers[:destination]
-      end
-
-      # Returns the id of this subscription, if it has been set.
-      #
-      # This is a convenience method, and may also be accessed through
-      # frame.headers[:id]
-      def id
-        @headers[:id]
-      end
-
-      # Returns the selector header of this subscription, if it has been set.
-      #
-      # This is a convenience method, and may also be accessed through
-      # frame.headers[:selector]
-      def selector
-        @headers[:selector]
-      end
-    end
-  end
-end

data/lib/stomper/frames/unsubscribe.rb

@@ -1,19 +0,0 @@
-module Stomper
-  module Frames
-    # Encapsulates an "UNSUBSCRIBE" frame from the Stomp Protocol.
-    class Unsubscribe < Stomper::Frames::ClientFrame
-      def initialize(destination, headers={})
-        super(headers.merge({ :destination => destination }))
-      end
-
-      # Returns the id of the subscription being unsubscribed from, if it
-      # exists.
-      #
-      # This is a convenience method, and may also be accessed through
-      # frame.headers[:id]
-      def id
-        @headers[:id]
-      end
-    end
-  end
-end

data/lib/stomper/open_uri_interface.rb

@@ -1,41 +0,0 @@
-module Stomper
-  module OpenUriInterface
-    def put(msg, headers={})
-      send(default_destination, msg, headers.merge(:generate_content_length => false))
-    end
-    alias_method :puts, :put
-
-    def write(msg, headers={})
-      send(default_destination, msg, headers.merge(:generate_content_length => true))
-    end
-
-    def first(n=1)
-      received = []
-      each do |m|
-        received << m
-        break if received.size == n
-      end
-      n == 1 ? received.first : received
-    end
-    alias_method :get, :first
-    alias_method :gets, :first
-    alias_method :read, :first
-
-    # This is the tricky one.
-    # The subscriber interface is not going to work here, because it is built
-    # for an entirely different use case (threaded receiving)
-    # This interface, by contrast, is blocking... fudge.
-    def each(&block)
-      subscription = subscribe(default_destination) { |m| m }
-      loop do
-        m = receive
-        yield m if m.is_a?(Stomper::Frames::Message) && subscription.accepts?(m)
-      end
-    end
-
-    private
-    def default_destination
-      uri.path
-    end
-  end
-end

data/lib/stomper/receipt_handlers.rb

@@ -1,23 +0,0 @@
-module Stomper
-  class ReceiptHandlers
-    def initialize
-      @recps = {}
-      @recp_lock = Mutex.new
-    end
-
-    def add(receipt_id, callback)
-      @recp_lock.synchronize { @recps[receipt_id] = callback }
-    end
-    
-    def size
-      @recps.size
-    end
-
-    def perform(receipt)
-      @recp_lock.synchronize do
-        callback = @recps.delete(receipt.for)
-        callback.call(receipt) if callback
-      end
-    end
-  end
-end

data/lib/stomper/receiptor.rb

@@ -1,38 +0,0 @@
-module Stomper
-  module Receiptor
-    def self.included(base)
-      if base.method_defined?(:receive)
-        base.instance_eval do
-          alias_method :receive_without_receipt_dispatch, :receive
-          alias_method :receive, :receive_with_receipt_dispatch
-        end
-      end
-      if base.method_defined?(:send)
-        base.instance_eval do
-          alias_method :send_without_receipt_handler, :send
-          alias_method :send, :send_with_receipt_handler
-        end
-      end
-    end
-
-    # Receives a frame and dispatches it to the known receipt handlers, if the
-    # received frame is a RECEIPT frame.
-    def receive_with_receipt_dispatch
-      frame = receive_without_receipt_dispatch
-      receipt_handlers.perform(frame) if frame.is_a?(::Stomper::Frames::Receipt)
-      frame
-    end
-    
-    def send_with_receipt_handler(destination, body, headers={}, &block)
-      if block_given?
-        headers[:receipt] ||= "rcpt-#{Time.now.to_f}"
-        receipt_handlers.add(headers[:receipt], block)
-      end
-      send_without_receipt_handler(destination, body, headers)
-    end
-
-    def receipt_handlers
-      @receipt_handlers ||= ::Stomper::ReceiptHandlers.new
-    end
-  end
-end

data/lib/stomper/subscriber.rb

@@ -1,76 +0,0 @@
-module Stomper
-  module Subscriber
-    def self.included(base)
-      if base.method_defined?(:receive)
-        base.instance_eval do
-          alias_method :receive_without_message_dispatch, :receive
-          alias_method :receive, :receive_with_message_dispatch
-        end
-      end
-    end
-
-    # Receives a frame and dispatches it to the known subscriptions, if the
-    # received frame is a MESSAGE frame.
-    def receive_with_message_dispatch
-      frame = receive_without_message_dispatch
-      subscriptions.perform(frame) if frame.is_a?(::Stomper::Frames::Message)
-      frame
-    end
-
-    # Subscribes to the specified +destination+, passing along
-    # the optional +headers+ inside the subscription frame.  When a message
-    # is received for this subscription, the supplied +block+ is
-    # called with the received message as its argument.
-    #
-    # Examples:
-    #
-    #   client.subscribe("/queue/test")  { |msg| puts "Got message: #{msg.body}" }
-    #
-    #   client.subscribe("/queue/test", :ack => 'client', 'id' => 'subscription-001') do |msg|
-    #     puts "Got message: #{msg.body}"
-    #   end
-    #
-    #   client.subscribe("/queue/test", :selector => 'cost > 5') do |msg|
-    #     puts "Got message: #{msg.body}"
-    #   end
-    #
-    # See also: unsubscribe, Stomper::Subscription
-    def subscribe(destination, headers={}, &block)
-      unless destination.is_a?(Subscription)
-        destination = Subscription.new(headers.merge(:destination => destination), &block)
-      end
-      subscriptions << destination
-      transmit(destination.to_subscribe)
-      destination
-    end
-
-    # Unsubscribes from the specified +destination+.  The +destination+
-    # parameter may be either a string, such as "/queue/test", or Stomper::Subscription
-    # object.  If the optional +sub_id+ is supplied, the client will unsubscribe
-    # from the subscription with an id matching +sub_id+, regardless if the
-    # +destination+ parameter matches that of the registered subscription.  For
-    # this reason, it is vital that subscription ids, if manually specified, be
-    # unique.
-    #
-    # Examples:
-    #
-    #   client.unsubscribe("/queue/test")
-    #   # unsubscribes from all "naive" subscriptions for "/queue/test"
-    #
-    #   client.unsubscribe("/queue/does/not/matter", "sub-0013012031")
-    #   # unsubscribes from all subscriptions with id of "sub-0013012031"
-    #
-    #   client.unsubscribe(some_subscription)
-    #
-    # See also: subscribe, Stomper::Subscription
-    def unsubscribe(destination, sub_id=nil)
-      subscriptions.remove(destination, sub_id).each do |unsub|
-        transmit(unsub.to_unsubscribe)
-      end
-    end
-
-    def subscriptions
-      @subscriptions ||= ::Stomper::Subscriptions.new
-    end
-  end
-end