xmpp4r 0.3.2 → 0.4

data/lib/xmpp4r/pubsub/helper/nodebrowser.rb

@@ -16,8 +16,8 @@ module Jabber
       end
 
       ##
-      # Retrive the nodes
-      # Throws an ErrorException when receiving
+      # Retrieve the nodes
+      # Throws an ServerError when receiving
       # <tt><iq type='error'/></tt>
       # jid:: [JID] Target entity (set only domain!)
       # return:: [Array] of [String] or [nil]
@@ -26,26 +26,17 @@ module Jabber
         iq.from = @stream.jid
         iq.add(Discovery::IqQueryDiscoItems.new)
         nodes = []
-        err = nil
-        @stream.send_with_id(iq) { |answer|
-          if answer.type == :result
-            answer.query.each_element('item') { |item|
-              nodes.push(item.node)
-            }
-            true
-          elsif answer.type == :error
-            err = answer.error
-            true
-          else
-            false
-          end
-        }
-        return nodes
+        @stream.send_with_id(iq) do |answer|
+          answer.query.each_element('item') { |item|
+            nodes.push(item.node)
+          }
+        end
+        nodes
       end
 
       ##
-      # Retrive the nodes with names
-      # Throws an ErrorExeption when reciving
+      # Retrieve the nodes with names
+      # Throws a ServerError when receiving
       # <tt><iq type='error'/></tt>
       # jid:: [Jabber::JID] Target entity (set only domain!)
       # return:: [Array] of [Hash] with keys 'node' => [String] and 'name' => [String] or [nil]
@@ -54,27 +45,18 @@ module Jabber
         iq.from = @stream.jid
         iq.add(Discovery::IqQueryDiscoItems.new)
         nodes = []
-        err = nil
         @stream.send_with_id(iq) { |answer|
-          if answer.type == :result
-            answer.query.each_element('item') { |item|
-              nodes.push( {'node' => item.node,'name' => item.iname } )
-            }
-            true
-          elsif answer.type == :error
-            err = answer.error
-            true
-          else
-            false
-          end
-        }
-        return nodes
+          answer.query.each_element('item') do |item|
+            nodes.push( {'node' => item.node,'name' => item.iname } )
+          }
+        end
+        nodes
       end
 
 
       ##
-      # Retrive the items from a node
-      # Throws an ErrorExeption when reciving
+      # Retrieve the items from a node
+      # Throws an ServerError when receiving
       # <tt><iq type='error'/></tt>
       # jid:: [Jabber::JID] Target entity (set only domain!)
       # node:: [String]
@@ -82,25 +64,17 @@ module Jabber
       def items(jid,node)
         iq = Iq.new(:get,jid)
         iq.from = @stream.jid
-	discoitems = Discovery::IqQueryDiscoItems.new
-	discoitems.node = node
+        discoitems = Discovery::IqQueryDiscoItems.new
+        discoitems.node = node
         iq.add(discoitems)
         items = []
         err = nil
-        @stream.send_with_id(iq) { |answer|
-          if answer.type == :result
-            answer.query.each_element('item') { |item|
-              items.push( {'jid' => item.jid,'name' => item.iname } )
-            }
-            true
-          elsif answer.type == :error
-            err = answer.error
-            true
-          else
-            false
-          end
-        }
-        return items
+        @stream.send_with_id(iq) do |answer|
+          answer.query.each_element('item') { |item|
+            items.push( {'jid' => item.jid,'name' => item.iname } )
+          }
+        end
+        items
       end
 
       ##
@@ -109,64 +83,46 @@ module Jabber
       # node:: [String]
       # return:: [Hash] with possible keys type:: [String] ,category:: [String],features:: [Array] of feature, nodeinformation:: [Jabber::XData]
       # check http://www.xmpp.org/extensions/xep-0060.html#entity for more infos
-      
-      # this is only for a xep <-> nodebrowser.rb understanding
-      alias get_metadata get_info
-      
       def get_info(jid,node)
         iq = Iq.new(:get,jid)
-	iq.from = @stream.jid
-	discoinfo = Discovery::IqQueryDiscoInfo.new
-	discoinfo.node = node
-	iq.add(discoinfo)
-	info = {}
-	@stream.send_with_id(iq) { |answer|
-	  if answer.type == :result
-	    
-	    identity = answer.query.identity
-	    info['type'] = identity.type
-	    info['category'] = identity.category
-	    
-	    info['features'] = answer.query.features
-	    
-# i think its not needed - if you think so then delete it	    
-#	    answer.query.each_element('identity') { |identity|
-#	      info['type'] = identity.type
-#	      info['category'] = identity.category
-#	    }
-#	    
-#	    features = []
-#	    answer.query.each_element('feature') { |feature|
-#	     features.push(feature)
-#	    }
-#	    info['features'] = features
-#	    
-	    answer.query.each_element('x') { |x|
-	      info['nodeinformation'] = x 
-	    }
-	  end
-	}
-	return info
+        iq.from = @stream.jid
+        discoinfo = Discovery::IqQueryDiscoInfo.new
+        discoinfo.node = node
+        iq.add(discoinfo)
+        info = {}
+        @stream.send_with_id(iq) do |answer|
+          identity = answer.query.identity
+          info['type'] = identity.type
+          info['category'] = identity.category
+          info['features'] = answer.query.features
+          
+          answer.query.each_element('x') { |x|
+            info['nodeinformation'] = x
+          }
+        end
+        info
       end
-      
+      # this is only for a xep <-> nodebrowser.rb understanding
+      alias get_metadata get_info
+
       ##
       # get type of node
       # jid:: [Jabber::JID]
       # node:: [String]
-      # 
+      #
       def type(jid,node)
         info = get_info(jid,node)
-	return info['type']
+        return info['type']
       end
-      
+
       ##
       # get category of node
       # jid:: [Jabber::JID]
       # node:: [String]
-      # 
+      #
       def category(jid,node)
         info = get_info(jid,node)
-	return info['category']
+        return info['category']
       end
 
     end #class

data/lib/xmpp4r/pubsub/helper/nodehelper.rb

@@ -2,10 +2,9 @@
 # License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
 # Website::http://home.gna.org/xmpp4r/
 #
-# For a documentation of the retunvalues please look into the
-# documentation of [Jabber::PubSub::ServiceHelper]
+# For documentation of the return values please see [Jabber::PubSub::ServiceHelper]
 # This class is only a wrapper around [Jabber::PubSub::ServiceHelper]
-# 
+#
 
 
 require 'xmpp4r/pubsub/helper/servicehelper'
@@ -17,52 +16,56 @@ module Jabber
 
       attr_reader :nodename
       attr_reader :name
-      attr_reader :jiod
+      attr_reader :jid
       attr_reader :my_subscriptions
       ##
-      # creates a new node  
+      # creates a new node
       # new(client,service,nodename)
       # stream:: [Jabber::Stream]
       # jid:: [String] (jid of the pubsub service)
       # nodename:: [String]
-      def initialize(stream,jid,nodename=nil,create_if_not_exist=true)
+      def initialize(stream, jid, nodename = nil, create_if_not_exist = true)
         super(stream,jid)
         @nodename = nodename
-	@jid = jid
-	@stream = client
-	
-	get_subscriptions 
-	
-	if create_if_not_exist and not node_exist?
-	  # if no nodename is given a instant node will created 
-	  # (if the service supports instant nodes)
-	  @nodename = create_node 
-	end
+        @jid = jid
+        @stream = stream
+
+        if create_if_not_exist and not node_exist?
+          # if no nodename is given a instant node will created
+          # (if the service supports instant nodes)
+          @nodename = create_node
+        else
+          get_subscriptions
+        end
       end
 
       ##
       # creates the node
       # create(configuration=nil)
       # configuration:: [Jabber::XData]
-      def create_node(configuration=nil)
-        create(@nodename,configuration)
+      def create_node(configuration = Jabber::PubSub::NodeConfig.new)
+        unless node_exist?
+          super(@nodename,configuration)
+        else
+          false
+        end
       end
-      
+
       ##
       # get the configuration of the node
       # get_configuration(configuration=nil)
       # configuration:: [Jabber::XData]
-      def get_configuration(subid=nil)
-        get_options(@nodename,subid)
+      def get_configuration(subid = nil)
+        get_options(@nodename, subid)
       end
-      
+
       ##
       # set the configuration of the node
       # set_configuration(configuration=nil)
       # configuration:: [Jabber::XData]
       # subid:: [String] default is nil
-      def set_configuration(configuration,subid=nil)
-        set_options(@nodename,configuration,subid)
+      def set_configuration(configuration,subid = nil)
+        set_options(@nodename, configuration, subid)
       end
 
       ##
@@ -73,22 +76,22 @@ module Jabber
       end
 
       ##
-      # publishing content on this node 
+      # publishing content on this node
       # publish_content(items)
       # items:: [REXML::Element]
       def publish_content(items)
-        publish(@nodename,items)
+        publish_item_to(@nodename,items)
       end
 
       ##
-      # gets all items from the node 
+      # gets all items from the node
       # get_all_items
       def get_all_items
         items(@nodename)
       end
 
       ##
-      # get a count of items 
+      # get a count of items
       # get_items(count)
       # count:: [Fixnum]
       def get_items(count)
@@ -106,7 +109,7 @@ module Jabber
       # get all subscriptions on this node
       # get_subscriptions
       def get_subscriptions
-        subscriptions(@nodename)
+        get_subscriptions_from(@nodename)
       end
 
       ##
@@ -120,8 +123,8 @@ module Jabber
       # subscribe to this node
       # do_subscribe
       def do_subscribe
-        subscribe(@nodename)
-	get_subscriptions
+        subscribe_to(@nodename)
+        get_subscriptions
       end
 
       ##
@@ -131,23 +134,23 @@ module Jabber
       def do_unsubscribe(subid)
         unsubscribe(@nodename,subid)
       end
-      
+
       ##
       # purge all items from this node
       # purge_items
       def purge_items
         purge(@nodename)
       end
-      
+
     private
-    
+
       def node_exist?
         nodebrowser = PubSub::NodeBrowser.new(@stream)
-        nodebrowser.nodes.include?(nodename)
+        nodebrowser.nodes(@jid).include?(@nodename)
       end
       def disco_info
       end
 
     end #class
   end #module
-end #module
+end #module

data/lib/xmpp4r/pubsub/helper/servicehelper.rb

@@ -2,14 +2,49 @@
 # License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
 # Website::http://home.gna.org/xmpp4r/
 #
-# It's recommented to read the XEP-0066 before you use this Helper.
+# It's recommented to read the XEP-0060 before you use this Helper. (Maybe its 
+# better not use the helper for now ) ;)
+# The whole code is getting better, but may still contain bugs - be careful!
+# 
+# Maybe the following structure is good 
+# ( taken from the xep-0060 )
+#
+# entity usecases
+#  retrieve all subscriptions
+#  retrieve all affiliations
+# NOTE: the disco stuff will done by the nodebrowserhelper
+# subscriber usecases
+#   subscribe
+#   unsubscribe
+#   configure subscription options
+#   retrieve items from a node
+# publisher usecases
+#   publish a item to a node
+#   delete a item from a node
+# owner usecases
+#   create a node
+#   configure a node
+#   request default configuration options
+#   delete a node
+#   purge all node items
+#   manage subscription requests
+#   process pending subscriptions
+#   manage subscriptions
+#   manage affiliations
+#  
+# collection nodes
+#    
+#  If someone want to implement something i think its better to do this in  
+#  this order because everyone who reads the xep-0060 do know where to search in the file
 # 
-
 require 'xmpp4r/pubsub/iq/pubsub'
-require 'xmpp4r/pubsub/stanzas/event'
-require 'xmpp4r/pubsub/stanzas/item'
-require 'xmpp4r/pubsub/stanzas/items'
-require 'xmpp4r/pubsub/stanzas/subscription'
+require 'xmpp4r/pubsub/children/event'
+require 'xmpp4r/pubsub/children/item'
+require 'xmpp4r/pubsub/children/items'
+require 'xmpp4r/pubsub/children/subscription'
+require 'xmpp4r/pubsub/children/unsubscribe'
+require 'xmpp4r/pubsub/children/node_config'
+require 'xmpp4r/pubsub/children/subscription_config'
 require 'xmpp4r/dataforms'
 
 module Jabber
@@ -20,71 +55,114 @@ module Jabber
 
       ##
       # Creates a new representation of a pubsub service
-      # client:: [Jabber::Stream]
+      # stream:: [Jabber::Stream]
       # pubsubjid:: [String] or [Jabber::JID]
-      def initialize(client, pubsubjid)
-        @client = client
+      def initialize(stream, pubsubjid)
+        @stream = stream
         @pubsubjid = pubsubjid
         @event_cbs = CallbackList.new
-        @client.add_message_callback(200,self) { |message|
+        @stream.add_message_callback(200,self) { |message|
           handle_message(message)
         }
       end
 
       ##
-      # Create a new node on the pubsub service
-      # node:: [String] you node name - otherwise you get a automaticly generated one (in most cases)
-      # configure:: [Jabber::XMLStanza] if you want to configure you node (default nil)
-      # return:: [String]
-      def create(node=nil, configure=nil)
-        rnode = nil
-        iq = basic_pubsub_query(:set)
-        iq.pubsub.add(REXML::Element.new('create')).attributes['node'] = node
-        if configure
-          confele =  REXML::Element.new('configure')
-
-          if configure.type_of?(XMLStanza)
-            confele << configure
+      # get all subscriptions on a pubsub component
+      # return:: [Hash] of [PubSub::Subscription]
+      def get_subscriptions_from_all_nodes
+        iq = basic_pubsub_query(:get)
+        entities = iq.pubsub.add(REXML::Element.new('subscriptions'))
+        res = nil
+        @stream.send_with_id(iq) { |reply|
+          if reply.pubsub.first_element('subscriptions')
+            res = []
+            reply.pubsub.first_element('subscriptions').each_element('subscription') { |subscription|
+              res << Jabber::PubSub::Subscription.import(subscription)
+            }
           end
-          iq.pubsub.add(confele)
-        end
+        }
 
-        @client.send_with_id(iq) do |reply|
-          if (create = reply.first_element('pubsub/create'))
-            rnode = create.attributes['node']
+        res
+      end
+      ##
+      # subscribe to a node
+      # node:: [String]
+      # return:: [Hash] of { attributename => value }
+      def subscribe_to(node)
+        iq = basic_pubsub_query(:set)
+        sub = REXML::Element.new('subscribe')
+        sub.attributes['node'] = node
+        sub.attributes['jid'] = @stream.jid.strip.to_s
+        iq.pubsub.add(sub)
+        res = nil
+        @stream.send_with_id(iq) do |reply|
+          pubsubanswer = reply.pubsub
+          if pubsubanswer.first_element('subscription')
+            res = PubSub::Subscription.import(pubsubanswer.first_element('subscription'))
           end
-          true
-        end
-
-        rnode
+        end # @stream.send_with_id(iq)
+        res
       end
 
       ##
-      # Delete a pubsub node
+      # Unsubscribe from a node with an optional subscription id
+      #
+      # May raise ServerError
       # node:: [String]
+      # subid:: [String] or nil (not supported)
       # return:: true
-      def delete(node)
-        iq = basic_pubsub_query(:set,true)
-        iq.pubsub.add(REXML::Element.new('delete')).attributes['node'] = node
-        @client.send_with_id(iq) { |reply|
+      def unsubscribe_from(node, subid=nil)
+        iq = basic_pubsub_query(:set)
+        unsub = PubSub::Unsubscribe.new
+        unsub.node = node
+        unsub.jid = @stream.jid.strip
+        iq.pubsub.add(unsub)
+        ret = false
+        @stream.send_with_id(iq) { |reply| 
+          ret = reply.kind_of?(Jabber::Iq) and reply.type == :result
+        } # @stream.send_with_id(iq)
+        ret
+      end
+      
+      ##
+      # gets all items from a pubsub node
+      # node:: [String]
+      # count:: [Fixnum]
+      # return:: [Hash] { id => [Jabber::PubSub::Item] }
+      def get_items_from(node, count=nil)
+        iq = basic_pubsub_query(:get)
+        items = Jabber::PubSub::Items.new
+        items.node = node
+        iq.pubsub.add(items)
+        res = nil
+        @stream.send_with_id(iq) { |reply|
+          if reply.kind_of?(Iq) and reply.pubsub and reply.pubsub.first_element('items')
+            res = {}
+            reply.pubsub.first_element('items').each_element('item') do |item|
+              res[item.attributes['id']] = item.children.first if item.children.first
+            end
+          end
           true
         }
+        res
       end
 
       ##
-      # NOTE: this method sends only one item per publish request because some services may not
-      # allow batch processing
-      # maybe this will changed in the future
+      # NOTE: this method sends only one item per publish request because some services 
+      # may not allow batch processing.  Maybe this will changed in the future?
       # node:: [String]
       # item:: [Jabber::PubSub::Item]
       # return:: true
-      def publish(node,item)
+      # it automatically generates an id for the item 
+      def publish_item_to(node,item)
         iq = basic_pubsub_query(:set)
-        publish = iq.pubsub.add(REXML::Element.new('publish'))
+	      publish = iq.pubsub.add(REXML::Element.new('publish'))
         publish.attributes['node'] = node
+        
         if item.kind_of?(Jabber::PubSub::Item)
+          item.id = Jabber::IdGenerator.generate_id
           publish.add(item)
-          @client.send_with_id(iq) { |reply| true }
+          @stream.send_with_id(iq)
         end
       end
 
@@ -93,48 +171,117 @@ module Jabber
       # item:: [REXML::Element]
       # id:: [String]
       # return:: true
-      def publish_with_id(node,item,id)
+      def publish_item_with_id_to(node,item,id)
+        iq = basic_pubsub_query(:set)
+        publish = iq.pubsub.add(REXML::Element.new('publish'))
+        publish.attributes['node'] = node
+          
         if item.kind_of?(REXML::Element)
           xmlitem = Jabber::PubSub::Item.new
           xmlitem.id = id
-          xmlitem.add(item)
-          publish(node,xmlitem)
+          xmlitem.import(item)
+          publish.add(xmlitem)
         else
           raise "given item is not a proper xml document or Jabber::PubSub::Item"
         end
+        @stream.send_with_id(iq)
       end
 
       ##
-      # gets all items from a pubsub node
+      # purges all items on a persistent node
       # node:: [String]
-      # count:: [Fixnum]
-      # return:: [Hash] { id => [Jabber::PubSub::Item] }
-      def items(node,count=nil)
-        iq = basic_pubsub_query(:get)
-        items = Jabber::PubSub::Items.new
-        items.node = node
-        iq.pubsub.add(items)
-        res = nil
-        @client.send_with_id(iq) { |reply|
-          if reply.kind_of?(Iq) and reply.pubsub and reply.pubsub.first_element('items')
-            res = {}
-            reply.pubsub.first_element('items').each_element('item') do |item|
-              res[item.attributes['id']] = item.children.first if item.children.first
-            end
+      # return:: true
+      def purge_items_from(node)
+        iq = basic_pubsub_query(:set)
+        purge = REXML::Element.new('purge')
+        purge.attributes['node'] = node
+        iq.pubsub.add(purge)
+        @stream.send_with_id(iq)
+      end
+
+      ##
+      # Create a new node on the pubsub service
+      # node:: [String] the node name - otherwise you get a automatically generated one (in most cases)
+      # configure:: [Jabber::PubSub::NodeConfig] if you want to configure your node (default nil)
+      # return:: [String]
+      def create_node(node = nil, configure = Jabber::PubSub::NodeConfig.new)
+        rnode = nil
+        iq = basic_pubsub_query(:set)
+        iq.pubsub.add(REXML::Element.new('create')).attributes['node'] = node
+        if configure
+          if configure.kind_of?(Jabber::PubSub::NodeConfig)
+            iq.pubsub.add(configure)
           end
-          true
-        }
-        res
+        end
+
+        @stream.send_with_id(iq) do |reply|
+          if reply.kind_of?(Jabber::Iq) and reply.type == :result
+            rnode = node
+          end
+        end
+
+        rnode
+      end
+
+      ##
+      # Create a new collection node on the pubsub service
+      # node:: [String] the node name - otherwise you get an automatically generated one (in most cases)
+      # configure:: [Jabber::PubSub::NodeConfig] if you want to configure your node (default nil)
+      # return:: [String]
+      def create_collection_node(node = nil, configure = Jabber::PubSub::NodeConfig.new)
+        if configure.options['pubsub#node_type'] && configure.options['pubsub#node_type'] != 'collection'
+          raise Jabber::ArgumentError, "Invalid node_type specified in node configuration. Either do not specify one, or use 'collection'"
+        end
+        configure.options = configure.options.merge({'pubsub#node_type' => 'collection'})
+        create_node(node, configure)
       end
 
+      ##
+      # get configuration from a node
+      # node:: [String]
+      # return:: [Jabber::PubSub::Configure]
+      def get_config_from(node)
+        iq = basic_pubsub_query(:get, true)
+        iq.pubsub.add(Jabber::PubSub::OwnerNodeConfig.new(node))
+        ret = nil
+        @stream.send_with_id(iq) do |reply|
+          ret = reply.pubsub.first_element('configure')
+        end
+        ret
+      end
+
+      ##
+      # set configuration for a node
+      # node:: [String]
+      # options:: [Jabber::PubSub::NodeConfig]
+      # return:: true on success
+      def set_config_for(node, config)
+        iq = basic_pubsub_query( :set )
+        iq.pubsub.add(config.form)
+        @stream.send_with_id(iq)
+      end
+
+      ##
+      # Delete a pubsub node
+      # node:: [String]
+      # return:: true
+      def delete_node(node)
+        iq = basic_pubsub_query(:set,true)
+        iq.pubsub.add(REXML::Element.new('delete')).attributes['node'] = node
+        @stream.send_with_id(iq)
+      end
+
+
       ##
       # shows the affiliations on a pubsub service
+      # node:: [String]
       # return:: [Hash] of { node => symbol }
-      def affiliations
+      def get_affiliations(node = nil)
         iq = basic_pubsub_query(:get)
-        iq.pubsub.add(REXML::Element.new('affiliations'))
+        affiliations = iq.pubsub.add(REXML::Element.new('affiliations'))
+        affiliations.attributes['node'] = node
         res = nil
-        @client.send_with_id(iq) { |reply|
+        @stream.send_with_id(iq) { |reply|
           if reply.pubsub.first_element('affiliations')
             res = {}
             reply.pubsub.first_element('affiliations').each_element('affiliation') do |affiliation|
@@ -156,19 +303,21 @@ module Jabber
 
       ##
       # shows all subscriptions on the given node
-      # node:: [String], or nil for all
-      # return:: [Array] of [REXML::Element]
-      def subscriptions(node=nil)
+      # node:: [String]
+      # return:: [Array] of [Jabber::Pubsub::Subscription]
+      def get_subscriptions_from(node)
         iq = basic_pubsub_query(:get)
         entities = iq.pubsub.add(REXML::Element.new('subscriptions'))
         entities.attributes['node'] = node
         res = nil
-        @client.send_with_id(iq) { |reply|
+        @stream.send_with_id(iq) { |reply|
           if reply.pubsub.first_element('subscriptions')
             res = []
-            reply.pubsub.first_element('subscriptions').each_element('subscription') { |subscription|
-              res << REXML::Element.new(subscription)
-            }
+            if reply.pubsub.first_element('subscriptions').attributes['node'] == node
+              reply.pubsub.first_element('subscriptions').each_element('subscription') { |subscription|
+    	        res << PubSub::Subscription.import(subscription)
+              } 
+            end
           end
           true
         }
@@ -179,107 +328,49 @@ module Jabber
       # shows all jids of subscribers of a node
       # node:: [String]
       # return:: [Array] of [String]
-      def subscribers(node)
+      def get_subscribers_from(node)
         res = []
-        subscriptions(node).each { |sub|
-          res << sub.attributes['jid']
+        get_subscriptions_from(node).each { |sub|
+          res << sub.jid
         }
         res
       end
 
-      ##
-      # subscribe to a node
-      # node:: [String]
-      # return:: [Hash] of { attributename => value }
-      def subscribe(node)
-        iq = basic_pubsub_query(:set)
-        sub = REXML::Element.new('subscribe')
-        sub.attributes['node'] = node
-        sub.attributes['jid'] = @client.jid.strip
-        iq.pubsub.add(sub)
-        res = {}
-        @client.send_with_id(iq) do |reply|
-          pubsubanswer = reply.pubsub
-          if pubsubanswer.first_element('subscription')
-            pubsubanswer.each_element('subscription') { |element|
-              element.attributes.each { |name,value| res[name] = value }
-            }
-          end
-          true
-        end # @client.send_with_id(iq)
-        res
-      end
 
       ##
-      # Unsubscibe from a node with an optional subscription id
-      #
-      # May raise ErrorException
+      # get options from a subscription
       # node:: [String]
+      # jid:: [Jabber::JID] or [String]
       # subid:: [String] or nil
-      # return:: true
-      def unsubscribe(node,subid=nil)
-        iq = basic_pubsub_query(:set)
-        unsub = REXML::Element.new('unsubscribe')
-        unsub.attributes['node'] = node
-        unsub.attributes['jid'] = @client.jid.strip
-        unsub.attributes['subid'] = subid
-        iq.pubsub.add(unsub)
-        @client.send_with_id(iq) { |reply| true        } # @client.send_with_id(iq)
-      end
-
-      ##
-      # get options of a node
-      # node:: [String]
-      # subid:: [String] or nil
-      # return:: [Jabber::XData]
-      def get_options(node,subid=nil)
+      # return:: [Jabber::PubSub::OwnerConfigure]
+      def get_options_from(node, jid, subid = nil)
         iq = basic_pubsub_query(:get)
-        opt = REXML::Element.new('options')
-        opt.attributes['node'] = node
-        opt.attributes['jid'] = @client.jid.strip
-        opt.attributes['subid'] = subid
-        iq.pubsub.add(opt)
+        iq.pubsub.add(Jabber::PubSub::SubscriptionConfig.new(node, jid.kind_of?(String) ? Jabber::JID.new(jid).strip: jid.strip, subid))
         ret = nil
-        @client.send_with_id(iq) { |reply|
-          reply.pubsub.options.first_element('x') { |xdata|
-    
-            ret = xdata if xdata.kind_of?(Jabber::XData)
-    
-          }
-        true
-        }
-        return ret
+        @stream.send_with_id(iq) do |reply|
+          ret = reply.pubsub.first_element('options')
+        end
+        ret
       end
 
       ##
-      # set options for a node
+      # set options for a subscription
       # node:: [String]
-      # options:: [Jabber::XData]
+      # jid:: [Jabber::JID] or [String]
+      # options:: [Jabber::PubSub::SubscriptionConfig} specifying configuration options
       # subid:: [String] or nil
       # return:: true 
-      def set_options(node,options,subid=nil)
-        iq = basic_pubsub_query(:set)
-        opt = REXML::Element.new('options')
-        opt.attributes['node'] = node
-        opt.attributes['jid'] = @client.jid.strip
-        opt.attributes['subid'] = subid
-        iq.pubsub.add(opt)
-        iq.pubsub.options.add(options)
-        @client.send_with_id(iq) { |reply| true }
-      end
-      
-      ##
-      # purges all items on a persist node
-      # node:: [String]
-      # return:: true
-      def purge(node)
+      def set_options_for(node, jid, options, subid = nil)
         iq = basic_pubsub_query(:set)
-	purge = REXML::Element.new('purge')
-	purge.attributes['node'] = node
-	iq.pubsub.add(purge)
-	@client.send_with_id(iq) { |reply| true }
-      end
+        iq.pubsub.add(Jabber::PubSub::SubscriptionConfig.new(node, jid.kind_of?(String) ? Jabber::JID.new(jid).strip: jid.strip, options, subid))
+        ret = false
+        @stream.send_with_id(iq) do  |reply|
+          ret = ( reply.type == :result )
+        end
 
+        ret
+      end
+     
       ##
       # String representation
       # result:: [String] The PubSub service's JID
@@ -301,12 +392,13 @@ module Jabber
       # basic_pubsub_query(type)
       # type:: [Symbol]
       def basic_pubsub_query(type,ownerusecase = false)
-        iq = Jabber::Iq::new(type,@pubsubjid)
-	if ownerusecase 
-	  iq.add(IqPubSubOwner.new)
-	else
+        iq = Jabber::Iq.new(type,@pubsubjid)
+        if ownerusecase
+          iq.add(IqPubSubOwner.new)
+        else
           iq.add(IqPubSub.new)
-	end
+        end
+        iq.from = @stream.jid #.strip
         iq
       end
 
@@ -320,7 +412,6 @@ module Jabber
           @event_cbs.process(event)
         end
       end
-
     end
   end
 end