mojodna-xmpp4r 0.4.0.2

data/lib/xmpp4r/muc.rb

@@ -0,0 +1,14 @@
+# =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/dataforms'
+require 'xmpp4r/muc/x/muc'
+require 'xmpp4r/muc/x/mucuserinvite'
+require 'xmpp4r/muc/x/mucuseritem'
+require 'xmpp4r/muc/iq/mucowner'
+require 'xmpp4r/muc/iq/mucadmin'
+require 'xmpp4r/muc/iq/mucadminitem'
+require 'xmpp4r/muc/helper/mucbrowser'
+require 'xmpp4r/muc/helper/mucclient'
+require 'xmpp4r/muc/helper/simplemucclient'

data/lib/xmpp4r/presence.rb

@@ -0,0 +1,232 @@
+# =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/x'
+
+module Jabber
+  ##
+  # The presence class is used to construct presence messages to
+  # send to the Jabber service.
+  class Presence < XMPPStanza
+    name_xmlns 'presence', 'jabber:client'
+    force_xmlns true
+
+    include Comparable
+    include XParent
+
+    ##
+    # 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()
+      set_show(show) if show
+      set_status(status) if status
+      set_priority(priority) if priority
+    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 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 String then raise "Invalid value for show."
+        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/pubsub/children/configuration.rb

@@ -0,0 +1,86 @@
+# =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/xmppelement'
+require 'xmpp4r/pubsub/iq/pubsub'
+
+module Jabber
+  module PubSub
+
+    class Configuration < XMPPElement
+      ##
+      # get the underlying XData form element
+      def form
+        children.each do |c|
+          return c if c.kind_of?(Jabber::Dataforms::XData)
+        end
+
+        nil
+      end
+
+      def form=(form)
+        children.each do |c|
+          delete_element(c)
+          if c.kind_of?(Jabber::Dataforms::XData)
+            delete(c)
+          end
+        end
+        add(form)
+      end
+
+      # Implemented by NodeConfig and SubscriptionConfig
+      def form_type
+        ''
+      end
+
+      def options=(options)
+        if options
+          self.form = form_for_options( form_type, options )
+        end
+      end
+
+      ##
+      # get a list of the configured options represented by this stanza
+      # return:: [Hash] the options and their values
+      def options
+        configured_options = {}
+
+        if !form.nil?
+          form.fields.each do |f|
+            f.values.size == 1 ? configured_options[f.var] = f.values.first : configured_options[f.var] = f.values
+          end
+        end
+
+        configured_options
+      end
+
+      def node=(node)
+        attributes['node'] = node
+      end
+
+      def node
+        attributes['node']
+      end
+
+      private
+
+      ##
+      # creates a Dataform for configuration
+      # config:: [Hash] the desired configuration options
+      def form_for_options(type, options)
+        form = Jabber::Dataforms::XData.new(:submit)
+        pubsub_config = Jabber::Dataforms::XDataField.new('FORM_TYPE', :hidden)
+        pubsub_config.values = [type]
+        form.add(pubsub_config)
+        options.each_pair do |key, value|
+          f = Jabber::Dataforms::XDataField.new(key)
+          f.values = [value]
+          form.add(f)
+        end
+
+        form
+      end
+    end
+  end
+end

data/lib/xmpp4r/pubsub/children/event.rb

@@ -0,0 +1,49 @@
+# =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
+  module PubSub
+
+    ##
+    # Event
+    # a publishing event
+    class Event < XMPPElement
+      name_xmlns 'event', NS_PUBSUB + '#event'
+      force_xmlns true
+
+      ##
+      # return payload
+      def payload
+        elements
+      end
+
+      ##
+      # add payload
+      # payload:: [REXML::Element]
+      def payload=(pl)
+        add_element = pl
+      end
+
+      ##
+      # return the payload type
+      def event_type?
+        # each child of event
+        # this should iterate only one time
+        each_element('./event/*') { |plelement|
+          case plelement.name
+            when 'collection' 	   then return :collection
+            when 'configuration'   then	return :configuration
+            when 'delete'	   then return :delete
+            when 'items'	   then return :items
+            when 'purge'	   then return :purge
+            when 'subscription'	   then return :subscription
+            else return nil
+          end
+        }
+      end
+    end
+  end
+end

data/lib/xmpp4r/pubsub/children/item.rb

@@ -0,0 +1,35 @@
+# =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
+  module PubSub
+    ##
+    # Item
+    # One PubSub Item
+    class Item < XMPPElement
+      name_xmlns 'item', NS_PUBSUB
+      def initialize(id=nil)
+        super()
+        attributes['id'] = id
+      end
+      def id
+        attributes['id']
+      end
+      def id=(myid)
+        attributes['id'] = myid
+      end
+    end
+
+    ##
+    # An Item wrapped in a Pubsub Event.
+    #
+    # See example 2 in http://www.xmpp.org/extensions/xep-0060.html#intro-howitworks
+    # and http://www.xmpp.org/extensions/xep-0060.html#schemas-event
+    class EventItem < Item
+      name_xmlns 'item', NS_PUBSUB + "#event"
+    end
+  end
+end

data/lib/xmpp4r/pubsub/children/items.rb

@@ -0,0 +1,53 @@
+# =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
+  module PubSub
+    ##
+    # Items
+    # a collection of Items
+    class Items < XMPPElement
+      include Enumerable
+      name_xmlns 'items', NS_PUBSUB
+
+      def node
+        attributes['node']
+      end
+      def node=(mynodename)
+        attributes['node'] = mynodename
+      end
+      def subid
+        attributes['subid']
+      end
+      def subid=(mysubid)
+        attributes['subid'] = mysubid.to_s
+      end
+      def max_items
+        attributes['max_items']
+      end
+      def max_items=(mymaxitems)
+        attributes['max_items'] = mymaxitems.to_s
+      end
+
+      def items
+        get_elements("item")
+      end
+
+      def each(&block)
+        items.each(&block)
+      end
+    end
+
+    ##
+    # Items wrapped in a Pubsub Event.
+    #
+    # See example 2 in http://www.xmpp.org/extensions/xep-0060.html#intro-howitworks
+    # and http://www.xmpp.org/extensions/xep-0060.html#schemas-event
+    class EventItems < Items
+      name_xmlns 'items', NS_PUBSUB + "#event"
+    end
+  end
+end

data/lib/xmpp4r/pubsub/children/node_config.rb

@@ -0,0 +1,48 @@
+# =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/xmppelement'
+require 'xmpp4r/pubsub/children/configuration'
+
+module Jabber
+  module PubSub
+    ##
+    # NodeConfig
+    #
+    # A <configure> XMPP element for pubsub nodes, see example 123 in
+    # http://www.xmpp.org/extensions/xep-0060.html#owner-create-and-configure
+    class NodeConfig < Configuration
+      name_xmlns 'configure', NS_PUBSUB
+
+      ##
+      # Construct a <configure> element.
+      # node:: [String] the node to configure
+      # options:: [Hash] the configuration to apply
+      def initialize(node = nil, options = nil)
+        super()
+
+        self.node = node
+        self.options = options
+      end
+
+      private
+
+      def form_type
+        'http://jabber.org/protocol/pubsub#node_config'
+      end
+    end
+
+    ##
+    #
+    # OwnerNodeConfig
+    #
+    # A <configure> stanza for 'Owner' use cases
+    #
+    # see example 125 in
+    # http://www.xmpp.org/extensions/xep-0060.html#owner-configure-request
+    class OwnerNodeConfig < NodeConfig
+      name_xmlns 'configure', NS_PUBSUB + '#owner'
+    end
+  end
+end

data/lib/xmpp4r/pubsub/children/publish.rb

@@ -0,0 +1,38 @@
+# =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/xmppelement'
+
+module Jabber
+  module PubSub
+
+    ##
+    # Publish
+    #
+    # A <publish> XMPP element, see example 1 in
+    # http://www.xmpp.org/extensions/xep-0060.html#intro-howitworks
+    class Publish < XMPPElement
+      include Enumerable
+      name_xmlns 'publish', NS_PUBSUB
+
+      ##
+      # support for enumerating <item> elements
+      def each(&block)
+        items.each(&block)
+      end
+
+      ##
+      # return child <item> elements
+      def items
+        get_elements("item")
+      end
+
+      ##
+      # return the node for this publication
+      def node
+        attributes['node']
+      end
+    end
+  end
+end

data/lib/xmpp4r/pubsub/children/retract.rb

@@ -0,0 +1,41 @@
+# =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/xmppelement'
+
+module Jabber
+  module PubSub
+
+    ##
+    # Retract 
+    #
+    # A <retract> XMPP element, see example 103 in
+    # http://xmpp.org/extensions/xep-0060.html#publisher-delete 
+    class Retract < XMPPElement
+      name_xmlns 'retract', NS_PUBSUB
+      ##
+      # get the node for this retraction
+      def node
+        attributes['node']
+      end
+
+      ##
+      # set the node for this retraction
+      def node=(s)
+        attributes['node'] = s
+      end
+
+      ##
+      # Get <item/> children
+      def items
+        res = []
+        each_element('item') { |item|
+          res << item
+        }
+        res
+      end
+    end
+  end
+end
+

data/lib/xmpp4r/pubsub/children/subscription.rb

@@ -0,0 +1,62 @@
+# =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
+  module PubSub
+    ##
+    # Subscription
+    class Subscription < XMPPElement
+      name_xmlns 'subscription', NS_PUBSUB
+      def initialize(myjid=nil,mynode=nil,mysubid=nil,mysubscription=nil)
+        super()
+        jid = myjid
+        node =  mynode
+        subid =  mysubid
+        state = mysubscription
+      end
+      def jid
+        (a = attribute('jid')).nil? ? a : JID.new(a.value)
+      end
+      def jid=(myjid)
+        add_attribute('jid', myjid ? myjid.to_s : nil)
+      end
+
+      def node
+        attributes['node']
+      end
+      def node=(mynode)
+        attributes['node'] = mynode
+      end
+
+      def subid
+        attributes['subid']
+      end
+      def subid=(mysubid)
+        attributes['subid'] = mysubid
+      end
+
+      def state
+          # each child of event
+          # this should interate only one time
+          case attributes['subscription']
+              when 'none'      		then return :none
+              when 'pending'   		then return :pending
+              when 'subscribed'         then return :subscribed
+              when 'unconfigured'       then return :unconfigured
+              else return nil
+          end
+      end
+      def state=(mystate)
+        attributes['subscription'] = mystate
+      end
+      alias subscription state
+
+      def need_approval?
+        state == :pending
+      end
+    end
+  end
+end