xmpp4r 0.3

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

@@ -0,0 +1,58 @@
+# =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
+  module MUC
+    class XMUCUserInvite < REXML::Element
+      def initialize(to=nil, reason=nil)
+        super('invite')
+        set_to(to)
+        set_reason(reason)
+      end
+
+      def to
+        attributes['to'].nil? ? nil : JID::new(attributes['to'])
+      end
+
+      def to=(j)
+        attributes['to'] = j.nil? ? nil : j.to_s
+      end
+
+      def set_to(j)
+        self.to = j
+        self
+      end
+
+      def from
+        attributes['from'].nil? ? nil : JID::new(attributes['from'])
+      end
+
+      def from=(j)
+        attributes['from'] = (j.nil? ? nil : j.to_s)
+      end
+
+      def set_from(j)
+        self.from = j
+        self
+      end
+
+      def reason
+        first_element_text('reason')
+      end
+
+      def reason=(s)
+        if s
+          replace_element_text('reason', s)
+        else
+          delete_elements('reason')
+        end
+      end
+
+      def set_reason(s)
+        self.reason = s
+        self
+      end
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+# =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
+  module MUC
+    class XMUCUserItem < REXML::Element
+      def initialize(affiliation=nil, role=nil, jid=nil)
+        super('item')
+        set_affiliation(affiliation)
+        set_role(role)
+        set_jid(jid)
+      end
+
+      def affiliation
+        case attributes['affiliation']
+          when 'admin' then :admin
+          when 'member' then :member
+          when 'none' then :none
+          when 'outcast' then :outcast
+          when 'owner' then :owner
+          else nil
+        end
+      end
+
+      def affiliation=(v)
+        case v
+          when :admin then attributes['affiliation'] = 'admin'
+          when :member then attributes['affiliation'] = 'member'
+          when :none then attributes['affiliation'] = 'none'
+          when :outcast then attributes['affiliation'] = 'outcast'
+          when :owner then attributes['affiliation'] = 'owner'
+          else attributes['affiliation'] = nil
+        end
+      end
+
+      def set_affiliation(v)
+        self.affiliation = v
+        self
+      end
+
+      def jid
+        attributes['jid'].nil? ? nil : JID::new(attributes['jid'])
+      end
+
+      def jid=(j)
+        attributes['jid'] = j.nil? ? nil : j.to_s
+      end
+
+      def set_jid(j)
+        self.jid = j
+        self
+      end
+
+      def nick
+        attributes['nick']
+      end
+
+      def nick=(n)
+        attributes['nick'] = n
+      end
+
+      def set_nick(n)
+        self.nick = n
+        self
+      end
+      
+      def role
+        case attributes['role']
+          when 'moderator' then :moderator
+          when 'none' then :none
+          when 'participant' then :participant
+          when 'visitor' then :visitor
+          else nil
+        end
+      end
+
+      def role=(r)
+        case r
+          when :moderator then attributes['role'] = 'moderator'
+          when :none then attributes['role'] = 'none'
+          when :participant then attributes['role'] = 'participant'
+          when :visitor then attributes['role'] = 'visitor'
+          else attributes['role'] = nil
+        end
+      end
+
+      def set_role(r)
+        self.role = r
+        self
+      end
+
+      def reason
+        text = nil
+        each_element('reason') { |xe| text = xe.text }
+        text
+      end
+
+      def reason=(s)
+        delete_elements('reasion')
+        add_element('reason').text = s
+      end
+
+      def set_reason(s)
+        self.reason = s
+        self
+      end
+
+      def continue
+        c = nil
+        each_element('continue') { |xe| c = xe }
+        c.nil?
+      end
+
+      def continue=(c)
+        delete_elements('continue')
+        add_element('continue') if c
+      end
+
+      def set_continue(c)
+        self.continue = c
+        self
+      end
+
+      def actors
+        a = []
+        each_element('actor') { |xe|
+          a.push(JID::new(xe.attributes['jid']))
+        }
+        a
+      end
+
+      def actors=(a)
+        delete_elements('actor')
+        a.each { |jid|
+          e = add_element('actor')
+          e.attributes['jid'] = jid.to_s
+        }
+      end
+
+      def set_actors(a)
+        self.actors = a
+        self
+      end
+    end
+  end
+end
+

data/lib/xmpp4r/muc.rb

@@ -0,0 +1,6 @@
+require 'xmpp4r/muc/x/muc'
+require 'xmpp4r/muc/x/mucuserinvite'
+require 'xmpp4r/muc/x/mucuseritem'
+require 'xmpp4r/muc/helper/mucbrowser'
+require 'xmpp4r/muc/helper/mucclient'
+require 'xmpp4r/muc/helper/simplemucclient'

data/lib/xmpp4r/presence.rb

@@ -0,0 +1,255 @@
+# =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 presence class is used to construct presence messages to 
+  # send to the Jabber service.
+  class Presence < XMLStanza
+    include Comparable
+
+    ##
+    # Create presence stanza
+    # show:: [String] Initial Availability Status
+    # status:: [String] Initial status message
+    # priority:: [Fixnum] Initial priority value
+    def initialize(show=nil, status=nil, priority=nil)
+      super("presence")
+      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
+    #
+    # result:: [Symbol] or [Nil] Possible values are:
+    # * :error
+    # * :probe (Servers send this to request presence information)
+    # * :subscribe (Subscription request)
+    # * :subscribed (Subscription approval)
+    # * :unavailable (User has gone offline)
+    # * :unsubscribe (Unsubscription request)
+    # * :unsubscribed (Unsubscription approval)
+    # * [nil] (available)
+    # See RFC3921 - 2.2.1. for explanation.
+    def type
+      case super
+        when 'error' then :error
+        when 'probe' then :probe
+        when 'subscribe' then :subscribe
+        when 'subscribed' then :subscribed
+        when 'unavailable' then :unavailable
+        when 'unsubscribe' then :unsubscribe
+        when 'unsubscribed' then :unsubscribed
+        else nil
+      end
+    end
+
+    ##
+    # Set type of presence
+    # val:: [Symbol] See type for possible subscription types
+    def type=(val)
+      case val
+        when :error then super('error')
+        when :probe then super('probe')
+        when :subscribe then super('subscribe')
+        when :subscribed then super('subscribed')
+        when :unavailable then super('unavailable')
+        when :unsubscribe then super('unsubscribe')
+        when :unsubscribed then super('unsubscribed')
+        else super(nil)
+      end
+    end
+
+    ##
+    # Set type of presence (chaining-friendly)
+    # val:: [Symbol] See type for possible subscription types
+    def set_type(val)
+      self.type = val
+      self
+    end
+
+    ##
+    # Get the first <x/> element of this stanza
+    # result:: [REXML::Element] or nil
+    def x
+      xe = nil
+      each_element('x') { |e| xe = e }
+      xe
+    end
+
+    ##
+    # Get Availability Status (RFC3921 - 5.2)
+    # result:: [Symbol] or [Nil] Valid values according to RFC3921:
+    # * nil (Available, no <show/> element)
+    # * :away
+    # * :chat (Free for chat)
+    # * :dnd (Do not disturb)
+    # * :xa (Extended away)
+    def show
+      e = first_element('show')
+      text = e ? e.text : nil
+      case text
+        when 'away' then :away
+        when 'chat' then :chat
+        when 'dnd' then :dnd
+        when 'xa' then :xa
+        else nil
+      end
+    end
+
+    ##
+    # Set Availability Status
+    # val:: [Symbol] or [Nil] See show for explanation
+    def show=(val)
+      xe = first_element('show')
+      if xe.nil?
+        xe = add_element('show')
+      end
+      case val
+        when :away then text = 'away'
+        when :chat then text = 'chat'
+        when :dnd then text = 'dnd'
+        when :xa then text = 'xa'
+        when nil then text = nil
+        else raise "Invalid value for show."
+      end
+
+      if text.nil?
+        delete_element(xe)
+      else
+        xe.text = text
+      end
+    end
+
+    ##
+    # Set Availability Status (chaining-friendly)
+    # val:: [Symbol] or [Nil] See show for explanation
+    def set_show(val)
+      self.show = val
+      self
+    end
+
+    ##
+    # Get status message
+    # result:: [String] or nil
+    def status
+      first_element_text('status')
+    end
+
+    ##
+    # Set status message
+    # val:: [String] or nil
+    def status=(val)
+      if val.nil?
+        delete_element('status')
+      else
+        replace_element_text('status', val)
+      end
+    end
+
+    ##
+    # Set status message (chaining-friendly)
+    # val:: [String] or nil
+    def set_status(val)
+      self.status = val
+      self
+    end
+
+    ##
+    # Get presence priority, or nil if absent
+    # result:: [Integer]
+    def priority
+       e = first_element_text('priority')
+      if e
+        return e.to_i
+      else
+        return nil
+      end
+    end
+
+    ##
+    # Set presence priority
+    # val:: [Integer] Priority value between -128 and +127
+    #
+    # *Warning:* negative values make you receive no subscription requests etc.
+    # (RFC3921 - 2.2.2.3.)
+    def priority=(val)
+      if val.nil?
+        delete_element('priority')
+      else
+        replace_element_text('priority', val)
+      end
+    end
+
+    ##
+    # Set presence priority (chaining-friendly)
+    # val:: [Integer] Priority value between -128 and +127
+    def set_priority(val)
+      self.priority = val
+      self
+    end
+
+    ##
+    # Compare two presences using priority
+    # (with cmp_interest as fall-back).
+    def <=>(o)
+      if priority.to_i == o.priority.to_i
+        cmp_interest(o)
+      else
+        priority.to_i <=> o.priority.to_i
+      end
+    end
+
+    ##
+    # Compare two presences. The most suitable to talk with is the
+    # biggest.
+    PRESENCE_STATUS = { :chat => 4,
+                        nil => 3,
+                        :dnd => 2,
+                        :away => 1,
+                        :xa => 0,
+                        :unavailable => -1,
+                        :error => -2 }
+    def cmp_interest(o)
+      if type.nil?
+        if o.type.nil?
+          # both available.
+          PRESENCE_STATUS[show] <=> PRESENCE_STATUS[o.show]
+        else
+          return -1
+        end
+      elsif o.type.nil?
+        return 1
+      else
+        # both are non-nil. We consider this is equal.
+        return 0
+      end
+    end
+
+  end
+end

data/lib/xmpp4r/query.rb

@@ -0,0 +1,43 @@
+# =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/iq'
+
+module Jabber
+  ##
+  # A class used to build/parse IQ Query requests/responses
+  #
+  class IqQuery < REXML::Element
+    @@namespace_classes = {}
+
+    ##
+    # Initialize a <query/> element
+    #
+    # Does nothing more than setting the element's name to 'query'
+    def initialize
+      super("query")
+    end
+
+    ##
+    # Create a new [IqQuery] from iq.query
+    # element:: [REXML::Element] to import, will be automatically converted if namespace appropriate
+    def IqQuery.import(element)
+      if @@namespace_classes.has_key?(element.namespace)
+        @@namespace_classes[element.namespace]::new.import(element)
+      else
+        IqQuery::new.import(element)
+      end
+    end
+
+    ##
+    # Add a class by namespace for automatic IqQuery conversion (see IqQuery.import)
+    # ns:: [String] Namespace (e.g. 'jabber:iq:roster')
+    # queryclass:: [IqQuery] Query class derived from IqQuery
+    def IqQuery.add_namespaceclass(ns, queryclass)
+      @@namespace_classes[ns] = queryclass
+    end
+  end
+
+  Iq.add_elementclass('query', IqQuery)
+end