ahoy 0.0.2 → 0.1.0

data/lib/ahoy.rb

@@ -8,11 +8,7 @@ end
 module Ahoy
   SERVICE_TYPE = "_presence._tcp"
   
-  def self.more_coming?(reply)
-    reply.flags.to_i & DNSSD::Flags::MoreComing > 0
-  end
-  
-  def self.add?(reply)
-    reply.flags.to_i & DNSSD::Flags::Add > 0
+  class << self
+    attr_accessor :use_markdown # default for Chat#use_markdown
   end
 end

data/lib/ahoy/broadcast.rb

@@ -1,13 +1,31 @@
 require File.expand_path("#{File.dirname(__FILE__)}/../ahoy")
 
 module Ahoy
+  
+  # Ahoy::Broadcast provides a simple interface to send a message to all online
+  # users. Example:
+  #   user = Ahoy::User.new("Dr. Nick")
+  #   cast = Ahoy::Broadcast.new(user)
+  #   
+  #   cast.send("Hi, everybody!")
+  #   cast.close
+  # 
   class Broadcast
+    
+    # :call-seq: Broadcast.new(user) -> broadcast
+    # 
+    # Create a new Ahoy::Broadcast.
+    # 
     def initialize(user)
       user.sign_in
       sleep 1
       @chats = user.contacts.map {|contact| user.chat(contact)}
     end
     
+    # :call-seq: broadcast.send(string) -> array
+    # 
+    # Send string to all online contacts.
+    # 
     def send(message)
       @chats.each do |chat|
         begin
@@ -18,6 +36,10 @@ module Ahoy
       end
     end
     
+    # :call-seq: broadcast.close -> close
+    # 
+    # End all chats.
+    # 
     def close
       @chats.each {|chat| chat.close}
     end

data/lib/ahoy/chat.rb

@@ -1,44 +1,68 @@
 require 'rubygems'
 require 'xmpp4r'
-require File.expand_path("#{File.dirname(__FILE__)}/xmpp4r_hack")
 
 module Ahoy
+  
+  # Ahoy::Chat models a conversation between the user and one of their contacts.
+  # It can be thought of as representing an iChat chat window, or treated more
+  # like a Ruby socket.
+  # 
   class Chat
-    attr_reader :user, :contact
-    attr_accessor :client
-    protected :client, :client=
+    attr_reader :contact_name
     
-    def initialize(user, contact)
-      @user = user
-      @contact = contact
+    # :call-seq: Chat.new(contact_name) -> chat
+    # 
+    # Create a new Ahoy::Chat.
+    # 
+    def initialize(contact_name)
+      @contact_name = contact_name
       @client = nil
+      self.use_markdown = Ahoy.use_markdown
+    end
+    
+    # :call-seq: chat.connect(target, port) -> chat
+    # chat.connect(socket) -> chat
+    # 
+    # Connect to target on port, or use the connection provided by socket.
+    # 
+    def connect(host, port=nil)
+      if host.respond_to?(:read) && host.respond_to?(:write)
+        connect_with(host)
+      else
+        begin
+          client.connect(host, port)
+        rescue Errno::ECONNREFUSED
+          raise Ahoy::ContactOfflineError.new("Contact Offline")
+        end
+      end
+      self
     end
     
-    # May raise Ahoy::ContactOfflineError
+    # :call-seq: chat.connected? -> bool
     # 
-    def start
-      user.contact.resolve.getaddrinfo
-      connect
+    def connected?
+      client.is_connected?
     end
     
-    # May raise Ahoy::ContactOfflineError
+    # :call-seq: chat.send(string) -> message
+    # 
+    # Send string to contact. May raise Ahoy::ContactOfflineError.
     # 
-    def send(message)
-      start unless client
+    def send(text)
+      raise Ahoy::NotConnectedError.new("Not Connected") unless connected?
       
-      message = Jabber::Message.new(contact.name, message)
+      message = Jabber::Message.new(contact_name, text)
       message.type = :chat
-      begin
-        client.send(message)
-      rescue IOError
-        connect
-        retry
-      end
+      markdown(message) if markdown?
+      client.send(message)
       message
     end
     
+    # :call-seq: chat.on_reply {|string| block }
+    # 
+    # Set up block as a callback for when a message is received.
+    # 
     def on_reply(&block)
-      start unless client
       client.delete_message_callback("on_reply")
       
       client.add_message_callback(0, "on_reply") do |message|
@@ -46,8 +70,12 @@ module Ahoy
       end
     end
     
-    def receive
-      start unless client
+    # :call-seq: chat.receive -> string
+    # 
+    # Block until a message is received, then return the message body as a
+    # string.
+    # 
+    def receive(*ignore_args)
       thread = Thread.current
       reply = nil
       
@@ -62,23 +90,108 @@ module Ahoy
       client.delete_message_callback("receive")
       reply
     end
+    alias read receive
+    alias sysread receive
+    alias gets receive
+    alias readline receive
     
+    # :call-seq: chat.close -> nil
+    # 
+    # End the chat.
+    # 
     def close
       client.close
-      self.client = nil
+      @client = nil
     end
     
-    private
-    def connect
-      contact.resolve
-      
-      self.client = Jabber::Client.new(Jabber::JID.new(user.name))
-      sleep 0.5
-      begin
-        client.connect(contact.target, contact.port, user.contact.ip)
-      rescue Errno::ECONNREFUSED
-        raise Ahoy::ContactOfflineError.new("Contact Offline")
+    # :call-seq: chat.use_markdown = bool -> bool
+    # 
+    # Set true to send a html copy of messages, by interpreting the message text
+    # as markdown.
+    # 
+    def use_markdown=(value)
+      @use_markdown = value
+      if value && !markdown_processor
+        %W{rdiscount kramdown maruku bluecloth}.each do |lib|
+          begin
+            require lib
+            break
+          rescue LoadError
+          end
+        end
       end
+      value
+    end
+    
+    # :call-seq: chat.markdown? -> bool
+    # 
+    # Are messages sent to this chat being interpreted as markdown?
+    # 
+    def markdown?
+      @use_markdown && markdown_processor
+    end
+    alias use_markdown markdown?
+    
+    # :call-seq: chat << string -> chat
+    # 
+    # See #send
+    # 
+    def <<(string)
+      send(string)
+      self
+    end
+    
+    # :call-seq: chat.puts(string) -> nil
+    # 
+    # See #send
+    # 
+    def puts(string)
+      send(string)
+      nil
+    end
+    
+    # :call-seq: chat.write -> integer
+    # 
+    # See #send
+    # 
+    def write(string)
+      send(string)
+      string.length
+    end
+    alias syswrite write
+    
+    private
+    def connect_with(socket)
+      client.instance_variable_set(:@socket, socket)
+      client.start
+      client.accept_features
+      client.instance_variable_set(:@keepaliveThread, Thread.new do
+        Thread.current.abort_on_exception = true
+        client.__send__(:keepalive_loop)
+      end)
+    end
+    
+    def client
+      return @client if @client
+      @client = Jabber::Client.new(nil)
+      @client.features_timeout = 0.001
+      @client
+    end
+    
+    def markdown(message)
+      html = REXML::Element.new("html")
+      html.add_attribute("xmlns", "http://www.w3.org/1999/xhtml")
+      body = html.add_element("body")
+      markdown = markdown_processor.new(message.body)
+      body.add_element(REXML::Document.new(markdown.to_html))
+      message.add_element(html)
+    end
+    
+    def markdown_processor
+      return RDiscount if defined?(RDiscount)
+      return Kramdown::Document if defined?(Kramdown::Document)
+      return Maruku if defined?(Maruku)
+      return BlueCloth if defined?(BlueCloth)
     end
     
   end

data/lib/ahoy/contact.rb

@@ -2,56 +2,134 @@ require 'rubygems'
 require 'dnssd'
 
 module Ahoy
+  
+  # Ahoy::Contact represents another user or system, available to recieve
+  # messages, or who may send them to our user.
+  # 
   class Contact
-    attr_reader :name, :domain, :target, :ip, :port, :interface
+    attr_reader :name, :domain
     attr_accessor :online
+    alias online? online
     
-    def initialize(name, domain="local")
+    # :call-seq: Contact.new(name, domain="local.") -> contact
+    # 
+    # Create a new Ahoy::Contact. name should be in name@location format.
+    # 
+    def initialize(name, domain="local.")
       @name = name
       @domain = domain
       @target = nil
-      @ip = nil
       @port = nil
-      @interface = nil
+      @interface_addresses = {}
       @online = true
     end
     
+    # :call-seq: contact.fullname -> string
+    # 
+    # Returns the contact's full name in name@location.service.domain format
+    # 
     def fullname
       [name, Ahoy::SERVICE_TYPE, domain].join(".")
     end
     
-    def ==(other)
-      other.is_a?(self.class) && other.fullname == fullname
+    # :call-seq: contact.target -> string
+    # 
+    # Return the contact's target attribute. Pass true as the argument to use
+    # the cached value rather than looking it up.
+    # 
+    def target(use_cache=nil)
+      resolve(use_cache)
+      @target
     end
     
-    def online?
-      online
+    # :call-seq: contact.port -> string
+    # 
+    # Return the contact's port attribute. Pass true as the argument to use
+    # the cached value rather than looking it up.
+    # 
+    def port(use_cache=nil)
+      resolve(use_cache)
+      @port
     end
     
-    def resolve
-      service = DNSSD::Service.new
-      main = Thread.current
-      service.resolve(name, Ahoy::SERVICE_TYPE, domain) do |resolved|
-        next if Ahoy::more_coming?(resolved)
-        service.stop unless service.stopped?
+    # :call-seq: contact.interfaces -> array
+    # 
+    # Return the contact's interfaces. Pass true as the argument to use the
+    # cached value rather than looking it up.
+    # 
+    def interfaces(use_cache=nil)
+      resolve(use_cache)
+      @interface_addresses.keys
+    end
+    
+    # Internal use only.
+    # 
+    def add_interface(name) # :nodoc:
+      @interface_addresses[name] = [] unless @interface_addresses.key?(name)
+    end
+    
+    # :call-seq: contact.ip_addresses(interface=nil)
+    # 
+    # Returns all of contact's IP addresses, or if an interface is supplied as
+    # an argument, just the IP addresses for that interface.
+    # 
+    # Pass true as the second argument to prevent a lookup of interfaces, pass
+    # true as the third argument to prevent a lookup of IP addresses, and
+    # instead use the cached value.
+    # 
+    def ip_addresses(interface=nil, resolve_cache=nil, use_cache=nil)
+      getaddrinfo(resolve_cache) unless use_cache
+      if interface
+        @interface_addresses[interface]
+      else
+        @interface_addresses.values.flatten
+      end
+    end
+    
+    # :call-seq: contact == other_contact -> bool
+    # 
+    # Equality. Two contacts are equal if they have the same fullname (and
+    # therefore name, location, service, and domain).
+    # 
+    def ==(other)
+      other.is_a?(self.class) && other.fullname == fullname
+    end
+    
+    # :call-seq: contact.resolve -> contact
+    # 
+    # Determine and set the contact's target, port, and interfaces.
+    # 
+    def resolve(use_cache=nil)
+      if use_cache && @target && @port && @interface_addresses.keys.any?
+        return self
+      end
+      @interface_addresses.clear
+      DNSSD::Service.new.resolve(name, Ahoy::SERVICE_TYPE, domain) do |resolved|
         @target = resolved.target
         @port = resolved.port
-        @interface = resolved.interface
-        main.run
+        @interface_addresses[resolved.interface] = []
+        break unless resolved.flags.more_coming?
       end
-      Thread.stop unless service.stopped?
       self
     end
     
-    def getaddrinfo
+    # :call-seq: contact.getaddrinfo(interface=nil) -> self
+    # 
+    # Determine and set the contact's IP addresses. If an interface is passed,
+    # only lookup the IP addresses for that interface.
+    # 
+    # Pass true as the second argument to prevent a resolve.
+    # 
+    def getaddrinfo(interface=nil, resolve_cache=nil)
+      unless interface
+        interfaces(resolve_cache).each {|inter| getaddrinfo(inter, true)}
+        return self
+      end
       service = DNSSD::Service.new
-      main = Thread.current
-      service.getaddrinfo(target, DNSSD::Service::IPv4, 0, interface) do |addressed|
-        service.stop unless service.stopped?
-        @ip = addressed.address
-        main.run
+      service.getaddrinfo(target(resolve_cache), 0, 0, interface) do |addressed|
+        @interface_addresses[addressed.interface].push(addressed.address)
+        break unless addressed.flags.more_coming?
       end
-      Thread.stop unless service.stopped?
       self
     end
     

data/lib/ahoy/contact_list.rb

@@ -2,14 +2,23 @@ require 'thread'
 require 'weakref'
 
 module Ahoy
+  
+  # Ahoy::ContactList is a self-populating collection of Contacts, and provides
+  # methods to retrieve and iterate over its contents.
+  # 
   class ContactList
     include Enumerable
     
-    attr_reader :list, :weak_list, :lock, :user
+    attr_reader :list, :weak_list, :lock, :user_name
     private :list, :weak_list, :lock
     
-    def initialize(user)
-      @user = user
+    # :call-seq: ContactList.new(user_name=nil) -> contact_list
+    # 
+    # Create a new Ahoy::ContactList. Provide a username as the argument to
+    # avoid adding our user to the list.
+    # 
+    def initialize(user_name=nil)
+      @user_name = user_name
       @list = []
       @weak_list = []
       @lock = Mutex.new
@@ -17,38 +26,52 @@ module Ahoy
       start_browse
     end
     
+    # :call-seq: contact_list.each {|contact| block } -> contact_list
+    # 
+    # Calls block once for each contact in the contact list.
+    # 
     def each(&block)
-      lock.synchronize do
-        list.each(&block)
-      end
+      lock.synchronize {list.each(&block)}
+      self
+    end
+    
+    # :call-seq: contact_list[name] -> contact or nil
+    # 
+    # Returns the first contact who's fullname or name matches name.
+    # 
+    # The case equality operator (===) is used in the comparison, so strings or
+    # regexps can be used as the argument.
+    # 
+    def [](name)
+      find {|c| name === c.fullname || name === c.name}
+    end
+    alias find_by_name []
+    
+    # :call-seq: contact_list.find_by_ip(string) -> contact or nil
+    # 
+    # Returns the first contact with the ip address matching string.
+    # 
+    def find_by_ip(ip)
+      find {|contact| contact.ip_addresses.include?(ip)}
     end
     
     private
     def start_browse
       DNSSD.browse(Ahoy::SERVICE_TYPE) do |browsed|
-        # next if Ahoy::more_coming?(browsed)
-        if Ahoy::add?(browsed) && browsed.name != user.name
-          add(Ahoy::Contact.new(browsed.name, browsed.domain))
-        elsif Ahoy::add?(browsed)
-          user.contact = Ahoy::Contact.new(browsed.name, browsed.domain)
+        if browsed.flags.add? && browsed.name != user_name
+          existing = self[browsed.fullname]
+          contact = existing || find_in_weak_list(browsed.fullname) ||
+            Ahoy::Contact.new(browsed.name, browsed.domain)
+          contact.online = true
+          contact.add_interface(browsed.interface)
+          lock.synchronize {list.push(contact)} unless existing
         else
           remove(browsed.fullname)
         end
       end
     end
     
-    def add(contact)
-      lock.synchronize do
-        unless list.find {|in_list| contact == in_list}
-          contact ||= find_in_weak_list(contact)
-          contact.online = true
-          list.push(contact)
-        end
-      end
-    end
-    
     def remove(fullname)
-      fullname = fullname.fullname if fullname.respond_to?(:fullname)
       lock.synchronize do
         contact = list.find {|c| c.fullname == fullname}
         if contact
@@ -60,16 +83,17 @@ module Ahoy
       end
     end
     
-    def find_in_weak_list(contact)
-      existing_contact = nil
+    def find_in_weak_list(fullname)
       Thread.exclusive do
-        GC.disable
-        weak_list.select! {|ref| ref.weakref_alive?}
-        contact_ref = weak_list.find {|ref| contact == ref}
-        existing_contact = contact_ref.__getobj__
-        GC.enable
+        begin
+          GC.disable
+          weak_list.reject! {|ref| !ref.weakref_alive?}
+          refrence = weak_list.find {|ref| fullname == ref.fullname}
+          refrence.__getobj__ if refrence
+        ensure
+          GC.enable
+        end
       end
-      existing_contact
     end
     
   end

data/lib/ahoy/errors.rb

@@ -1,3 +1,4 @@
 module Ahoy
   ContactOfflineError = Class.new(StandardError)
+  NotConnectedError = Class.new(StandardError)
 end

data/lib/ahoy/user.rb

@@ -1,28 +1,65 @@
+require 'socket'
 require 'rubygems'
 require 'dnssd'
 
 module Ahoy
+  
+  # Ahoy::User represents us, or the current system, and is the entry point for
+  # using the Ahoy library.
+  # 
+  # Send a message to a specific example:
+  #   user = Ahoy::User.new("Ford")
+  #   user.sign_in
+  #   
+  #   chat = user.chat(user.contacts[/Arthur/])
+  #   chat.send("Don't panic")
+  # 
+  # Simple echo server:
+  #   user = Ahoy::User.new("echo")
+  #   user.sign_in
+  #   
+  #   user.on_chat do |chat|
+  #     chat.on_reply do |reply|
+  #       chat.send(reply)
+  #     end
+  #   end.join
+  # 
+  # 
   class User
-    attr_reader :short_name, :location, :domain, :contacts
-    attr_accessor :port, :flags, :interface, :contact
+    attr_reader :display_name, :short_name, :location, :domain, :contacts
+    attr_accessor :port, :flags, :interface
     
-    def initialize(name, location="nowhere", domain="local")
-      @short_name = name
-      @location = location
+    # :call-seq: User.new(name, location="nowhere", domain="local.") -> user
+    # 
+    # Create a new Ahoy::User.
+    # 
+    # Location should be set to the bonjour/zeroconf hostname.
+    # 
+    def initialize(display_name, location="nowhere", domain="local.")
+      @display_name = display_name
+      @short_name = display_name.downcase.gsub(/ /, "-").gsub(/[^a-z0-9-]/, "")
+      @location = location.downcase.gsub(/ /, "-").gsub(/[^a-z0-9-]/, "")
       @domain = domain
       
-      @contacts = Ahoy::ContactList.new(self)
-      @contact = nil
+      @contacts = Ahoy::ContactList.new(name)
       
       @port = 5562
       @flags = 0
       @interface = DNSSD::InterfaceAny
     end
     
+    # :call-seq: user.name -> string
+    # 
+    # The user's name, in name@location format.
+    # 
     def name
       "#{short_name}@#{location}"
     end
     
+    # :call-seq: user.sign_in(status="avail", msg=nil) -> user
+    # 
+    # Register user as 'on-line' and available to send/receive messages.
+    # 
     def sign_in(status="avail", msg=nil)
       @registrar = DNSSD.register(
         name,
@@ -32,15 +69,42 @@ module Ahoy
         txt_record(status, msg),
         flags.to_i,
         interface)
+      self
     end
     
-    def contact
-      sleep 0.01 until @contact
-      @contact
+    # :call-seq: user.chat(contact) -> chat
+    # 
+    # Initiate a new chat session with contact.
+    # 
+    def chat(contact)
+      chat = Ahoy::Chat.new(contact.name)
+      chat.connect(contact.target, contact.port(true))
     end
     
-    def chat(contact)
-      Ahoy::Chat.new(self, contact)
+    # :call-seq: user.listen -> chat
+    # 
+    # Listen for an incoming chat. This method will block until a chat is
+    # recieved.
+    # 
+    def listen
+      socket = server.accept
+      domain, port, hostname, ip = socket.peeraddr
+      Ahoy::Chat.new(name, contacts.find_by_ip(ip).name).connect(socket)
+    end
+    
+    # :call-seq: user.on_chat {|chat| block } -> thread
+    # 
+    # Set up block as a callback for when a chat is initiated by a contact.
+    # 
+    # This method does not block, but does return a thread, which can be joined
+    # if you wish to block.
+    # 
+    def on_chat(&block)
+      Thread.new do
+        while chat = listen
+          block.call(chat)
+        end
+      end
     end
     
     private
@@ -50,7 +114,11 @@ module Ahoy
        "port.p2pj" => port,
        "status" => status,
        "msg" => msg,
-       "1st" => short_name)
+       "1st" => display_name)
+    end
+    
+    def server
+      @server ||= TCPServer.new("0.0.0.0", port)
     end
     
   end

data/readme.rdoc

@@ -9,8 +9,6 @@ The Bonjour chat protocol is pretty much XMPP with the presence and server parts
 
 Ahoy isn't much more than a wrapper with a nice API around the dnssd and xmpp4r gems.
 
-The API is based around the idea that this is an instant messaging protocol, there is a user, that user has a list of contacts, you can start a chat with a contact and send messages the contact though that chat session. This may be refined, but is unlikely to change in it's outlook.
-
 Example:
 
   require 'rubygems'
@@ -52,13 +50,7 @@ Along with the blocking Chat#receive method to receive replies, there is an on_r
     sleep 1
   end
 
-If you are sending messages to a contact on the same machine (likely while testing, sending messages to yourself in iChat), you may need to set the interface on the user to your primary network interface:
-
-  user = Ahoy::User.new("mat")
-  user.interface = "en1"   # on Mac OS X en1 is usually Wi-Fi, en0 is ethernet
-  user.sign_in
-  
-  ...
+Messages can be formatted using markdown, simply set Chat#use_markdown (or Ahoy.use_markdown for the global default). Ahoy will use any of the following markdown processors, in order of preference: rdiscount, kramdown, maruku, bluecloth.
 
 The current use case is to send a message to a team of developers when a deploy script is run, there is a simplified interface for this:
 

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ahoy
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
 platform: ruby
 authors: 
 - Mat Sadler
@@ -9,29 +15,39 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-04 00:00:00 +00:00
+date: 2011-05-07 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: dnssd
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        version: 1.3.1
-    version: 
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :runtime
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: xmpp4r
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 0
+        - 5
         version: "0.5"
-    version: 
+  type: :runtime
+  version_requirements: *id002
 description: Serverless Messaging using DNSDS/mDNS, XMPP, and Ruby
 email: mat@sourcetagsandcodes.com
 executables: []
@@ -47,11 +63,10 @@ files:
 - lib/ahoy/contact_list.rb
 - lib/ahoy/errors.rb
 - lib/ahoy/user.rb
-- lib/ahoy/xmpp4r_hack.rb
 - lib/ahoy.rb
 - readme.rdoc
 has_rdoc: true
-homepage: http://sourcetagsandcodes.com
+homepage: http://github.com/matsadler/ahoy
 licenses: []
 
 post_install_message: 
@@ -61,21 +76,27 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Bonjour Chat for Ruby

data/lib/ahoy/xmpp4r_hack.rb

@@ -1,41 +0,0 @@
-require 'rubygems'
-require 'xmpp4r'
-
-module Jabber
-  class Connection
-    def connect(host, port, local_host=nil, local_port=nil)
-      @host = host
-      @port = port
-      # Reset is_tls?, so that it works when reconnecting
-      @tls = false
-      
-      Jabber::debuglog("CONNECTING:\n#{@host}:#{@port}, local #{local_host}:#{local_port}")
-      @socket = TCPSocket.new(@host, @port, local_host, local_port)
-      
-      # We want to use the old and deprecated SSL protocol (usually on port 5223)
-      if @use_ssl
-        ssl = OpenSSL::SSL::SSLSocket.new(@socket)
-        ssl.connect # start SSL session
-        ssl.sync_close = true
-        Jabber::debuglog("SSL connection established.")
-        @socket = ssl
-      end
-      
-      start
-      
-      accept_features
-      
-      @keepaliveThread = Thread.new do
-        Thread.current.abort_on_exception = true
-        keepalive_loop
-      end
-    end
-  end
-  
-  class Client
-    def connect(host, port, local_host=nil, local_port=nil)
-      super
-      self
-    end
-  end
-end