shingara-blather 0.4.8

data/lib/blather/stanza/pubsub/unsubscribe.rb

@@ -0,0 +1,68 @@
+module Blather
+class Stanza
+class PubSub
+
+  # # PubSub Unsubscribe Stanza
+  #
+  # [XEP-0060 Section 6.2 - Unsubscribe from a Node](http://xmpp.org/extensions/xep-0060.html#subscriber-unsubscribe)
+  #
+  # @handler :pubsub_unsubscribe
+  class Unsubscribe < PubSub
+    register :pubsub_unsubscribe, :unsubscribe, self.registered_ns
+
+    # Create a new unsubscribe node
+    #
+    # @param [Blather::Stanza::Iq::VALID_TYPES] type the IQ stanza type
+    # @param [String] host the host to send the request to
+    # @param [String] node the node to unsubscribe from
+    # @param [Blather::JID, #to_s] jid the JID of the unsubscription
+    def self.new(type = :set, host = nil, node = nil, jid = nil)
+      new_node = super(type, host)
+      new_node.node = node
+      new_node.jid = jid
+      new_node
+    end
+
+    # Get the JID of the unsubscription
+    #
+    # @return [Blather::JID]
+    def jid
+      JID.new(unsubscribe[:jid])
+    end
+
+    # Set the JID of the unsubscription
+    #
+    # @param [Blather::JID, #to_s] jid
+    def jid=(jid)
+      unsubscribe[:jid] = jid
+    end
+
+    # Get the name of the node to unsubscribe from
+    #
+    # @return [String]
+    def node
+      unsubscribe[:node]
+    end
+
+    # Set the name of the node to unsubscribe from
+    #
+    # @param [String] node
+    def node=(node)
+      unsubscribe[:node] = node
+    end
+
+    # Get or create the actual unsubscribe node
+    #
+    # @return [Blather::XMPPNode]
+    def unsubscribe
+      unless unsubscribe = pubsub.find_first('ns:unsubscribe', :ns => self.class.registered_ns)
+        self.pubsub << (unsubscribe = XMPPNode.new('unsubscribe', self.document))
+        unsubscribe.namespace = self.pubsub.namespace
+      end
+      unsubscribe
+    end
+  end  # Unsubscribe
+
+end  # PubSub
+end  # Stanza
+end  # Blather

data/lib/blather/stanza/pubsub.rb

@@ -0,0 +1,129 @@
+module Blather
+class Stanza
+
+  # # Pubsub Stanza
+  #
+  # [XEP-0060 - Publish-Subscribe](http://xmpp.org/extensions/xep-0060.html)
+  #
+  # The base class for all PubSub nodes. This provides helper methods common to
+  # all PubSub nodes.
+  #
+  # @handler :pubsub_node
+  class PubSub < Iq
+    register :pubsub_node, :pubsub, 'http://jabber.org/protocol/pubsub'
+
+    # @private
+    def self.import(node)
+      klass = nil
+      if pubsub = node.document.find_first('//ns:pubsub', :ns => self.registered_ns)
+        pubsub.children.detect do |e|
+          ns = e.namespace ? e.namespace.href : nil
+          klass = class_from_registration(e.element_name, ns)
+        end
+      end
+      (klass || self).new(node[:type]).inherit(node)
+    end
+
+    # Overwrites the parent constructor to ensure a pubsub node is present.
+    # Also allows the addition of a host attribute
+    #
+    # @param [<Blather::Stanza::Iq::VALID_TYPES>] type the IQ type
+    # @param [String, nil] host the host the node should be sent to
+    def self.new(type = nil, host = nil)
+      new_node = super type
+      new_node.to = host
+      new_node.pubsub
+      new_node
+    end
+
+    # Overrides the parent to ensure the current pubsub node is destroyed before
+    # inheritting the new content
+    #
+    # @private
+    def inherit(node)
+      remove_children :pubsub
+      super
+    end
+
+    # Get or create the pubsub node on the stanza
+    #
+    # @return [Blather::XMPPNode]
+    def pubsub
+      p = find_first('ns:pubsub', :ns => self.class.registered_ns) ||
+          find_first('pubsub', :ns => self.class.registered_ns)
+
+      unless p
+        self << (p = XMPPNode.new('pubsub', self.document))
+        p.namespace = self.class.registered_ns
+      end
+      p
+    end
+  end  # PubSub
+
+  # # PubSubItem Fragment
+  #
+  # This fragment is found in many places throughout the pubsub spec
+  # This is a convenience class to attach methods to the node
+  class PubSubItem < XMPPNode
+    ATOM_NS = 'http://www.w3.org/2005/Atom'.freeze
+
+    # Create a new PubSubItem
+    #
+    # @param [String, nil] id the id of the stanza
+    # @param [#to_s, nil] payload the payload to attach to this item.
+    # @param [XML::Document, nil] document the document the node should be
+    # attached to. This should be the document of the parent PubSub node.
+    def self.new(id = nil, payload = nil, document = nil)
+      new_node = super 'item', document
+      new_node.id = id
+      new_node.payload = payload if payload
+      new_node
+    end
+
+    # Get the item's ID
+    #
+    # @return [String, nil]
+    def id
+      read_attr :id
+    end
+
+    # Set the item's ID
+    #
+    # @param [#to_s] id the new ID
+    def id=(id)
+      write_attr :id, id
+    end
+
+    # Get the item's payload
+    #
+    # To get the XML representation use #entry
+    #
+    # @return [String, nil]
+    def payload
+      self.entry.content.empty? ? nil : content
+    end
+
+    # Set the item's payload
+    #
+    # @param [String, nil] payload the payload
+    def payload=(payload)
+      self.entry.content = payload
+    end
+
+    # Get or create the entry node
+    #
+    # @return [Blather::XMPPNode]
+    def entry
+      e = find_first('ns:entry', :ns => ATOM_NS) ||
+          find_first('entry', :ns => ATOM_NS)
+
+      unless e
+        self << (e = XMPPNode.new('entry', self.document))
+        e.namespace = ATOM_NS
+      end
+      e
+    end
+  end  # PubSubItem
+
+end  # Stanza
+end  # Blather

data/lib/blather/stanza/pubsub_owner/delete.rb

@@ -0,0 +1,52 @@
+module Blather
+class Stanza
+class PubSubOwner
+
+  # # PubSubOwner Delete Stanza
+  #
+  # [XEP-0060 Section 8.4 Delete a Node](http://xmpp.org/extensions/xep-0060.html#owner-delete)
+  #
+  # @handler :pubsub_delete
+  class Delete < PubSubOwner
+    register :pubsub_delete, :delete, self.registered_ns
+
+    # Create a new delete stanza
+    #
+    # @param [Blather::Stanza::Iq::VALID_TYPES] type the IQ stanza type
+    # @param [String] host the host to send the request to
+    # @param [String] node the name of the node to delete
+    def self.new(type = :set, host = nil, node = nil)
+      new_node = super(type, host)
+      new_node.node = node
+      new_node
+    end
+
+    # Get the name of the node to delete
+    #
+    # @return [String]
+    def node
+      delete_node[:node]
+    end
+
+    # Set the name of the node to delete
+    #
+    # @param [String] node
+    def node=(node)
+      delete_node[:node] = node
+    end
+
+    # Get or create the actual delete node on the stanza
+    #
+    # @return [Blather::XMPPNode]
+    def delete_node
+      unless delete_node = pubsub.find_first('ns:delete', :ns => self.class.registered_ns)
+        self.pubsub << (delete_node = XMPPNode.new('delete', self.document))
+        delete_node.namespace = self.pubsub.namespace
+      end
+      delete_node
+    end
+  end  # Retract
+
+end  # PubSub
+end  # Stanza
+end  # Blather

data/lib/blather/stanza/pubsub_owner/purge.rb

@@ -0,0 +1,52 @@
+module Blather
+class Stanza
+class PubSubOwner
+
+  # # PubSubOwner Purge Stanza
+  #
+  # [XEP-0060 Section 8.5 - Purge All Node Items](http://xmpp.org/extensions/xep-0060.html#owner-purge)
+  #
+  # @handler :pubsub_purge
+  class Purge < PubSubOwner
+    register :pubsub_purge, :purge, self.registered_ns
+
+    # Create a new purge stanza
+    #
+    # @param [Blather::Stanza::Iq::VALID_TYPES] type the IQ stanza type
+    # @param [String] host the host to send the request to
+    # @param [String] node the name of the node to purge
+    def self.new(type = :set, host = nil, node = nil)
+      new_node = super(type, host)
+      new_node.node = node
+      new_node
+    end
+
+    # Get the name of the node to delete
+    #
+    # @return [String]
+    def node
+      purge_node[:node]
+    end
+
+    # Set the name of the node to delete
+    #
+    # @param [String] node
+    def node=(node)
+      purge_node[:node] = node
+    end
+
+    # Get or create the actual purge node on the stanza
+    #
+    # @return [Blather::XMPPNode]
+    def purge_node
+      unless purge_node = pubsub.find_first('ns:purge', :ns => self.class.registered_ns)
+        self.pubsub << (purge_node = XMPPNode.new('purge', self.document))
+        purge_node.namespace = self.pubsub.namespace
+      end
+      purge_node
+    end
+  end  # Retract
+
+end  # PubSub
+end  # Stanza
+end  # Blather

data/lib/blather/stanza/pubsub_owner.rb

@@ -0,0 +1,51 @@
+module Blather
+class Stanza
+
+  # # PubSubOwner Base Class
+  #
+  # [XEP-0060 - Publish-Subscribe](http://xmpp.org/extensions/xep-0060.html)
+  #
+  # @handler :pubsub_owner
+  class PubSubOwner < Iq
+    register :pubsub_owner, :pubsub, 'http://jabber.org/protocol/pubsub#owner'
+
+    # Creates the proper class from the stana's child
+    # @private
+    def self.import(node)
+      klass = nil
+      if pubsub = node.document.find_first('//ns:pubsub', :ns => self.registered_ns)
+        pubsub.children.each { |e| break if klass = class_from_registration(e.element_name, (e.namespace.href if e.namespace)) }
+      end
+      (klass || self).new(node[:type]).inherit(node)
+    end
+
+    # Overrides the parent to ensure a pubsub node is created
+    # @private
+    def self.new(type = nil, host = nil)
+      new_node = super type
+      new_node.to = host
+      new_node.pubsub
+      new_node
+    end
+
+    # Overrides the parent to ensure the pubsub node is destroyed
+    # @private
+    def inherit(node)
+      remove_children :pubsub
+      super
+    end
+
+    # Get or create the pubsub node on the stanza
+    #
+    # @return [Blather::XMPPNode]
+    def pubsub
+      unless p = find_first('ns:pubsub', :ns => self.class.registered_ns)
+        self << (p = XMPPNode.new('pubsub', self.document))
+        p.namespace = self.class.registered_ns
+      end
+      p
+    end
+  end  # PubSubOwner
+
+end  # Stanza
+end  # Blather

data/lib/blather/stanza.rb

@@ -0,0 +1,149 @@
+module Blather
+
+  # # Base XMPP Stanza
+  #
+  # All stanzas inherit this class. It provides a set of methods and helpers
+  # common to all XMPP Stanzas
+  #
+  # @handler :stanza
+  class Stanza < XMPPNode
+    # @private
+    @@last_id = 0
+    # @private
+    @@handler_list = []
+
+    class_inheritable_array :handler_hierarchy
+
+    # Registers a callback onto the callback stack
+    #
+    # @param [Symbol] handler the name of the handler
+    # @param [Symbol, String, nil] name the name of the first element in the
+    #        stanza. If nil the inherited name will be used. If that's nil the
+    #        handler name will be used.
+    # @param [String, nil] ns the namespace of the stanza
+    def self.register(handler, name = nil, ns = nil)
+      @@handler_list << handler
+      self.handler_hierarchy ||= [:stanza]
+      self.handler_hierarchy.unshift handler
+
+      name = name || self.registered_name || handler
+      super name, ns
+    end
+
+    # The handler stack for the current stanza class
+    #
+    # @return [Array<Symbol>]
+    def self.handler_list
+      @@handler_list
+    end
+
+    # Helper method that creates a unique ID for stanzas
+    #
+    # @return [String] a new unique ID
+    def self.next_id
+      @@last_id += 1
+      'blather%04x' % @@last_id
+    end
+
+    # Check if the stanza is an error stanza
+    #
+    # @return [true, false]
+    def error?
+      self.type == :error
+    end
+
+    # Creates a copy with to and from swapped
+    #
+    # @return [Blather::Stanza]
+    def reply
+      self.dup.reply!
+    end
+
+    # Swaps from and to
+    #
+    # @return [self]
+    def reply!
+      self.to, self.from = self.from, self.to
+      self
+    end
+
+    # Get the stanza's ID
+    #
+    # @return [String, nil]
+    def id
+      read_attr :id
+    end
+
+    # Set the stanza's ID
+    #
+    # @param [#to_s] id the new stanza ID
+    def id=(id)
+      write_attr :id, id
+    end
+
+    # Get the stanza's to
+    #
+    # @return [Blather::JID, nil]
+    def to
+      JID.new(self[:to]) if self[:to]
+    end
+
+    # Set the stanza's to field
+    #
+    # @param [#to_s] to the new JID for the to field
+    def to=(to)
+      write_attr :to, to
+    end
+
+    # Get the stanza's from
+    #
+    # @return [Blather::JID, nil]
+    def from
+      JID.new(self[:from]) if self[:from]
+    end
+
+    # Set the stanza's from field
+    #
+    # @param [#to_s] from the new JID for the from field
+    def from=(from)
+      write_attr :from, from
+    end
+
+    # Get the stanza's type
+    #
+    # @return [Symbol, nil]
+    def type
+      read_attr :type, :to_sym
+    end
+
+    # Set the stanza's type
+    #
+    # @param [#to_s] type the new stanza type
+    def type=(type)
+      write_attr :type, type
+    end
+
+    # Create an error stanza from the current stanza
+    #
+    # @param [String] name the error name
+    # @param [<Blather::StanzaError::VALID_TYPES>] type the error type
+    # @param [String, nil] text the error text
+    # @param [Array<XML::Node>] extras an array of extra nodes to attach to
+    # the error
+    #
+    # @return [Blather::StanzaError]
+    def as_error(name, type, text = nil, extras = [])
+      StanzaError.new self, name, type, text, extras
+    end
+
+  protected
+    # @private
+    def reply_if_needed!
+      unless @reversed_endpoints
+        reply!
+        @reversed_endpoints = true
+      end
+      self
+    end
+  end
+end

data/lib/blather/stream/client.rb

@@ -0,0 +1,31 @@
+module Blather
+class Stream
+
+  class Client < Stream
+    LANG = 'en'
+    VERSION = '1.0'
+    NAMESPACE = 'jabber:client'
+
+    def start
+      @parser = Parser.new self
+      start_stream = <<-STREAM
+        <stream:stream
+          to='#{@to}'
+          xmlns='#{NAMESPACE}'
+          xmlns:stream='#{STREAM_NS}'
+          version='#{VERSION}'
+          xml:lang='#{LANG}'
+        >
+      STREAM
+      send start_stream.gsub(/\s+/, ' ')
+    end
+
+    def send(stanza)
+      stanza.from = self.jid if stanza.is_a?(Stanza) && !stanza.from.nil?
+      super stanza
+    end
+
+  end #Client
+
+end #Stream
+end #Blather

data/lib/blather/stream/component.rb

@@ -0,0 +1,38 @@
+module Blather
+class Stream
+
+  class Component < Stream
+    NAMESPACE = 'jabber:component:accept'
+
+    def receive(node) # :nodoc:
+      if node.element_name == 'handshake'
+        ready!
+      else
+        super
+      end
+
+      if node.document.find_first('/stream:stream[not(stream:error)]', :xmlns => NAMESPACE, :stream => STREAM_NS)
+        send("<handshake>#{Digest::SHA1.hexdigest(@node['id']+@password)}</handshake>")
+      end
+    end
+
+    def send(stanza)
+      stanza.from ||= self.jid if stanza.respond_to?(:from) && stanza.respond_to?(:from=)
+      super stanza
+    end
+
+    def start
+      @parser = Parser.new self
+      start_stream = <<-STREAM
+        <stream:stream
+          to='#{@jid}'
+          xmlns='#{NAMESPACE}'
+          xmlns:stream='#{STREAM_NS}'
+        >
+      STREAM
+      send start_stream.gsub(/\s+/, ' ')
+    end
+  end #Client
+
+end #Stream
+end #Blather

data/lib/blather/stream/features/resource.rb

@@ -0,0 +1,63 @@
+module Blather # :nodoc:
+class Stream # :nodoc:
+
+  class Resource < Features # :nodoc:
+    BIND_NS = 'urn:ietf:params:xml:ns:xmpp-bind'.freeze
+    register BIND_NS
+
+    def initialize(stream, succeed, fail)
+      super
+      @jid = stream.jid
+    end
+
+    def receive_data(stanza)
+      @node = stanza
+      case stanza.element_name
+      when 'bind' then  bind
+      when 'iq'   then  result
+      else              fail!(UnknownResponse.new(@node))
+      end
+    end
+
+  private
+    ##
+    # Respond to the bind request
+    # If @jid has a resource set already request it from the server
+    def bind
+      response = Stanza::Iq.new :set
+      @id = response.id
+
+      response << (binder = XMPPNode.new('bind', response.document))
+      binder.namespace = BIND_NS
+
+      if @jid.resource
+        binder << (resource = XMPPNode.new('resource', binder.document))
+        resource.content = @jid.resource
+      end
+
+      @stream.send response
+    end
+
+    ##
+    # Process the result from the server
+    # Sets the sends the JID (now bound to a resource)
+    # back to the stream
+    def result
+      if @node[:type] == 'error'
+        fail! StanzaError.import(@node)
+        return
+      end
+
+      Blather.logger.debug "RESOURCE NODE #{@node}"
+      # ensure this is a response to our original request
+      if @id == @node['id']
+        @stream.jid = JID.new @node.find_first('bind_ns:bind/bind_ns:jid', :bind_ns => BIND_NS).content
+        succeed!
+      else
+        fail!("BIND result ID mismatch. Expected: #{@id}. Received: #{@node['id']}")
+      end
+    end
+  end #Resource
+
+end #Stream
+end #Blather