xmpp4r 0.3

data/lib/xmpp4r/discovery/iq/discoinfo.rb

@@ -0,0 +1,225 @@
+# =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/query'
+
+module Jabber
+  module Discovery
+    ##
+    # Class for handling Service Discovery queries,
+    # info
+    # (JEP 0030)
+    #
+    # This <query/> may contain multiple Identity and Feature
+    # elements, describing the type and the supported namespaces of
+    # the service.
+    class IqQueryDiscoInfo < IqQuery
+      ##
+      # Create a new query
+      # with namespace http://jabber.org/protocol/disco#info
+      def initialize
+        super
+        add_namespace('http://jabber.org/protocol/disco#info')
+      end
+
+      ##
+      # Add a children element
+      #
+      # Converts <identity/> elements to [Identity]
+      # and <feature/> elements to [Feature]
+      def typed_add(element)
+        if element.kind_of?(REXML::Element)
+
+          if element.name == 'identity'
+            super(Identity::new.import(element))
+          elsif element.name == 'feature'
+            super(Feature::new.import(element))
+          else
+            super(element)
+          end
+
+        else
+          super(element)
+        end
+      end
+
+      ##
+      # Get the queried Service Discovery node or nil
+      #
+      # See IqQueryDiscoItems#node for a
+      # small explanation of this.
+      def node
+        attributes['node']
+      end
+
+      ##
+      # Get the queried Service Discovery node or nil
+      # val:: [String]
+      def node=(val)
+        attributes['node'] = val
+      end
+
+      ##
+      # Get the queried Service Discovery node or nil
+      # (chaining-friendly)
+      # val:: [String]
+      def set_node(val)
+        self.node = val
+        self
+      end
+
+      ##
+      # Get the first identity child
+      # result:: [Identity]
+      def identity
+        first_element('identity')
+      end
+
+      ##
+      # Get list of features
+      # result:: [Array] of [String]
+      def features
+        res = []
+        each_element('feature') { |feature|
+          res.push(feature.var)
+        }
+        res
+      end
+    end
+
+    IqQuery.add_namespaceclass('http://jabber.org/protocol/disco#info', IqQueryDiscoInfo)
+
+    ##
+    # Service Discovery identity to add() to IqQueryDiscoInfo
+    #
+    # Please note that JEP 0030 requires both category and type to occur
+    class Identity < REXML::Element
+      ##
+      # Initialize a new Identity
+      # category:: [String] Initial category or nil
+      # iname:: [String] Initial identity name or nil
+      # type:: [String] Initial type or nil
+      def initialize(category=nil, iname=nil, type=nil)
+        super('identity')
+        set_category(category)
+        set_iname(iname)
+        set_type(type)
+      end
+
+      ##
+      # Get the identity's category or nil
+      # result:: [String]
+      def category
+        attributes['category']
+      end
+
+      ##
+      # Set the identity's category
+      #
+      # Service Discovery categories should be somewhat
+      # standardized by some registry, so clients may
+      # represent specific categories by specific icons...
+      # (see http://www.jabber.org/registrar/disco-categories.html)
+      # val:: [String]
+      def category=(val)
+        attributes['category'] = val
+      end
+
+      ##
+      # Set the identity's category (chaining-friendly)
+      # val:: [String]
+      def set_category(val)
+        self.category = val
+        self
+      end
+
+      ##
+      # Get the identity's name or nil
+      #
+      # This has been renamed from <name/> to "iname" here
+      # to keep REXML::Element#name accessible
+      # result:: [String]
+      def iname
+        attributes['name']
+      end
+
+      ##
+      # Set the identity's name
+      # val:: [String]
+      def iname=(val)
+        attributes['name'] = val
+      end
+
+      ##
+      # Set the identity's name (chaining-friendly)
+      # val:: [String]
+      def set_iname(val)
+        self.iname = val
+        self
+      end
+
+      ##
+      # Get the identity's type or nil
+      # result:: [String]
+      def type
+        attributes['type']
+      end
+
+      ##
+      # Set the identity's type
+      # (see http://www.jabber.org/registrar/disco-categories.html)
+      # val:: [String]
+      def type=(val)
+        attributes['type'] = val
+      end
+
+      ##
+      # Set the identity's type (chaining-friendly)
+      # val:: [String]
+      def set_type(val)
+        self.type = val
+        self
+      end
+    end
+
+    ##
+    # Service Discovery feature to add() to IqQueryDiscoInfo
+    #
+    # Please note that JEP 0030 requires var to be set
+    class Feature < REXML::Element
+      ##
+      # Create a new <feature/> element
+      # var:: [String] New var
+      def initialize(var=nil)
+        super('feature')
+        set_var(var)
+      end
+
+      ##
+      # Get the feature's var or nil
+      # result:: [String]
+      def var
+        attributes['var']
+      end
+
+      ##
+      # Set the feature's var
+      # 
+      # This is a namespace the identity supports.
+      # val:: [String]
+      def var=(val)
+        attributes['var'] = val
+      end
+
+      ##
+      # Set the feature's var (chaining-friendly)
+      # val:: [String]
+      def set_var(val)
+        self.var = val
+        self
+      end
+    end
+  end
+end
+

data/lib/xmpp4r/discovery/iq/discoitems.rb

@@ -0,0 +1,162 @@
+# =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/query'
+
+module Jabber
+  module Discovery
+    ##
+    # Class for handling Service Discovery queries,
+    # items
+    # (JEP 0030)
+    #
+    # This <query/> may contain multiple Item elements,
+    # describing multiple services to be browsed by Jabber clients.
+    # These may then get further information about these items by
+    # querying IqQueryDiscoInfo and further sub-items by querying
+    # IqQueryDiscoItems.
+    class IqQueryDiscoItems < IqQuery
+      ##
+      # Create a new query
+      # with namespace http://jabber.org/protocol/disco#items
+      def initialize
+        super
+        add_namespace('http://jabber.org/protocol/disco#items')
+      end
+
+      ##
+      # Add a children element
+      #
+      # Converts <item/> elements to [Item]
+      def typed_add(element)
+        if element.kind_of?(REXML::Element)
+
+          if element.name == 'item'
+            super(Item::new.import(element))
+          else
+            super(element)
+          end
+
+        else
+          super(element)
+        end
+      end
+
+      ##
+      # Get the queried Service Discovery node or nil
+      #
+      # A Service Discovery node is _not_ a JID node,
+      # this may be a bit confusing. It's just to make
+      # Service Discovery browsing a bit more structured.
+      def node
+        attributes['node']
+      end
+
+      ##
+      # Get the queried Service Discovery node or nil
+      def node=(val)
+        attributes['node'] = val
+      end
+
+      ##
+      # Get the queried Service Discovery node or nil
+      # (chaining-friendly)
+      def set_node(val)
+        self.node = val
+        self
+      end
+    end
+
+    IqQuery.add_namespaceclass('http://jabber.org/protocol/disco#items', IqQueryDiscoItems)
+
+    ##
+    # Service Discovery item to add() to IqQueryDiscoItems
+    #
+    # Please note that JEP 0030 requires the jid to occur
+    class Item < REXML::Element
+      ##
+      # Initialize a new Service Discovery <item/>
+      # to be added to IqQueryDiscoItems
+      # jid:: [JID]
+      # iname:: [String] Item name
+      # node:: [String] Service Discovery node (_not_ JID#node)
+      def initialize(jid=nil, iname=nil, node=nil)
+        super('item')
+        set_jid(jid)
+        set_iname(iname)
+        set_node(node)
+      end
+
+      ##
+      # Get the item's jid or nil
+      # result:: [String]
+      def jid
+        JID::new(attributes['jid'])
+      end
+
+      ##
+      # Set the item's jid
+      # val:: [JID]
+      def jid=(val)
+        attributes['jid'] = val.to_s
+      end
+
+      ##
+      # Set the item's jid (chaining-friendly)
+      # val:: [JID]
+      def set_jid(val)
+        self.jid = val
+        self
+      end
+
+      ##
+      # Get the item's name or nil
+      #
+      # This has been renamed from <name/> to "iname" here
+      # to keep REXML::Element#name accessible
+      # result:: [String]
+      def iname
+        attributes['name']
+      end
+
+      ##
+      # Set the item's name
+      # val:: [String]
+      def iname=(val)
+        attributes['name'] = val
+      end
+
+      ##
+      # Set the item's name (chaining-friendly)
+      # val:: [String]
+      def set_iname(val)
+        self.iname = val
+        self
+      end
+
+      ##
+      # Get the item's Service Discovery node or nil
+      # result:: [String]
+      def node
+        attributes['node']
+      end
+
+      ##
+      # Set the item's Service Discovery node
+      # val:: [String]
+      def node=(val)
+        attributes['node'] = val
+      end
+
+      ##
+      # Set the item's Service Discovery node (chaining-friendly)
+      # val:: [String]
+      def set_node(val)
+        self.node = val
+        self
+      end
+    end
+  end
+end
+

data/lib/xmpp4r/discovery.rb

@@ -0,0 +1,2 @@
+require 'xmpp4r/discovery/iq/discoinfo.rb'
+require 'xmpp4r/discovery/iq/discoitems.rb'

data/lib/xmpp4r/error.rb

@@ -0,0 +1,230 @@
+# =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
+  ##
+  # A class used to build/parse <error/> elements.
+  # Look at JEP 0086 for explanation.
+  class Error < REXML::Element
+    ##
+    # errorcondition:: [nil] or [String] of the following:
+    # * "bad-request"
+    # * "conflict"
+    # * "feature-not-implemented"
+    # * "forbidden"
+    # * "gone"
+    # * "internal-server-error"
+    # * "item-not-found"
+    # * "jid-malformed"
+    # * "not-acceptable"
+    # * "not-allowed"
+    # * "not-authorized"
+    # * "payment-required"
+    # * "recipient-unavailable"
+    # * "redirect"
+    # * "registration-required"
+    # * "remote-server-not-found"
+    # * "remote-server-timeout"
+    # * "resource-constraint"
+    # * "service-unavailable"
+    # * "subscription-required"
+    # * "undefined-condition"
+    # * "unexpected-request"
+    # Will raise an [Exception] if not [nil] and none of the above
+    #
+    # Does also set type and code to appropriate values according to errorcondition
+    #
+    # text: [nil] or [String] Error text
+    def initialize(errorcondition=nil, text=nil)
+      if errorcondition.nil?
+        super('error')
+        set_text(text) unless text.nil?
+      else
+        errortype = nil
+        errorcode = nil
+        @@Errors.each { |cond,type,code|
+          if errorcondition == cond
+            errortype = type
+            errorcode = code
+          end
+        }
+
+        if errortype.nil? || errorcode.nil?
+          raise("Unknown error condition when initializing Error")
+        end
+        
+        super("error")
+        set_error(errorcondition)
+        set_type(errortype)
+        set_code(errorcode)
+        set_text(text) unless text.nil?
+      end
+    end
+
+    ##
+    # Create a new <error/> element and import from existing
+    # element:: [REXML::Element] to import
+    def Error.import(element)
+      Error::new.import(element)
+    end
+    
+    ##
+    # Get the 'Legacy error code' or nil
+    # result:: [Integer] Error code
+    def code
+      if attributes['code']
+        attributes['code'].to_i
+      else
+        nil
+      end
+    end
+
+    ##
+    # Set the 'Legacy error code' or nil
+    # i:: [Integer] Error code
+    def code=(i)
+      if i.nil?
+        attributes['code'] = nil
+      else
+        attributes['code'] = i.to_s
+      end
+    end
+
+    ##
+    # Set the 'Legacy error code' (chaining-friendly)
+    def set_code(i)
+      self.code = i
+      self
+    end
+
+    ##
+    # Get the 'XMPP error condition'
+    #
+    # This can be anything that possess the specific namespace,
+    # checks don't apply here
+    def error
+      name = nil
+      each_element { |e| name = e.name if (e.namespace == 'urn:ietf:params:xml:ns:xmpp-stanzas') && (e.name != 'text') }
+      name
+    end
+
+    ##
+    # Set the 'XMPP error condition'
+    #
+    # One previous element with that namespace will be deleted before
+    #
+    # s:: [String] Name of the element to be added,
+    # namespace will be added automatically, checks don't apply here
+    def error=(s)
+      xe = nil
+      each_element { |e| xe = e if (e.namespace == 'urn:ietf:params:xml:ns:xmpp-stanzas') && (e.name != 'text') }
+      unless xe.nil?
+        delete_element(xe)
+      end
+
+      add_element(s).add_namespace('urn:ietf:params:xml:ns:xmpp-stanzas')
+    end
+
+    ##
+    # Set the 'XMPP error condition' (chaining-friendly)
+    def set_error(s)
+      self.error = s
+      self
+    end
+
+    ##
+    # Get the errors <text/> element text
+    # result:: [String] or nil
+    def text
+      first_element_text('text') || super
+    end
+
+    ##
+    # Set the errors <text/> element text
+    # (Previous <text/> elements will be deleted first)
+    # s:: [String] <text/> content or [nil] if no <text/> element
+    def text=(s)
+      delete_elements('text')
+
+      unless s.nil?
+        e = add_element('text')
+        e.add_namespace('urn:ietf:params:xml:ns:xmpp-stanzas')
+        e.text = s
+      end
+    end
+
+    ##
+    # Set the errors <text/> element text (chaining-friendly)
+    def set_text(s)
+      self.text = s
+      self
+    end
+    
+    ##
+    # Get the type of error
+    # (meaning how to proceed)
+    # result:: [Symbol] or [nil] as following:
+    # * :auth
+    # * :cancel
+    # * :continue
+    # * :modify
+    # * :wait
+    def type
+      case attributes['type']
+        when 'auth' then :auth
+        when 'cancel' then :cancel
+        when 'continue' then :continue
+        when 'modify' then :modify
+        when 'wait' then :wait
+        else nil
+      end
+    end
+
+    ##
+    # Set the type of error (see Error#type)
+    def type=(t)
+      case t
+        when :auth then attributes['type'] = 'auth'
+        when :cancel then attributes['type'] = 'cancel'
+        when :continue then attributes['type'] = 'continue'
+        when :modify then attributes['type'] = 'modify'
+        when :wait then attributes['type'] = 'wait'
+        else attributes['type'] = nil
+      end
+    end
+
+    ##
+    # Set the type of error (chaining-friendly)
+    def set_type(t)
+      self.type = t
+      self
+    end
+
+    ##
+    # Possible XMPP error conditions, types and codes
+    # (JEP 0086)
+    @@Errors = [['bad-request', :modify, 400],
+                ['conflict', :cancel, 409],
+                ['feature-not-implemented', :cancel, 501],
+                ['forbidden', :auth, 403],
+                ['gone', :modify, 302],
+                ['internal-server-error', :wait, 500],
+                ['item-not-found', :cancel, 404],
+                ['jid-malformed', :modify, 400],
+                ['not-acceptable', :modify, 406],
+                ['not-allowed', :cancel, 405],
+                ['not-authorized', :auth, 401],
+                ['payment-required', :auth, 402],
+                ['recipient-unavailable', :wait, 404],
+                ['redirect', :modify, 302],
+                ['registration-required', :auth, 407],
+                ['remote-server-not-found', :cancel, 404],
+                ['remote-server-timeout', :wait, 504],
+                ['resource-constraint', :wait, 500],
+                ['service-unavailable', :cancel, 503],
+                ['subscription-required', :auth, 407],
+                ['undefined-condition', nil, 500],
+                ['unexpected-request', :wait, 400]]
+  end
+end

data/lib/xmpp4r/errorexception.rb

@@ -0,0 +1,32 @@
+# =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
+  ##
+  # This exception can be raised by Helpers when they
+  # receive answers with <tt>type='error'</tt>
+  #
+  # The ErrorException carries a Jabber::Error element
+  class ErrorException < RuntimeError
+    ##
+    # The error element which caused this exception
+    attr_reader :error
+
+    ##
+    # Initialize an ErrorException
+    # error:: [Error]
+    def initialize(error)
+      @error = error
+    end
+
+    ##
+    # Textual output
+    #
+    # Sample:
+    #  subscription-required: Please subscribe first
+    def to_s
+      "#{@error.error}: #{@error.text}"
+    end
+  end
+end

data/lib/xmpp4r/feature_negotiation/iq/feature.rb

@@ -0,0 +1,42 @@
+require 'xmpp4r/iq'
+require 'xmpp4r/dataforms/x/data'
+
+module Jabber
+  module FeatureNegotiation
+    ##
+    # Feature negotiation,
+    # can appear as direct child to Iq
+    # or as child of IqSi
+    class IqFeature < REXML::Element
+      def initialize
+        super('feature')
+
+        add_namespace 'http://jabber.org/protocol/feature-neg'
+      end
+
+      def IqFeature.import(element)
+        IqFeature::new.import(element)
+      end
+
+      def typed_add(element)
+        if element.name == 'x' and element.namespace == 'jabber:x:data'
+          super Dataforms::XData.new.import(element)
+        else
+          super element
+        end
+      end
+
+      ##
+      # First <x/> child with xmlns='jabber:x:data'
+      def x
+        res = nil
+        each_element('x') { |e|
+          res = e if e.namespace == 'jabber:x:data'
+        }
+        res
+      end
+    end
+
+    Iq.add_elementclass('feature', IqFeature)
+  end
+end

data/lib/xmpp4r/feature_negotiation.rb

@@ -0,0 +1 @@
+require 'xmpp4r/feature_negotiation/iq/feature.rb'