xmpp4r 0.3

data/lib/xmpp4r/idgenerator.rb

@@ -0,0 +1,37 @@
+# =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 'singleton'
+
+module Jabber
+  ##
+  # The Jabber::IdGenerator class generates unique IDs for use
+  # in XMMP stanzas. Jabber::IdGenerator includes the Singleton
+  # Mixin, usage as following:
+  #  Jabber::IdGenerator.generate_id
+  #    => "23"
+  class IdGenerator
+    include Singleton
+
+    def initialize
+      @last_id = 0
+    end
+
+    ##
+    # Generate an unique ID.
+    #
+    # This is kind of boring this way, as it just counts up
+    # a number. Maybe something more random somewhen...
+    def IdGenerator.generate_id
+      IdGenerator.instance.generate_id
+    end
+
+    def generate_id
+      @last_id += 1
+      timefrac = Time.new.to_f.to_s.split(/\./, 2).last[-3..-1]
+      
+      "#{@last_id}#{timefrac}"
+    end
+  end
+end

data/lib/xmpp4r/iq.rb

@@ -0,0 +1,229 @@
+# =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/xmlstanza'
+require 'xmpp4r/jid'
+require 'digest/sha1'
+
+module Jabber
+  ##
+  # IQ: Information/Query
+  # (see RFC3920 - 9.2.3
+  #
+  # A class used to build/parse IQ requests/responses
+  class Iq < XMLStanza
+    @@element_classes = {}
+
+    ##
+    # Build a new <iq/> stanza
+    # type:: [Symbol] or nil, see Iq#type
+    # to:: [JID] Recipient
+    def initialize(type = nil, to = nil)
+      super("iq")
+      if not to.nil?
+        set_to(to)
+      end 
+      if not type.nil?
+        set_type(type)
+      end 
+    end
+
+    ##
+    # Get the type of the Iq stanza
+    #
+    # The following values are allowed:
+    # * :get
+    # * :set
+    # * :result
+    # * :error
+    # result:: [Symbol] or nil
+    def type
+      case super
+        when 'get' then :get
+        when 'set' then :set
+        when 'result' then :result
+        when 'error' then :error
+        else nil
+      end
+    end
+
+    ##
+    # Set the type of the Iq stanza (see Iq#type)
+    # v:: [Symbol] or nil
+    def type=(v)
+      case v
+        when :get then super('get')
+        when :set then super('set')
+        when :result then super('result')
+        when :error then super('error')
+        else super(nil)
+      end
+    end
+
+    ##
+    # Set the type of the Iq stanza (chaining-friendly)
+    # v:: [Symbol] or nil
+    def set_type(v)
+      self.type = v
+      self
+    end
+
+    ##
+    # Returns the iq's query child, or nil
+    # result:: [IqQuery]
+    def query 
+      first_element('query')
+    end
+
+    ##
+    # Delete old elements named newquery.name
+    #
+    # newquery:: [REXML::Element] will be added
+    def query=(newquery)
+      delete_elements(newquery.name)
+      add(newquery)
+    end
+
+    ##
+    # Returns the iq's query's namespace, or nil
+    # result:: [String]
+    def queryns 
+      e = first_element('query')
+      if e
+        return e.namespace
+      else
+        return nil
+      end
+    end
+
+    ##
+    # Returns the iq's <vCard/> child, or nil
+    # result:: [IqVcard]
+    def vcard 
+      first_element('vCard')
+    end
+
+    ##
+    # Create a new iq from a stanza,
+    # copies all attributes and children from xmlstanza
+    # xmlstanza:: [REXML::Element] Source stanza
+    # return:: [Iq] New stanza
+    def Iq.import(xmlstanza)
+      Iq::new.import(xmlstanza)
+    end
+
+    ##
+    # Add an element to the Iq stanza
+    # element:: [REXML::Element] Element to add.
+    # Will be automatically converted (imported) to
+    # a class registered with add_elementclass
+    def typed_add(element)
+      if element.kind_of?(REXML::Element) && @@element_classes.has_key?(element.name)
+        super(@@element_classes[element.name]::import(element))
+      else
+        super(element)
+      end
+    end
+
+    ##
+    # Create a new Iq stanza with an unspecified query child
+    # (<query/> has no namespace)
+    def Iq.new_query(type = nil, to = nil)
+      iq = Iq::new(type, to)
+      query = IqQuery::new
+      iq.add(query)
+      iq
+    end
+
+    ##
+    # Create a new jabber:iq:auth set Stanza.
+    def Iq.new_authset(jid, password)
+      iq = Iq::new(:set)
+      query = IqQuery::new
+      query.add_namespace('jabber:iq:auth')
+      query.add(REXML::Element::new('username').add_text(jid.node))
+      query.add(REXML::Element::new('password').add_text(password))
+      query.add(REXML::Element::new('resource').add_text(jid.resource)) if not jid.resource.nil?
+      iq.add(query)
+      iq
+    end
+
+    ##
+    # Create a new jabber:iq:auth set Stanza for Digest authentication
+    def Iq.new_authset_digest(jid, session_id, password)
+      iq = Iq::new(:set)
+      query = IqQuery::new
+      query.add_namespace('jabber:iq:auth')
+      query.add(REXML::Element::new('username').add_text(jid.node))
+      query.add(REXML::Element::new('digest').add_text(Digest::SHA1.new(session_id + password).hexdigest))
+      query.add(REXML::Element::new('resource').add_text(jid.resource)) if not jid.resource.nil?
+      iq.add(query)
+      iq
+    end
+
+    ##
+    # Create a new jabber:iq:register set stanza for service/server registration
+    # username:: [String] (Element will be ommited if unset)
+    # password:: [String] (Element will be ommited if unset)
+    def Iq.new_register(username=nil, password=nil)
+      iq = Iq::new(:set)
+      query = IqQuery::new
+      query.add_namespace('jabber:iq:register')
+      query.add(REXML::Element::new('username').add_text(username)) if username
+      query.add(REXML::Element::new('password').add_text(password)) if password
+      iq.add(query)
+      iq
+    end
+
+    ##
+    # Create a new jabber:iq:roster get Stanza.
+    #
+    # IqQueryRoster is unused here because possibly not require'd
+    def Iq.new_rosterget
+      iq = Iq::new(:get)
+      query = IqQuery::new
+      query.add_namespace('jabber:iq:roster')
+      iq.add(query)
+      iq
+    end
+
+    ##
+    # Create a new jabber:iq:roster get Stanza.
+    def Iq.new_browseget
+      iq = Iq::new(:get)
+      query = IqQuery::new
+      query.add_namespace('jabber:iq:browse')
+      iq.add(query)
+      iq
+    end
+
+    ##
+    # Create a new jabber:iq:roster set Stanza.
+    def Iq.new_rosterset
+      iq = Iq::new(:set)
+      query = IqQuery::new
+      query.add_namespace('jabber:iq:roster')
+      iq.add(query)
+      iq
+    end
+
+    ##
+    # Add a class by name.
+    # Elements with this name will be automatically converted
+    # to the specific class.
+    # Used for <query/>, <vCard>, <pubsub> etc.
+    # name:: [String] Element name
+    # elementclass:: [Class] Target class
+    def Iq.add_elementclass(name, elementclass)
+      @@element_classes[name] = elementclass
+    end
+  end
+end
+
+# Actually these should be included at the top,
+# but then they would be unable to call Iq.add_elementclass
+# because it hasn't just been defined.
+
+require 'xmpp4r/query'
+require 'xmpp4r/vcard/iq/vcard'

data/lib/xmpp4r/jid.rb

@@ -0,0 +1,167 @@
+# =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/
+
+module Jabber
+  ##
+  # The JID class represents a Jabber Identifier as described by 
+  # RFC3920 section 3.1.
+  #
+  # Note that you can use JIDs also for Sorting, Hash keys, ...
+  class JID
+    include Comparable
+
+    PATTERN = /^(?:([^@]*)@)??([^@\/]*)(?:\/(.*?))?$/
+
+    begin
+      require 'idn'
+      USE_STRINGPREP = true
+    rescue LoadError
+      USE_STRINGPREP = false
+    end
+
+    ##
+    # Create a new JID. If called as new('a@b/c'), parse the string and
+    # split (node, domain, resource)
+    def initialize(node = "", domain = nil, resource = nil)
+      @resource = resource
+      @domain = domain
+      @node = node
+      if @domain.nil? and @resource.nil? and @node
+        @node, @domain, @resource = @node.to_s.scan(PATTERN).first
+      end
+
+      if USE_STRINGPREP
+        @node = IDN::Stringprep.nodeprep(@node) if @node
+        @domain = IDN::Stringprep.nameprep(@domain) if @domain
+        @resource = IDN::Stringprep.resourceprep(@resource) if @resource
+      else
+        @node.downcase! if @node
+        @domain.downcase! if @domain
+      end
+
+      raise ArgumentError, 'Node too long' if (@node || '').length > 1023
+      raise ArgumentError, 'Domain too long' if (@domain || '').length > 1023
+      raise ArgumentError, 'Resource too long' if (@resource || '').length > 1023
+    end
+
+    ##
+    # Returns a string representation of the JID
+    # * ""
+    # * "domain"
+    # * "node@domain"
+    # * "domain/resource"
+    # * "node@domain/resource"
+    def to_s
+      s = @domain
+      s = "#{@node}@#{s}" if @node
+      s += "/#{@resource}" if @resource
+      return s
+    end
+
+    ##
+    # Returns a new JID with resource removed.
+    # return:: [JID]
+    def strip
+      JID::new(@node, @domain)
+    end
+    alias_method :bare, :strip
+
+    ##
+    # Removes the resource (sets it to nil)
+    # return:: [JID] self
+    def strip!
+      @resource = nil
+      self
+    end
+    alias_method :bare!, :strip!
+
+    ##
+    # Returns a hash value of the String representation
+    # (see JID#to_s)
+    def hash
+      return to_s.hash
+    end
+
+    ##
+    # Ccompare to another JID
+    #
+    # String representations are compared, see JID#to_s
+    def eql?(o)
+      to_s.eql?(o.to_s)
+    end
+
+    ##
+    # Ccompare to another JID
+    #
+    # String representations are compared, see JID#to_s
+    def ==(o)
+      to_s == o.to_s
+    end
+
+    ##
+    # Compare two JIDs,
+    # helpful for sorting etc.
+    #
+    # String representations are compared, see JID#to_s
+    def <=>(o)
+      to_s <=> o.to_s
+    end
+
+    # Get the JID's node
+    def node
+      @node
+    end
+
+    # Set the JID's node
+    def node=(v)
+      @node = v.to_s
+      if USE_STRINGPREP
+        @node = IDN::Stringprep.nodeprep(@node) if @node
+      end
+    end
+
+    # Get the JID's domain
+    def domain
+      return nil if @domain.empty?
+      @domain
+    end
+
+    # Set the JID's domain
+    def domain=(v)
+      @domain = v.to_s
+      if USE_STRINGPREP
+        @domain = IDN::Stringprep.nodeprep(@domain)
+      end
+    end
+
+    # Get the JID's resource
+    def resource
+      @resource
+    end
+
+    # Set the JID's resource
+    def resource=(v)
+      @resource = v.to_s
+      if USE_STRINGPREP
+        @resource = IDN::Stringprep.nodeprep(@resource)
+      end
+    end
+
+    # Escape JID
+    def JID::escape(jid)
+      return jid.to_s.gsub('@', '%')
+    end
+
+    # Test if jid is empty
+    def empty?
+      to_s.empty?
+    end
+
+    # Test id jid is strepped
+    def stripped?
+      @resource.nil?
+    end
+    alias_method :bared?, :stripped?
+  end
+end

data/lib/xmpp4r/message.rb

@@ -0,0 +1,171 @@
+# =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/xmlstanza'
+require 'xmpp4r/x'
+
+module Jabber
+  ##
+  # The Message class manages the <message/> stanzas,
+  # which is used for all messaging communication.
+  class Message < XMLStanza
+
+    ##
+    # Create a new message
+    # >to:: a JID or a String object to send the message to.
+    # >body:: the message's body
+    def initialize(to = nil, body = nil)
+      super("message")
+      if not to.nil?
+        set_to(to)
+      end
+      if !body.nil?
+        add_element(REXML::Element::new("body").add_text(body))
+      end
+    end
+
+    ##
+    # Add a sub-element
+    #
+    # Will be converted to [X] if named "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
+
+    ##
+    # Get the type of the Message stanza
+    #
+    # The following Symbols are allowed:
+    # * :chat
+    # * :error
+    # * :groupchat
+    # * :headline
+    # * :normal
+    # result:: [Symbol] or nil
+    def type
+      case super
+        when 'chat' then :chat
+        when 'error' then :error
+        when 'groupchat' then :groupchat
+        when 'headline' then :headline
+        when 'normal' then :normal
+        else nil
+      end
+    end
+
+    ##
+    # Set the type of the Message stanza (see Message#type for details)
+    # v:: [Symbol] or nil
+    def type=(v)
+      case v
+        when :chat then super('chat')
+        when :error then super('error')
+        when :groupchat then super('groupchat')
+        when :headline then super('headline')
+        when :normal then super('normal')
+        else super(nil)
+      end
+    end
+
+    ##
+    # Set the type of the Message stanza (chaining-friendly)
+    # v:: [Symbol] or nil
+    def set_type(v)
+      self.type = v
+      self
+    end
+
+    ##
+    # Get the first <x/> element of this stanza, or nil if none found.
+    def x
+      first_element('x')
+    end
+
+    ##
+    # Returns the message's body, or nil.
+    # This is the message's plain-text content.
+    def body
+      first_element_text('body')
+    end
+
+    ##
+    # Create a new message from a stanza,
+    # by copying all attributes and children from it.
+    # xmlstanza:: [REXML::Element] Source
+    # return:: [Message] Result
+    def Message.import(xmlstanza)
+      Message::new.import(xmlstanza)
+    end
+
+    ##
+    # Sets the message's body
+    #
+    # b:: [String] body to set
+    def body=(b)
+      replace_element_text('body', b)
+    end
+
+    ##
+    # Sets the message's body
+    #
+    # b:: [String] body to set
+    # return:: [REXML::Element] self for chaining
+    def set_body(b)
+      self.body = b
+      self
+    end
+
+    ##
+    # sets the message's subject
+    #
+    # s:: [String] subject to set
+    def subject=(s)
+      replace_element_text('subject', s)
+    end
+
+    ##
+    # sets the message's subject
+    #
+    # s:: [String] subject to set
+    # return:: [REXML::Element] self for chaining
+    def set_subject(s)
+      self.subject = s
+      self
+    end
+
+    ##
+    # Returns the message's subject, or nil
+    def subject
+      first_element_text('subject')
+    end
+
+    ##
+    # sets the message's thread
+    # s:: [String] thread to set
+    def thread=(s)
+      delete_elements('thread')
+      replace_element_text('thread', s) unless s.nil?
+    end
+
+    ##
+    # gets the message's thread (chaining-friendly)
+    # Please note that this are not [Thread] but a [String]-Identifier to track conversations
+    # s:: [String] thread to set
+    def set_thread(s)
+      self.thread = s
+      self
+    end
+
+    ##
+    # Returns the message's thread, or nil
+    def thread
+      first_element_text('thread')
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# =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 MUC
+    ##
+    # The MUCBrowser helper can be used to discover
+    # Multi-User-Chat components via Service Discovery
+    #
+    # See JEP 0045 sections 6.1. and 6.2.
+    #
+    # Usage of its functions should be threaded as
+    # responses can take a while
+    class MUCBrowser
+      ##
+      # Initialize a new MUCBrowser helper
+      def initialize(stream)
+        @stream = stream
+      end
+
+      ##
+      # Retrieve the name of a MUC component,
+      # depending upon whether the target entity supports
+      # the MUC protocol.
+      #
+      # A return-value of nil does *not* mean that the entity
+      # does not exist or does not support Service Discovery!
+      # nil just means that this is not a MUC-compliant service.
+      #
+      # Throws an ErrorException when receiving
+      # <tt><iq type='error'/></tt>
+      # jid:: [JID] Target entity (set only domain!)
+      # return:: [String] or [nil]
+      def muc_name(jid)
+        iq = Iq.new(:get, jid)
+        iq.from = @stream.jid  # Enable components to use this
+        iq.add(Discovery::IqQueryDiscoInfo.new)
+
+        res = nil
+
+        @stream.send_with_id(iq) do |answer|
+          if answer.type == :result
+            answer.query.each_element('feature') { |feature|
+              # Look if the component has a MUC or Groupchat feature
+              if feature.var == 'http://jabber.org/protocol/muc' or feature.var == 'gc-1.0'
+                # If so, get the identity
+                if answer.query.first_element('identity')
+                  res = answer.query.first_element('identity').iname
+                end
+              end
+            }
+            true
+          else
+            false
+          end
+        end
+
+        res
+      end
+
+      ##
+      # Retrieve the existing rooms of a MUC component
+      #
+      # The resulting Hash contains pairs of room JID and room name
+      #
+      # Usage:
+      #  my_mucbrowse_helper.muc_rooms('conference.jabber.org').each { |jid,name| ... }
+      #
+      # Throws an exception when receiving <tt><iq type='error'/></tt>
+      # jid:: [JID] Target entity (set only domain!)
+      # return:: [Hash]
+      def muc_rooms(jid)
+        iq = Iq.new(:get, jid)
+        iq.from = @stream.jid  # Enable components to use this
+        iq.add(Discovery::IqQueryDiscoItems.new)
+
+        rooms = {}
+        err = nil
+
+        @stream.send_with_id(iq) do |answer|
+
+          if answer.type == :result
+            answer.query.each_element('item') { |item|
+              rooms[item.jid] = item.iname
+            }
+            true
+          elsif answer.type == :error
+            err = answer.error
+            true
+          else
+            false
+          end
+        end
+
+        if err
+          raise "Error getting MUC rooms: #{err.error}, #{err.text}"
+        end
+
+        rooms
+      end
+    end
+  end
+end
+