mad-p-xmpp4r 0.6.0

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,221 @@
+# =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/xmppstanza'
+require 'xmpp4r/jid'
+require 'digest/sha1'
+
+require 'xmpp4r/query'
+require 'xmpp4r/vcard/iq/vcard'
+
+module Jabber
+  ##
+  # IQ: Information/Query
+  # (see RFC3920 - 9.2.3
+  #
+  # A class used to build/parse IQ requests/responses
+  class Iq < XMPPStanza
+    name_xmlns 'iq', 'jabber:client'
+    force_xmlns true
+
+    @@element_classes = {}
+
+    ##
+    # Build a new <iq/> stanza
+    # type:: [Symbol] or nil, see Iq#type
+    # to:: [JID] Recipient
+    def initialize(type = nil, to = nil)
+      super()
+
+      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
+
+    ##
+    # Returns the iq's <pubsub/> child, or nil
+    # result:: [IqVcard]
+    def pubsub
+      first_element('pubsub')
+    end
+
+    ##
+    # Returns the iq's <command/> child, or nil
+    # resulte:: [IqCommand]
+    def command
+      first_element("command")
+    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.hexdigest(session_id + 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: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:register get stanza for retrieval
+    # of accepted registration information
+    def Iq.new_registerget
+      iq = Iq.new(:get)
+      query = IqQuery.new
+      query.add_namespace('jabber:iq:register')
+      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
+  end
+end

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/last.rb

@@ -0,0 +1,2 @@
+require 'xmpp4r/last/iq/last'
+require 'xmpp4r/last/helper/helper'

data/lib/xmpp4r/last/helper/helper.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 'xmpp4r'
+require 'xmpp4r/last'
+
+module Jabber
+  module LastActivity
+    ##
+    # A Helper to manage discovery of Last Activity.
+    class Helper
+      def initialize(client)
+        @stream = client
+      end
+
+      ##
+      # Gets the last activity from a JID.
+      # jid:: [JID]
+      # return:: [Jabber::LastActivity::IqQueryLastActivity]
+      def get_last_activity_from(jid)
+        iq = Jabber::Iq.new(:get, jid)
+        iq.from = @stream.jid
+        iq.add(Jabber::LastActivity::IqQueryLastActivity.new)
+
+        reply = @stream.send_with_id(iq)
+
+        if reply.query && reply.query.kind_of?(IqQueryLastActivity)
+          reply.query
+        else
+          nil
+        end
+      end
+
+    end
+  end
+end