sprsquish-blather 0.3.4 → 0.4.0

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

@@ -0,0 +1,53 @@
+module Blather
+class Stanza
+class PubSub
+
+  class Retract < PubSub
+    register :pubsub_retract, :retract, self.registered_ns
+
+    include Enumerable
+    alias_method :find, :xpath
+
+    def self.new(host = nil, node = nil, type = :set, retractions = [])
+      new_node = super(type, host)
+      new_node.node = node
+      new_node.retractions = retractions
+      new_node
+    end
+
+    def node
+      retract[:node]
+    end
+
+    def node=(node)
+      retract[:node] = node
+    end
+
+    def retract
+      unless retract = pubsub.find_first('ns:retract', :ns => self.class.registered_ns)
+        self.pubsub << (retract = XMPPNode.new('retract', self.document))
+        retract.namespace = self.pubsub.namespace
+      end
+      retract
+    end
+
+    def retractions=(retractions = [])
+      [retractions].flatten.each { |id| self.retract << PubSubItem.new(id, nil, self.document) }
+    end
+
+    def retractions
+      retract.find('ns:item', :ns => self.class.registered_ns).map { |i| i[:id] }
+    end
+
+    def each(&block)
+      retractions.each &block
+    end
+
+    def size
+      retractions.size
+    end
+  end #Retract
+
+end #PubSub
+end #Stanza
+end #Blather

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

@@ -0,0 +1,42 @@
+module Blather
+class Stanza
+class PubSub
+
+  class Subscribe < PubSub
+    register :pubsub_subscribe, :subscribe, self.registered_ns
+
+    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
+
+    def jid
+      JID.new(subscribe[:jid])
+    end
+
+    def jid=(jid)
+      subscribe[:jid] = jid
+    end
+
+    def node
+      subscribe[:node]
+    end
+
+    def node=(node)
+      subscribe[:node] = node
+    end
+
+    def subscribe
+      unless subscribe = pubsub.find_first('ns:subscribe', :ns => self.class.registered_ns)
+        self.pubsub << (subscribe = XMPPNode.new('subscribe', self.document))
+        subscribe.namespace = self.pubsub.namespace
+      end
+      subscribe
+    end
+  end #Subscribe
+
+end #PubSub
+end #Stanza
+end #Blather

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

@@ -0,0 +1,66 @@
+module Blather
+class Stanza
+class PubSub
+
+  class Subscription < PubSub
+    VALID_TYPES = [:none, :pending, :subscribed, :unconfigured]
+
+    register :pubsub_subscription, :subscription, self.registered_ns
+
+    def self.new(type = :result, host = nil, node = nil, jid = nil, subid = nil, subscription = nil)
+      new_node = super(type, host)
+      new_node.node = node
+      new_node.jid = jid
+      new_node.subid = subid
+      new_node.subscription = subscription
+      new_node
+    end
+
+    attribute_helpers_for :subscription, VALID_TYPES
+
+    def jid
+      JID.new(subscription_node[:jid])
+    end
+
+    def jid=(jid)
+      subscription_node[:jid] = jid
+    end
+
+    def node
+      subscription_node[:node]
+    end
+
+    def node=(node)
+      subscription_node[:node] = node
+    end
+
+    def subid
+      subscription_node[:subid]
+    end
+
+    def subid=(subid)
+      subscription_node[:subid] = subid
+    end
+
+    def subscription
+      s = subscription_node[:subscription]
+      s.to_sym if s
+    end
+
+    def subscription=(subscription)
+      raise ArgumentError, "Invalid Type (#{type}), use: #{VALID_TYPES*' '}" if subscription && !VALID_TYPES.include?(subscription.to_sym)
+      subscription_node[:subscription] = subscription
+    end
+
+    def subscription_node
+      unless subscription = pubsub.find_first('ns:subscription', :ns => self.class.registered_ns)
+        self.pubsub << (subscription = XMPPNode.new('subscription', self.document))
+        subscription.namespace = self.pubsub.namespace
+      end
+      subscription
+    end
+  end #Subscribe
+
+end #PubSub
+end #Stanza
+end #Blather

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

@@ -0,0 +1,55 @@
+module Blather
+class Stanza
+class PubSub
+
+  class Subscriptions < PubSub
+    register :pubsub_subscriptions, :subscriptions, self.registered_ns
+
+    include Enumerable
+    alias_method :find, :xpath
+
+    ##
+    # Ensure the namespace is set to the query node
+    def self.new(type = nil, host = nil)
+      new_node = super type
+      new_node.to = host
+      new_node.subscriptions
+      new_node
+    end
+
+    ##
+    # Kill the pubsub node before running inherit
+    def inherit(node)
+      subscriptions.remove
+      super
+    end
+
+    def subscriptions
+      aff = pubsub.find_first('subscriptions', self.class.registered_ns)
+      (self.pubsub << (aff = XMPPNode.new('subscriptions', self.document))) unless aff
+      aff
+    end
+
+    def each(&block)
+      list.each &block
+    end
+
+    def size
+      list.size
+    end
+
+    def list
+      subscriptions.find('//ns:subscription', :ns => self.class.registered_ns).inject({}) do |hash, item|
+        hash[item[:subscription].to_sym] ||= []
+        hash[item[:subscription].to_sym] << {
+          :node => item[:node],
+          :jid => item[:jid]
+        }
+        hash
+      end
+    end
+  end #Subscriptions
+
+end #PubSub
+end #Stanza
+end #Blather

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

@@ -0,0 +1,42 @@
+module Blather
+class Stanza
+class PubSub
+
+  class Unsubscribe < PubSub
+    register :pubsub_unsubscribe, :unsubscribe, self.registered_ns
+
+    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
+
+    def jid
+      JID.new(unsubscribe[:jid])
+    end
+
+    def jid=(jid)
+      unsubscribe[:jid] = jid
+    end
+
+    def node
+      unsubscribe[:node]
+    end
+
+    def node=(node)
+      unsubscribe[:node] = node
+    end
+
+    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,63 @@
+module Blather
+class Stanza
+
+  class PubSub < Iq
+    register :pubsub_node, :pubsub, 'http://jabber.org/protocol/pubsub'
+
+    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
+
+    ##
+    # Ensure the namespace is set to the query node
+    def self.new(type = nil, host = nil)
+      new_node = super type
+      new_node.to = host
+      new_node.pubsub
+      new_node
+    end
+
+    ##
+    # Kill the pubsub node before running inherit
+    def inherit(node)
+      remove_children :pubsub
+      super
+    end
+
+    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
+
+  class PubSubItem < XMPPNode
+    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
+
+    attribute_accessor :id
+
+    def payload=(payload = nil)
+      self.content = payload
+    end
+
+    def payload
+      content.empty? ? nil : content
+    end
+  end
+
+end #Stanza
+end #Blather

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

@@ -0,0 +1,34 @@
+module Blather
+class Stanza
+class PubSubOwner
+
+  class Delete < PubSubOwner
+    
+    register :pubsub_delete, :delete, self.registered_ns
+
+    def self.new(type = :set, host = nil, node = nil)
+      new_node = super(type, host)
+      new_node.node = node
+      new_node
+    end
+
+    def node
+      delete_node[:node]
+    end
+
+    def node=(node)
+      delete_node[:node] = node
+    end
+
+    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,34 @@
+module Blather
+class Stanza
+class PubSubOwner
+
+  class Purge < PubSubOwner
+    
+    register :pubsub_purge, :purge, self.registered_ns
+
+    def self.new(type = :set, host = nil, node = nil)
+      new_node = super(type, host)
+      new_node.node = node
+      new_node
+    end
+
+    def node
+      purge_node[:node]
+    end
+
+    def node=(node)
+      purge_node[:node] = node
+    end
+
+    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,41 @@
+module Blather
+class Stanza
+
+  class PubSubOwner < Iq
+    register :pubsub_owner, :pubsub, 'http://jabber.org/protocol/pubsub#owner'
+
+    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
+
+    ##
+    # Ensure the namespace is set to the query node
+    def self.new(type = nil, host = nil)
+      new_node = super type
+      new_node.to = host
+      new_node.pubsub
+      new_node
+    end
+
+    ##
+    # Kill the pubsub node before running inherit
+    def inherit(node)
+      remove_children :pubsub
+      super
+    end
+
+    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
+
+end #Stanza
+end #Blather

data/lib/blather/stanza.rb

@@ -14,12 +14,12 @@ module Blather
     # that inherits Stanza can register a callback for itself
     # which is added to a list and iterated over when looking for
     # a callback to use
-    def self.register(type, name = nil, ns = nil)
-      @@handler_list << type
+    def self.register(handler, name = nil, ns = nil)
+      @@handler_list << handler
       self.handler_heirarchy ||= []
-      self.handler_heirarchy.unshift type
+      self.handler_heirarchy.unshift handler
 
-      name = name || self.name || type
+      name = name || self.registered_name || handler
       super name, ns
     end
 
@@ -44,24 +44,32 @@ module Blather
     ##
     # Automatically set the stanza's ID
     # and attach it to a document so XPath searching works
-    def initialize(name = nil)
-      super
-      XML::Document.new.root = self
-      self.name = name.to_s if name
-      self.id = self.class.next_id
+    def self.new(name = nil)
+      node = super
+      node.name = name.to_s if name
+      node
     end
 
     ##
-    # Helper method to ask the object if it's an error
-    def error?
-      self.type == :error
+    # Helper method to generate stanza guard methods
+    #
+    # attribute_helpers_for(:type, [:subscribe, :unsubscribe])
+    #
+    # This generates "subscribe?" and "unsubscribe?" methods that return
+    # true if self.type == :subscribe or :unsubscribe, respectively.
+    def self.attribute_helpers_for(attr, values)
+      [values].flatten.each do |v|
+        define_method("#{v}?") { __send__(attr) == v }
+      end
     end
 
+    attribute_helpers_for(:type, :error)
+
     ##
     # Copies itself then swaps from and to
     # then returns the new stanza
     def reply
-      self.copy(true).reply!
+      self.dup.reply!
     end
 
     ##
@@ -71,23 +79,23 @@ module Blather
       self
     end
 
-    attribute_accessor :id, :to_sym => false
+    attribute_accessor :id
 
     attribute_writer :to, :from
 
     ##
     # returns:: JID created from the "to" value of the stanza
     def to
-      JID.new(attributes[:to]) if attributes[:to]
+      JID.new(self[:to]) if self[:to]
     end
 
     ##
     # returns:: JID created from the "from" value of the stanza
     def from
-      JID.new(attributes[:from]) if attributes[:from]
+      JID.new(self[:from]) if self[:from]
     end
 
-    attribute_accessor :type
+    attribute_accessor :type, :call => :to_sym
 
     ##
     # Transform the stanza into a stanza error
@@ -96,5 +104,14 @@ module Blather
     def as_error(name, type, text = nil, extras = [])
       StanzaError.new self, name, type, text, extras
     end
+
+    protected
+    def reply_if_needed!
+      unless @reversed_endpoints
+        reply!
+        @reversed_endpoints = true
+      end
+      self
+    end
   end
-end
+end

data/lib/blather/stream/client.rb

@@ -6,14 +6,13 @@ class Stream
     VERSION = '1.0'
     NAMESPACE = 'jabber:client'
 
-  protected
     def start
       @parser = Parser.new self
       start_stream = <<-STREAM
         <stream:stream
           to='#{@to}'
           xmlns='#{NAMESPACE}'
-          xmlns:stream='http://etherx.jabber.org/streams'
+          xmlns:stream='#{STREAM_NS}'
           version='#{VERSION}'
           xml:lang='#{LANG}'
         >

data/lib/blather/stream/component.rb

@@ -6,24 +6,28 @@ class Stream
 
     def receive(node) # :nodoc:
       if node.element_name == 'handshake'
-        @client.post_init
+        ready!
       else
         super
       end
 
-      if node.namespaces.find_by_href('http://etherx.jabber.org/streams') && node.find_first('/stream:stream[not(stream:error)]')
-        send("<handshake>#{Digest::SHA1.hexdigest(@node['id']+@pass)}</handshake>")
+      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
 
-  protected
+    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='http://etherx.jabber.org/streams'
+          xmlns:stream='#{STREAM_NS}'
         >
       STREAM
       send start_stream.gsub(/\s+/, ' ')

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/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