blather 0.2.1 → 0.2.2

data/lib/blather/errors/stream_error.rb

@@ -0,0 +1,253 @@
+module Blather
+
+##
+# Stream Errors
+# RFC3920 Section 9.3 (http://xmpp.org/rfcs/rfc3920.html#streams-error-rules)
+class StreamError < BlatherError
+  class_inheritable_accessor :err_name
+  @@registrations = {}
+
+  register :stream_error
+
+  attr_reader :text, :extras
+
+  ##
+  # Register the handler and type to simplify importing
+  def self.register(handler, err_name)
+    super handler
+    self.err_name = err_name
+    @@registrations[err_name] = self
+  end
+
+  ##
+  # Retreive an error class from a given name
+  def self.class_from_registration(err_name)
+    @@registrations[err_name.to_s] || self
+  end
+
+  ##
+  # Factory method for instantiating the proper class
+  # for the error
+  def self.import(node)
+    name = node.find_first('descendant::*[name()!="text"]', 'urn:ietf:params:xml:ns:xmpp-streams').element_name
+    text = node.find_first 'descendant::text', 'urn:ietf:params:xml:ns:xmpp-streams'
+    text = text.content if text
+
+    extras = node.find("descendant::*[name()!='text' and name()!='#{name}']").map { |n| n }
+
+    class_from_registration(name).new text, extras
+  end
+
+  ##
+  # <tt>text</tt> is the (optional) error message.
+  # <tt>extras</tt> should be an array of nodes to attach to the error
+  # each extra should be in an application specific namespace
+  # see RFC3920 Section 4.7.2 (http://xmpp.org/rfcs/rfc3920.html#rfc.section.4.7.2)
+  def initialize(text = nil, extras = [])
+    @text = text
+    @extras = extras
+  end
+
+  ##
+  # XMPP defined error name
+  def err_name
+    self.class.err_name
+  end
+
+  ##
+  # Creates an XML node from the error
+  def to_node
+    node = XMPPNode.new('stream:error')
+
+    err = XMPPNode.new(self.err_name)
+    err.namespace = 'urn:ietf:params:xml:ns:xmpp-streams'
+    node << err
+
+    if self.text
+      text = XMPPNode.new('text')
+      text.namespace = 'urn:ietf:params:xml:ns:xmpp-streams'
+      text << self.text
+      node << text
+    end
+
+    self.extras.each do |extra|
+      extra_copy = extra.copy
+      extra_copy.namespace = extra.namespace
+      node << extra_copy
+    end
+    node
+  end
+
+  ##
+  # Turns the object into XML fit to be sent over the stream
+  def to_xml
+    to_node.to_s
+  end
+
+  def inspect # :nodoc:
+    "Stream Error (#{self.err_name}): #{self.text}"
+  end
+  alias_method :to_s, :inspect # :nodoc:
+
+  ##
+  # The entity has sent XML that cannot be processed; this error MAY be used instead of the more specific XML-related errors,
+  # such as <bad-namespace-prefix/>, <invalid-xml/>, <restricted-xml/>, <unsupported-encoding/>, and <xml-not-well-formed/>,
+  # although the more specific errors are preferred.
+  class BadFormat < StreamError
+    register :stream_bad_format_error, 'bad-format'
+  end
+
+  ##
+  # The entity has sent a namespace prefix that is unsupported, or has sent no namespace prefix on an element that requires
+  # such a prefix (see XML Namespace Names and Prefixes).
+  class BadNamespacePrefix < StreamError
+    register :stream_bad_namespace_prefix_error, 'bad-namespace-prefix'
+  end
+  
+  ##
+  # The server is closing the active stream for this entity because a new stream has been initiated that conflicts with the
+  # existing stream.
+  class Conflict < StreamError
+    register :stream_conflict_error, 'conflict'
+  end
+  
+  ##
+  # The entity has not generated any traffic over the stream for some period of time (configurable according to a local service policy).
+  class ConnectionTimeout < StreamError
+    register :stream_connection_timeout_error, 'connection-timeout'
+  end
+  
+  ##
+  # The value of the 'to' attribute provided by the initiating entity in the stream header corresponds to a hostname that is no
+  # longer hosted by the server.
+  class HostGone < StreamError
+    register :stream_host_gone_error, 'host-gone'
+  end
+  
+  ##
+  # The value of the 'to' attribute provided by the initiating entity in the stream header does not correspond to a hostname that
+  # is hosted by the server.
+  class HostUnknown < StreamError
+    register :stream_host_unknown_error, 'host-unknown'
+  end
+  
+  ##
+  # a stanza sent between two servers lacks a 'to' or 'from' attribute (or the attribute has no value).
+  class ImproperAddressing < StreamError
+    register :stream_improper_addressing_error, 'improper-addressing'
+  end
+  
+  ##
+  # The server has experienced a misconfiguration or an otherwise-undefined internal error that prevents it from servicing the stream.
+  class InternalServerError < StreamError
+    register :stream_internal_server_error, 'internal-server-error'
+  end
+  
+  ##
+  # The JID or hostname provided in a 'from' address does not match an authorized JID or validated domain negotiated between
+  # servers via SASL or dialback, or between a client and a server via authentication and resource binding.
+  class InvalidFrom < StreamError
+    register :stream_invalid_from_error, 'invalid-from'
+  end
+  
+  ##
+  # The stream ID or dialback ID is invalid or does not match an ID previously provided.
+  class InvalidId < StreamError
+    register :stream_invalid_id_error, 'invalid-id'
+  end
+  
+  ##
+  # The streams namespace name is something other than "http://etherx.jabber.org/streams" or the dialback namespace name is something
+  # other than "jabber:server:dialback" (see XML Namespace Names and Prefixes).
+  class InvalidNamespace < StreamError
+    register :stream_invalid_namespace_error, 'invalid-namespace'
+  end
+  
+  ##
+  # The entity has sent invalid XML over the stream to a server that performs validation (see Validation).
+  class InvalidXml < StreamError
+    register :stream_invalid_xml_error, 'invalid-xml'
+  end
+  
+  ##
+  # The entity has attempted to send data before the stream has been authenticated, or otherwise is not authorized to perform an action
+  # related to stream negotiation; the receiving entity MUST NOT process the offending stanza before sending the stream error.
+  class NotAuthorized < StreamError
+    register :stream_not_authorized_error, 'not-authorized'
+  end
+  
+  ##
+  # The entity has violated some local service policy; the server MAY choose to specify the policy in the <text/> element or an
+  # application-specific condition element.
+  class PolicyViolation < StreamError
+    register :stream_policy_violation_error, 'policy-violation'
+  end
+  
+  ##
+  # The server is unable to properly connect to a remote entity that is required for authentication or authorization.
+  class RemoteConnectionFailed < StreamError
+    register :stream_remote_connection_failed_error, 'remote-connection-failed'
+  end
+  
+  ##
+  # The server lacks the system resources necessary to service the stream.
+  class ResourceConstraint < StreamError
+    register :stream_resource_constraint_error, 'resource-constraint'
+  end
+  
+  ##
+  # The entity has attempted to send restricted XML features such as a comment, processing instruction, DTD, entity reference,
+  # or unescaped character (see Restrictions).
+  class RestrictedXml < StreamError
+    register :stream_restricted_xml_error, 'restricted-xml'
+  end
+  
+  ##
+  # The server will not provide service to the initiating entity but is redirecting traffic to another host; the server SHOULD
+  # specify the alternate hostname or IP address (which MUST be a valid domain identifier) as the XML character data of the
+  # <see-other-host/> element.
+  class SeeOtherHost < StreamError
+    register :stream_see_other_host_error, 'see-other-host'
+  end
+  
+  ##
+  # The server is being shut down and all active streams are being closed.
+  class SystemShutdown < StreamError
+    register :stream_system_shutdown_error, 'system-shutdown'
+  end
+  
+  ##
+  # The error condition is not one of those defined by the other conditions in this list; this error condition SHOULD be used
+  # only in conjunction with an application-specific condition.
+  class UndefinedCondition < StreamError
+    register :stream_undefined_condition_error, 'undefined-condition'
+  end
+  
+  ##
+  # The initiating entity has encoded the stream in an encoding that is not supported by the server (see Character Encoding).
+  class UnsupportedEncoding < StreamError
+    register :stream_unsupported_encoding_error, 'unsupported-encoding'
+  end
+  
+  ##
+  # The initiating entity has sent a first-level child of the stream that is not supported by the server.
+  class UnsupportedStanzaType < StreamError
+    register :stream_unsupported_stanza_type_error, 'unsupported-stanza-type'
+  end
+  
+  ##
+  # The value of the 'version' attribute provided by the initiating entity in the stream header specifies a version of XMPP
+  # That is not supported by the server; the server MAY specify the version(s) it supports in the <text/> element.
+  class UnsupportedVersion < StreamError
+    register :stream_unsupported_version_error, 'unsupported-version'
+  end
+  
+  ##
+  # The initiating entity has sent XML that is not well-formed as defined by [XML].
+  class XmlNotWellFormed < StreamError
+    register :stream_xml_not_well_formed_error, 'xml-not-well-formed'
+  end
+
+end #StreamError
+
+end #Blather

data/lib/blather/jid.rb

@@ -5,24 +5,23 @@ module Blather
   class JID
     include Comparable
 
-    PATTERN = /^(?:([^@]*)@)??([^@\/]*)(?:\/(.*?))?$/
-
-    begin
-      require 'idn'
-      USE_STRINGPREP = true
-    rescue LoadError
-      USE_STRINGPREP = false
-    end
+    PATTERN = /^(?:([^@]*)@)??([^@\/]*)(?:\/(.*?))?$/.freeze
 
+    ##
     # Get the JID's node
     attr_reader :node
 
+    ##
     # Get the JID's domain
     attr_reader :domain
 
+    ##
     # Get the JID's resource
     attr_reader :resource
 
+    ##
+    # If a JID is passed in just return it. 
+    # No need to copy out all the values
     def self.new(node, domain = nil, resource = nil)
       node.is_a?(JID) ? node : super
     end
@@ -39,14 +38,8 @@ module Blather
         @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
+      @node.downcase!   if @node
+      @domain.downcase! if @domain
 
       raise ArgumentError, 'Node too long'      if (@node || '').length > 1023
       raise ArgumentError, 'Domain too long'    if (@domain || '').length > 1023

data/lib/blather/roster.rb

@@ -71,6 +71,15 @@ module Blather
       @items.dup
     end
 
+    ##
+    # A hash of items keyed by group
+    def grouped
+      self.inject(Hash.new{|h,k|h[k]=[]}) do |hash, item|
+        item[1].groups.each { |group| hash[group] << item[1] }
+        hash
+      end
+    end
+
   private
     def self.key(jid)
       JID.new(jid).stripped.to_s

data/lib/blather/roster_item.rb

@@ -17,6 +17,7 @@ module Blather
     # item:: can be a JID, String (a@b) or a Stanza
     def initialize(item)
       @statuses = []
+      @groups = []
 
       case item
       when JID
@@ -24,12 +25,14 @@ module Blather
       when String
         self.jid = JID.new(item).stripped
       when XMPPNode
-        self.jid          = JID.new(item['jid']).stripped
-        self.name         = item['name']
-        self.subscription = item['subscription']
-        self.ask          = item['ask']
+        self.jid          = JID.new(item[:jid]).stripped
+        self.name         = item[:name]
+        self.subscription = item[:subscription]
+        self.ask          = item[:ask]
         item.groups.each { |g| self.groups << g }
       end
+
+      @groups = [nil] if @groups.empty?
     end
 
     ##

data/lib/blather/stanza.rb

@@ -3,6 +3,7 @@ module Blather
   # Base XMPP Stanza
   class Stanza < XMPPNode
     @@last_id = 0
+    @@handler_list = []
 
     class_inheritable_array :handler_heirarchy
 
@@ -13,12 +14,17 @@ module Blather
     # that inherits Stanza can register a callback for itself
     # which is added to a list and iterated over when looking for
     # a callback to use
-    def self.register(type, name = nil, xmlns = nil)
+    def self.register(type, name = nil, ns = nil)
+      @@handler_list << type
       self.handler_heirarchy ||= []
       self.handler_heirarchy.unshift type
 
       name = name || self.name || type
-      super name, xmlns
+      super name, ns
+    end
+
+    def self.handler_list
+      @@handler_list
     end
 
     ##
@@ -65,43 +71,31 @@ module Blather
       self
     end
 
-    def id=(id)
-      attributes['id'] = id
-    end
-
-    def id
-      attributes['id']
-    end
+    attribute_accessor :id, :to_sym => false
 
-    def to=(to)
-      attributes['to'] = to
-    end
+    attribute_writer :to, :from
 
     ##
     # returns:: JID created from the "to" value of the stanza
     def to
-      JID.new(attributes['to']) if attributes['to']
-    end
-
-    def from=(from)
-      attributes['from'] = from
+      JID.new(attributes[:to]) if attributes[:to]
     end
 
     ##
     # returns:: JID created from the "from" value of the stanza
     def from
-      JID.new(attributes['from']) if attributes['from']
+      JID.new(attributes[:from]) if attributes[:from]
     end
 
-    def type=(type)
-      attributes['type'] = type
-    end
+    attribute_accessor :type
 
     ##
-    # returns:: a symbol of the type
-    def type
-      attributes['type'].to_sym unless attributes['type'].blank?
+    # Transform the stanza into a stanza error
+    # <tt>err_name_or_class</tt> can be the name of the error or the error class to use
+    # <tt>type</tt>, <tt>text</tt>, <tt>extras</tt> are the same as for StanzaError#new
+    def as_error(err_name_or_class, type, text = nil, extras = [])
+      klass = (err_name_or_class.is_a?(Class) ? err_name_or_class : StanzaError.class_from_registration(err_name_or_class))
+      klass.new self, type, text, extras
     end
-
   end
 end

data/lib/blather/stanza/disco.rb

@@ -0,0 +1,9 @@
+module Blather
+class Stanza
+
+  class Disco < Iq::Query
+    attribute_accessor :node, :to_sym => false
+  end
+
+end #Stanza
+end #Blather

data/lib/blather/stanza/disco/disco_info.rb

@@ -0,0 +1,84 @@
+module Blather
+class Stanza
+
+  ##
+  # DiscoInfo object ()
+  # 
+  class DiscoInfo < Disco
+    register :disco_info, nil, 'http://jabber.org/protocol/disco#info'
+
+    def initialize(type = nil, node = nil, identities = [], features = [])
+      super type
+
+      self.node = node
+
+      [identities].flatten.each do |id|
+        query << (id.is_a?(Identity) ? id : Identity.new(id[:name], id[:type], id[:category]))
+      end
+
+      [features].flatten.each do |feature|
+        query << (feature.is_a?(Feature) ? feature : Feature.new(feature))
+      end
+    end
+
+    ##
+    # List of identity objects
+    def identities
+      identities = query.find('identity')
+      identities = query.find('query_ns:identity', :query_ns => self.class.ns) if identities.empty?
+      identities.map { |i| Identity.new i }
+    end
+
+    ##
+    # List of feature objects
+    def features
+     features = query.find('feature')
+     features = query.find('query_ns:feature', :query_ns => self.class.ns) if features.empty?
+     features.map { |i| Feature.new i }
+    end
+
+    class Identity < XMPPNode
+      attribute_accessor :category, :type
+      attribute_accessor :name, :to_sym => false
+
+      def initialize(name, type = nil, category = nil)
+        super :identity
+
+        if name.is_a?(XML::Node)
+          self.inherit name
+        else
+          self.name = name
+          self.type = type
+          self.category = category
+        end
+      end
+
+      def eql?(other)
+        other.kind_of?(self.class) &&
+        other.name == self.name &&
+        other.type == self.type &&
+        other.category == self.category
+      end
+    end
+
+    class Feature < XMPPNode
+      attribute_accessor :var, :to_sym => false
+
+      def initialize(var)
+        super :feature
+        if var.is_a?(XML::Node)
+          self.inherit var
+        else
+          self.var = var
+        end
+      end
+
+      def eql?(other)
+        other.kind_of?(self.class) &&
+        other.var == self.var
+      end
+    end
+  end
+
+end #Stanza
+end #Blather