mojodna-xmpp4r 0.4.0.2

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

@@ -0,0 +1,211 @@
+# =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
+    NS_DISCO_INFO = 'http://jabber.org/protocol/disco#info'
+
+    ##
+    # 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
+      name_xmlns 'query', NS_DISCO_INFO
+
+      ##
+      # Get the queried Service Discovery node or nil
+      #
+      # See IqQueryDiscoItems#node for a
+      # small explanation of this.
+      def node
+        attributes['node']
+      end
+
+      ##
+      # Set the queried Service Discovery node or nil
+      # val:: [String]
+      def node=(val)
+        attributes['node'] = val
+      end
+
+      ##
+      # Set 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 identities
+      # result:: [Array] of [Identity]
+      def identities
+        get_elements('identity')
+      end
+
+      ##
+      # Get list of features
+      # result:: [Array] of [String]
+      def features
+        res = []
+        each_element('feature') { |feature|
+          res.push(feature.var)
+        }
+        res
+      end
+    end
+
+
+    ##
+    # Service Discovery identity to add() to IqQueryDiscoInfo
+    #
+    # Please note that XEP 0030 requires both category and type to occur,
+    # for a reference see: http://www.xmpp.org/registrar/disco-categories.html
+    class Identity < XMPPElement
+      name_xmlns 'identity', NS_DISCO_INFO
+
+      ##
+      # 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()
+        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,
+    # for a reference see: http://www.xmpp.org/registrar/disco-features.html
+    class Feature < XMPPElement
+      name_xmlns 'feature', NS_DISCO_INFO
+
+      ##
+      # Create a new <feature/> element
+      # var:: [String] New var
+      def initialize(var=nil)
+        super()
+        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,147 @@
+# =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
+    NS_DISCO_ITEMS = 'http://jabber.org/protocol/disco#items'
+
+    ##
+    # 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
+      name_xmlns 'query', NS_DISCO_ITEMS
+
+      ##
+      # 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
+
+      ##
+      # Set the queried Service Discovery node or nil
+      def node=(val)
+        attributes['node'] = val
+      end
+
+      ##
+      # Set the queried Service Discovery node or nil
+      # (chaining-friendly)
+      def set_node(val)
+        self.node = val
+        self
+      end
+
+      ##
+      # Get all item children
+      # result:: Array of [Discovery::Item]
+      def items
+        get_elements('item')
+      end
+    end
+
+
+    ##
+    # Service Discovery item to add() to IqQueryDiscoItems
+    #
+    # Please note that JEP 0030 requires the jid to occur
+    class Item < XMPPElement
+      name_xmlns 'item', NS_DISCO_ITEMS
+
+      ##
+      # 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()
+        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,8 @@
+# =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/iq/discoinfo'
+require 'xmpp4r/discovery/iq/discoitems'
+require 'xmpp4r/discovery/helper/helper'
+require 'xmpp4r/discovery/helper/responder'

data/lib/xmpp4r/errors.rb

@@ -0,0 +1,283 @@
+# =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
+
+  # CUSTOM ERROR CLASSES
+
+  # All of our custom errors are superclassed by JabberError < StandardError
+  class JabberError < StandardError; end
+
+  # A client-side only argument error
+  class ArgumentError < JabberError; end
+
+  ##
+  # An error returned from the server
+  #
+  # e.g. This exception can be raised by helpers when they
+  # receive a server reply with <tt>type='error'</tt>
+  #
+  # The ServerError carries a Jabber::ErrorResponse element
+  #
+  class ServerError < JabberError #:nodoc:
+
+    ##
+    # The error element which caused this exception
+    attr_reader :error
+
+    ##
+    # Initialize a ServerError by passing an ErrorResponse instance
+    # error:: [Error]
+    def initialize(error)
+      @error = error
+    end
+
+    ##
+    # Sample output:
+    # 'subscription-required: Please subscribe first'
+    def to_s
+      "#{@error.error}: #{@error.text}"
+    end
+  end
+
+  class ClientAuthenticationFailure < JabberError; end
+
+  class ComponentAuthenticationFailure < JabberError; end
+
+  # TODO : Give this a better name
+  class NoNameXmlnsRegistered < JabberError
+    def initialize(klass)
+      super "Class #{klass} has not set name and xmlns"
+    end
+  end
+
+  # TODO : Give this a better name
+  class SOCKS5Error < JabberError; end
+
+  class InvalidChatState < JabberError; end
+
+  ##
+  # A class used to build/parse <error/> elements.
+  # Look at XEP-0086 for explanation:
+  # http://www.xmpp.org/extensions/xep-0086.html
+  #
+  # FIXME : XEP-0086 is officially deprecated.  What effect does that have on this class? Any?
+  #
+  class ErrorResponse < XMPPElement
+    name_xmlns 'error'
+
+    ##
+    # 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
+    #
+    # Also sets type and code to appropriate values according to errorcondition
+    #
+    # text: [nil] or [String] ErrorResponse text
+    def initialize(errorcondition=nil, text=nil)
+      if errorcondition.nil?
+        super()
+        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 ArgumentError, "Unknown error condition when initializing ErrorReponse"
+        end
+
+        super()
+        set_error(errorcondition)
+        set_type(errortype)
+        set_code(errorcode)
+        set_text(text) unless text.nil?
+      end
+    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 ErrorResponse#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 (XEP-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/feature_negotiation/iq/feature.rb

@@ -0,0 +1,28 @@
+# =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'
+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 < XMPPElement
+      name_xmlns 'feature', 'http://jabber.org/protocol/feature-neg'
+
+      ##
+      # 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
+  end
+end

data/lib/xmpp4r/feature_negotiation.rb

@@ -0,0 +1,5 @@
+# =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/feature_negotiation/iq/feature.rb'