xmpp-agent 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: cc18c3e39574543fd3941ec362455ad1de84f879
-  data.tar.gz: 0814d2fd8695a4b085495ea7423a1f3f97e7d4f6
+SHA256:
+  metadata.gz: 577bb2cc12f813639ee3d0b732b0809f26a0acb38fe23d4bcfc7a3b56966adbb
+  data.tar.gz: 8a35a77d8e4d593d1cda6b7d7d881011bfffef1a323f57a52afb0300c692e06f
 SHA512:
-  metadata.gz: 8cc44846f6d4fe645e779602a6ec18ecc31d68d3dfe8b09e4eb20ee81504063696c33b68ddbd96168d92363f5584c7b17566f162eb9211d8e76256b36fad2bee
-  data.tar.gz: 00819f6dc86d2739d5c787cf471787e8c2b82f0ec3766af63ab766f96354b3f836dbd12cd15d9e5fe3c64b0fd9d652586c0d41e05b8f69d418aaca29ab01da72
+  metadata.gz: 7db481786756250f1dc7b60bb6be95c73d337860db32dc27f120d6b38504b681e68650c77547905df7482b7ce964936a896b9f98a29b354f92f5fe189fc3dfbf
+  data.tar.gz: 5a25264b3e434b5c30b73f7e1331f0041dfe107d5058e62153f9c5dd319f84b10fc86d6f6439c05608b524a2874e7b33aecd2d3f0df74538749541bd35ac0ef6

data/lib/xmpp-agent.rb

@@ -2,62 +2,98 @@
 
 # file: xmpp-agent.rb
 
-require 'em-xmpp'
+require "xrc"
 require 'app-routes'
 
+
 class XMPPAgent
   include AppRoutes
   
-  def initialize()
-    @routes = {}; @params = {}; @conn = nil; @ctx = nil    
-    super()    
-  end
+  attr_reader :client
   
-  def received(conn,ctx)
+  def initialize(jid: '', password: '', port: 5222, host: nil, debug: false, callback: nil)
+    
+    @routes = {}; @params = {}; msg = nil  
+    @debug = debug
+    
+    super()
+    
+    h = {
+      jid: @jid = jid,
+      password: password,
+      port: port
+    }
+    
+    h.merge!({hosts: [ host ]}) if host
 
-    @conn = conn
-    @ctx = ctx
-    messages(@params, @conn, @ctx)
-    run_route ctx.body.strip   
-  end
+    @client = client = Xrc::Client.new(h)
+            
+    @client.on_private_message do |message|
+
+      messages(@params, client, message)
+      run_route message.body.strip              
+
+    end            
+    
+    @client.on_connection_established do
+
+      on_connected()
 
-  def messages(params, conn, ctx)
+    end                
+    
+    @client.on_event do |e|
+
+      if e.name.to_s == 'presence' then
+        on_presence_update(show=e.text('show'), status=e.text('status'), user=e.attributes['from'] )
+      end
+      
+    end
+
+    
+  end
+            
+  def connect()
+    @client.connect
+  end
+  
+  protected
+  
+  def on_connected()
+  end
+  
+  def on_presence_update(show, status, user)
+  end  
+  
+  private
+                        
+  def messages(params, client, msg)
 
     message %r{(send_to|send2)\s+([^\s]+)\s+(.*)} do
 
-      user, message = params[:captures].values_at 1,2
-      data = conn.message_stanza('to' => user) {|xml| xml.body(message) }       
-      conn.send_stanza data
+      user, msgout = params[:captures].values_at 1,2            
+
+      client.say(body: msgout, from: @jid, to: user, type: "chat")            
     end
 
     message 'help' do
-      data = conn.message_stanza('to' => ctx.from) do |xml| 
-          xml.body('available commands: help, send_to')
-      end      
-      conn.send_stanza data
+      msgout = 'available commands: help, send_to'
+      client.reply(body: msgout, to: msg)            
     end
 
     message '.*' do
 
-      data = conn.message_stanza('to' => ctx.from) do |xml| 
-          xml.body('need some help? type help')
-      end            
-      conn.send_stanza data
+      msgout = 'need some help? type help'
+      client.reply(body: msgout, to: msg)                        
     end
 
   end  
   
   def add_route(arg)
-    get(arg) {yield(@params, @conn, @ctx)}
+    get(arg) {yield(@params, @client, @msg)}
   end
   
   def message(route, &blk)
     get(route, &blk)
-  end
-  
-  def conn() @conn end
-  
-  def presence_update(ctx)
-  end
+  end  
 
 end 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: xmpp-agent
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - James Robertson
@@ -10,65 +10,80 @@ bindir: bin
 cert_chain:
 - |
   -----BEGIN CERTIFICATE-----
-  MIIDljCCAn6gAwIBAgIBATANBgkqhkiG9w0BAQUFADBIMRIwEAYDVQQDDAlnZW1t
-  YXN0ZXIxHjAcBgoJkiaJk/IsZAEZFg5qYW1lc3JvYmVydHNvbjESMBAGCgmSJomT
-  8ixkARkWAmV1MB4XDTE0MDQwNTE5MjM1OVoXDTE1MDQwNTE5MjM1OVowSDESMBAG
-  A1UEAwwJZ2VtbWFzdGVyMR4wHAYKCZImiZPyLGQBGRYOamFtZXNyb2JlcnRzb24x
-  EjAQBgoJkiaJk/IsZAEZFgJldTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC
-  ggEBAL0Uq28c4pfHfHXtX03cuOL4svrytTcBVcAT0CMrQLWkp9exVzFEic6sK6w1
-  Gjfycf39ij1yFLEvR5rhZSL8qB+U+C7mjM5O2d1O4RB1sTQzs2bsEHx5Xvt9gY6b
-  4icqnJNfDpWdN4dCchhinYVet+MSOfwTrk6cSdeupKkLAJqzn7ckOLS6YGjvChGd
-  slsFgEO3Di50HGpYbky9AwfSrRtps6MjsOl/uedr+FPLT/nP894HAXJt5HHwj79j
-  tLHHM8FrWQokPBf2cVgWC2Rn5LghEo3IHD3En4nZKqJRJkd2zGkK03L2KSj1e2jN
-  aVQYzv8ARVXkg6NhmIIbkXjYKO8CAwEAAaOBijCBhzAJBgNVHRMEAjAAMAsGA1Ud
-  DwQEAwIEsDAdBgNVHQ4EFgQUHNdoeObmaJOyyCZrjWBargjqkiowJgYDVR0RBB8w
-  HYEbZ2VtbWFzdGVyQGphbWVzcm9iZXJ0c29uLmV1MCYGA1UdEgQfMB2BG2dlbW1h
-  c3RlckBqYW1lc3JvYmVydHNvbi5ldTANBgkqhkiG9w0BAQUFAAOCAQEARN5IbndL
-  vLnc2DlGh2kB9tcTSamlUM4bGke+GmItqk1IHfHFIvnCQU6WasCvi5sz2IifrBJ0
-  gAQGclMgasc/5YiRVRbLxTk8Cf9iJ39YpCk6xwVc2py/0g+B9k7ahk/Y0/QBYJug
-  VhnqZ064ebat8mLAHP+dL44SoMFsKGScYR5/RnjhQnONvg5xPuOg7wpXv9dz9TzL
-  Xq/YKsl9GmhmsDj/Wy9ugRxGupRi4CaUo2ZWz6YAjE7u3Y4x2AuYPFSmKPFg4WpJ
-  dK8nOI/ggrVJPOIbhAfE35/0QJ5Jec4k2Z1lGL+tzA//Tl8XlGDhTqcfVqnPwPxM
-  GiPYMZ7fiR8BAw==
+  MIIEXjCCAsagAwIBAgIBATANBgkqhkiG9w0BAQsFADAsMSowKAYDVQQDDCFnZW1t
+  YXN0ZXIvREM9amFtZXNyb2JlcnRzb24vREM9ZXUwHhcNMTkwOTIxMjMxNzMxWhcN
+  MjAwOTIwMjMxNzMxWjAsMSowKAYDVQQDDCFnZW1tYXN0ZXIvREM9amFtZXNyb2Jl
+  cnRzb24vREM9ZXUwggGiMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQDtgFiq
+  +G7z+lIkbabWI1SzgWk9rBl8iI85tELX3YFvz4ayg7DX+NuHC/X720NBXTEppcf8
+  NWNtopq2XXCHlPerLKQFa4InW2O+AvOyTtitCR+Sza3zKxk3gUw2ToddLvwWk6cD
+  ZP+FCorucGhDhGCGABM9BEGMSkJG9Lod3MvHXVS/oLHhPvqaYAaZECH1khWL7RWM
+  jAqBvU/A00xN7jOJVBkH+UA9EyVL2lk7830P8D+5jhERAc/XLX2q+I2sdsFn6Wor
+  wxkfCTU/rL+eDS/gOPeigMlYg1Mt4vjmEwK+8QNKqmONa2AYB3o15ejP0TrsZR72
+  3W1XFw2OIQG/01l89BgtaFRb4ylMGbHFpYNpNqEJumwksKgsTSZC5JeJyS9BnCeV
+  gcjV+DxwN+smzXrEeV8d3vr0u6tgVQPjF+qvy4rRvJ9lqZUAiml69Izd2oFEHXKo
+  kgwxCMzMFOW3xa9J6g0j7rkhz9GJxKeEaM2eL33cE/LhUcAC/ifbkQxzBQECAwEA
+  AaOBijCBhzAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQU/0itzTBw
+  3QvdhrAlvTjNB+5tAVkwJgYDVR0RBB8wHYEbZ2VtbWFzdGVyQGphbWVzcm9iZXJ0
+  c29uLmV1MCYGA1UdEgQfMB2BG2dlbW1hc3RlckBqYW1lc3JvYmVydHNvbi5ldTAN
+  BgkqhkiG9w0BAQsFAAOCAYEAAxdl3NXLewgOSwPtfdtQqhRDMoFlziIB0es/atjt
+  Hn7M7sV0rXG46qNiAuS33aoSI3lxf+ylHFonhwnyO8I0wfAq46pRxyEA4Xswmhzz
+  Nk4lRCJym7DGrPuciNZKJt8EEMLny9UBZUQGPlAnayqcLYWhTWCLU9G/xbka2chI
+  wM5OZO2ubW1HN1kqvLzh8zAxJKAxxuwkGAlQczmbnatp+ZpTLJ2jRMCK/d+G0yos
+  j8lmbAVbxD+f1fB1+P4/DvpKlN2h8HxdDirdbWjE+6QvgSE9cymnhz5Qgc1EwbR+
+  HrlBlt200+/DSQvjwXFY3+T+NPT4ESPe1cHPtkce8xNPbNLgKu7Qr9GZP/XqUGJn
+  71RBgFbe7Wp4fFf1dj6v8xgG+uqxCVtK4LbHgCYqnmWvCfD9x3jhBTfwzPUJHQSR
+  9Eg9Gbw3IF8iMcIPwTT7WTzb3vLw4+o6hP8oRi2CD1KB4KMDSxn4li5v8VuGdZ1o
+  ZPG6kphiEV/Pdc0QAh4qYhIN
   -----END CERTIFICATE-----
-date: 2014-04-05 00:00:00.000000000 Z
+date: 2019-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: em-xmpp
+  name: xrc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.11
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.11
+        version: 0.1.8
 - !ruby/object:Gem::Dependency
   name: app-routes
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.19
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.19
 description: 
-email: james@r0bertson.co.uk
+email: james@jamesrobertson.eu
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/xmpp-agent.rb
-- lib/xmpp4r-simple.rb
 homepage: https://github.com/jrobertson/xmpp-agent
 licenses:
 - MIT
@@ -81,16 +96,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.1.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: xmpp-agent
+summary: Uses the Xrc gem to build a simple XMPP client.
 test_files: []

data/lib/xmpp4r-simple.rb

@@ -1,494 +0,0 @@
-# Jabber::Simple - An extremely easy-to-use Jabber client library.
-# Copyright 2006 Blaine Cook <blaine@obvious.com>, Obvious Corp.
-# 
-# Jabber::Simple is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-# 
-# Jabber::Simple is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-# 
-# You should have received a copy of the GNU General Public License
-# along with Jabber::Simple; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
-require 'rubygems'
-require 'xmpp4r'
-require 'xmpp4r/roster'
-require 'xmpp4r/vcard'
-
-module Jabber
-
-  class ConnectionError < StandardError #:nodoc:
-  end
-  
-  class Contact #:nodoc:
-
-    include DRb::DRbUndumped if defined?(DRb::DRbUndumped)
-
-    def initialize(client, jid)
-      @jid = jid.respond_to?(:resource) ? jid : JID.new(jid)
-      @client = client
-    end
-
-    def inspect
-      "Jabber::Contact #{jid.to_s}"
-    end
-
-    def subscribed?
-      [:to, :both].include?(subscription)
-    end
-
-    def subscription
-      roster_item && roster_item.subscription
-    end
-
-    def ask_for_authorization!
-      subscription_request = Presence.new.set_type(:subscribe)
-      subscription_request.to = jid
-      client.send!(subscription_request)
-    end
-    
-    def unsubscribe!
-      unsubscription_request = Presence.new.set_type(:unsubscribe)
-      unsubscription_request.to = jid
-      client.send!(unsubscription_request)
-      client.send!(unsubscription_request.set_type(:unsubscribed))
-    end
-
-    def jid(bare=true)
-      bare ? @jid.strip : @jid
-    end
-
-    private
-
-    def roster_item
-      client.roster.items[jid]
-    end
-   
-    def client
-      @client
-    end
-  end
-
-  class Simple
-
-    include DRb::DRbUndumped if defined?(DRb::DRbUndumped)
-
-    # Create a new Jabber::Simple client. You will be automatically connected
-    # to the Jabber server and your status message will be set to the string
-    # passed in as the status_message argument.
-    #
-    # jabber = Jabber::Simple.new("me@example.com", "password", "Chat with me - Please!")
-    def initialize(jid, password, status = nil, status_message = "Available")
-      @jid = jid
-      @password = password
-      @disconnected = false
-      status(status, status_message)
-      start_deferred_delivery_thread
-    end
-
-    def inspect #:nodoc:
-      "Jabber::Simple #{@jid}"
-    end
-    
-    # Send a message to jabber user jid.
-    #
-    # Valid message types are:
-    # 
-    #   * :normal (default): a normal message.
-    #   * :chat: a one-to-one chat message.
-    #   * :groupchat: a group-chat message.
-    #   * :headline: a "headline" message.
-    #   * :error: an error message.
-    #
-    # If the recipient is not in your contacts list, the message will be queued
-    # for later delivery, and the Contact will be automatically asked for
-    # authorization (see Jabber::Simple#add).
-    #
-    # message should be a string or a valid Jabber::Message object. In either case,
-    # the message recipient will be set to jid.
-    def deliver(jid, message, type=:chat)
-      contacts(jid) do |friend|
-        unless subscribed_to? friend
-          add(friend.jid)
-          return deliver_deferred(friend.jid, message, type)
-        end
-        if message.kind_of?(Jabber::Message)
-          msg = message
-          msg.to = friend.jid
-        else
-          msg = Message.new(friend.jid)
-          msg.type = type
-          msg.body = message
-        end
-        send!(msg)
-      end
-    end
-
-    # Set your presence, with a message.
-    #
-    # Available values for presence are:
-    # 
-    #   * nil: online.
-    #   * :chat: free for chat.
-    #   * :away: away from the computer.
-    #   * :dnd: do not disturb.
-    #   * :xa: extended away.
-    #
-    # It's not possible to set an offline status - to do that, disconnect! :-)
-    def status(presence, message)
-      @presence = presence
-      @status_message = message
-      stat_msg = Presence.new(@presence, @status_message)
-      send!(stat_msg)
-    end
-
-    # Ask the users specified by jids for authorization (i.e., ask them to add
-    # you to their contact list). If you are already in the user's contact list,
-    # add() will not attempt to re-request authorization. In order to force
-    # re-authorization, first remove() the user, then re-add them.
-    #
-    # Example usage:
-    # 
-    #   jabber_simple.add("friend@friendosaurus.com")
-    #
-    # Because the authorization process might take a few seconds, or might
-    # never happen depending on when (and if) the user accepts your
-    # request, results are placed in the Jabber::Simple#new_subscriptions queue.
-    def add(*jids)
-      contacts(*jids) do |friend|
-        next if subscribed_to? friend
-        friend.ask_for_authorization!
-      end
-    end
-
-    # Remove the jabber users specified by jids from the contact list.
-    def remove(*jids)
-      contacts(*jids) do |unfriend|
-        unfriend.unsubscribe!
-      end
-    end
-
-    # Returns true if this Jabber account is subscribed to status updates for
-    # the jabber user jid, false otherwise.
-    def subscribed_to?(jid)
-      contacts(jid) do |contact|
-        return contact.subscribed?
-      end
-    end
-
-    # If contacts is a single contact, returns a Jabber::Contact object
-    # representing that user; if contacts is an array, returns an array of
-    # Jabber::Contact objects.
-    #
-    # When called with a block, contacts will yield each Jabber::Contact object
-    # in turn. This is mainly used internally, but exposed as an utility
-    # function.
-    def contacts(*contacts, &block)
-      @contacts ||= {}
-      contakts = []
-      contacts.each do |contact|
-        jid = contact.to_s
-        unless @contacts[jid]
-          @contacts[jid] = contact.respond_to?(:ask_for_authorization!) ? contact : Contact.new(self, contact)
-        end
-        yield @contacts[jid] if block_given?
-        contakts << @contacts[jid]
-      end
-      contakts.size > 1 ? contakts : contakts.first
-    end
-
-    # Returns true if the Jabber client is connected to the Jabber server,
-    # false otherwise.
-    def connected?
-      @client ||= nil
-      connected = @client.respond_to?(:is_connected?) && @client.is_connected?
-      return connected
-    end
-
-    # Returns an array of messages received since the last time
-    # received_messages was called. Passing a block will yield each message in
-    # turn, allowing you to break part-way through processing (especially
-    # useful when your message handling code is not thread-safe (e.g.,
-    # ActiveRecord).
-    #
-    # e.g.:
-    #
-    #   jabber.received_messages do |message|
-    #     puts "Received message from #{message.from}: #{message.body}"
-    #   end
-    def received_messages(&block)
-      dequeue(:received_messages, &block)
-    end
-
-    # Returns true if there are unprocessed received messages waiting in the
-    # queue, false otherwise.
-    def received_messages?
-      !queue(:received_messages).empty?
-    end
-
-    # Returns an array of presence updates received since the last time
-    # presence_updates was called. Passing a block will yield each update in
-    # turn, allowing you to break part-way through processing (especially
-    # useful when your presence handling code is not thread-safe (e.g.,
-    # ActiveRecord).
-    #
-    # e.g.:
-    #
-    #   jabber.presence_updates do |friend, new_presence|
-    #     puts "Received presence update from #{friend}: #{new_presence}"
-    #   end
-    def presence_updates(&block)
-      updates = []
-      @presence_mutex.synchronize do
-        dequeue(:presence_updates) do |friend|
-          presence = @presence_updates[friend]
-          next unless presence
-          new_update = [friend, presence[0], presence[1]]
-          yield new_update if block_given?
-          updates << new_update
-          @presence_updates.delete(friend)
-        end
-      end
-      return updates
-    end
-    
-    # Returns true if there are unprocessed presence updates waiting in the
-    # queue, false otherwise.
-    def presence_updates?
-      !queue(:presence_updates).empty?
-    end
-
-    # Returns an array of subscription notifications received since the last
-    # time new_subscriptions was called. Passing a block will yield each update
-    # in turn, allowing you to break part-way through processing (especially
-    # useful when your subscription handling code is not thread-safe (e.g.,
-    # ActiveRecord).
-    #
-    # e.g.:
-    #
-    #   jabber.new_subscriptions do |friend, presence|
-    #     puts "Received presence update from #{friend.to_s}: #{presence}"
-    #   end
-    def new_subscriptions(&block)
-      dequeue(:new_subscriptions, &block)
-    end
-    
-    # Returns true if there are unprocessed presence updates waiting in the
-    # queue, false otherwise.
-    def new_subscriptions?
-      !queue(:new_subscriptions).empty?
-    end
-    
-    # Returns an array of subscription notifications received since the last
-    # time subscription_requests was called. Passing a block will yield each update
-    # in turn, allowing you to break part-way through processing (especially
-    # useful when your subscription handling code is not thread-safe (e.g.,
-    # ActiveRecord).
-    #
-    # e.g.:
-    #
-    #   jabber.subscription_requests do |friend, presence|
-    #     puts "Received presence update from #{friend.to_s}: #{presence}"
-    #   end
-    def subscription_requests(&block)
-      dequeue(:subscription_requests, &block)
-    end
- 
-    # Returns true if auto-accept subscriptions (friend requests) is enabled
-    # (default), false otherwise.
-    def accept_subscriptions?
-      @accept_subscriptions = true if @accept_subscriptions.nil?
-      @accept_subscriptions
-    end
-
-    # Change whether or not subscriptions (friend requests) are automatically accepted.
-    def accept_subscriptions=(accept_status)
-      @accept_subscriptions = accept_status
-    end
-    
-    # Direct access to the underlying Roster helper.
-    def roster
-      return @roster if @roster
-      self.roster = Roster::Helper.new(client)
-    end
-
-    # Direct access to the underlying Jabber client.
-    def client
-      connect!() unless connected?
-      @client
-    end
-    
-    # Send a Jabber stanza over-the-wire.
-    def send!(msg)
-      attempts = 0
-      begin
-        attempts += 1
-        client.send(msg)
-      rescue Errno::EPIPE, IOError => e
-        sleep 1
-        disconnect
-        reconnect
-        retry unless attempts > 3
-        raise e
-      rescue Errno::ECONNRESET => e
-        sleep (attempts^2) * 60 + 60
-        disconnect
-        reconnect
-        retry unless attempts > 3
-        raise e
-      end
-    end
-
-    # Use this to force the client to reconnect after a force_disconnect.
-    def reconnect
-      @disconnected = false
-      connect!
-    end
-
-    # Use this to force the client to disconnect and not automatically
-    # reconnect.
-    def disconnect
-      disconnect!
-    end
-    
-    # Queue messages for delivery once a user has accepted our authorization
-    # request. Works in conjunction with the deferred delivery thread.
-    #
-    # You can use this method if you want to manually add friends and still
-    # have the message queued for later delivery.
-    def deliver_deferred(jid, message, type)
-      msg = {:to => jid, :message => message, :type => type}
-      queue(:pending_messages) << [msg]
-    end
-
-    private
-
-    def client=(client)
-      self.roster = nil # ensure we clear the roster, since that's now associated with a different client.
-      @client = client
-    end
-
-    def roster=(new_roster)
-      @roster = new_roster
-    end
-
-    def connect!
-      raise ConnectionError, "Connections are disabled - use Jabber::Simple::force_connect() to reconnect." if @disconnected
-      # Pre-connect
-      @connect_mutex ||= Mutex.new
-
-      # don't try to connect if another thread is already connecting.
-      return if @connect_mutex.locked?
-
-      @connect_mutex.lock
-      disconnect!(false) if connected?
-
-      # Connect
-      jid = JID.new(@jid)
-      my_client = Client.new(@jid)
-      my_client.connect
-      my_client.auth(@password)
-      self.client = my_client
-
-      # Post-connect
-      register_default_callbacks
-      status(@presence, @status_message)
-      @connect_mutex.unlock
-    end
-
-    def disconnect!(auto_reconnect = true)
-      if client.respond_to?(:is_connected?) && client.is_connected?
-        begin
-          client.close
-        rescue Errno::EPIPE, IOError => e
-          # probably should log this.
-          nil
-        end
-      end
-      client = nil
-      @disconnected = auto_reconnect
-    end
-
-    def register_default_callbacks
-      client.add_message_callback do |message|
-        queue(:received_messages) << message unless message.body.nil?
-      end
-
-      roster.add_subscription_callback do |roster_item, presence|
-        if presence.type == :subscribed
-          queue(:new_subscriptions) << [roster_item, presence]
-        end
-      end
-
-      roster.add_subscription_request_callback do |roster_item, presence|
-        if accept_subscriptions?
-          roster.accept_subscription(presence.from) 
-        else
-          queue(:subscription_requests) << [roster_item, presence]
-        end
-      end
-
-      @presence_updates = {}
-      @presence_mutex = Mutex.new
-      roster.add_presence_callback do |roster_item, old_presence, new_presence|
-        simple_jid = roster_item.jid.strip.to_s
-        presence = case new_presence.type
-                   when nil
-                     new_presence.show || :online
-                   when :unavailable
-		     :unavailable
-                   else
-                     nil
-                   end
-
-        if presence && @presence_updates[simple_jid] != presence
-          queue(:presence_updates) << simple_jid
-          @presence_mutex.synchronize { @presence_updates[simple_jid] = [presence, new_presence.status] }
-        end
-      end
-    end
-
-    # This thread facilitates the delivery of messages to users who haven't yet
-    # accepted an invitation from us. When we attempt to deliver a message, if
-    # the user hasn't subscribed, we place the message in a queue for later
-    # delivery. Once a user has accepted our authorization request, we deliver
-    # any messages that have been queued up in the meantime.
-    def start_deferred_delivery_thread #:nodoc:
-      Thread.new {
-        loop {
-          messages = [queue(:pending_messages).pop].flatten
-          messages.each do |message|
-            if subscribed_to?(message[:to])
-              deliver(message[:to], message[:message], message[:type])
-            else
-              queue(:pending_messages) << message
-            end
-          end
-        }
-      }
-    end
-
-    def queue(queue)
-      @queues ||= Hash.new { |h,k| h[k] = Queue.new }
-      @queues[queue]
-    end
-
-    def dequeue(queue, non_blocking = true, max_items = 100, &block)
-      queue_items = []
-      max_items.times do
-        queue_item = queue(queue).pop(non_blocking) rescue nil
-        break if queue_item.nil?
-        queue_items << queue_item
-        yield queue_item if block_given?
-      end
-      queue_items
-    end
-  end
-end
-
-true