tp-blather 0.8.2

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

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

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

@@ -0,0 +1,18 @@
+module Blather
+class Stanza
+
+  # # PusSub Error Stanza
+  #
+  # @private
+  class PubSubErrors < PubSub
+    def node
+      read_attr :node
+    end
+
+    def node=(node)
+      write_attr :node, node
+    end
+  end  # PubSubErrors
+
+end  # Stanza
+end  # Blather

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

@@ -0,0 +1,139 @@
+module Blather
+class Stanza
+class PubSub
+
+  # # PubSub Event Stanza
+  #
+  # [XEP-0060](http://xmpp.org/extensions/xep-0060.html)
+  #
+  # The PubSub Event stanza is used in many places. Please see the XEP for more
+  # information.
+  #
+  # @handler :pubsub_event
+  class Event < Message
+    # @private
+    SHIM_NS = 'http://jabber.org/protocol/shim'.freeze
+
+    register :pubsub_event, :event, 'http://jabber.org/protocol/pubsub#event'
+
+    # Ensures the event_node is created
+    # @private
+    def self.new(type = nil)
+      node = super
+      node.event_node
+      node
+    end
+
+    # Kill the event_node node before running inherit
+    # @private
+    def inherit(node)
+      event_node.remove
+      super
+    end
+
+    # Get the name of the node
+    #
+    # @return [String, nil]
+    def node
+      !purge? ? items_node[:node] : purge_node[:node]
+    end
+
+    # Get a list of retractions
+    #
+    # @return [Array<String>]
+    def retractions
+      items_node.find('//ns:retract', :ns => self.class.registered_ns).map do |i|
+        i[:id]
+      end
+    end
+
+    # Check if this is a retractions stanza
+    #
+    # @return [Boolean]
+    def retractions?
+      !retractions.empty?
+    end
+
+    # Get the list of items attached to this event
+    #
+    # @return [Array<Blather::Stanza::PubSub::PubSubItem>]
+    def items
+      items_node.find('//ns:item', :ns => self.class.registered_ns).map do |i|
+        PubSubItem.new(nil,nil,self.document).inherit i
+      end
+    end
+
+    # Check if this stanza has items
+    #
+    # @return [Boolean]
+    def items?
+      !items.empty?
+    end
+
+    # Check if this is a purge stanza
+    #
+    # @return [XML::Node, nil]
+    def purge?
+      purge_node
+    end
+
+    # Get or create the actual event node
+    #
+    # @return [Blather::XMPPNode]
+    def event_node
+      node = find_first('//ns:event', :ns => self.class.registered_ns)
+      node = find_first('//event', self.class.registered_ns) unless node
+      unless node
+        (self << (node = XMPPNode.new('event', self.document)))
+        node.namespace = self.class.registered_ns
+      end
+      node
+    end
+
+    # Get or create the actual items node
+    #
+    # @return [Blather::XMPPNode]
+    def items_node
+      node = find_first('ns:event/ns:items', :ns => self.class.registered_ns)
+      unless node
+        (self.event_node << (node = XMPPNode.new('items', self.document)))
+        node.namespace = event_node.namespace
+      end
+      node
+    end
+
+    # Get the actual purge node
+    #
+    # @return [Blather::XMPPNode]
+    def purge_node
+      event_node.find_first('//ns:purge', :ns => self.class.registered_ns)
+    end
+
+    # Get the subscription IDs associated with this event
+    #
+    # @return [Array<String>]
+    def subscription_ids
+      find('//ns:header[@name="SubID"]', :ns => SHIM_NS).map do |n|
+        n.content
+      end
+    end
+
+    # Check if this is a subscription stanza
+    #
+    # @return [XML::Node, nil]
+    def subscription?
+      subscription_node
+    end
+
+    # Get the actual subscription node
+    #
+    # @return [Blather::XMPPNode]
+    def subscription_node
+      event_node.find_first('//ns:subscription', :ns => self.class.registered_ns)
+    end
+    alias_method :subscription, :subscription_node
+  end  # Event
+
+end  # PubSub
+end  # Stanza
+end  # Blather

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

@@ -0,0 +1,103 @@
+module Blather
+class Stanza
+class PubSub
+
+  # # PubSub Items Stanza
+  #
+  # [XEP-0060 Section 6.5 - Retrieve Items from a Node](http://xmpp.org/extensions/xep-0060.html#subscriber-retrieve)
+  #
+  # @handler :pubsub_items
+  class Items < PubSub
+    register :pubsub_items, :items, self.registered_ns
+
+    include Enumerable
+    alias_method :find, :xpath
+
+    # Create a new Items request
+    #
+    # @param [String] host the pubsub host to send the request to
+    # @param [String] path the path of the node
+    # @param [Array<String>] list an array of IDs to request
+    # @param [#to_s] max the maximum number of items to return
+    #
+    # @return [Blather::Stanza::PubSub::Items]
+    def self.request(host, path, list = [], max = nil)
+      node = self.new :get, host
+
+      node.node = path
+      node.max_items = max
+
+      (list || []).each do |id|
+        node.items_node << PubSubItem.new(id, nil, node.document)
+      end
+
+      node
+    end
+
+    # Overrides the parent to ensure an items node is created
+    # @private
+    def self.new(type = nil, host = nil)
+      new_node = super
+      new_node.items
+      new_node
+    end
+
+    # Get the node name
+    #
+    # @return [String]
+    def node
+      items_node[:node]
+    end
+
+    # Set the node name
+    #
+    # @param [String, nil] node
+    def node=(node)
+      items_node[:node] = node
+    end
+
+    # Get the max number of items requested
+    #
+    # @return [Fixnum, nil]
+    def max_items
+      items_node[:max_items].to_i if items_node[:max_items]
+    end
+
+    # Set the max number of items requested
+    #
+    # @param [Fixnum, nil] max_items
+    def max_items=(max_items)
+      items_node[:max_items] = max_items
+    end
+
+    # Iterate over the list of items
+    #
+    # @yieldparam [Blather::Stanza::PubSub::PubSubItem] item
+    def each(&block)
+      items.each &block
+    end
+
+    # Get the list of items on this stanza
+    #
+    # @return [Array<Blather::Stanza::PubSub::PubSubItem>]
+    def items
+      items_node.find('ns:item', :ns => self.class.registered_ns).map do |i|
+        PubSubItem.new(nil,nil,self.document).inherit i
+      end
+    end
+
+    # Get or create the actual items node
+    #
+    # @return [Blather::XMPPNode]
+    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  # Items
+
+end  # PubSub
+end  # Stanza
+end  # Blather

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

@@ -0,0 +1,103 @@
+module Blather
+class Stanza
+class PubSub
+
+  # # PubSub Publish Stanza
+  #
+  # [XEP-0060 Section 7.1 - Publish an Item to a Node](http://xmpp.org/extensions/xep-0060.html#publisher-publish)
+  #
+  # @handler :pubsub_publish
+  class Publish < PubSub
+    register :pubsub_publish, :publish, self.registered_ns
+
+    include Enumerable
+    alias_method :find, :xpath
+
+    # Create a new publish node
+    #
+    # @param [String, nil] host the host to pushlish the node to
+    # @param [String, nil] node the name of the node to publish to
+    # @param [Blather::Stanza::Iq::VALID_TYPES] type the node type
+    # @param [#to_s] payload the payload to publish see {#payload=}
+    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
+
+    # Set the payload to publish
+    #
+    # @overload payload=(hash)
+    #   Set the payload as a set of ID => payload entries
+    #   @param [Hash<id => payload>] hash
+    # @overload payload=(array)
+    #   Set the list of payloads all at once
+    #   @param [Array<#to_s>] array
+    # @overload payload=(string)
+    #   Set the payload as a string
+    #   @param [#to_s] string
+    def payload=(payload)
+      payload = case payload
+      when Hash   then  payload.to_a
+      when Array  then  payload.map { |v| [nil, v] }
+      else              [[nil, payload]]
+      end
+      payload.each do |id, value|
+        self.publish << PubSubItem.new(id, value, self.document)
+      end
+    end
+
+    # Get the name of the node to publish to
+    #
+    # @return [String, nil]
+    def node
+      publish[:node]
+    end
+
+    # Set the name of the node to publish to
+    #
+    # @param [String, nil] node
+    def node=(node)
+      publish[:node] = node
+    end
+
+    # Get or create the actual publish node
+    #
+    # @return [Blather::XMPPNode]
+    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
+
+    # Get the list of items
+    #
+    # @return [Array<Blather::Stanza::PubSub::PubSubItem>]
+    def items
+      publish.find('ns:item', :ns => self.class.registered_ns).map do |i|
+        PubSubItem.new(nil,nil,self.document).inherit i
+      end
+    end
+
+    # Iterate over the list of items
+    #
+    # @yield [item] a block to accept each item
+    # @yieldparam [Blather::Stanza::PubSub::PubSubItem]
+    def each(&block)
+      items.each &block
+    end
+
+    # Get the size of the items list
+    #
+    # @return [Fixnum]
+    def size
+      items.size
+    end
+  end  # Publish
+
+end  # PubSub
+end  # Stanza
+end  # Blather

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

@@ -0,0 +1,92 @@
+module Blather
+class Stanza
+class PubSub
+
+  # # PubSub Retract Stanza
+  #
+  # [XEP-0060 Section 7.2 - Delete an Item from a Node](http://xmpp.org/extensions/xep-0060.html#publisher-delete)
+  #
+  # @handler :pubsub_retract
+  class Retract < PubSub
+    register :pubsub_retract, :retract, self.registered_ns
+
+    include Enumerable
+    alias_method :find, :xpath
+
+    # Createa new Retraction stanza
+    #
+    # @param [String] host the host to send the request to
+    # @param [String] node the node to retract items from
+    # @param [Blather::Stanza::Iq::VALID_TYPES] type the IQ stanza type
+    # @param [Array<String>] retractions an array of ids to retract
+    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
+
+    # Get the name of the node to retract from
+    #
+    # @return [String]
+    def node
+      retract[:node]
+    end
+
+    # Set the name of the node to retract from
+    #
+    # @param [String] node
+    def node=(node)
+      retract[:node] = node
+    end
+
+    # Get or create the actual retract node
+    #
+    # @return [Blather::XMPPNode]
+    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
+
+    # Set the retraction ids
+    #
+    # @overload retractions=(id)
+    #   @param [String] id an ID to retract
+    # @overload retractions=(ids)
+    #   @param [Array<String>] ids an array of IDs to retract
+    def retractions=(retractions = [])
+      [retractions].flatten.each do |id|
+        self.retract << PubSubItem.new(id, nil, self.document)
+      end
+    end
+
+    # Get the list of item IDs to retract
+    #
+    # @return [Array<String>]
+    def retractions
+      retract.find('ns:item', :ns => self.class.registered_ns).map do |i|
+        i[:id]
+      end
+    end
+
+    # Iterate over each retraction ID
+    #
+    # @yieldparam [String] id an ID to retract
+    def each(&block)
+      retractions.each &block
+    end
+
+    # The size of the retractions array
+    #
+    # @return [Fixnum]
+    def size
+      retractions.size
+    end
+  end  # Retract
+
+end  # PubSub
+end  # Stanza
+end  # Blather