blather 0.8.1 → 0.8.2

data/.gitignore

@@ -17,3 +17,4 @@ notes
 vendor
 .rvmrc
 .rbx
+tmp

data/.travis.yml

@@ -1,8 +1,9 @@
+language: ruby
 rvm:
   - 1.9.2
   - 1.9.3
-  - jruby-18mode
   - jruby-19mode
-  - rbx-18mode
   - rbx-19mode
   - ruby-head
+notifications:
+  irc: "irc.freenode.org#adhearsion"

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # [develop](https://github.com/adhearsion/blather/compare/master...develop)
 
+# [v0.8.2](https://github.com/adhearsion/blather/compare/v0.8.1...v0.8.2) - [2013-01-02](https://rubygems.org/gems/blather/versions/0.8.2)
+  * Bugfix: General spec fixes
+  * Bugfix: Fixes for JRuby and Rubinius
+  * Bugfix: Ensure parsers are shut down correctly
+  * Update: Bump Nokogiri (1.5.6) and EventMachine (1.0.0) minimum versions
+
 # [v0.8.1](https://github.com/adhearsion/blather/compare/v0.8.0...v0.8.1) - [2012-09-17](https://rubygems.org/gems/blather/versions/0.8.1)
   * Project moved to the Adhearsion Foundation
   * Fixes for EventMachine 1.0.x

data/Guardfile

@@ -1,4 +1,4 @@
-guard 'rspec', :version => 2, :cli => '--format documentation' do
+guard 'rspec', :cli => '--format documentation' do
   watch(%r{^spec/.+_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { "spec/" }

data/README.md

@@ -1,4 +1,4 @@
-# Blather [ ![Build status](http://travis-ci.org/adhearsion/blather.png) ](http://travis-ci.org/adhearsion/blather)
+# Blather [![Build Status](https://travis-ci.org/adhearsion/blather.png?branch=develop)](https://travis-ci.org/adhearsion/blather)
 
 XMPP DSL (and more) for Ruby written on [EventMachine](http://rubyeventmachine.com/) and [Nokogiri](http://nokogiri.org/).
 
@@ -11,7 +11,7 @@ XMPP DSL (and more) for Ruby written on [EventMachine](http://rubyeventmachine.c
 ## Project Pages
 
 * [GitHub](https://github.com/adhearsion/blather)
-* [Gemcutter](http://gemcutter.org/gems/blather)
+* [Rubygems](http://rubygems.org/gems/blather)
 * [API Documentation](http://rdoc.info/gems/blather/file/README.md)
 * [Google Group](http://groups.google.com/group/xmpp-blather)
 

data/blather.gemspec

@@ -33,8 +33,8 @@ Gem::Specification.new do |s|
   s.rdoc_options = %w{--charset=UTF-8}
   s.extra_rdoc_files = %w{LICENSE README.md}
 
-  s.add_dependency "eventmachine", [">= 0.12.6"]
-  s.add_dependency "nokogiri", ["~> 1.5.5"]
+  s.add_dependency "eventmachine", [">= 1.0.0"]
+  s.add_dependency "nokogiri", ["~> 1.5", ">= 1.5.6"]
   s.add_dependency "niceogiri", ["~> 1.0"]
   s.add_dependency "activesupport", [">= 2.3.11"]
   s.add_dependency "girl_friday"
@@ -42,10 +42,11 @@ Gem::Specification.new do |s|
   s.add_development_dependency "bundler", ["~> 1.0"]
   s.add_development_dependency "rake"
   s.add_development_dependency "rspec", ["~> 2.7"]
-  s.add_development_dependency "mocha", ["~> 0.9.12"]
+  s.add_development_dependency "mocha", ["~> 0.9"]
   s.add_development_dependency "guard-rspec"
-  s.add_development_dependency "yard", ["~> 0.6.1"]
-  s.add_development_dependency "jruby-openssl", ["~> 0.7.4"] if jruby?
+  s.add_development_dependency "yard", ["~> 0.6"]
+  s.add_development_dependency "jruby-openssl", ["~> 0.7"] if jruby?
   s.add_development_dependency "bluecloth" unless jruby? || rbx?
   s.add_development_dependency "countdownlatch"
+  s.add_development_dependency 'rb-fsevent', ['~> 0.9']
 end

data/lib/blather/cert_store.rb

@@ -6,9 +6,6 @@ module Blather
   # This uses the #{cert_directory}/*.crt files as the list of trusted root
   # CA certificates.
   class CertStore
-    @@certs = nil
-    @cert_directory = nil
-
     def initialize(cert_directory)
       @cert_directory = cert_directory
       @store = OpenSSL::X509::Store.new
@@ -19,19 +16,24 @@ module Blather
     # store. If the certificate can be trusted, it's added to the store so
     # it can be used to trust other certs.
     def trusted?(pem)
-      if cert = OpenSSL::X509::Certificate.new(pem) rescue nil
+      if cert = OpenSSL::X509::Certificate.new(pem)
         @store.verify(cert).tap do |trusted|
-          @store.add_cert(cert) if trusted rescue nil
+          begin
+            @store.add_cert(cert) if trusted
+          rescue OpenSSL::X509::StoreError
+          end
         end
       end
+    rescue OpenSSL::X509::CertificateError
+      nil
     end
 
     # Return true if the domain name matches one of the names in the
     # certificate. In other words, is the certificate provided to us really
     # for the domain to which we think we're connected?
     def domain?(pem, domain)
-      if cert = OpenSSL::X509::Certificate.new(pem) rescue nil
-        OpenSSL::SSL.verify_certificate_identity(cert, domain) rescue false
+      if cert = OpenSSL::X509::Certificate.new(pem)
+        OpenSSL::SSL.verify_certificate_identity(cert, domain)
       end
     end
 
@@ -39,15 +41,15 @@ module Blather
     # certificates are used to start the trust chain needed to validate certs
     # we receive from clients and servers.
     def certs
-      unless @@certs
+      @certs ||= begin
         pattern = /-{5}BEGIN CERTIFICATE-{5}\n.*?-{5}END CERTIFICATE-{5}\n/m
-        dir = @cert_directory
-        certs = Dir[File.join(dir, '*.crt')].map {|f| File.read(f) }
-        certs = certs.map {|c| c.scan(pattern) }.flatten
-        certs.map! {|c| OpenSSL::X509::Certificate.new(c) }
-        @@certs = certs.reject {|c| c.not_after < Time.now }
+        Dir[File.join(@cert_directory, '*.crt')]
+          .map {|f| File.read(f) }
+          .map {|c| c.scan(pattern) }
+          .flatten
+          .map {|c| OpenSSL::X509::Certificate.new(c) }
+          .reject {|c| c.not_after < Time.now }
       end
-      @@certs
     end
   end
-end
+end

data/lib/blather/client.rb

@@ -30,7 +30,7 @@ optparse = OptionParser.new do |opts|
     end
     options[:log] = log
   end
-  
+
   opts.on('--certs=[CERTS DIRECTORY]', 'The directory path where the trusted certificates are stored') do |certs|
     if !File.directory?(certs)
       $stderr.puts "The certs directory path (#{certs}) is no good."
@@ -38,7 +38,7 @@ optparse = OptionParser.new do |opts|
     end
     options[:certs] = certs
   end
-  
+
   opts.on_tail('-h', '--help', 'Show this message') do
     puts opts
     exit

data/lib/blather/file_transfer.rb

@@ -11,7 +11,7 @@ module Blather
 
     # Set this to true if you want SOCKS5 Bytestreams to attempt to use private network addresses
     attr_accessor :allow_private_ips
-    
+
     # Create a new FileTransfer
     #
     # @param [Blather::Stream] stream the stream the file transfer should use

data/lib/blather/file_transfer/ibb.rb

@@ -65,4 +65,4 @@ module Blather
       end
     end
   end
-end
+end

data/lib/blather/file_transfer/s5b.rb

@@ -97,7 +97,7 @@ module Blather
 
         def post_init
           self.succeed
-          
+
           class << self
             include @@handler
           end

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

@@ -142,7 +142,7 @@ class Stanza
       # The Identity's xml_lang
       # @return [String]
       def xml_lang
-        read_attr "lang"
+        read_attr "xml:lang"
       end
 
       # Set the Identity's name

data/lib/blather/stanza/iq/query.rb

@@ -50,4 +50,4 @@ class Iq
 
 end #Iq
 end #Stanza
-end
+end

data/lib/blather/stanza/iq/roster.rb

@@ -182,4 +182,4 @@ class Iq
 
 end #Iq
 end #Stanza
-end
+end

data/lib/blather/stream.rb

@@ -57,7 +57,6 @@ module Blather
     STREAM_NS = 'http://etherx.jabber.org/streams'
     attr_accessor :password
     attr_reader :jid
-    @@store = nil
 
     # Start the stream between client and server
     #
@@ -76,7 +75,7 @@ module Blather
       jid = JID.new jid
       port ||= 5222
       if certs_directory
-        @@store = CertStore.new(certs_directory)
+        @store = CertStore.new(certs_directory)
       end
       if host
         connect host, port, self, client, jid, pass, connect_timeout
@@ -142,6 +141,8 @@ module Blather
       @to = self.jid.domain
       @password = pass
       @connect_timeout = connect_timeout || 180
+
+      @parser = Parser.new self
     end
 
     # Called when EM completes the connection to the server
@@ -154,7 +155,6 @@ module Blather
         end
       end
       @connected = true
-#      @keepalive = EM::PeriodicTimer.new(60) { send_data ' ' }
       start
     end
 
@@ -162,11 +162,9 @@ module Blather
     # @private
     def receive_data(data)
       @parser << data
-
     rescue ParseError => e
       @error = e
-      send "<stream:error><xml-not-well-formed xmlns='#{StreamError::STREAM_ERR_NS}'/></stream:error>"
-      stop
+      stop "<stream:error><xml-not-well-formed xmlns='#{StreamError::STREAM_ERR_NS}'/></stream:error>"
     end
 
     # Called by EM to verify the peer certificate. If a certificate store directory
@@ -178,8 +176,8 @@ module Blather
       # but it only does that for inbound connections, not when we
       # make a connection to another server.
       Blather.log "Checking SSL cert: #{pem}"
-      return true if !@@store
-      @@store.trusted?(pem).tap do |trusted|
+      return true unless @store
+      @store.trusted?(pem).tap do |trusted|
         close_connection unless trusted
       end
     end
@@ -193,29 +191,33 @@ module Blather
     # Called by EM when the connection is closed
     # @private
     def unbind
+      cleanup
+
       raise NoConnection unless @inited
       raise ConnectionFailed unless @connected
 
-      @connect_timer.cancel if @connect_timer
-#      @keepalive.cancel
       @state = :stopped
       @client.receive_data @error if @error
       @client.unbind
     end
 
+    def cleanup
+      @parser.finish
+      @connect_timer.cancel if @connect_timer
+    end
+
     # Called by the parser with parsed nodes
     # @private
     def receive(node)
       Blather.log "RECEIVING (#{node.element_name}) #{node}"
-      @node = node
 
-      if @node.namespace && @node.namespace.prefix == 'stream'
-        case @node.element_name
+      if node.namespace && node.namespace.prefix == 'stream'
+        case node.element_name
         when 'stream'
           @state = :ready if @state == :stopped
           return
         when 'error'
-          handle_stream_error
+          handle_stream_error node
           return
         when 'end'
           stop
@@ -229,7 +231,7 @@ module Blather
           )
         end
       end
-      @receiver.receive_data @node.to_stanza
+      @receiver.receive_data node.to_stanza
     end
 
     # Ensure the JID gets attached to the client
@@ -242,16 +244,16 @@ module Blather
   protected
     # Stop the stream
     # @private
-    def stop
+    def stop(error = nil)
       unless @state == :stopped
         @state = :stopped
-        send '</stream:stream>'
+        send "#{error}</stream:stream>"
       end
     end
 
     # @private
-    def handle_stream_error
-      @error = StreamError.import(@node)
+    def handle_stream_error(node)
+      @error = StreamError.import(node)
       stop
     end
 

data/lib/blather/stream/client.rb

@@ -8,17 +8,7 @@ class Stream
     NAMESPACE = 'jabber:client'
 
     def start
-      @parser = Parser.new self
-      start_stream = <<-STREAM
-        <stream:stream
-          to='#{@to}'
-          xmlns='#{NAMESPACE}'
-          xmlns:stream='#{STREAM_NS}'
-          version='#{VERSION}'
-          xml:lang='#{LANG}'
-        >
-      STREAM
-      send start_stream.gsub(/\s+/, ' ')
+      send "<stream:stream to='#{@to}' xmlns='#{NAMESPACE}' xmlns:stream='#{STREAM_NS}' version='#{VERSION}' xml:lang='#{LANG}'>"
     end
 
     def send(stanza)

data/lib/blather/stream/component.rb

@@ -13,7 +13,7 @@ class Stream
       end
 
       if node.document.find_first('/stream:stream[not(stream:error)]', :xmlns => NAMESPACE, :stream => STREAM_NS)
-        send("<handshake>#{Digest::SHA1.hexdigest(@node['id']+@password)}</handshake>")
+        send "<handshake>#{Digest::SHA1.hexdigest(node['id']+@password)}</handshake>"
       end
     end
 
@@ -23,15 +23,7 @@ class Stream
     end
 
     def start
-      @parser = Parser.new self
-      start_stream = <<-STREAM
-        <stream:stream
-          to='#{@jid}'
-          xmlns='#{NAMESPACE}'
-          xmlns:stream='#{STREAM_NS}'
-        >
-      STREAM
-      send start_stream.gsub(/\s+/, ' ')
+      send "<stream:stream to='#{@jid}' xmlns='#{NAMESPACE}' xmlns:stream='#{STREAM_NS}'>"
     end
   end #Client
 

data/lib/blather/stream/features.rb

@@ -13,9 +13,7 @@ class Stream
     end
 
     def initialize(stream, succeed, fail)
-      @stream = stream
-      @succeed = succeed
-      @fail = fail
+      @stream, @succeed, @fail = stream, succeed, fail
     end
 
     def receive_data(stanza)

data/lib/blather/stream/parser.rb

@@ -15,13 +15,15 @@ class Stream
       @namespaces = {}
       @namespace_definitions = []
       @parser = Nokogiri::XML::SAX::PushParser.new self
-      @parser.options = Nokogiri::XML::ParseOptions::DEFAULT_XML | Nokogiri::XML::ParseOptions::NOENT
+      @parser.options = Nokogiri::XML::ParseOptions::NOENT
     end
 
     def receive_data(string)
       Blather.log "PARSING: (#{string})" if @@debug
       @parser << string
       self
+    rescue Nokogiri::XML::SyntaxError => e
+      error e.message
     end
     alias_method :<<, :receive_data
 
@@ -54,13 +56,6 @@ class Stream
       end
 
       deliver(node) if elem == 'stream'
-
-      # $stderr.puts "\n\n"
-      # $stderr.puts [elem, attrs, prefix, uri, namespaces].inspect
-      # $stderr.puts @namespaces.inspect
-      # $stderr.puts [@namespaces[[prefix, uri]].prefix, @namespaces[[prefix, uri]].href].inspect if @namespaces[[prefix, uri]]
-      # $stderr.puts node.inspect
-      # $stderr.puts node.document.to_s.gsub(/\n\s*/,'')
     end
 
     def end_element_namespace(elem, prefix, uri)
@@ -91,6 +86,11 @@ class Stream
       raise ParseError.new(msg)
     end
 
+    def finish
+      @parser.finish
+    rescue ParseError, RuntimeError
+    end
+
   private
     def deliver(node)
       @current, @namespaces, @namespace_definitions = nil, {}, []

data/lib/blather/version.rb

@@ -1,3 +1,3 @@
 module Blather
-  VERSION = '0.8.1'
+  VERSION = '0.8.2'
 end

data/spec/blather/client/client_spec.rb

@@ -2,204 +2,202 @@ require 'spec_helper'
 require 'blather/client/client'
 
 describe Blather::Client do
+  let(:jid)     { Blather::JID.new 'n@d/r' }
+  let(:stream)  { mock 'Stream' }
+
   before do
-    @client = Blather::Client.new
-    @stream = mock
-    @stream.stubs(:send)
-    @jid = Blather::JID.new('n@d/r')
+    stream.stubs :send
   end
 
   it 'provides a Blather::JID reader' do
-    @client.post_init @stream, @jid
-    @client.should respond_to :jid
-    @client.jid.should == @jid
+    subject.post_init stream, jid
+    subject.should respond_to :jid
+    subject.jid.should == jid
   end
 
   it 'provides a reader for the roster' do
-    @client.should respond_to :roster
-    @client.roster.should be_kind_of Blather::Roster
+    subject.should respond_to :roster
+    subject.roster.should be_kind_of Blather::Roster
   end
 
   it 'provides a status reader' do
-    @client.post_init @stream, @jid
-    @client.should respond_to :status
-    @client.status = :away
-    @client.status.should == :away
+    subject.post_init stream, jid
+    subject.should respond_to :status
+    subject.status = :away
+    subject.status.should == :away
   end
 
   it 'should have a caps handler' do
-    @client.should respond_to :caps
-    @client.caps.should be_kind_of Blather::Stanza::Capabilities
+    subject.should respond_to :caps
+    subject.caps.should be_kind_of Blather::Stanza::Capabilities
   end
 
   it 'can be setup' do
-    @client.should respond_to :setup
-    @client.setup('me@me.com', 'pass').should == @client
+    subject.should respond_to :setup
+    subject.setup('me@me.com', 'pass').should == subject
   end
 
   it 'knows if it has been setup' do
-    @client.should respond_to :setup?
-    @client.setup?.should == false
-    @client.setup 'me@me.com', 'pass'
-    @client.setup?.should == true
+    subject.should respond_to :setup?
+    subject.should_not be_setup
+    subject.setup 'me@me.com', 'pass'
+    subject.should be_setup
   end
 
   it 'cannot be run before being setup' do
-    lambda { @client.run }.should raise_error RuntimeError
+    lambda { subject.run }.should raise_error RuntimeError
   end
 
   it 'starts up a Component connection when setup without a node' do
     setup = 'pubsub.jabber.local', 'secret'
-    @client.setup *setup
-    Blather::Stream::Component.expects(:start).with @client, *setup + [nil, nil, nil, nil]
-    @client.run
+    subject.setup *setup
+    Blather::Stream::Component.expects(:start).with subject, *setup + [nil, nil, nil, nil]
+    subject.run
   end
 
   it 'starts up a Client connection when setup with a node' do
     setup = 'test@jabber.local', 'secret'
-    @client.setup *setup
-    Blather::Stream::Client.expects(:start).with @client, *setup + [nil, nil, nil, nil]
-    @client.run
+    subject.setup *setup
+    Blather::Stream::Client.expects(:start).with subject, *setup + [nil, nil, nil, nil]
+    subject.run
   end
 
   it 'knows if it is disconnected' do
-    @client.should respond_to :connected?
-    @client.connected?.should == false
+    subject.should respond_to :connected?
+    subject.should_not be_connected
   end
 
   it 'knows if it is connected' do
-    stream = mock
     stream.expects(:stopped?).returns false
-    @client.setup('me.com', 'secret')
-    @client.post_init stream, Blather::JID.new('me.com')
-    @client.connected?.should == true
+    subject.setup 'me.com', 'secret'
+    subject.post_init stream, Blather::JID.new('me.com')
+    subject.should be_connected
   end
 
   describe 'if it has been setup but not connected yet' do
     it 'should consider itself disconnected' do
-      @client.setup('me.com', 'secret')
-      @client.connected?.should == false
+      subject.setup 'me.com', 'secret'
+      subject.should_not be_connected
     end
   end
 
   it 'writes to the connection the closes when #close is called' do
-    stream = mock()
     stream.expects(:close_connection_after_writing)
-    @client.setup('me.com', 'secret')
-    @client.post_init stream, Blather::JID.new('me.com')
-    @client.close
+    subject.setup 'me.com', 'secret'
+    subject.post_init stream, Blather::JID.new('me.com')
+    subject.close
   end
 
   it 'shuts down EM when #unbind is called if it is running' do
     EM.expects(:reactor_running?).returns true
     EM.expects(:stop)
-    @client.unbind
+    subject.unbind
   end
 
   it 'does nothing when #unbind is called and EM is not running' do
     EM.expects(:reactor_running?).returns false
     EM.expects(:stop).never
-    @client.unbind
+    subject.unbind
   end
 
   it 'calls the :disconnected handler with #unbind is called' do
     EM.expects(:reactor_running?).returns false
-    disconnected = mock()
+    disconnected = mock
     disconnected.expects(:call)
-    @client.register_handler(:disconnected) { disconnected.call }
-    @client.unbind
+    subject.register_handler(:disconnected) { disconnected.call }
+    subject.unbind
   end
 
   it 'does not call EM.stop on #unbind if a handler returns positive' do
     EM.expects(:reactor_running?).never
     EM.expects(:stop).never
-    disconnected = mock()
+    disconnected = mock
     disconnected.expects(:call).returns true
-    @client.register_handler(:disconnected) { disconnected.call }
-    @client.unbind
+    subject.register_handler(:disconnected) { disconnected.call }
+    subject.unbind
   end
 
   it 'calls EM.stop on #unbind if a handler returns negative' do
     EM.expects(:reactor_running?).returns true
     EM.expects(:stop)
-    disconnected = mock()
+    disconnected = mock
     disconnected.expects(:call).returns false
-    @client.register_handler(:disconnected) { disconnected.call }
-    @client.unbind
+    subject.register_handler(:disconnected) { disconnected.call }
+    subject.unbind
   end
 
   it 'can register a temporary handler based on stanza ID' do
     stanza = Blather::Stanza::Iq.new
-    response = mock()
+    response = mock
     response.expects(:call)
-    @client.register_tmp_handler(stanza.id) { |_| response.call }
-    @client.receive_data stanza
+    subject.register_tmp_handler(stanza.id) { |_| response.call }
+    subject.receive_data stanza
   end
 
   it 'removes a tmp handler as soon as it is used' do
     stanza = Blather::Stanza::Iq.new
-    response = mock()
+    response = mock
     response.expects(:call)
-    @client.register_tmp_handler(stanza.id) { |_| response.call }
-    @client.receive_data stanza
-    @client.receive_data stanza
+    subject.register_tmp_handler(stanza.id) { |_| response.call }
+    subject.receive_data stanza
+    subject.receive_data stanza
   end
 
   it 'will create a handler then write the stanza' do
     stanza = Blather::Stanza::Iq.new
-    response = mock()
+    response = mock
     response.expects(:call)
-    @client.expects(:write).with do |s|
-      @client.receive_data stanza
+    subject.expects(:write).with do |s|
+      subject.receive_data stanza
       s.should == stanza
     end
-    @client.write_with_handler(stanza) { |_| response.call }
+    subject.write_with_handler(stanza) { |_| response.call }
   end
 
   it 'can register a handler' do
     stanza = Blather::Stanza::Iq.new
-    response = mock()
+    response = mock
     response.expects(:call).times(2)
-    @client.register_handler(:iq) { |_| response.call }
-    @client.receive_data stanza
-    @client.receive_data stanza
+    subject.register_handler(:iq) { |_| response.call }
+    subject.receive_data stanza
+    subject.receive_data stanza
   end
 
   it 'allows for breaking out of handlers' do
     stanza = Blather::Stanza::Iq.new
     response = mock(:iq => nil)
-    @client.register_handler(:iq) do |_|
+    subject.register_handler(:iq) do |_|
       response.iq
       throw :halt
       response.fail
     end
-    @client.receive_data stanza
+    subject.receive_data stanza
   end
 
   it 'allows for passing to the next handler of the same type' do
     stanza = Blather::Stanza::Iq.new
     response = mock(:iq1 => nil, :iq2 => nil)
-    @client.register_handler(:iq) do |_|
+    subject.register_handler(:iq) do |_|
       response.iq1
       throw :pass
       response.fail
     end
-    @client.register_handler(:iq) do |_|
+    subject.register_handler(:iq) do |_|
       response.iq2
     end
-    @client.receive_data stanza
+    subject.receive_data stanza
   end
 
   it 'allows for passing to the next handler in the hierarchy' do
     stanza = Blather::Stanza::Iq::Query.new
     response = mock(:query => nil, :iq => nil)
-    @client.register_handler(:query) do |_|
+    subject.register_handler(:query) do |_|
       response.query
       throw :pass
       response.fail
     end
-    @client.register_handler(:iq) { |_| response.iq }
-    @client.receive_data stanza
+    subject.register_handler(:iq) { |_| response.iq }
+    subject.receive_data stanza
   end
 
   it 'can clear handlers' do
@@ -209,479 +207,447 @@ describe Blather::Client do
     response = mock
     response.expects(:call).once
 
-    @client.register_handler(:message, :chat?) { |_| response.call }
-    @client.receive_data stanza
+    subject.register_handler(:message, :chat?) { |_| response.call }
+    subject.receive_data stanza
 
-    @client.clear_handlers(:message, :chat?)
-    @client.receive_data stanza
+    subject.clear_handlers :message, :chat?
+    subject.receive_data stanza
   end
-end
 
-describe 'Blather::Client#write' do
-  before do
-    @client = Blather::Client.new
+  describe '#write' do
+    it 'writes to the stream' do
+      stanza = Blather::Stanza::Iq.new
+      stream.expects(:send).with stanza
+      subject.setup 'me@me.com', 'me'
+      subject.post_init stream, Blather::JID.new('me.com')
+      subject.write stanza
+    end
   end
 
-  it 'writes to the stream' do
-    stanza = Blather::Stanza::Iq.new
-    stream = mock()
-    stream.expects(:send).with stanza
-    @client.setup('me@me.com', 'me')
-    @client.post_init stream, Blather::JID.new('me.com')
-    @client.write stanza
-  end
-end
+  describe '#status=' do
+    before do
+      subject.post_init stream, Blather::JID.new('n@d/r')
+    end
 
-describe 'Blather::Client#status=' do
-  before do
-    @client = Blather::Client.new
-    @stream = mock()
-    @stream.stubs(:send)
-    @client.post_init @stream, Blather::JID.new('n@d/r')
-  end
+    it 'updates the state when not sending to a Blather::JID' do
+      stream.stubs(:write)
+      subject.status.should_not equal :away
+      subject.status = :away, 'message'
+      subject.status.should == :away
+    end
 
-  it 'updates the state when not sending to a Blather::JID' do
-    @stream.stubs(:write)
-    @client.status.should_not equal :away
-    @client.status = :away, 'message'
-    @client.status.should == :away
-  end
+    it 'does not update the state when sending to a Blather::JID' do
+      stream.stubs(:write)
+      subject.status.should_not equal :away
+      subject.status = :away, 'message', 'me@me.com'
+      subject.status.should_not equal :away
+    end
 
-  it 'does not update the state when sending to a Blather::JID' do
-    @stream.stubs(:write)
-    @client.status.should_not equal :away
-    @client.status = :away, 'message', 'me@me.com'
-    @client.status.should_not equal :away
+    it 'writes the new status to the stream' do
+      Blather::Stanza::Presence::Status.stubs(:next_id).returns 0
+      status = [:away, 'message']
+      stream.expects(:send).with do |s|
+        s.should be_kind_of Blather::Stanza::Presence::Status
+        s.to_s.should == Blather::Stanza::Presence::Status.new(*status).to_s
+      end
+      subject.status = status
+    end
   end
 
-  it 'writes the new status to the stream' do
-    Blather::Stanza::Presence::Status.stubs(:next_id).returns 0
-    status = [:away, 'message']
-    @stream.expects(:send).with do |s|
-      s.should be_kind_of Blather::Stanza::Presence::Status
-      s.to_s.should == Blather::Stanza::Presence::Status.new(*status).to_s
+  describe 'default handlers' do
+    it 're-raises errors' do
+      err = Blather::BlatherError.new
+      lambda { subject.receive_data err }.should raise_error Blather::BlatherError
     end
-    @client.status = status
-  end
-end
 
-describe 'Blather::Client default handlers' do
-  before do
-    @client = Blather::Client.new
-    @stream = mock()
-    @stream.stubs(:send)
-    @client.post_init @stream, Blather::JID.new('n@d/r')
-  end
-
-  it 're-raises errors' do
-    err = Blather::BlatherError.new
-    lambda { @client.receive_data err }.should raise_error Blather::BlatherError
-  end
-
-  # it 'responds to iq:get with a "service-unavailable" error' do
-  #   get = Blather::Stanza::Iq.new :get
-  #   err = Blather::StanzaError.new(get, 'service-unavailable', :cancel).to_node
-  #   @client.expects(:write).with err
-  #   @client.receive_data get
-  # end
-
-  # it 'responds to iq:get with a "service-unavailable" error' do
-  #   get = Blather::Stanza::Iq.new :get
-  #   err = Blather::StanzaError.new(get, 'service-unavailable', :cancel).to_node
-  #   @client.expects(:write).with { |n| n.to_s.should == err.to_s }
-  #   @client.receive_data get
-  # end
-
-  # it 'responds to iq:set with a "service-unavailable" error' do
-  #   get = Blather::Stanza::Iq.new :set
-  #   err = Blather::StanzaError.new(get, 'service-unavailable', :cancel).to_node
-  #   @client.expects(:write).with { |n| n.to_s.should == err.to_s }
-  #   @client.receive_data get
-  # end
-
-  it 'responds to s2c pings with a pong' do
-    ping = Blather::Stanza::Iq::Ping.new :get
-    pong = ping.reply
-    @client.expects(:write).with { |n| n.to_s.should == pong.to_s }
-    @client.receive_data ping
-  end
-
-  it 'handles status changes by updating the roster if the status is from a Blather::JID in the roster' do
-    jid = 'friend@jabber.local'
-    status = Blather::Stanza::Presence::Status.new :away
-    status.stubs(:from).returns jid
-    roster_item = mock()
-    roster_item.expects(:status=).with status
-    @client.stubs(:roster).returns({status.from => roster_item})
-    @client.receive_data status
-  end
-
-  it 'lets status stanzas fall through to other handlers' do
-    jid = 'friend@jabber.local'
-    status = Blather::Stanza::Presence::Status.new :away
-    status.stubs(:from).returns jid
-    roster_item = mock()
-    roster_item.expects(:status=).with status
-    @client.stubs(:roster).returns({status.from => roster_item})
-
-    response = mock()
-    response.expects(:call).with jid
-    @client.register_handler(:status) { |s| response.call s.from.to_s }
-    @client.receive_data status
-  end
-
-  it 'handles an incoming roster node by processing it through the roster' do
-    roster = Blather::Stanza::Iq::Roster.new
-    client_roster = mock()
-    client_roster.expects(:process).with roster
-    @client.stubs(:roster).returns client_roster
-    @client.receive_data roster
-  end
-
-  it 'handles an incoming roster node by processing it through the roster' do
-    roster = Blather::Stanza::Iq::Roster.new
-    client_roster = mock()
-    client_roster.expects(:process).with roster
-    @client.stubs(:roster).returns client_roster
-
-    response = mock()
-    response.expects(:call)
-    @client.register_handler(:roster) { |_| response.call }
-    @client.receive_data roster
-  end
-end
+    # it 'responds to iq:get with a "service-unavailable" error' do
+    #   get = Blather::Stanza::Iq.new :get
+    #   err = Blather::StanzaError.new(get, 'service-unavailable', :cancel).to_node
+    #   subject.expects(:write).with err
+    #   subject.receive_data get
+    # end
+
+    # it 'responds to iq:get with a "service-unavailable" error' do
+    #   get = Blather::Stanza::Iq.new :get
+    #   err = Blather::StanzaError.new(get, 'service-unavailable', :cancel).to_node
+    #   subject.expects(:write).with { |n| n.to_s.should == err.to_s }
+    #   subject.receive_data get
+    # end
+
+    # it 'responds to iq:set with a "service-unavailable" error' do
+    #   get = Blather::Stanza::Iq.new :set
+    #   err = Blather::StanzaError.new(get, 'service-unavailable', :cancel).to_node
+    #   subject.expects(:write).with { |n| n.to_s.should == err.to_s }
+    #   subject.receive_data get
+    # end
+
+    it 'responds to s2c pings with a pong' do
+      ping = Blather::Stanza::Iq::Ping.new :get
+      pong = ping.reply
+      subject.expects(:write).with { |n| n.to_s.should == pong.to_s }
+      subject.receive_data ping
+    end
 
-describe 'Blather::Client with a Component stream' do
-  before do
-    class MockComponent < Blather::Stream::Component; def initialize(); end; end
-    @stream = MockComponent.new('')
-    @stream.stubs(:send_data)
-    @client = Blather::Client.new
-    @client.setup('me.com', 'secret')
-  end
+    it 'handles status changes by updating the roster if the status is from a Blather::JID in the roster' do
+      jid = 'friend@jabber.local'
+      status = Blather::Stanza::Presence::Status.new :away
+      status.stubs(:from).returns jid
+      roster_item = mock
+      roster_item.expects(:status=).with status
+      subject.stubs(:roster).returns({status.from => roster_item})
+      subject.receive_data status
+    end
 
-  it 'calls the ready handler when sent post_init' do
-    ready = mock()
-    ready.expects(:call)
-    @client.register_handler(:ready) { ready.call }
-    @client.post_init @stream
-  end
-end
+    it 'lets status stanzas fall through to other handlers' do
+      jid = 'friend@jabber.local'
+      status = Blather::Stanza::Presence::Status.new :away
+      status.stubs(:from).returns jid
+      roster_item = mock
+      roster_item.expects(:status=).with status
+      subject.stubs(:roster).returns({status.from => roster_item})
+
+      response = mock
+      response.expects(:call).with jid
+      subject.register_handler(:status) { |s| response.call s.from.to_s }
+      subject.receive_data status
+    end
 
-describe 'Blather::Client with a Client stream' do
-  before do
-    class MockClientStream < Blather::Stream::Client; def initialize(); end; end
-    @stream = MockClientStream.new('')
-    @client = Blather::Client.new
-    Blather::Stream::Client.stubs(:start).returns @stream
-    @client.setup('me@me.com', 'secret').run
-  end
+    it 'handles an incoming roster node by processing it through the roster' do
+      roster = Blather::Stanza::Iq::Roster.new
+      client_roster = mock
+      client_roster.expects(:process).with roster
+      subject.stubs(:roster).returns client_roster
+      subject.receive_data roster
+    end
+
+    it 'handles an incoming roster node by processing it through the roster' do
+      roster = Blather::Stanza::Iq::Roster.new
+      client_roster = mock
+      client_roster.expects(:process).with roster
+      subject.stubs(:roster).returns client_roster
 
-  it 'sends a request for the roster when post_init is called' do
-    @stream.expects(:send).with { |stanza| stanza.should be_kind_of Blather::Stanza::Iq::Roster }
-    @client.post_init @stream, Blather::JID.new('n@d/r')
+      response = mock
+      response.expects(:call)
+      subject.register_handler(:roster) { |_| response.call }
+      subject.receive_data roster
+    end
   end
 
-  it 'calls the ready handler after post_init and roster is received' do
-    result_roster = Blather::Stanza::Iq::Roster.new :result
-    @stream.stubs(:send).with { |s| result_roster.id = s.id; @client.receive_data result_roster; true }
+  describe 'with a Component stream' do
+    before do
+      class MockComponent < Blather::Stream::Component; def initialize(); end; end
+      stream = MockComponent.new('')
+      stream.stubs(:send_data)
+      subject.setup 'me.com', 'secret'
+    end
 
-    ready = mock()
-    ready.expects(:call)
-    @client.register_handler(:ready) { ready.call }
-    @client.post_init @stream, Blather::JID.new('n@d/r')
+    it 'calls the ready handler when sent post_init' do
+      ready = mock
+      ready.expects(:call)
+      subject.register_handler(:ready) { ready.call }
+      subject.post_init stream
+    end
   end
-end
 
-describe 'Blather::Client filters' do
-  before do
-    @client = Blather::Client.new
-    @stream = mock()
-    @stream.stubs(:send)
-    @client.post_init @stream, Blather::JID.new('n@d/r')
-  end
+  describe 'with a Client stream' do
+    before do
+      class MockClientStream < Blather::Stream::Client; def initialize(); end; end
+      stream = MockClientStream.new('')
+      Blather::Stream::Client.stubs(:start).returns stream
+      subject.setup('me@me.com', 'secret').run
+    end
 
-  it 'raises an error when an invalid filter type is registered' do
-    lambda { @client.register_filter(:invalid) {} }.should raise_error RuntimeError
-  end
+    it 'sends a request for the roster when post_init is called' do
+      stream.expects(:send).with { |stanza| stanza.should be_kind_of Blather::Stanza::Iq::Roster }
+      subject.post_init stream, Blather::JID.new('n@d/r')
+    end
 
-  it 'can be guarded' do
-    stanza = Blather::Stanza::Iq.new
-    ready = mock()
-    ready.expects(:call).once
-    @client.register_filter(:before, :iq, :id => stanza.id) { |_| ready.call }
-    @client.register_filter(:before, :iq, :id => 'not-id') { |_| ready.call }
-    @client.receive_data stanza
+    it 'calls the ready handler after post_init and roster is received' do
+      result_roster = Blather::Stanza::Iq::Roster.new :result
+      stream.stubs(:send).with do |s|
+        result_roster.id = s.id
+        subject.receive_data result_roster
+        true
+      end
+
+      ready = mock
+      ready.expects(:call)
+      subject.register_handler(:ready) { ready.call }
+      subject.post_init stream, Blather::JID.new('n@d/r')
+    end
   end
 
-  it 'can pass to the next handler' do
-    stanza = Blather::Stanza::Iq.new
-    ready = mock()
-    ready.expects(:call).once
-    @client.register_filter(:before) { |_| throw :pass; ready.call }
-    @client.register_filter(:before) { |_| ready.call }
-    @client.receive_data stanza
-  end
+  describe 'filters' do
+    it 'raises an error when an invalid filter type is registered' do
+      lambda { subject.register_filter(:invalid) {} }.should raise_error RuntimeError
+    end
 
-  it 'runs them in order' do
-    stanza = Blather::Stanza::Iq.new
-    count = 0
-    @client.register_filter(:before) { |_| count.should == 0; count = 1 }
-    @client.register_filter(:before) { |_| count.should == 1; count = 2 }
-    @client.register_handler(:iq) { |_| count.should == 2; count = 3 }
-    @client.register_filter(:after) { |_| count.should == 3; count = 4 }
-    @client.register_filter(:after) { |_| count.should == 4 }
-    @client.receive_data stanza
-  end
+    it 'can be guarded' do
+      stanza = Blather::Stanza::Iq.new
+      ready = mock
+      ready.expects(:call).once
+      subject.register_filter(:before, :iq, :id => stanza.id) { |_| ready.call }
+      subject.register_filter(:before, :iq, :id => 'not-id') { |_| ready.call }
+      subject.receive_data stanza
+    end
 
-  it 'can modify the stanza' do
-    stanza = Blather::Stanza::Iq.new
-    stanza.from = 'from@test.local'
-    new_jid = 'before@filter.local'
-    ready = mock()
-    ready.expects(:call).with new_jid
-    @client.register_filter(:before) { |s| s.from = new_jid }
-    @client.register_handler(:iq) { |s| ready.call s.from.to_s }
-    @client.receive_data stanza
-  end
+    it 'can pass to the next handler' do
+      stanza = Blather::Stanza::Iq.new
+      ready = mock
+      ready.expects(:call).once
+      subject.register_filter(:before) { |_| throw :pass; ready.call }
+      subject.register_filter(:before) { |_| ready.call }
+      subject.receive_data stanza
+    end
 
-  it 'can halt the handler chain' do
-    stanza = Blather::Stanza::Iq.new
-    ready = mock()
-    ready.expects(:call).never
-    @client.register_filter(:before) { |_| throw :halt }
-    @client.register_handler(:iq) { |_| ready.call }
-    @client.receive_data stanza
-  end
+    it 'runs them in order' do
+      stanza = Blather::Stanza::Iq.new
+      count = 0
+      subject.register_filter(:before) { |_| count.should == 0; count = 1 }
+      subject.register_filter(:before) { |_| count.should == 1; count = 2 }
+      subject.register_handler(:iq) { |_| count.should == 2; count = 3 }
+      subject.register_filter(:after) { |_| count.should == 3; count = 4 }
+      subject.register_filter(:after) { |_| count.should == 4 }
+      subject.receive_data stanza
+    end
 
-  it 'can be specific to a handler' do
-    stanza = Blather::Stanza::Iq.new
-    ready = mock()
-    ready.expects(:call).once
-    @client.register_filter(:before, :iq) { |_| ready.call }
-    @client.register_filter(:before, :message) { |_| ready.call }
-    @client.receive_data stanza
-  end
-end
+    it 'can modify the stanza' do
+      stanza = Blather::Stanza::Iq.new
+      stanza.from = 'from@test.local'
+      new_jid = 'before@filter.local'
+      ready = mock
+      ready.expects(:call).with new_jid
+      subject.register_filter(:before) { |s| s.from = new_jid }
+      subject.register_handler(:iq) { |s| ready.call s.from.to_s }
+      subject.receive_data stanza
+    end
 
-describe 'Blather::Client guards' do
-  before do
-    stream = mock()
-    stream.stubs(:send)
-    @client = Blather::Client.new
-    @client.post_init stream, Blather::JID.new('n@d/r')
-    @stanza = Blather::Stanza::Iq.new
-    @response = mock()
+    it 'can halt the handler chain' do
+      stanza = Blather::Stanza::Iq.new
+      ready = mock
+      ready.expects(:call).never
+      subject.register_filter(:before) { |_| throw :halt }
+      subject.register_handler(:iq) { |_| ready.call }
+      subject.receive_data stanza
+    end
+
+    it 'can be specific to a handler' do
+      stanza = Blather::Stanza::Iq.new
+      ready = mock
+      ready.expects(:call).once
+      subject.register_filter(:before, :iq) { |_| ready.call }
+      subject.register_filter(:before, :message) { |_| ready.call }
+      subject.receive_data stanza
+    end
   end
 
-  it 'can be a symbol' do
-    @response.expects :call
-    @client.register_handler(:iq, :chat?) { |_| @response.call }
+  describe 'guards' do
+    let(:stanza)    { Blather::Stanza::Iq.new }
+    let(:response)  { mock }
 
-    @stanza.expects(:chat?).returns true
-    @client.receive_data @stanza
+    it 'can be a symbol' do
+      response.expects :call
+      subject.register_handler(:iq, :chat?) { |_| response.call }
 
-    @stanza.expects(:chat?).returns false
-    @client.receive_data @stanza
-  end
+      stanza.expects(:chat?).returns true
+      subject.receive_data stanza
 
-  it 'can be a hash with string match' do
-    @response.expects :call
-    @client.register_handler(:iq, :body => 'exit') { |_| @response.call }
+      stanza.expects(:chat?).returns false
+      subject.receive_data stanza
+    end
 
-    @stanza.expects(:body).returns 'exit'
-    @client.receive_data @stanza
+    it 'can be a hash with string match' do
+      response.expects :call
+      subject.register_handler(:iq, :body => 'exit') { |_| response.call }
 
-    @stanza.expects(:body).returns 'not-exit'
-    @client.receive_data @stanza
-  end
+      stanza.expects(:body).returns 'exit'
+      subject.receive_data stanza
 
-  it 'can be a hash with a value' do
-    @response.expects :call
-    @client.register_handler(:iq, :number => 0) { |_| @response.call }
+      stanza.expects(:body).returns 'not-exit'
+      subject.receive_data stanza
+    end
 
-    @stanza.expects(:number).returns 0
-    @client.receive_data @stanza
+    it 'can be a hash with a value' do
+      response.expects :call
+      subject.register_handler(:iq, :number => 0) { |_| response.call }
 
-    @stanza.expects(:number).returns 1
-    @client.receive_data @stanza
-  end
+      stanza.expects(:number).returns 0
+      subject.receive_data stanza
 
-  it 'can be a hash with a regexp' do
-    @response.expects :call
-    @client.register_handler(:iq, :body => /exit/) { |_| @response.call }
+      stanza.expects(:number).returns 1
+      subject.receive_data stanza
+    end
 
-    @stanza.expects(:body).returns 'more than just exit, but exit still'
-    @client.receive_data @stanza
+    it 'can be a hash with a regexp' do
+      response.expects :call
+      subject.register_handler(:iq, :body => /exit/) { |_| response.call }
 
-    @stanza.expects(:body).returns 'keyword not found'
-    @client.receive_data @stanza
+      stanza.expects(:body).returns 'more than just exit, but exit still'
+      subject.receive_data stanza
 
-    @stanza.expects(:body).returns nil
-    @client.receive_data @stanza
-  end
+      stanza.expects(:body).returns 'keyword not found'
+      subject.receive_data stanza
 
-  it 'can be a hash with an array' do
-    @response.expects(:call).times(2)
-    @client.register_handler(:iq, :type => [:result, :error]) { |_| @response.call }
+      stanza.expects(:body).returns nil
+      subject.receive_data stanza
+    end
 
-    stanza = Blather::Stanza::Iq.new
-    stanza.expects(:type).at_least_once.returns :result
-    @client.receive_data stanza
+    it 'can be a hash with an array' do
+      response.expects(:call).times(2)
+      subject.register_handler(:iq, :type => [:result, :error]) { |_| response.call }
 
-    stanza = Blather::Stanza::Iq.new
-    stanza.expects(:type).at_least_once.returns :error
-    @client.receive_data stanza
+      stanza = Blather::Stanza::Iq.new
+      stanza.expects(:type).at_least_once.returns :result
+      subject.receive_data stanza
 
-    stanza = Blather::Stanza::Iq.new
-    stanza.expects(:type).at_least_once.returns :get
-    @client.receive_data stanza
-  end
+      stanza = Blather::Stanza::Iq.new
+      stanza.expects(:type).at_least_once.returns :error
+      subject.receive_data stanza
 
-  it 'chained are treated like andand (short circuited)' do
-    @response.expects :call
-    @client.register_handler(:iq, :type => :get, :body => 'test') { |_| @response.call }
+      stanza = Blather::Stanza::Iq.new
+      stanza.expects(:type).at_least_once.returns :get
+      subject.receive_data stanza
+    end
 
-    stanza = Blather::Stanza::Iq.new
-    stanza.expects(:type).at_least_once.returns :get
-    stanza.expects(:body).returns 'test'
-    @client.receive_data stanza
+    it 'chained are treated like andand (short circuited)' do
+      response.expects :call
+      subject.register_handler(:iq, :type => :get, :body => 'test') { |_| response.call }
 
-    stanza = Blather::Stanza::Iq.new
-    stanza.expects(:type).at_least_once.returns :set
-    stanza.expects(:body).never
-    @client.receive_data stanza
-  end
+      stanza = Blather::Stanza::Iq.new
+      stanza.expects(:type).at_least_once.returns :get
+      stanza.expects(:body).returns 'test'
+      subject.receive_data stanza
 
-  it 'within an Array are treated as oror (short circuited)' do
-    @response.expects(:call).times 2
-    @client.register_handler(:iq, [{:type => :get}, {:body => 'test'}]) { |_| @response.call }
+      stanza = Blather::Stanza::Iq.new
+      stanza.expects(:type).at_least_once.returns :set
+      stanza.expects(:body).never
+      subject.receive_data stanza
+    end
 
-    stanza = Blather::Stanza::Iq.new
-    stanza.expects(:type).at_least_once.returns :set
-    stanza.expects(:body).returns 'test'
-    @client.receive_data stanza
+    it 'within an Array are treated as oror (short circuited)' do
+      response.expects(:call).times 2
+      subject.register_handler(:iq, [{:type => :get}, {:body => 'test'}]) { |_| response.call }
 
-    stanza = Blather::Stanza::Iq.new
-    stanza.stubs(:type).at_least_once.returns :get
-    stanza.expects(:body).never
-    @client.receive_data stanza
-  end
+      stanza = Blather::Stanza::Iq.new
+      stanza.expects(:type).at_least_once.returns :set
+      stanza.expects(:body).returns 'test'
+      subject.receive_data stanza
 
-  it 'can be a lambda' do
-    @response.expects :call
-    @client.register_handler(:iq, lambda { |s| s.number % 3 == 0 }) { |_| @response.call }
+      stanza = Blather::Stanza::Iq.new
+      stanza.stubs(:type).at_least_once.returns :get
+      stanza.expects(:body).never
+      subject.receive_data stanza
+    end
 
-    @stanza.expects(:number).at_least_once.returns 3
-    @client.receive_data @stanza
+    it 'can be a lambda' do
+      response.expects :call
+      subject.register_handler(:iq, lambda { |s| s.number % 3 == 0 }) { |_| response.call }
 
-    @stanza.expects(:number).at_least_once.returns 2
-    @client.receive_data @stanza
-  end
+      stanza.expects(:number).at_least_once.returns 3
+      subject.receive_data stanza
 
-  it 'can be an xpath and will send the result to the handler' do
-    @response.expects(:call).with do |stanza, xpath|
-      xpath.should be_instance_of Nokogiri::XML::NodeSet
-      xpath.should_not be_empty
-      stanza.should == @stanza
+      stanza.expects(:number).at_least_once.returns 2
+      subject.receive_data stanza
     end
-    @client.register_handler(:iq, "/iq[@id='#{@stanza.id}']") { |stanza, xpath| @response.call stanza, xpath }
-    @client.receive_data @stanza
-  end
 
-  it 'can be an xpath with namespaces and will send the result to the handler' do
-    @stanza = Blather::Stanza.parse('<message><foo xmlns="http://bar.com"></message>')
-    @response.expects(:call).with do |stanza, xpath|
-      xpath.should be_instance_of Nokogiri::XML::NodeSet
-      xpath.should_not be_empty
-      stanza.should == @stanza
+    it 'can be an xpath and will send the result to the handler' do
+      response.expects(:call).with do |stanza, xpath|
+        xpath.should be_instance_of Nokogiri::XML::NodeSet
+        xpath.should_not be_empty
+        stanza.should == stanza
+      end
+      subject.register_handler(:iq, "/iq[@id='#{stanza.id}']") { |stanza, xpath| response.call stanza, xpath }
+      subject.receive_data stanza
+    end
+
+    it 'can be an xpath with namespaces and will send the result to the handler' do
+      stanza = Blather::Stanza.parse('<message><foo xmlns="http://bar.com"></message>')
+      response.expects(:call).with do |stanza, xpath|
+        xpath.should be_instance_of Nokogiri::XML::NodeSet
+        xpath.should_not be_empty
+        stanza.should == stanza
+      end
+      subject.register_handler(:message, "/message/bar:foo", :bar => 'http://bar.com') { |stanza, xpath| response.call stanza, xpath }
+      subject.receive_data stanza
     end
-    @client.register_handler(:message, "/message/bar:foo", :bar => 'http://bar.com') { |stanza, xpath| @response.call stanza, xpath }
-    @client.receive_data @stanza
-  end
 
-  it 'raises an error when a bad guard is tried' do
-    lambda { @client.register_handler(:iq, 0) {} }.should raise_error RuntimeError
+    it 'raises an error when a bad guard is tried' do
+      lambda { subject.register_handler(:iq, 0) {} }.should raise_error RuntimeError
+    end
   end
-end
 
-describe 'Blather::Client::Caps' do
-  before do
-    @client = Blather::Client.new
-    @stream = mock()
-    @stream.stubs(:send)
-    @client.post_init @stream, Blather::JID.new('n@d/r')
-    @caps = @client.caps
-  end
-
-  it 'must be of type result' do
-    @caps.should respond_to :type
-    @caps.type.should == :result
-  end
-
-  it 'can have a client node set' do
-    @caps.should respond_to :node=
-    @caps.node = "somenode"
-  end
-
-  it 'provides a client node reader' do
-    @caps.should respond_to :node
-    @caps.node = "somenode"
-    @caps.node.should == "somenode##{@caps.ver}"
-  end
-
-  it 'can have identities set' do
-    @caps.should respond_to :identities=
-    @caps.identities = [{:name => "name", :type => "type", :category => "cat"}]
-  end
-
-  it 'provides an identities reader' do
-    @caps.should respond_to :identities
-    @caps.identities = [{:name => "name", :type => "type", :category => "cat"}]
-    @caps.identities.should == [Blather::Stanza::Iq::DiscoInfo::Identity.new({:name => "name", :type => "type", :category => "cat"})]
-  end
-
-  it 'can have features set' do
-    @caps.should respond_to :features=
-    @caps.features.size.should == 0
-    @caps.features = ["feature1"]
-    @caps.features.size.should == 1
-    @caps.features += [Blather::Stanza::Iq::DiscoInfo::Feature.new("feature2")]
-    @caps.features.size.should == 2
-    @caps.features = nil
-    @caps.features.size.should == 0
-  end
-
-  it 'provides a features reader' do
-    @caps.should respond_to :features
-    @caps.features = %w{feature1 feature2}
-    @caps.features.should == [Blather::Stanza::Iq::DiscoInfo::Feature.new("feature1"), Blather::Stanza::Iq::DiscoInfo::Feature.new("feature2")]
-  end
-
-  it 'provides a client ver reader' do
-    @caps.should respond_to :ver
-    @caps.node = 'http://code.google.com/p/exodus'
-    @caps.identities = [Blather::Stanza::Iq::DiscoInfo::Identity.new({:name => 'Exodus 0.9.1', :type => 'pc', :category => 'client'})]
-    @caps.features = %w{
-                          http://jabber.org/protocol/caps
-                          http://jabber.org/protocol/disco#info
-                          http://jabber.org/protocol/disco#items
-                          http://jabber.org/protocol/muc
-                        }
-    @caps.ver.should == 'QgayPKawpkPSDYmwT/WM94uAlu0='
-    @caps.node.should == "http://code.google.com/p/exodus#QgayPKawpkPSDYmwT/WM94uAlu0="
-  end
-
-  it 'can construct caps presence correctly' do
-    @caps.should respond_to :c
-    @caps.node = 'http://code.google.com/p/exodus'
-    @caps.identities = [Blather::Stanza::Iq::DiscoInfo::Identity.new({:name => 'Exodus 0.9.1', :type => 'pc', :category => 'client'})]
-    @caps.features = %w{
-                          http://jabber.org/protocol/caps
-                          http://jabber.org/protocol/disco#info
-                          http://jabber.org/protocol/disco#items
-                          http://jabber.org/protocol/muc
-                        }
-    Nokogiri::XML(@caps.c.to_xml).to_s.should == Nokogiri::XML("<presence><c xmlns=\"http://jabber.org/protocol/caps\" hash=\"sha-1\" node=\"http://code.google.com/p/exodus\" ver=\"QgayPKawpkPSDYmwT/WM94uAlu0=\"/></presence>").to_s
+  describe '#caps' do
+    let(:caps) { subject.caps }
+
+    it 'must be of type result' do
+      caps.should respond_to :type
+      caps.type.should == :result
+    end
+
+    it 'can have a client node set' do
+      caps.should respond_to :node=
+      caps.node = "somenode"
+    end
+
+    it 'provides a client node reader' do
+      caps.should respond_to :node
+      caps.node = "somenode"
+      caps.node.should == "somenode##{caps.ver}"
+    end
+
+    it 'can have identities set' do
+      caps.should respond_to :identities=
+      caps.identities = [{:name => "name", :type => "type", :category => "cat"}]
+    end
+
+    it 'provides an identities reader' do
+      caps.should respond_to :identities
+      caps.identities = [{:name => "name", :type => "type", :category => "cat"}]
+      caps.identities.should == [Blather::Stanza::Iq::DiscoInfo::Identity.new({:name => "name", :type => "type", :category => "cat"})]
+    end
+
+    it 'can have features set' do
+      caps.should respond_to :features=
+      caps.features.size.should == 0
+      caps.features = ["feature1"]
+      caps.features.size.should == 1
+      caps.features += [Blather::Stanza::Iq::DiscoInfo::Feature.new("feature2")]
+      caps.features.size.should == 2
+      caps.features = nil
+      caps.features.size.should == 0
+    end
+
+    it 'provides a features reader' do
+      caps.should respond_to :features
+      caps.features = %w{feature1 feature2}
+      caps.features.should == [Blather::Stanza::Iq::DiscoInfo::Feature.new("feature1"), Blather::Stanza::Iq::DiscoInfo::Feature.new("feature2")]
+    end
+
+    it 'provides a client ver reader' do
+      caps.should respond_to :ver
+      caps.node = 'http://code.google.com/p/exodus'
+      caps.identities = [Blather::Stanza::Iq::DiscoInfo::Identity.new({:name => 'Exodus 0.9.1', :type => 'pc', :category => 'client'})]
+      caps.features = %w{
+                            http://jabber.org/protocol/caps
+                            http://jabber.org/protocol/disco#info
+                            http://jabber.org/protocol/disco#items
+                            http://jabber.org/protocol/muc
+                          }
+      caps.ver.should == 'QgayPKawpkPSDYmwT/WM94uAlu0='
+      caps.node.should == "http://code.google.com/p/exodus#QgayPKawpkPSDYmwT/WM94uAlu0="
+    end
+
+    it 'can construct caps presence correctly' do
+      caps.should respond_to :c
+      caps.node = 'http://code.google.com/p/exodus'
+      caps.identities = [Blather::Stanza::Iq::DiscoInfo::Identity.new({:name => 'Exodus 0.9.1', :type => 'pc', :category => 'client'})]
+      caps.features = %w{
+                            http://jabber.org/protocol/caps
+                            http://jabber.org/protocol/disco#info
+                            http://jabber.org/protocol/disco#items
+                            http://jabber.org/protocol/muc
+                          }
+      Nokogiri::XML(caps.c.to_xml).to_s.should == Nokogiri::XML("<presence><c xmlns=\"http://jabber.org/protocol/caps\" hash=\"sha-1\" node=\"http://code.google.com/p/exodus\" ver=\"QgayPKawpkPSDYmwT/WM94uAlu0=\"/></presence>").to_s
+    end
   end
 end