sprsquish-blather 0.1 → 0.2.3

data/lib/blather/stream.rb

@@ -0,0 +1,249 @@
+module Blather
+
+  class Stream < EventMachine::Connection
+    ##
+    # Start the stream between client and server
+    #   [client] must be an object that will respond to #call and #jid=
+    #   [jid] must be a valid argument for JID.new (see JID)
+    #   [pass] must be the password
+    #   [host] (optional) must be the hostname or IP to connect to. defaults to the domain of [jid]
+    #   [port] (optional) must be the port to connect to. defaults to 5222
+    def self.start(client, jid, pass, host = nil, port = 5222)
+      jid = JID.new jid
+      host ||= jid.domain
+
+      EM.connect host, port, self, client, jid, pass
+    end
+
+    ##
+    # Send data over the wire
+    #   The argument for this can be anything that
+    #   responds to #to_s
+    def send(stanza)
+      #TODO Queue if not ready
+      LOG.debug "SENDING: (#{caller[1]}) #{stanza}"
+      send_data stanza.respond_to?(:to_xml) ? stanza.to_xml : stanza.to_s
+    end
+
+    ##
+    # True if the stream is in the stopped state
+    def stopped?
+      @state == :stopped
+    end
+
+    ##
+    # True when the stream is in the negotiation phase.
+    def negotiating?
+      ![:stopped, :ready].include? @state
+    end
+
+    ##
+    # True when the stream is ready
+    #   The stream is ready immediately after receiving <stream:stream>
+    #   and before any feature negotion. Once feature negoation starts
+    #   the stream will not be ready until all negotations have completed
+    #   successfully.
+    def ready?
+      @state == :ready
+    end
+
+    ##
+    # Called by EM.connect to initialize stream variables
+    def initialize(client, jid, pass) # :nodoc:
+      super()
+
+      @error = nil
+      @client = client
+
+      self.jid = jid
+      @pass = pass
+
+      @to = @jid.domain
+    end
+
+    ##
+    # Called when EM completes the connection to the server
+    # this kicks off the starttls/authorize/bind process
+    def connection_completed # :nodoc:
+#      @keepalive = EM::Timer.new(60) { send_data ' ' }
+      @state = :stopped
+      dispatch
+    end
+
+    ##
+    # Called by EM with data from the wire
+    def receive_data(data) # :nodoc:
+      LOG.debug "\n#{'-'*30}\n"
+      LOG.debug "<< #{data}"
+      @parser.receive_data data
+
+    rescue ParseError => e
+      @error = e
+      stop
+    end
+
+    ##
+    # Called by EM when the connection is closed
+    def unbind # :nodoc:
+#      @keepalive.cancel
+      @state = :stopped
+      @client.call @error if @error
+      @client.stopped
+    end
+
+    ##
+    # Called by the parser with parsed nodes
+    def receive(node) # :nodoc:
+      LOG.debug "RECEIVING (#{node.element_name}) #{node}"
+      @node = node
+
+      case @node.element_name
+      when 'stream:stream'
+        @state = :ready if @state == :stopped
+
+      when 'stream:end'
+        stop
+
+      when 'stream:features'
+        @features = @node.children
+        @state = :features
+        dispatch
+
+      when 'stream:error'
+        @error = StreamError.import @node
+        stop
+        @state = :error
+
+      else
+        dispatch
+
+      end
+    end
+
+    ##
+    # Ensure the JID gets attached to the client
+    def jid=(new_jid) # :nodoc:
+      LOG.debug "NEW JID: #{new_jid}"
+      @jid = JID.new new_jid
+      @client.jid = @jid
+    end
+
+  protected
+    ##
+    # Dispatch based on current state
+    def dispatch
+      __send__ @state
+    end
+
+    ##
+    # Start the stream
+    #   Each time the stream is started or re-started we need to kill off the old
+    #   parser so as not to confuse it
+    def start
+    end
+
+    ##
+    # Stop the stream
+    def stop
+      unless @state == :stopped
+        @state = :stopped
+        send '</stream:stream>'
+      end
+    end
+
+    ##
+    # Called when @state == :stopped to start the stream
+    #   Counter intuitive, I know
+    def stopped
+      start
+    end
+
+    ##
+    # Called when @state == :ready
+    #   Simply passes the stanza to the client
+    def ready
+      @client.call @node.to_stanza
+    end
+
+    ##
+    # Called when @state == :features
+    #   Runs through the list of features starting each one in turn
+    def features
+      feature = @features.first
+      LOG.debug "FEATURE: #{feature}"
+      @state = case feature ? feature.namespaces.default.href : nil
+      when 'urn:ietf:params:xml:ns:xmpp-tls'      then :establish_tls
+      when 'urn:ietf:params:xml:ns:xmpp-sasl'     then :authenticate_sasl
+      when 'urn:ietf:params:xml:ns:xmpp-bind'     then :bind_resource
+      when 'urn:ietf:params:xml:ns:xmpp-session'  then :establish_session
+      else :ready
+      end
+
+      # Dispatch to the individual feature methods unless
+      # feature negotiation is complete
+      dispatch unless ready?
+    end
+
+    ##
+    # Start TLS
+    def establish_tls
+      unless @tls
+        @tls = TLS.new self
+        # on success destroy the TLS object and restart the stream
+        @tls.on_success { LOG.debug "TLS: SUCCESS"; @tls = nil; start }
+        # on failure stop the stream
+        @tls.on_failure { |err| LOG.debug "TLS: FAILURE"; @error = err; stop }
+
+        @node = @features.shift
+      end
+      @tls.handle @node
+    end
+
+    ##
+    # Authenticate via SASL
+    def authenticate_sasl
+      unless @sasl
+        @sasl = SASL.new(self, @jid, @pass)
+        # on success destroy the SASL object and restart the stream
+        @sasl.on_success { LOG.debug "SASL SUCCESS"; @sasl = nil; start }
+        # on failure set the error and stop the stream
+        @sasl.on_failure { |err| LOG.debug "SASL FAIL"; @error = err; stop }
+
+        @node = @features.shift
+      end
+      @sasl.handle @node
+    end
+
+    ##
+    # Bind to the resource provided by either the client or the server
+    def bind_resource
+      unless @resource
+        @resource = Resource.new self, @jid
+        # on success destroy the Resource object, set the jid, continue along the features dispatch process
+        @resource.on_success { |jid| LOG.debug "RESOURCE: SUCCESS"; @resource = nil; self.jid = jid; @state = :features; dispatch }
+        # on failure end the stream
+        @resource.on_failure { |err| LOG.debug "RESOURCE: FAILURE"; @error = err; stop }
+
+        @node = @features.shift
+      end
+      @resource.handle @node
+    end
+
+    ##
+    # Establish the session between client and server
+    def establish_session
+      unless @session
+        @session = Session.new self, @to
+        # on success destroy the session object, let the client know the stream has been started
+        # then continue the features dispatch process
+        @session.on_success { LOG.debug "SESSION: SUCCESS"; @session = nil; @client.stream_started(self); @state = :features; dispatch }
+        # on failure end the stream
+        @session.on_failure { |err| LOG.debug "SESSION: FAILURE"; @error = err; stop }
+
+        @node = @features.shift
+      end
+      @session.handle @node
+    end
+  end
+
+end

data/lib/blather/xmpp_node.rb

@@ -0,0 +1,199 @@
+module Blather
+
+  ##
+  # Base XML Node
+  # All XML classes subclass XMPPNode
+  # it allows the addition of helpers
+  class XMPPNode < XML::Node
+    BASE_NAMES = %w[presence message iq].freeze
+
+    @@registrations = {}
+
+    class_inheritable_accessor  :ns,
+                                :name
+
+    ##
+    # Lets a subclass register itself
+    #
+    # This registers a namespace that is used when looking
+    # up the class name of the object to instantiate when a new
+    # stanza is received
+    def self.register(name, ns = nil)
+      self.name = name.to_s
+      self.ns = ns
+      @@registrations[[self.name, self.ns]] = self
+    end
+
+    ##
+    # Find the class to use given the name and namespace of a stanza
+    def self.class_from_registration(name, xmlns)
+      name = name.to_s
+      @@registrations[[name, xmlns]] || @@registrations[[name, nil]]
+    end
+
+    ##
+    # Looks up the class to use then instantiates an object
+    # of that class and imports all the <tt>node</tt>'s attributes
+    # and children into it.
+    def self.import(node)
+      klass = class_from_registration(node.element_name, node.namespace)
+      if klass && klass != self
+        klass.import(node)
+      else
+        new(node.element_name).inherit(node)
+      end
+    end
+
+    ##
+    # Provides an attribute reader helper. Default behavior is to
+    # conver the values of the attribute into a symbol. This can
+    # be turned off by passing <tt>:to_sym => false</tt>
+    #
+    #   class Node
+    #     attribute_reader :type
+    #     attribute_reader :name, :to_sym => false
+    #   end
+    #
+    #   n = Node.new
+    #   n.attributes[:type] = 'foo'
+    #   n.type == :foo
+    #   n.attributes[:name] = 'bar'
+    #   n.name == 'bar'
+    def self.attribute_reader(*syms)
+      opts = syms.last.is_a?(Hash) ? syms.pop : {}
+      syms.flatten.each do |sym|
+        class_eval(<<-END, __FILE__, __LINE__)
+          def #{sym}
+            attributes[:#{sym}]#{".to_sym unless attributes[:#{sym}].blank?" unless opts[:to_sym] == false}
+          end
+        END
+      end
+    end
+
+    ##
+    # Provides an attribute writer helper.
+    #
+    #   class Node
+    #     attribute_writer :type
+    #   end
+    #
+    #   n = Node.new
+    #   n.type = 'foo'
+    #   n.attributes[:type] == 'foo'
+    def self.attribute_writer(*syms)
+      syms.flatten.each do |sym|
+        next if sym.is_a?(Hash)
+        class_eval(<<-END, __FILE__, __LINE__)
+          def #{sym}=(value)
+            attributes[:#{sym}] = value
+          end
+        END
+      end
+    end
+
+    ##
+    # Provides an attribute accessor helper combining
+    # <tt>attribute_reader</tt> and <tt>attribute_writer</tt>
+    #
+    #   class Node
+    #     attribute_accessor :type
+    #     attribute_accessor :name, :to_sym => false
+    #   end
+    #
+    #   n = Node.new
+    #   n.type = 'foo'
+    #   n.type == :foo
+    #   n.name = 'bar'
+    #   n.name == 'bar'
+    def self.attribute_accessor(*syms)
+      attribute_reader *syms
+      attribute_writer *syms
+    end
+
+    ##
+    # Automatically sets the namespace registered by the subclass
+    def initialize(name = nil, content = nil)
+      name ||= self.class.name
+      content = content.to_s if content
+
+      super name.to_s, content
+      self.namespace = self.class.ns unless BASE_NAMES.include?(name.to_s)
+    end
+
+    ##
+    # Quickway of turning itself into a proper object
+    def to_stanza
+      self.class.import self
+    end
+
+    def namespace=(ns)
+      if ns
+        ns = {nil => ns} unless ns.is_a?(Hash)
+        ns.each { |p,n| XML::Namespace.new self, p, n }
+      end
+    end
+
+    def namespace(prefix = nil)
+      (ns = namespaces.find_by_prefix(prefix)) ? ns.href : nil
+    end
+
+    ##
+    # Remove a child with the name and (optionally) namespace given
+    def remove_child(name, ns = nil)
+      name = name.to_s
+      self.detect { |n| n.remove! if n.element_name == name && (!ns || n.namespace == ns) }
+    end
+
+    ##
+    # Remove all children with a given name
+    def remove_children(name)
+      name = name.to_s
+      self.find(name).each { |n| n.remove! }
+    end
+
+    ##
+    # Pull the content from a child
+    def content_from(name)
+      name = name.to_s
+      (child = self.detect { |n| n.element_name == name }) ? child.content : nil
+    end
+
+    ##
+    # Create a copy
+    def copy(deep = true)
+      copy = self.class.new.inherit(self)
+      copy.element_name = self.element_name
+      copy
+    end
+
+    ##
+    # Inherit all of <tt>stanza</tt>'s attributes and children
+    def inherit(stanza)
+      inherit_attrs stanza.attributes
+      stanza.children.each { |c| self << c.copy(true) }
+      self
+    end
+
+    ##
+    # Inherit only <tt>stanza</tt>'s attributes
+    def inherit_attrs(attrs)
+      attrs.each  { |a| attributes[a.name] = a.value }
+      self
+    end
+
+    ##
+    # Turn itself into an XML string and remove all whitespace between nodes
+    def to_xml
+      # TODO: Fix this for HTML nodes (and any other that might require whitespace)
+      to_s.gsub(">\n<", '><')
+    end
+
+    ##
+    # Override #find to work when a node isn't attached to a document
+    def find(what, nslist = nil)
+      what = what.to_s
+      (self.doc ? super(what, nslist) : select { |i| i.element_name == what })
+    end
+  end #XMPPNode
+
+end

data/lib/blather.rb

@@ -1,54 +1,53 @@
 $:.unshift File.dirname(__FILE__)
+$:.unshift File.join(File.dirname(__FILE__), '..')
 
+# Require the necessary files
 %w[
   rubygems
-  xml/libxml
   eventmachine
+  ext/push_parser
+  xml/libxml
   digest/md5
   logger
 
-  blather/callback
-
-  blather/core/errors
-  blather/core/jid
-  blather/core/roster
-  blather/core/roster_item
-  blather/core/sugar
-  blather/core/xmpp_node
-
-  blather/core/stanza
-  blather/core/stanza/iq
-  blather/core/stanza/iq/query
-  blather/core/stanza/iq/roster
-  blather/core/stanza/message
-  blather/core/stanza/presence
-  blather/core/stanza/presence/status
-  blather/core/stanza/presence/subscription
-
-  blather/core/stream
-  blather/core/stream/parser
-  blather/core/stream/resource
-  blather/core/stream/sasl
-  blather/core/stream/session
-  blather/core/stream/tls
+  blather/core_ext/active_support
+  blather/core_ext/libxml
+
+  blather/errors
+  blather/errors/sasl_error
+  blather/errors/stanza_error
+  blather/errors/stream_error
+  blather/jid
+  blather/roster
+  blather/roster_item
+  blather/xmpp_node
+
+  blather/stanza
+  blather/stanza/iq
+  blather/stanza/iq/query
+  blather/stanza/iq/roster
+  blather/stanza/iq/disco
+  blather/stanza/iq/discos/disco_info
+  blather/stanza/iq/discos/disco_items
+  blather/stanza/message
+  blather/stanza/presence
+  blather/stanza/presence/status
+  blather/stanza/presence/subscription
+
+  blather/stream
+  blather/stream/client
+  blather/stream/component
+  blather/stream/stream_handler
+  blather/stream/parser
+  blather/stream/resource
+  blather/stream/sasl
+  blather/stream/session
+  blather/stream/tls
 ].each { |r| require r }
 
-XML::Parser.indent_tree_output = false
+XML.indent_tree_output = false
 
 module Blather
-  LOG = Logger.new STDOUT
-
-  def run(jid, password, client, host = nil, port = 5222)
-    EM.run { Stream.start client, JID.new(jid), password, host, port }
-  end
-  module_function :run
-
-  MAJOR = 0
-  MINOR = 1
-  VERSION = [MAJOR, MINOR]*'.'
-
-  def version
-    VERSION
-  end
-  module_function :version
+  LOG = Logger.new(STDOUT) unless const_defined?(:LOG)
+  LOG.level = Logger::INFO
 end

data/spec/blather/core_ext/libxml_spec.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. spec_helper])
+
+describe 'LibXML::XML::Node' do
+  it 'aliases #name to #element_name' do
+    node = LibXML::XML::Node.new 'foo'
+    node.must_respond_to :element_name
+    node.element_name.must_equal node.name
+  end
+
+  it 'aliases #name= to #element_name=' do
+    node = LibXML::XML::Node.new 'foo'
+    node.must_respond_to :element_name=
+    node.element_name.must_equal node.name
+    node.element_name = 'bar'
+    node.element_name.must_equal 'bar'
+  end
+end
+
+describe 'LibXML::XML::Attributes' do
+  it 'provides a helper to remove a specified attribute' do
+    attrs = LibXML::XML::Node.new('foo').attributes
+    attrs['foo'] = 'bar'
+    attrs['foo'].must_equal 'bar'
+    attrs.remove 'foo'
+    attrs['foo'].must_be_nil
+
+    attrs['foo'] = 'bar'
+    attrs['foo'].must_equal 'bar'
+    attrs.remove :foo
+    attrs['foo'].must_be_nil
+  end
+
+  it 'allows symbols as hash keys' do
+    attrs = LibXML::XML::Node.new('foo').attributes
+    attrs['foo'] = 'bar'
+
+    attrs['foo'].must_equal 'bar'
+    attrs[:foo].must_equal 'bar'
+  end
+
+  it 'removes an attribute when set to nil' do
+    attrs = LibXML::XML::Node.new('foo').attributes
+    attrs['foo'] = 'bar'
+
+    attrs['foo'].must_equal 'bar'
+    attrs['foo'] = nil
+    attrs['foo'].must_be_nil
+  end
+
+  it 'allows attribute values to change' do
+    attrs = LibXML::XML::Node.new('foo').attributes
+    attrs['foo'] = 'bar'
+
+    attrs['foo'].must_equal 'bar'
+    attrs['foo'] = 'baz'
+    attrs['foo'].must_equal 'baz'
+  end
+end

data/spec/blather/errors/sasl_error_spec.rb

@@ -0,0 +1,56 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. spec_helper])
+
+def sasl_error_node(err_name = 'aborted')
+  node = XMPPNode.new 'failure'
+  node.namespace = 'urn:ietf:params:xml:ns:xmpp-sasl'
+
+  node << XMPPNode.new(err_name)
+  node
+end
+
+describe 'Blather::SASLError' do
+  it 'can import a node' do
+    SASLError.must_respond_to :import
+    e = SASLError.import sasl_error_node
+    e.must_be_kind_of SASLError
+  end
+
+  it 'knows what class to instantiate' do
+    e = SASLError.import sasl_error_node
+    e.must_be_instance_of SASLError::Aborted
+  end
+
+  describe 'when instantiated' do
+    before do
+      @err_name = 'mechanism-too-weak'
+      @err = SASLError.import sasl_error_node(@err_name)
+    end
+
+    it 'provides a err_name attribute' do
+      @err.must_respond_to :err_name
+      @err.err_name.must_equal @err_name
+    end
+  end
+
+  describe 'each XMPP SASL error type' do
+    %w[ aborted
+        incorrect-encoding
+        invalid-authzid
+        invalid-mechanism
+        mechanism-too-weak
+        not-authorized
+        temporary-auth-failure
+    ].each do |error_type|
+      it "provides a class for #{error_type}" do
+        e = SASLError.import sasl_error_node(error_type)
+        klass = error_type.gsub(/^\w/) { |v| v.upcase }.gsub(/\-(\w)/) { |v| v.delete('-').upcase }
+        e.must_be_instance_of eval("SASLError::#{klass}")
+      end
+
+      it "registers #{error_type} in the handler heirarchy" do
+        e = SASLError.import sasl_error_node(error_type)
+        e.handler_heirarchy.must_equal ["sasl_#{error_type.gsub('-','_').gsub('_error','')}_error".to_sym, :sasl_error, :error]
+      end
+    end
+  end
+end