xmpp4r 0.3.1 → 0.3.2

data/lib/xmpp4r/muc.rb

@@ -2,9 +2,11 @@
 # License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
 # Website::http://home.gna.org/xmpp4r/
 
+require 'xmpp4r/dataforms'
 require 'xmpp4r/muc/x/muc'
 require 'xmpp4r/muc/x/mucuserinvite'
 require 'xmpp4r/muc/x/mucuseritem'
+require 'xmpp4r/muc/iq/mucowner'
 require 'xmpp4r/muc/helper/mucbrowser'
 require 'xmpp4r/muc/helper/mucclient'
 require 'xmpp4r/muc/helper/simplemucclient'

data/lib/xmpp4r/muc/helper/mucclient.rb

@@ -94,6 +94,11 @@ module Jabber
           # but all join-failures should be type='error'
           elsif r.from == jid and r.kind_of?(Presence) and r.type != :unavailable
             # Our own presence reflected back - success
+            if r.x(XMUCUser) and (i = r.x(XMUCUser).items.first)
+              @affiliation = i.affiliation  # we're interested in if it's :owner
+              @role = i.role                # :moderator ?
+            end
+
             handle_presence(r, false)
             true
           else
@@ -235,7 +240,7 @@ module Jabber
       # If stanza is a Jabber::Message, <tt>stanza.type</tt> will be
       # automatically set to :groupchat if directed to room or :chat
       # if directed to participant.
-      # stanza:: [XMLStanza] to send
+      # stanza:: [XMPPStanza] to send
       # to:: [String] Stanza destination recipient, or room if +nil+
       def send(stanza, to=nil)
         if stanza.kind_of? Message
@@ -377,6 +382,50 @@ module Jabber
         @stream.delete_presence_callback(self)
         @stream.delete_message_callback(self)
       end
+
+    public
+      def owner?
+        @affiliation == :owner
+      end
+
+      def configure(options={})
+        raise 'You are not the owner' unless owner?
+        
+        iq = Iq.new(:get, jid)
+        iq.to = @jid
+        iq.from = @my_jid
+        iq.add(IqQueryMUCOwner.new)
+
+        fields = []
+        
+        answer = @stream.send_with_id(iq)
+        raise "Configuration not possible for this room" unless answer.query && answer.query.x(XData)
+
+        answer.query.x(XData).fields.each { |field|
+          if (var = field.attributes['var'])
+            fields << var
+          end
+        }
+
+        
+        # fill out the reply form
+        iq = Iq.new(:set, jid)
+        iq.to = @jid
+        iq.from = @my_jid
+        query = IqQueryMUCOwner.new
+        form = Dataforms::XData.new
+        form.type = :submit
+        options.each do |var, values|
+          field = Dataforms::XDataField.new
+          values = [values] unless values.is_a?(Array)
+          field.var, field.values = var, values
+          form.add(field)
+        end
+        query.add(form)
+        iq.add(query)   
+
+        @stream.send_with_id(iq)
+      end
     end
   end
 end

data/lib/xmpp4r/muc/helper/simplemucclient.rb

@@ -155,9 +155,9 @@ module Jabber
       # recipients:: [Hash] of [JID] => [String] Reason
       def invite(recipients)
         msg = Message.new
-        x = msg.add(XMucUser.new)
+        x = msg.add(XMUCUser.new)
         recipients.each { |jid,reason|
-          x.add(XMucUserInvite.new(jid, reason))
+          x.add(XMUCUserInvite.new(jid, reason))
         }
         send(msg)
       end

data/lib/xmpp4r/muc/iq/mucowner.rb

@@ -0,0 +1,11 @@
+require 'xmpp4r/x'
+
+module Jabber
+  module MUC
+    class IqQueryMUCOwner < IqQuery
+      name_xmlns 'query', 'http://jabber.org/protocol/muc#owner'
+      
+      include XParent
+    end
+  end
+end

data/lib/xmpp4r/muc/x/muc.rb

@@ -13,13 +13,7 @@ module Jabber
     #
     # See JEP-0045 for details
     class XMUC < X
-      ##
-      # Initialize an <x/> element
-      # and set namespace to http://jabber.org/protocol/muc
-      def initialize
-        super
-        add_namespace('http://jabber.org/protocol/muc')
-      end
+      name_xmlns 'x', 'http://jabber.org/protocol/muc'
 
       ##
       # Text content of the <tt><password/></tt> element
@@ -45,26 +39,7 @@ module Jabber
     #
     # See JEP-0058 for details
     class XMUCUser < X
-      ##
-      # Initialize an <x/> element
-      # and set namespace to http://jabber.org/protocol/muc#user
-      def initialize
-        super
-        add_namespace('http://jabber.org/protocol/muc#user')
-      end
-
-      ##
-      # Add a children element,
-      # will be imported to [XMUCUserItem] if name is "item"
-      def typed_add(element)
-        if element.kind_of?(REXML::Element) && (element.name == 'item')
-          super(XMUCUserItem::new.import(element))
-        elsif element.kind_of?(REXML::Element) && (element.name == 'invite')
-          super(XMUCUserInvite::new.import(element))
-        else
-          super(element)
-        end
-      end
+      name_xmlns 'x', 'http://jabber.org/protocol/muc#user'
 
       ##
       # Retrieve the three-digit code in
@@ -91,8 +66,5 @@ module Jabber
         res
       end
     end
-
-    X.add_namespaceclass('http://jabber.org/protocol/muc', XMUC)
-    X.add_namespaceclass('http://jabber.org/protocol/muc#user', XMUCUser)
   end
 end

data/lib/xmpp4r/muc/x/mucuserinvite.rb

@@ -4,9 +4,11 @@
 
 module Jabber
   module MUC
-    class XMUCUserInvite < REXML::Element
+    class XMUCUserInvite < XMPPElement
+      name_xmlns 'invite', 'http://jabber.org/protocol/muc#user'
+
       def initialize(to=nil, reason=nil)
-        super('invite')
+        super()
         set_to(to)
         set_reason(reason)
       end

data/lib/xmpp4r/muc/x/mucuseritem.rb

@@ -4,9 +4,11 @@
 
 module Jabber
   module MUC
-    class XMUCUserItem < REXML::Element
+    class XMUCUserItem < XMPPElement
+      name_xmlns 'item', 'http://jabber.org/protocol/muc#user'
+
       def initialize(affiliation=nil, role=nil, jid=nil)
-        super('item')
+        super()
         set_affiliation(affiliation)
         set_role(role)
         set_jid(jid)

data/lib/xmpp4r/presence.rb

@@ -2,15 +2,19 @@
 # License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
 # Website::http://home.gna.org/xmpp4r/
 
-require 'xmpp4r/xmlstanza'
+require 'xmpp4r/xmppstanza'
 require 'xmpp4r/x'
 
 module Jabber
   ##
   # The presence class is used to construct presence messages to 
   # send to the Jabber service.
-  class Presence < XMLStanza
+  class Presence < XMPPStanza
+    name_xmlns 'presence', 'jabber:client'
+    force_xmlns true
+
     include Comparable
+    include XParent
 
     ##
     # Create presence stanza
@@ -18,31 +22,12 @@ module Jabber
     # status:: [String] Initial status message
     # priority:: [Fixnum] Initial priority value
     def initialize(show=nil, status=nil, priority=nil)
-      super("presence")
+      super()
       set_show(show) if show
       set_status(status) if status
       set_priority(priority) if priority
     end
 
-    ##
-    # Add an element to the presence stanza
-    # * <x/> elements are converted to [X]
-    # element:: [REXML::Element] to add
-    def typed_add(element)
-      if element.kind_of?(REXML::Element) && (element.name == 'x')
-        super(X::import(element))
-      else
-        super(element)
-      end
-    end
-
-    ##
-    # Create a new presence from a stanza
-    # result:: [Presence] Imported XMLStanza
-    def Presence.import(xmlstanza)
-      Presence::new.import(xmlstanza)
-    end
-
     ##
     # Get type of presence
     #
@@ -93,19 +78,6 @@ module Jabber
       self
     end
 
-    ##
-    # Get the first <x/> element in this stanza, or nil if none found.
-    # namespace:: [String] Optional, find the first <x/> element having this xmlns
-    # result:: [REXML::Element] or nil
-    def x(namespace=nil)
-      each_element('x') { |x|
-        if namespace.nil? or namespace == x.namespace
-          return x
-        end
-      }
-      nil
-    end
-
     ##
     # Get Availability Status (RFC3921 - 5.2)
     # result:: [Symbol] or [Nil] Valid values according to RFC3921:

data/lib/xmpp4r/pubsub.rb

@@ -0,0 +1 @@
+require 'xmpp4r/pubsub/helper/servicehelper'

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

@@ -0,0 +1,174 @@
+# =XMPP4R - XMPP Library for Ruby
+# License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
+# Website::http://home.gna.org/xmpp4r/
+
+require 'xmpp4r/discovery'
+
+module Jabber
+  module PubSub
+    class NodeBrowser
+      ##
+      # Initialize a new NodeBrowser
+      # new(stream,pubsubservice)
+      # stream:: [Jabber::Stream]
+      def initialize(stream)
+        @stream = stream
+      end
+
+      ##
+      # Retrive the nodes
+      # Throws an ErrorException when receiving
+      # <tt><iq type='error'/></tt>
+      # jid:: [JID] Target entity (set only domain!)
+      # return:: [Array] of [String] or [nil]
+      def nodes(jid)
+        iq = Iq.new(:get,jid)
+        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
+      end
+
+      ##
+      # Retrive the nodes with names
+      # Throws an ErrorExeption when reciving
+      # <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]
+      def nodes_names(jid)
+        iq = Iq.new(:get,jid)
+        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
+      end
+
+
+      ##
+      # Retrive the items from a node
+      # Throws an ErrorExeption when reciving
+      # <tt><iq type='error'/></tt>
+      # jid:: [Jabber::JID] Target entity (set only domain!)
+      # node:: [String]
+      # return:: [Array] of [Hash] with keys 'name' => [String] and 'jid' => [Jabber::JID]
+      def items(jid,node)
+        iq = Iq.new(:get,jid)
+        iq.from = @stream.jid
+	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
+      end
+
+      ##
+      # get disco info for a node
+      # jid:: [Jabber::JID]
+      # 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
+      end
+      
+      ##
+      # get type of node
+      # jid:: [Jabber::JID]
+      # node:: [String]
+      # 
+      def type(jid,node)
+        info = get_info(jid,node)
+	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']
+      end
+
+    end #class
+  end #module
+end #module

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

@@ -0,0 +1,153 @@
+# =XMPP4R - XMPP Library for Ruby
+# 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]
+# This class is only a wrapper around [Jabber::PubSub::ServiceHelper]
+# 
+
+
+require 'xmpp4r/pubsub/helper/servicehelper'
+require 'xmpp4r/pubsub/helper/nodebrowser'
+
+module Jabber
+  module PubSub
+    class NodeHelper < ServiceHelper
+
+      attr_reader :nodename
+      attr_reader :name
+      attr_reader :jiod
+      attr_reader :my_subscriptions
+      ##
+      # 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)
+        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
+      end
+
+      ##
+      # creates the node
+      # create(configuration=nil)
+      # configuration:: [Jabber::XData]
+      def create_node(configuration=nil)
+        create(@nodename,configuration)
+      end
+      
+      ##
+      # get the configuration of the node
+      # get_configuration(configuration=nil)
+      # configuration:: [Jabber::XData]
+      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)
+      end
+
+      ##
+      # deletes the node
+      # delete
+      def delete_node
+        delete(@nodename)
+      end
+
+      ##
+      # publishing content on this node 
+      # publish_content(items)
+      # items:: [REXML::Element]
+      def publish_content(items)
+        publish(@nodename,items)
+      end
+
+      ##
+      # gets all items from the node 
+      # get_all_items
+      def get_all_items
+        items(@nodename)
+      end
+
+      ##
+      # get a count of items 
+      # get_items(count)
+      # count:: [Fixnum]
+      def get_items(count)
+        items(@nodename,count)
+      end
+
+      ##
+      # get all node affiliations
+      # get_affiliations
+      def get_affiliations
+        affiliations
+      end
+
+      ##
+      # get all subscriptions on this node
+      # get_subscriptions
+      def get_subscriptions
+        subscriptions(@nodename)
+      end
+
+      ##
+      # get all subscribers subscribed on this node
+      # get_subscribers
+      def get_subscribers
+        @subscriptions = subscribers(@nodename)
+      end
+
+      ##
+      # subscribe to this node
+      # do_subscribe
+      def do_subscribe
+        subscribe(@nodename)
+	get_subscriptions
+      end
+
+      ##
+      # unsubscribe from this node
+      # do_unsubscribe(subid = nil)
+      # subid:: [String]
+      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)
+      end
+      def disco_info
+      end
+
+    end #class
+  end #module
+end #module