blather 0.3.4 → 0.4.0

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

@@ -0,0 +1,63 @@
+module Blather
+class Stanza
+class PubSub
+
+  class Items < PubSub
+    register :pubsub_items, :items, self.registered_ns
+
+    include Enumerable
+    alias_method :find, :xpath
+
+    def self.request(host, path, list = [], max = nil)
+      node = self.new :get, host
+
+      node.node = path
+      node.max_items = max
+
+      (list || []).each { |id| node.items_node << PubSubItem.new(id, nil, node.document) }
+
+      node
+    end
+
+    def self.new(type = nil, host = nil)
+      new_node = super
+      new_node.items
+      new_node
+    end
+
+    def node
+      items_node[:node]
+    end
+
+    def node=(node)
+      items_node[:node] = node
+    end
+
+    def max_items
+      items_node[:max_items].to_i if items_node[:max_items]
+    end
+
+    def max_items=(max_items)
+      items_node[:max_items] = max_items
+    end
+
+    def each(&block)
+      items.each &block
+    end
+
+    def items
+      items_node.find('ns:item', :ns => self.class.registered_ns).map { |i| PubSubItem.new(nil,nil,self.document).inherit i }
+    end
+
+    def items_node
+      unless node = self.pubsub.find_first('ns:items', :ns => self.class.registered_ns)
+        (self.pubsub << (node = XMPPNode.new('items', self.document)))
+        node.namespace = self.pubsub.namespace
+      end
+      node
+    end
+  end
+
+end #PubSub
+end #Stanza
+end #Blather

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

@@ -0,0 +1,58 @@
+module Blather
+class Stanza
+class PubSub
+
+  class Publish < PubSub
+    register :pubsub_publish, :publish, self.registered_ns
+
+    include Enumerable
+    alias_method :find, :xpath
+
+    def self.new(host = nil, node = nil, type = :set, payload = nil)
+      new_node = super(type, host)
+      new_node.node = node
+      new_node.payload = payload if payload
+      new_node
+    end
+
+    def payload=(payload)
+      payload = case payload
+      when Hash   then  payload.to_a
+      when Array  then  payload.map { |v| [nil, v] }
+      else              [[nil, payload.to_s]]
+      end
+      payload.each { |id,value| self.publish << PubSubItem.new(id, value, self.document) }
+    end
+
+    def node
+      publish[:node]
+    end
+
+    def node=(node)
+      publish[:node] = node
+    end
+
+    def publish
+      unless publish = pubsub.find_first('ns:publish', :ns => self.class.registered_ns)
+        self.pubsub << (publish = XMPPNode.new('publish', self.document))
+        publish.namespace = self.pubsub.namespace
+      end
+      publish
+    end
+
+    def items
+      publish.find('ns:item', :ns => self.class.registered_ns).map { |i| PubSubItem.new(nil,nil,self.document).inherit i }
+    end
+
+    def each(&block)
+      items.each &block
+    end
+
+    def size
+      items.size
+    end
+  end #Publish
+
+end #PubSub
+end #Stanza
+end #Blather

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