xmpp4em 0.2.0 → 0.2.3

data/README.md

@@ -2,8 +2,6 @@
 
 Simple XMPP client built on EventMachine.
 
-Requires eventmachine-xmlpushparser (in vendor/) and eventmachine 0.12.1
-
 # CREDIT
 
  * by Aman Gupta

data/lib/xmpp4em.rb

@@ -1,6 +1,6 @@
 module XMPP4EM
   class NotConnected < Exception; end
-  VERSION='0.2.0'
+  VERSION='0.2.3'
   autoload :ClientConnection, 'xmpp4em/client_connection'
   autoload :Client, 'xmpp4em/client'
   autoload :BaseClient, 'xmpp4em/base_client'  

data/lib/xmpp4em/base_client.rb

@@ -1,9 +1,6 @@
 #encoding: utf-8
 require 'rubygems'
 
-require 'stringio'
-require 'rexml/parsers/sax2parser'
-
 require 'xmpp4r/idgenerator'
 require 'xmpp4r/xmppstanza'
 require 'xmpp4r/iq'
@@ -12,15 +9,15 @@ require 'xmpp4r/presence'
 require 'resolv'
 
 require 'eventmachine'
-require 'evma_xmlpushparser'
-EM.epoll
 
 module XMPP4EM
-  
+
   class BaseClient
-    include EM::Deferrable
-    
-    def initialize user, pass, logger=nil,opts = {}
+    include ::EM::Deferrable
+    attr_reader :authenticated
+    alias :authenticated? :authenticated
+
+    def initialize(user, pass, logger=nil, opts = {})
       @user = user
       @pass = pass
       @logger=logger
@@ -29,81 +26,85 @@ module XMPP4EM
       @authenticated = false
       @opts = opts
       @auth_callback = nil
-      @id_callbacks  = {}
+      @id_callbacks = {}
       @on_stanza=nil
       @events_callbacks = {
-        :message    => [],
-        :presence   => [],
-        :iq         => [],
-        :exception  => [],
-        :login      => [],
-        :disconnect => [],
-        :connected  => []
-      }     
-      
+          :message => [],
+          :presence => [],
+          :iq => [],
+          :exception => [],
+          :login => [],
+          :disconnect => [],
+          :connected => []
+      }
+
       on(:disconnect) do
         @deferred_status = nil
         @authenticated=false
-      end         
+      end
       on(:login) do
         succeed
-      end    
+      end
     end
+
     attr_reader :connection, :user
-    
+
     def reconnect
       @connection.close_connection_after_writing
       @deferred_status = nil
       connect
     end
-    
+
     def connected?
       @connection and !@connection.error?
     end
-        
-    def register_stanza &blk          
+
+    def register_stanza &blk
       @on_stanza = blk if block_given?
-    end       
-    
-    def send data, safe=false,  &blk
-      
-      if block_given? and data.is_a? Jabber::XMPPStanza
-        if data.id.nil?
-          data.id = Jabber::IdGenerator.instance.generate_id
-        end
-        @id_callbacks[ data.id ] = blk
+    end
+
+    def send data, safe=false, &blk
+      if data.is_a? ::Jabber::XMPPStanza
+        data.id = ::Jabber::IdGenerator.instance.generate_id if data.id.nil?
+        @id_callbacks[data.id] = blk if block_given?
       end
+
       if safe
-        callback {   @connection.send(data) }
+        callback { @connection.send(data) }
       else
         @connection.send(data)
       end
     end
-    
+
     def close
       @connection.close_connection_after_writing
       @deferred_status = nil
       @connection = nil
     end
+
     alias :disconnect :close
-        
+
     def receive stanza
-      if stanza.kind_of?(Jabber::XMPPStanza) and stanza.id and blk = @id_callbacks[ stanza.id ]
+
+      if stanza.kind_of?(::Jabber::XMPPStanza) and stanza.id and blk = @id_callbacks[stanza.id]
         @id_callbacks.delete stanza.id
         blk.call(stanza)
         return
       end
-      
-      return if receive_stanza(stanza)      
-      return if @on_stanza && @on_stanza.call(stanza)  
-      
+
+      return if receive_stanza(stanza)
+      return if @on_stanza && @on_stanza.call(stanza)
+
       case stanza
-        when Jabber::Message then  on(:message, stanza)
-        when Jabber::Iq then  on(:iq, stanza)
-        when Jabber::Presence then on(:presence, stanza)
+        when Jabber::Presence then
+          on(:presence, stanza)
+        when Jabber::Iq then
+          on(:iq, stanza)
+        when Jabber::Message then
+          on(:message, stanza)
       end
     end
-    
+
     def on type, *args, &blk
       if blk
         @events_callbacks[type] << blk
@@ -113,10 +114,21 @@ module XMPP4EM
         end
       end
     end
-    
-    def add_message_callback  (&blk) on :message,   &blk end
-    def add_presence_callback (&blk) on :presence,  &blk end
-    def add_iq_callback       (&blk) on :iq,        &blk end
-    def on_exception          (&blk) on :exception, &blk end
+
+    def add_message_callback (&blk)
+      on(:message, &blk);
+    end
+
+    def add_presence_callback (&blk)
+      on(:presence, &blk);
+    end
+
+    def add_iq_callback (&blk)
+      on(:iq, &blk);
+    end
+
+    def on_exception (&blk)
+      on(:exception, &blk);
+    end
   end
 end

data/lib/xmpp4em/base_connection.rb

@@ -1,129 +1,148 @@
 #encoding: utf-8
-require 'stringio'
-require 'rexml/parsers/sax2parser'
-
+require 'nokogiri'
 require 'xmpp4r/idgenerator'
 require 'xmpp4r/xmppstanza'
 require 'xmpp4r/iq'
 require 'xmpp4r/message'
 require 'xmpp4r/presence'
 
-module XMPP4EM
-  
-  class BaseConnection < EventMachine::Connection
-    
-    def initialize host, port=5222
-      @host, @port = host, port
-      @client = nil
-    end
-    attr_accessor :client, :host, :port, :logger
-    
-    def connection_completed
-      @logger.debug{'connected'} if @logger
-      @stream_features, @stream_mechanisms = {}, []
-      @keepalive = EM::Timer.new(60){ send_data("\n") }
-      @client.on(:connected)
-      init
+module ::XMPP4EM
+
+  class XmppPushParser < ::Nokogiri::XML::SAX::Document
+
+    attr_accessor :started
+    attr_accessor :current
+
+    def process(&block)
+      @process=block
     end
-    attr_reader :stream_features
-    
-    include EventMachine::XmlPushParser
-    
+
     def encode2utf8(text)
-      text.respond_to?(:force_encoding) ? text.force_encoding("utf-8") : text
+      text
     end
-    
+
     def start_element name, attrs
-      e = REXML::Element.new(name)
-      attrs.each { |name, value|
-        e.add_attribute(name, encode2utf8(value))
-      }
-      
+      e = ::REXML::Element.new(name)
+      attrs.each { |a|
+        a_name, a_value = *a
+        if a_name =~ /^xmlns:(.+)$/
+          e.add_attribute($1, a_value.to_s)
+        else
+          e.add_namespace(a_name, a_value)
+        end
+      } if attrs.length > 0
       @current = @current.nil? ? e : @current.add_element(e)
-      
+
       if @current.name == 'stream' and not @started
         @started = true
-        process
+        @process.call(@current)
         @current = nil
       end
     end
-    
+
     def end_element name
-      if name == 'stream:stream' and @current.nil?
+      if name == 'stream' and @current.nil?
         @started = false
       else
         if @current.parent
           @current = @current.parent
         else
-          process
+          @process.call(@current)
           @current = nil
         end
       end
     end
-    
+
     def characters text
       @current.text = @current.text.to_s + encode2utf8(text) if @current
     end
-    
+  end
+
+  class BaseConnection < ::EventMachine::Connection
+
+    def initialize host, port=5222
+      @host, @port = host, port
+      @client = nil
+      @pushParser=::XMPP4EM::XmppPushParser.new
+      @pushParser.process do |c|
+        process(c)
+      end
+      @parser=::Nokogiri::XML::SAX::PushParser.new(@pushParser)
+    end
+
+    attr_accessor :client, :host, :port, :logger
+
+    def connection_completed
+      @logger.debug { 'connected' } if @logger
+      @stream_features, @stream_mechanisms = {}, []
+      @keepalive = ::EM::Timer.new(60) { send_data("\n") }
+      @client.on(:connected)
+      init
+    end
+
+    attr_reader :stream_features
+
     def error *args
-      p ['error', *args]
+      $stderr.puts ['error', *args]
     end
-    
+
     def receive_data data
-      @logger.debug{"<< #{data}"} if @logger
-      super
+      @logger.debug { "<< #{data}" } if @logger
+      #$stdout.puts "[Receive] #{data}"
+      @parser.write(data)
     end
-    
+
     def send data, &blk
-      @logger.debug{ ">> #{data}"} if @logger
-      send_data data.to_s     
+      @logger.debug { ">> #{data}" } if @logger
+      #$stdout.puts "[Send] #{data.to_s}"
+      send_data data.to_s
     end
-    
+
     def unbind
       if @keepalive
         @keepalive.cancel
         @keepalive = nil
       end
       @client.on(:disconnect)
-      @logger.debug{'disconnected'} if @logger
+      @logger.debug { 'disconnected' } if @logger
     end
-    
+
     def reconnect host = @host, port = @port
       super
     end
-    
+
     def init
-      send "<?xml version='1.0' ?>" unless @started
-      @started = false
+      send "<?xml version='1.0' ?>" unless @pushParser.started
+      @pushParser.started = false
       send "<stream:stream xmlns:stream='http://etherx.jabber.org/streams' xmlns='#{namespace;}' xml:lang='en' version='1.0' to='#{@host}'>"
     end
-    
+
     private
-    
-    def  pre_process_stanza(stanza)
-    end    
-    
-    def process
-      if @current.namespace('').to_s == '' # REXML namespaces are always strings
-        @current.add_namespace(@streamns)
+
+    def pre_process_stanza(stanza)
+    end
+
+    def process(current)
+      if current.namespace('').to_s == '' # REXML namespaces are always strings
+        current.add_namespace(@streamns)
       end
-      stanza = @current
+      stanza = current
       if  'stream'==stanza.prefix
         if 'stream'==stanza.name
-          @streamid = stanza.attributes['id']      
+          @streamid = stanza.attributes['id']
           #All connections has the same namespace
-          @streamns = 'jabber:client'    
+          @streamns = 'jabber:client'
         end
-        pre_process_stanza(stanza)	 
+        pre_process_stanza(stanza)
       end
       # Any stanza, classes are registered by XMPPElement::name_xmlns
       begin
-        stanza = Jabber::XMPPStanza::import(@current)
-      rescue Jabber::NoNameXmlnsRegistered
-        stanza = @current
+        stanza = ::Jabber::XMPPStanza::import(current)
+      rescue ::Jabber::NoNameXmlnsRegistered
+        stanza = current
       end
       @client.receive(stanza)
     end
   end
-  
+
 end

data/lib/xmpp4em/client.rb

@@ -3,136 +3,136 @@ require 'xmpp4r/sasl'
 require 'resolv'
 
 module XMPP4EM
-  
+
   class Client < BaseClient
-    
+
     def initialize user, pass, logger=nil, opts = {}
-      super      
-      @opts = { :auto_register => false }.merge(opts)        
+      super
+      @opts = {:auto_register => false}.merge(opts)
     end
-    
+
     def jid
-      @jid ||= if @user.kind_of?(Jabber::JID)
-        @user
-      else
-        @user =~ /@/ ? Jabber::JID.new(@user) : Jabber::JID.new(@user, 'localhost')
-      end
+      @jid ||= if @user.kind_of?(::Jabber::JID)
+                 @user
+               else
+                 @user =~ /@/ ? ::Jabber::JID.new(@user) : ::Jabber::JID.new(@user, 'localhost')
+               end
     end
-    
+
     def connect host = jid.domain, port = 5222
       if host=='localhost' || host=='127.0.0.1' || %r{^([0-9]{1,3}.){3}[0-9]{1,3}$}.match(host)
         target_host, target_port= host, port
       else
         target_host, target_port = resolve_host(host)
       end
-      EM.connect target_host, target_port, ClientConnection, jid.domain, port do |conn|
+      ::EM.connect target_host, target_port, ClientConnection, jid.domain, port do |conn|
         @connection = conn
         conn.client = self
         conn.logger=@logger
       end
-    end   
-    
+    end
+
     def resolve_host(domain)
       srv = []
-      begin        
-        Resolv::DNS.open { |dns|
+      begin
+        ::Resolv::DNS.open { |dns|
           # If ruby version is too old and SRV is unknown, this will raise a NameError
           # which is catched below
           #debug("RESOLVING:\n_xmpp-client._tcp.#{domain} (SRV)")
           srv = dns.getresources("_xmpp-client._tcp.#{domain}", Resolv::DNS::Resource::IN::SRV)
         }
       rescue NameError
-        
+
       end
-      
+
       unless srv.blank?
         # Sort SRV records: lowest priority first, highest weight first
-        srv.sort! { |a,b| (a.priority != b.priority) ? (a.priority <=> b.priority) : (b.weight <=> a.weight) }        
+        srv.sort! { |a, b| (a.priority != b.priority) ? (a.priority <=> b.priority) : (b.weight <=> a.weight) }
         #debug "USING #{srv.first.target.to_s}"
         return srv.first.target.to_s, srv.first.port
       else
         #debug "USING #{domain}:5222"          
         return domain, 5222
       end
-      
+
     end
-    
+
     def login &blk
-      Jabber::SASL::new(self, 'PLAIN').auth(@pass)
+      ::Jabber::SASL::new(self, 'PLAIN').auth(@pass)
       @auth_callback = blk if block_given?
     end
-    
+
     def register &blk
-      reg = Jabber::Iq.new_register(jid.node, @pass)
+      reg = ::Jabber::Iq.new_register(jid.node, @pass)
       reg.to = jid.domain
-      
-      send(reg){ |reply|
-        blk.call( reply.type == :result ? :success : reply.type )
+
+      send(reg) { |reply|
+        blk.call(reply.type == :result ? :success : reply.type)
       }
-    end 
-    
+    end
+
     def send_msg to, msg
-      send_safe Jabber::Message::new(to, msg).set_type(:chat)
+      send_safe ::Jabber::Message::new(to, msg).set_type(:chat)
     end
-    
+
     def receive_stanza(stanza)
-      
+
       case stanza.name
         when 'features'
-        unless @authenticated
-          login do |res|
-            # log ['login response', res].inspect
-            if res == :failure and @opts[:auto_register]
-              register do |res|
-                #p ['register response', res]
-                login unless res == :error
+          unless @authenticated
+            login do |res|
+              # log ['login response', res].inspect
+              if res == :failure and @opts[:auto_register]
+                register do |res|
+                  #p ['register response', res]
+                  login unless res == :error
+                end
               end
             end
+
+          else
+            if @connection.stream_features.has_key? 'bind'
+              iq = ::Jabber::Iq.new(:set)
+              bind = iq.add ::REXML::Element.new('bind')
+              bind.add_namespace @connection.stream_features['bind']
+              resource = bind.add ::REXML::Element.new('resource')
+              resource.text=jid.resource
+
+              send(iq) { |reply|
+                if reply.type == :result and jid = reply.first_element('//jid') and jid.text
+                  # log ['new jid is', jid.text].inspect
+                  @jid = ::Jabber::JID.new(jid.text)
+                end
+              }
+            end
+
+            if @connection.stream_features.has_key? 'session'
+              iq = ::Jabber::Iq.new(:set)
+              session = iq.add ::REXML::Element.new('session')
+              session.add_namespace @connection.stream_features['session']
+
+              send(iq) { |reply|
+                if reply.type == :result
+                  on(:login, stanza)
+                end
+              }
+            end
           end
-          
-        else
-          if @connection.stream_features.has_key? 'bind'
-            iq = Jabber::Iq.new(:set)
-            bind = iq.add REXML::Element.new('bind')
-            bind.add_namespace @connection.stream_features['bind']            
-            resource = bind.add REXML::Element.new('resource')
-            resource.text=jid.resource
-            
-            send(iq){ |reply|
-              if reply.type == :result and jid = reply.first_element('//jid') and jid.text
-                # log ['new jid is', jid.text].inspect
-                @jid = Jabber::JID.new(jid.text)
-              end
-            }
-          end
-          
-          if @connection.stream_features.has_key? 'session'
-            iq = Jabber::Iq.new(:set)
-            session = iq.add REXML::Element.new('session')
-            session.add_namespace @connection.stream_features['session']
-            
-            send(iq){ |reply|
-              if reply.type == :result
-                on(:login, stanza)
-              end
-            }
-          end
-        end
-        
-        return true
-        
+
+          return true
+
         when 'success', 'failure'
-        if stanza.name == 'success'
-          @authenticated = true
-          @connection.reset_parser
-          @connection.init
-        end
-        
-        @auth_callback.call(stanza.name.to_sym) if @auth_callback
-        return true
+          if stanza.name == 'success'
+            @authenticated = true
+            @connection.reset_parser
+            @connection.init
+          end
+
+          @auth_callback.call(stanza.name.to_sym) if @auth_callback
+          return true
       end
       false
-    end    
-    
+    end
+
   end
 end

data/lib/xmpp4em/component.rb

@@ -1,45 +1,44 @@
 #encoding: utf-8
 
 module XMPP4EM
-  
-  class Component < BaseClient    
+
+  class Component < BaseClient
     def initialize user, pass, opts = {}
       super
     end
-   
+
     def jid
-      @jid ||= @user.kind_of?(Jabber::JID) ? @user :  Jabber::JID.new(@user)               
+      @jid ||= @user.kind_of?(::Jabber::JID) ? @user : ::Jabber::JID.new(@user)
     end
-    
+
     def connect host = jid.domain, port = 5222
-      EM.connect host, port, ComponentConnection, jid.domain, port do |conn|
+      ::EM.connect host, port, ComponentConnection, jid.domain, port do |conn|
         @connection = conn
         conn.client = self
       end
     end
-    
+
     def receive_stanza(stanza)
-      
       case stanza.name
         when 'stream'
-        if !@authenticated && jid.domain == stanza.attributes['from']
-          streamid = stanza.attributes['id']
-          hash = Digest::SHA1::hexdigest(streamid.to_s + @pass)      
-          send("<handshake>#{hash}</handshake>")          
-        end
-        return true
-        when 'not-authorized'  
-        on(:error, 'not-authorized')
-        return true
-        when 'handshake'        
-        @authenticated = true
-        on(:login, stanza)
-        return true
-      end  
-      
+          if !@authenticated && jid.domain == stanza.attributes['from']
+            streamid = stanza.attributes['id']
+            hash = Digest::SHA1::hexdigest(streamid.to_s + @pass)
+            send("<handshake>#{hash}</handshake>")
+          end
+          return true
+        when 'not-authorized'
+          on(:error, 'not-authorized')
+          return true
+        when 'handshake'
+          @authenticated = true
+          on(:login, stanza)
+          return true
+      end
+
       false
-      
+
     end
-    
+
   end
 end

metadata

@@ -1,62 +1,59 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: xmpp4em
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 2
-  - 0
-  version: 0.2.0
+version: !ruby/object:Gem::Version
+  version: 0.2.3
+  prerelease: !!null 
 platform: ruby
-authors: 
+authors:
 - Aman Gupta
 - Kokorin Denis
-autorequire: 
+autorequire: !!null 
 bindir: bin
 cert_chain: []
-
-date: 2010-04-21 00:00:00 +04:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-09-07 00:00:00.000000000 +04:00
+default_executable: !!null 
+dependencies:
+- !ruby/object:Gem::Dependency
   name: eventmachine
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 12
-        - 10
-        version: 0.12.10
+  requirement: &11578068 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: *11578068
+- !ruby/object:Gem::Dependency
   name: xmpp4r
+  requirement: &11577696 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 5
-        version: "0.5"
+  version_requirements: *11577696
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: &11577408 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id002
+  prerelease: false
+  version_requirements: *11577408
 description: Simple XMPP client and component built on EventMachine.
 email: mccoder-nospam@ya.ru
 executables: []
-
 extensions: []
-
-extra_rdoc_files: []
-
-files: 
+extra_rdoc_files:
 - README.md
-- Rakefile
 - History.txt
+files:
 - lib/xmpp4em/base_client.rb
 - lib/xmpp4em/base_connection.rb
 - lib/xmpp4em/client.rb
@@ -66,38 +63,31 @@ files:
 - lib/xmpp4em.rb
 - examples/component_test.rb
 - examples/stress_test.rb
-- spec/spec_runner.rb
-- spec/xmpp4em_spec.rb
+- README.md
+- History.txt
 has_rdoc: true
 homepage: http://github.com/mccoder/xmpp4em
 licenses: []
-
-post_install_message: 
+post_install_message: !!null 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ~>
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 1
-      - 9
-      version: "1.9"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: 
-rubygems_version: 1.3.6
-signing_key: 
+rubyforge_project: !!null 
+rubygems_version: 1.5.0
+signing_key: !!null 
 specification_version: 3
 summary: EventMachine based XMPP client and component
 test_files: []
-

data/Rakefile

@@ -1,5 +0,0 @@
-task :default do
-  Dir.chdir('spec'){
-    sh 'bacon spec_runner.rb'
-  }
-end

data/spec/spec_runner.rb

@@ -1,26 +0,0 @@
-require 'bacon'
-$:.unshift File.dirname(__FILE__) + '/..'
-require 'xmpp4em'
-
-shared 'eventmachine' do
-  $bacon_thread = Thread.current
-  def wait
-    Thread.stop
-    @timer = EM::Timer.new(10) do
-      wake
-      should.flunk('waited too long')
-    end
-  end
-  def wake
-    $bacon_thread.wakeup
-    @timer.cancel if @timer
-  end
-end
-
-EM.run{
-  Thread.new{
-    Thread.abort_on_exception = true
-    require 'xmpp4em_spec'
-    EM.stop_event_loop
-  }
-}

data/spec/xmpp4em_spec.rb

@@ -1,57 +0,0 @@
-describe 'XMPP4EM' do
-  behaves_like 'eventmachine'
-
-  @foo = XMPP4EM::Client.new('foo@localhost', 'test', :auto_register => true)
-  @bar = XMPP4EM::Client.new('bar@localhost', 'test', :auto_register => true)
-
-  should 'login to an xmpp server' do
-    @foo.on(:login) do
-      @foo.send Jabber::Presence.new
-      wake
-    end
-
-    @foo.connect
-    wait
-
-    @foo.should.be.connected?
-  end
-
-  should 'send messages to others' do
-    @bar.on(:login) do
-      @bar.send Jabber::Presence.new do
-        wake
-      end
-    end
-
-    received = nil
-    @bar.on(:message) do |msg|
-      received = msg.first_element_text('//body')
-      wake
-    end
-
-    @bar.connect
-    wait
-
-    @foo.send_msg 'bar@localhost', 'hello'
-    wait
-
-    received.should == 'hello'
-  end
-
-  should 'fire disconnect callback and reconnect' do
-    user = XMPP4EM::Client.new('user@localhost', 'user', :auto_register => true)
-    user.on(:disconnect){ wake }
-    user.connect 'localhost', 5333 # invalid port
-    wait
-
-    user.should.not.be.connected?
-
-    user.instance_variable_get('@callbacks')[:disconnect] = []
-    user.connection.port = 5222
-    user.on(:login){ wake }
-    user.reconnect
-    wait
-
-    user.should.be.connected?
-  end
-end