blather 0.2.3 → 0.3.0

data/lib/blather/client/dsl.rb

@@ -0,0 +1,99 @@
+require File.join(File.dirname(__FILE__), 'client')
+
+module Blather
+  module DSL
+    def client
+      @client ||= Client.new
+    end
+    module_function :client
+
+    ##
+    # Prepare server settings
+    #   setup [node@domain/resource], [password], [host], [port]
+    # host and port are optional defaulting to the domain in the JID and 5222 respectively
+    def setup(jid, password, host = nil, port = nil)
+      client.setup(jid, password, host, port)
+      at_exit { client.run }
+    end
+
+    ##
+    # Shutdown the connection.
+    # Flushes the write buffer then stops EventMachine
+    def shutdown
+      client.stop
+    end
+
+    ##
+    # Set handler for a stanza type
+    def handle(stanza_type, *guards, &block)
+      client.register_handler stanza_type, *guards, &block
+    end
+
+    ##
+    # Wrapper for "handle :ready" (just a bit of syntactic sugar)
+    def when_ready(&block)
+      handle :ready, &block
+    end
+
+    ##
+    # Set current status
+    def status(state = nil, msg = nil)
+      client.status = state, msg
+    end
+
+    ##
+    # Direct access to the roster
+    def roster
+      client.roster
+    end
+
+    ##
+    # Write data to the stream
+    # Anything that resonds to #to_s can be paseed to the stream
+    def write(stanza)
+      client.write(stanza)
+    end
+
+    ##
+    # Helper method to make sending basic messages easier
+    #   say [jid], [msg]
+    def say(to, msg)
+      client.write Blather::Stanza::Message.new(to, msg)
+    end
+
+    ##
+    # Wrapper to grab the current JID
+    def jid
+      client.jid
+    end
+
+    ##
+    #
+    def discover(what, who, where, &callback)
+      stanza = Blather::Stanza.class_from_registration(:query, "http://jabber.org/protocol/disco##{what}").new
+      stanza.to = who
+      stanza.node = where
+
+      client.temporary_handler stanza.id, &callback
+      write stanza
+    end
+
+    ##
+    # PubSub proxy
+    def pubsub
+      client.pubsub
+    end
+
+    ##
+    # Checks to see if the method is part of the handlers list.
+    # If so it creates a handler, otherwise it'll pass it back
+    # to Ruby's method_missing handler
+    def method_missing(method, *args, &block)
+      if Blather::Stanza.handler_list.include?(method)
+        handle method, *args, &block
+      else
+        super
+      end
+    end
+  end #DSL
+end #Blather

data/lib/blather/errors.rb

@@ -9,6 +9,11 @@ module Blather
     def self.register(handler)
       self.handler_heirarchy.unshift handler
     end
+
+    # HACK!! until I can refactor the entire Error object model
+    def id
+      nil
+    end
   end
 
   ##

data/lib/blather/errors/sasl_error.rb

@@ -6,81 +6,17 @@ class SASLError < BlatherError
 
   register :sasl_error
 
-  ##
-  # 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 to create the proper error object from an error node
   def self.import(node)
-    err_name = node.children.first.element_name
-    class_from_registration(err_name).new
-  end
-
-  ##
-  # XMPP defined error name
-  def err_name
-    self.class.err_name
+    self.new node
   end
 
-  ##
-  # The receiving entity acknowledges an <abort/> element sent by the initiating entity; sent in reply to the <abort/> element.
-  class Aborted < SASLError
-    register :sasl_aborted_error, 'aborted'
+  def initialize(node)
+    super()
+    @node = node
   end
 
-  ##
-  # The data provided by the initiating entity could not be processed because the [BASE64] encoding is incorrect
-  # (e.g., because the encoding does not adhere to the definition in Section 3 of [BASE64]); sent in reply to a <response/>
-  # element or an <auth/> element with initial response data.
-  class IncorrectEncoding < SASLError
-    register :sasl_incorrect_encoding_error, 'incorrect-encoding'
-  end
-  
-  ##
-  # The authzid provided by the initiating entity is invalid, either because it is incorrectly formatted or because the
-  # initiating entity does not have permissions to authorize that ID; sent in reply to a <response/> element or an <auth/>
-  # element with initial response data.
-  class InvalidAuthzid < SASLError
-    register :sasl_invalid_authzid_error, 'invalid-authzid'
-  end
-  
-  ##
-  # The initiating entity did not provide a mechanism or requested a mechanism that is not supported by the receiving entity;
-  # sent in reply to an <auth/> element.
-  class InvalidMechanism < SASLError
-    register :sasl_invalid_mechanism_error, 'invalid-mechanism'
-  end
-  
-  ##
-  # The mechanism requested by the initiating entity is weaker than server policy permits for that initiating entity; sent in
-  # reply to a <response/> element or an <auth/> element with initial response data.
-  class MechanismTooWeak < SASLError
-    register :sasl_mechanism_too_weak_error, 'mechanism-too-weak'
-  end
-  
-  ##
-  # The authentication failed because the initiating entity did not provide valid credentials (this includes but is not limited
-  # to the case of an unknown username); sent in reply to a <response/> element or an <auth/> element with initial response data.
-  class NotAuthorized < SASLError
-    register :sasl_not_authorized_error, 'not-authorized'
-  end
-  
-  ##
-  # The authentication failed because of a temporary error condition within the receiving entity; sent in reply to an <auth/>
-  # element or <response/> element.
-  class TemporaryAuthFailure < SASLError
-    register :sasl_temporary_auth_failure_error, 'temporary-auth-failure'
+  def name
+    @node.children.first.element_name.gsub('-', '_').to_sym if @node
   end
 end #SASLError
 

data/lib/blather/errors/stanza_error.rb

@@ -6,26 +6,9 @@ module Blather
 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
+  attr_reader :original, :name, :type, :text, :extras
 
   ##
   # Factory method for instantiating the proper class
@@ -34,16 +17,16 @@ class StanzaError < BlatherError
     original = node.copy
     original.remove_child 'error'
 
-    error_node = node.find_first 'child::error'
+    error_node = node.find_first '//*[local-name()="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 = node.find_first '//err_ns:text', :err_ns => '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
+    self.new original, name, type, text, extras
   end
 
   ##
@@ -52,19 +35,14 @@ class StanzaError < BlatherError
   # <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 = [])
+  def initialize(original, name, type, text = nil, extras = [])
     @original = original
+    @name = name
     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)
@@ -73,13 +51,17 @@ class StanzaError < BlatherError
     @type = type
   end
 
+  def name
+    @name.gsub('-','_').to_sym
+  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 = XMPPNode.new(@name)
     err.namespace = 'urn:ietf:params:xml:ns:xmpp-stanzas'
     error_node << err
 
@@ -108,155 +90,9 @@ class StanzaError < BlatherError
   end
 
   def inspect # :nodoc:
-    "Stanza Error (#{self.err_name}): #{self.text}"
+    "Stanza Error (#{@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

@@ -4,38 +4,21 @@ 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 = node.find_first '//err_ns:text', :err_ns => '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
+    self.new name, text, extras
   end
 
   ##
@@ -43,15 +26,14 @@ class StreamError < BlatherError
   # <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 = [])
+  def initialize(name, text = nil, extras = [])
+    @name = name
     @text = text
     @extras = extras
   end
 
-  ##
-  # XMPP defined error name
-  def err_name
-    self.class.err_name
+  def name
+    @name.gsub('-','_').to_sym
   end
 
   ##
@@ -59,7 +41,7 @@ class StreamError < BlatherError
   def to_node
     node = XMPPNode.new('stream:error')
 
-    err = XMPPNode.new(self.err_name)
+    err = XMPPNode.new(@name)
     err.namespace = 'urn:ietf:params:xml:ns:xmpp-streams'
     node << err
 
@@ -85,169 +67,9 @@ class StreamError < BlatherError
   end
 
   def inspect # :nodoc:
-    "Stream Error (#{self.err_name}): #{self.text}"
+    "Stream Error (#{@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