sprsquish-blather 0.1 → 0.2.3

data/lib/blather/errors/stanza_error.rb

@@ -0,0 +1,262 @@
+module Blather
+
+##
+# Stanza errors
+# RFC3920 Section 9.3 (http://xmpp.org/rfcs/rfc3920.html#stanzas-error)
+class StanzaError < BlatherError
+  VALID_TYPES = [:cancel, :continue, :modify, :auth, :wait]
+
+  class_inheritable_accessor :err_name
+  @@registrations = {}
+  
+  register :stanza_error
+
+  attr_reader :original, :type, :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)
+    original = node.copy
+    original.remove_child 'error'
+
+    error_node = node.find_first 'child::error'
+
+    name = error_node.find_first('child::*[name()!="text"]', 'urn:ietf:params:xml:ns:xmpp-stanzas').element_name
+    type = error_node['type']
+    text = node.find_first 'descendant::text', 'urn:ietf:params:xml:ns:xmpp-stanzas'
+    text = text.content if text
+
+    extras = error_node.find("descendant::*[name()!='text' and name()!='#{name}']").map { |n| n }
+
+    class_from_registration(name).new original, type, text, extras
+  end
+
+  ##
+  # <tt>original</tt> An original node must be provided for stanza errors. You can't declare
+  # a stanza error on without a stanza.
+  # <tt>type</tt> is the error type specified in RFC3920 (http://xmpp.org/rfcs/rfc3920.html#rfc.section.9.3.2)
+  # <tt>text</tt> is an option error description
+  # <tt>extras</tt> an array of application specific nodes to add to the error. These should be properly namespaced.
+  def initialize(original, type, text = nil, extras = [])
+    @original = original
+    self.type = type
+    @text = text
+    @extras = extras
+  end
+
+  ##
+  # XMPP defined error name
+  def err_name
+    self.class.err_name
+  end
+
+  ##
+  # Set the error type (see RFC3920 Section 9.3.2 (http://xmpp.org/rfcs/rfc3920.html#rfc.section.9.3.2))
+  def type=(type)
+    type = type.to_sym
+    raise ArgumentError, "Invalid Type (#{type}), use: #{VALID_TYPES*' '}" if !VALID_TYPES.include?(type)
+    @type = type
+  end
+
+  ##
+  # Creates an XML node from the error
+  def to_node
+    node = self.original.reply
+
+    error_node = XMPPNode.new 'error'
+    err = XMPPNode.new(self.err_name)
+    err.namespace = 'urn:ietf:params:xml:ns:xmpp-stanzas'
+    error_node << err
+
+    if self.text
+      text = XMPPNode.new('text')
+      text.namespace = 'urn:ietf:params:xml:ns:xmpp-stanzas'
+      text << self.text
+      error_node << text
+    end
+
+    self.extras.each do |extra|
+      extra_copy = extra.copy
+      extra_copy.namespace = extra.namespace
+      error_node << extra_copy
+    end
+
+    node << error_node
+    node.type = 'error'
+    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:
+    "Stanza Error (#{self.err_name}): #{self.text}"
+  end
+  alias_method :to_s, :inspect # :nodoc:
+
+  ##
+  # The sender has sent XML that is malformed or that cannot be processed (e.g., an IQ stanza that includes
+  # an unrecognized value of the 'type' attribute); the associated error type SHOULD be "modify"
+  class BadRequest < StanzaError
+    register :stanza_bad_request_error, 'bad-request'
+  end
+
+  ##
+  # Access cannot be granted because an existing resource or session exists with the same name or address;
+  # the associated error type SHOULD be "cancel"
+  class Conflict < StanzaError
+    register :stanza_conflict_error, 'conflict'
+  end
+
+  ##
+  # the feature requested is not implemented by the recipient or server and therefore cannot be processed;
+  # the associated error type SHOULD be "cancel".
+  class FeatureNotImplemented < StanzaError
+    register :stanza_feature_not_implemented_error, 'feature-not-implemented'
+  end
+
+  ##
+  # the requesting entity does not possess the required permissions to perform the action;
+  # the associated error type SHOULD be "auth".
+  class Forbidden < StanzaError
+    register :stanza_forbidden_error, 'forbidden'
+  end
+
+  ##
+  # the recipient or server can no longer be contacted at this address (the error stanza MAY contain a new address
+  # in the XML character data of the <gone/> element); the associated error type SHOULD be "modify".
+  class Gone < StanzaError
+    register :stanza_gone_error, 'gone'
+  end
+
+  ##
+  # the server could not process the stanza because of a misconfiguration or an otherwise-undefined internal server error;
+  # the associated error type SHOULD be "wait".
+  class InternalServerError < StanzaError
+    register :stanza_internal_server_error, 'internal-server-error'
+  end
+
+  ##
+  # the addressed JID or item requested cannot be found; the associated error type SHOULD be "cancel".
+  class ItemNotFound < StanzaError
+    register :stanza_item_not_found_error, 'item-not-found'
+  end
+
+  ##
+  # the addressed JID or item requested cannot be found; the associated error type SHOULD be "cancel".
+  class JidMalformed < StanzaError
+    register :stanza_jid_malformed_error, 'jid-malformed'
+  end
+
+  ##
+  # the recipient or server understands the request but is refusing to process it because it does not meet criteria defined
+  # by the recipient or server (e.g., a local policy regarding acceptable words in messages); the associated error type SHOULD be "modify".
+  class NotAcceptable < StanzaError
+    register :stanza_not_acceptable_error, 'not-acceptable'
+  end
+
+  ##
+  # The recipient or server does not allow any entity to perform the action; the associated error type SHOULD be "cancel".
+  class NotAllowed < StanzaError
+    register :stanza_not_allowed_error, 'not-allowed'
+  end
+
+  ##
+  # the sender must provide proper credentials before being allowed to perform the action, or has provided improper credentials;
+  # the associated error type SHOULD be "auth".
+  class NotAuthorized < StanzaError
+    register :stanza_not_authorized_error, 'not-authorized'
+  end
+
+  ##
+  # the requesting entity is not authorized to access the requested service because payment is required; the associated error type SHOULD be "auth".
+  class PaymentRequired < StanzaError
+    register :stanza_payment_required_error, 'payment-required'
+  end
+
+  ##
+  # the intended recipient is temporarily unavailable; the associated error type SHOULD be "wait" (note: an application MUST NOT
+  # return this error if doing so would provide information about the intended recipient's network availability to an entity that
+  # is not authorized to know such information).
+  class RecipientUnavailable < StanzaError
+    register :stanza_recipient_unavailable_error, 'recipient-unavailable'
+  end
+
+  ##
+  # the recipient or server is redirecting requests for this information to another entity, usually temporarily (the error stanza SHOULD contain
+  # the alternate address, which MUST be a valid JID, in the XML character data of the <redirect/> element); the associated error type SHOULD be "modify".
+  class Redirect < StanzaError
+    register :stanza_redirect_error, 'redirect'
+  end
+
+  ##
+  # the requesting entity is not authorized to access the requested service because registration is required; the associated error type SHOULD be "auth".
+  class RegistrationRequired < StanzaError
+    register :stanza_registration_required_error, 'registration-required'
+  end
+
+  ##
+  # a remote server or service specified as part or all of the JID of the intended recipient does not exist; the associated error type SHOULD be "cancel".
+  class RemoteServerNotFound < StanzaError
+    register :stanza_remote_server_not_found_error, 'remote-server-not-found'
+  end
+
+  ##
+  # a remote server or service specified as part or all of the JID of the intended recipient (or required to fulfill a request) could not be
+  # contacted within a reasonable amount of time; the associated error type SHOULD be "wait".
+  class RemoteServerTimeout < StanzaError
+    register :stanza_remote_server_timeout_error, 'remote-server-timeout'
+  end
+
+  ##
+  # the server or recipient lacks the system resources necessary to service the request; the associated error type SHOULD be "wait".
+  class ResourceConstraint < StanzaError
+    register :stanza_resource_constraint_error, 'resource-constraint'
+  end
+
+  ##
+  # the server or recipient does not currently provide the requested service; the associated error type SHOULD be "cancel".
+  class ServiceUnavailable < StanzaError
+    register :stanza_service_unavailable_error, 'service-unavailable'
+  end
+
+  ##
+  # the requesting entity is not authorized to access the requested service because a subscription is required; the associated error type SHOULD be "auth".
+  class SubscriptionRequired < StanzaError
+    register :stanza_subscription_required_error, 'subscription-required'
+  end
+
+  ##
+  # the error condition is not one of those defined by the other conditions in this list; any error type may be associated with this condition,
+  # and it SHOULD be used only in conjunction with an application-specific condition.
+  class UndefinedCondition < StanzaError
+    register :stanza_undefined_condition_error, 'undefined-condition'
+  end
+
+  ##
+  # the recipient or server understood the request but was not expecting it at this time (e.g., the request was out of order);
+  # the associated error type SHOULD be "wait".
+  class UnexpectedRequest < StanzaError
+    register :stanza_unexpected_request_error, 'unexpected-request'
+  end
+end #StanzaError
+
+end #Blather

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/errors.rb

@@ -0,0 +1,48 @@
+module Blather
+  # Main error class
+  class BlatherError < StandardError
+    class_inheritable_array :handler_heirarchy
+
+    self.handler_heirarchy ||= []
+    self.handler_heirarchy << :error
+
+    def self.register(handler)
+      self.handler_heirarchy.unshift handler
+    end
+  end
+
+  ##
+  # Used in cases where a stanza only allows specific values for its attributes
+  # and an invalid value is attempted.
+  class ArgumentError < BlatherError
+    register :argument_error
+  end
+
+  ##
+  # The stream handler received a response it didn't know how to handle
+  class UnknownResponse < BlatherError
+    register :unknown_response_error
+    attr_reader :node
+
+    def initialize(node)
+      @node = node
+    end
+  end
+
+  ##
+  # TLS negotiations broke down
+  class TLSFailure < BlatherError
+    register :tls_failure
+  end
+
+  ##
+  # Something bad happened while parsing the incoming stream
+  class ParseError < BlatherError
+    register :parse_error
+    attr_reader :message
+
+    def initialize(message)
+      @message = message
+    end
+  end
+end

data/lib/blather/{core/jid.rb → jid.rb}

@@ -1,34 +1,27 @@
-# =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 Blather
+
   ##
-  # The JID class represents a Jabber Identifier as described by
-  # RFC3920 section 3.1.
-  #
-  # Note that you can use JIDs also for Sorting, Hash keys, ...
+  # This is a simple modification of the JID class from XMPP4R
   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
@@ -45,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
@@ -70,7 +57,7 @@ module Blather
       s = @domain
       s = "#{@node}@#{s}" if @node
       s = "#{s}/#{@resource}" if @resource
-      return s
+      s
     end
 
     ##
@@ -97,9 +84,11 @@ module Blather
       to_s <=> o.to_s
     end
 
-    # Test id jid is strepped
+    ##
+    # Test if JID is stripped
     def stripped?
       @resource.nil?
     end
   end
+
 end