tkellem 0.7.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Brian Palmer <brian@codekitchen.net>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/README.md

@@ -0,0 +1,17 @@
+# tkellem
+
+tkellem is an IRC bouncer, a proxy that keeps you permanently logged on to an
+IRC server and stores all messages so that when your client next connects, you
+can see the backlog of what happened while you were gone.
+
+tkellem supports multiple device-independent backlogs, and connecting to
+multiple IRC servers all from the same process.
+
+## IMPORTANT
+
+This is a very, very early version. Only the basic functionality is implemented.
+You probably don't want this yet.
+
+## Usage
+
+    bin/tkellem examples/config.yml

data/Rakefile

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'rake'
+require 'rspec'
+require 'rspec/core/rake_task'
+
+task :default => :spec
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/spec_helper.rb'
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = 'tkellem'
+    gem.summary = 'IRC bouncer with multi-client support'
+    gem.email = 'brian@codekitchen.net'
+    gem.homepage = 'http://github.com/codekitchen/tkellem'
+    gem.authors = ['Brian Palmer']
+    gem.add_dependency 'eventmachine'
+    gem.executables = %w(tkellem)
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  # om nom nom
+end

data/VERSION

@@ -0,0 +1 @@
+0.7.0

data/bin/tkellem

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'rubygems'
+rescue LoadError
+end
+require 'yaml'
+require 'optparse'
+
+opts = OptionParser.new
+opts.banner = <<BANNER
+Usage: #{opts.program_name} PATH_TO_CONFIG
+
+Start a tkellem instance using the specified configuration file (or ~/.tkellem/config.yml if none given)
+BANNER
+
+opts.on_tail("-h", "--help") { puts opts; exit }
+
+rest = opts.parse(ARGV)
+config_filename = rest.first || File.expand_path(ENV["HOME"]+'/.tkellem/config.yml')
+
+config = YAML.load_file(config_filename)
+
+$LOAD_PATH.push(File.expand_path(File.dirname(__FILE__)+'/../lib'))
+require 'tkellem'
+
+EM.run do
+  bouncer =
+    Tkellem::Bouncer.new(config['listen'] || '0.0.0.0',
+                         config['port'] || 10001,
+                         config['ssl'])
+
+  bouncer.max_backlog = config['max_backlog'].to_i
+
+  bouncer.on_authenticate do |username, password, irc_server|
+    server_config = config['connections'][irc_server.name]
+    if server_config && password_sha1 = server_config['password_sha1']
+      require 'openssl'
+      password_sha1 == OpenSSL::Digest::SHA1.hexdigest(password)
+    else
+      true
+    end
+  end
+
+  def add_irc_server(bouncer, name, conn)
+    server = bouncer.add_irc_server(name,
+                                    conn['host'], conn['port'], conn['ssl'],
+                                    conn['nick'])
+
+    (conn['rooms'] || []).each { |room| server.join_room(room['name']) }
+    conn['clients'].each { |client| server.add_client(client['name']) }
+  end
+
+  config['connections'].each do |name, conn|
+    Tkellem::EasyLogger.logger.info("adding new connection #{name}")
+    add_irc_server(bouncer, name, conn)
+  end
+
+  Signal.trap('HUP') do
+    Tkellem::EasyLogger.logger.warn("got HUP, reloading #{config_filename}")
+    new_config = YAML.load_file(config_filename)
+
+    bouncer.max_backlog = new_config['max_backlog'].to_i
+
+    # find changed connections
+    to_delete = config['connections'].keys
+
+    new_config['connections'].each do |name, new_conn|
+      to_delete.delete(name)
+      conn = config['connections'][name]
+      if !conn
+        Tkellem::EasyLogger.logger.info("adding new connection #{name}")
+        add_irc_server(bouncer, name, new_conn)
+      else
+        if new_conn['host'] != conn['host'] || new_conn['port'] != conn['port'] || new_conn['ssl'] != conn['ssl']
+          Tkellem::EasyLogger.logger.info("server settings changed for #{name}, dropping clients and reconnecting")
+          bouncer.remove_irc_server(name)
+          add_irc_server(bouncer, name, new_conn)
+        elsif conn['clients'] != new_conn['clients']
+          irc_server = bouncer.get_irc_server(name)
+
+          # we don't have to reconnect, but maybe clients changed. we ignore
+          # changes to nick and rooms on HUP, since those are dynamic once tkellem
+          # connects.  password change will be caught on the next client
+          # connect.
+          clients_to_delete = conn['clients'].map { |c| c['name'] }
+          new_conn['clients'].each do |new_client|
+            clients_to_delete.delete(new_client['name'])
+            # add -- if already exists, this is a no-op. this may change in the
+            # future though...
+            Tkellem::EasyLogger.logger.info("adding client #{new_client['name']} to server #{name}")
+            irc_server.add_client(new_client['name'])
+          end
+          clients_to_delete.each do |client_name|
+            Tkellem::EasyLogger.logger.info("removing client #{client_name} from server #{name}")
+            irc_server.remove_client(client_name) if irc_server
+          end
+        end
+      end
+    end
+
+    to_delete.each do |name|
+      Tkellem::EasyLogger.logger.info("deleting connection #{name}")
+      bouncer.remove_irc_server(name)
+    end
+
+    config = new_config
+  end
+
+end

data/examples/config.yml

@@ -0,0 +1,29 @@
+#     $ bin/tkellem examples/config.yml
+#
+# to connect: connect to localhost port 10001, ssl enabled, "real name" set to
+#
+#     <connection_name> <client_name>
+#
+# e.g.:
+#
+#     freenode laptop
+--- 
+listen: 0.0.0.0
+port: 10001
+ssl: true
+# max_backlog: 500
+connections: 
+  freenode:
+    host: irc.freenode.org
+    port: 6667
+    ssl: false
+    nick: tkellem_r0ck
+    # Uncomment to enable password auth (there's no auth by default, which
+    # means anybody can connect). You can generate a password_sha1 like so:
+    #     echo -n 'tkellem_r0ck' | openssl sha1
+    # password_sha1: a4f4a3b97c7b8a028d4e3f3fee85d6e5626baba5
+    rooms: 
+    - name: "#tkellem_test"
+    clients: 
+    - name: laptop
+    - name: iphone

data/lib/tkellem/backlog.rb

@@ -0,0 +1,85 @@
+require 'tkellem/irc_line'
+
+module Tkellem
+
+# Normally there will be one client per backlog, but there can be more than one
+# connection for the same backlog, if two or more IRC clients connect with the
+# same client name. That situation is equivalent to how most multi-connection
+# bouncers like bip work.
+
+class Backlog
+
+  class BacklogLine < Struct.new(:irc_line, :time)
+  end
+
+  def initialize(name, max_backlog = nil)
+    @name = name
+    @backlog = []
+    @pm_backlogs = Hash.new { |h,k| h[k] = [] }
+    @active_conns = []
+    @max_backlog = max_backlog
+  end
+  attr_reader :name, :backlog, :active_conns, :pm_backlogs, :max_backlog
+
+  def handle_message(msg)
+    # TODO: only send back response messages like WHO, NAMES, etc. to the
+    # BouncerConnection that requested it.
+    if !active_conns.empty?
+      case msg.command
+      when /3\d\d/, /join/i, /part/i
+        # transient response -- we want to forward these, but not backlog
+        active_conns.each { |conn| conn.transient_response(msg) }
+      when /privmsg/i
+        active_conns.each { |conn| conn.send_msg(msg) }
+      else
+        # do nothing?
+      end
+    elsif msg.command.match(/privmsg/i)
+      if msg.args.first.match(/^#/)
+        # room privmsg always goes in a specific backlog
+        pm_target = msg.args.first
+        bl = pm_backlogs[pm_target]
+      else
+        # other messages go in the general backlog
+        bl = backlog
+      end
+      bl.push(BacklogLine.new(msg, Time.now))
+      limit_backlog(bl)
+    end
+  end
+
+  def limit_backlog(bl)
+    bl.shift until !max_backlog || bl.size <= max_backlog
+  end
+
+  def max_backlog=(new_val)
+    @max_backlog = new_val
+    limit_backlog(backlog)
+    pm_backlogs.each { |k,bl| limit_backlog(bl) }
+  end
+
+  def add_conn(bouncer_conn)
+    active_conns << bouncer_conn
+  end
+
+  def remove_conn(bouncer_conn)
+    active_conns.delete(bouncer_conn)
+  end
+
+  def send_backlog(conn, pm_target = nil)
+    if pm_target
+      # send room-specific backlog
+      msgs = pm_backlogs.key?(pm_target) ? pm_backlogs[pm_target] : []
+    else
+      # send the general backlog
+      msgs = backlog
+    end
+
+    until msgs.empty?
+      backlog_line = msgs.shift
+      conn.send_msg(backlog_line.irc_line.with_timestamp(backlog_line.time))
+    end
+  end
+end
+
+end

data/lib/tkellem/bouncer.rb

@@ -0,0 +1,52 @@
+require 'eventmachine'
+
+require 'tkellem/irc_server'
+
+module Tkellem
+  class Bouncer
+    def initialize(listen_address, port, do_ssl)
+      @irc_servers = {}
+      @max_backlog = nil
+      @server = EM.start_server(listen_address, port, BouncerConnection,
+                                self, do_ssl)
+    end
+
+    def add_irc_server(name, host, port, do_ssl, nick)
+      server = EM.connect(host, port, IrcServer, self, name, do_ssl, nick)
+      @irc_servers[name] = server
+      server.set_max_backlog(@max_backlog) if @max_backlog
+      server
+    end
+
+    def remove_irc_server(name)
+      server = @irc_servers.delete(name)
+      if server
+        server.close_connection(true)
+      end
+    end
+
+    def on_authenticate(&block)
+      @auth_block = block
+    end
+
+    def max_backlog=(max_backlog)
+      @max_backlog = max_backlog && max_backlog > 0 ? max_backlog : nil
+      @irc_servers.each { |name, server| server.set_max_backlog(@max_backlog) }
+    end
+
+
+    # Internal API
+
+    def get_irc_server(name) #:nodoc:
+      @irc_servers[name]
+    end
+
+    def do_auth(username, password, irc_server) #:nodoc:
+      if @auth_block
+        @auth_block.call(username, password.to_s, irc_server)
+      else
+        true
+      end
+    end
+  end
+end

data/lib/tkellem/bouncer_connection.rb

@@ -0,0 +1,149 @@
+require 'eventmachine'
+require 'tkellem/irc_line'
+require 'tkellem/backlog'
+
+module Tkellem
+
+module BouncerConnection
+  include EM::Protocols::LineText2
+  include Tkellem::EasyLogger
+
+  def initialize(bouncer, do_ssl)
+    set_delimiter "\r\n"
+
+    @ssl = do_ssl
+    @bouncer = bouncer
+
+    @irc_server = nil
+    @backlog = nil
+    @nick = nil
+    @conn_name = nil
+    @name = nil
+  end
+  attr_reader :ssl, :irc_server, :backlog, :bouncer, :nick
+
+  def connected?
+    !!irc_server
+  end
+
+  def name
+    @name || "new-conn"
+  end
+
+  def post_init
+    if ssl
+      debug "starting TLS"
+      start_tls :verify_peer => false
+    end
+  end
+
+  def ssl_handshake_completed
+    debug "TLS complete"
+  end
+
+  def error!(msg)
+    info("ERROR :#{msg}")
+    send_msg("ERROR :#{msg}")
+    close_connection(true)
+  end
+
+  def connect(conn_name, client_name, password)
+    @irc_server = bouncer.get_irc_server(conn_name.downcase)
+    unless irc_server && irc_server.connected?
+      error!("unknown connection #{conn_name}")
+      return
+    end
+
+    unless bouncer.do_auth(conn_name, @password, irc_server)
+      error!("bad auth, please check your password")
+      @irc_server = @conn_name = @name = @backlog = nil
+      return
+    end
+
+    @conn_name = conn_name
+    @name = client_name
+    @backlog = irc_server.bouncer_connect(self)
+    unless backlog
+      error!("unknown client #{client_name}")
+      @irc_server = @conn_name = @name = nil
+      return
+    end
+
+    info "connected"
+
+    irc_server.send_welcome(self)
+    backlog.send_backlog(self)
+    irc_server.rooms.each { |room| simulate_join(room) }
+  end
+
+  def tkellem(msg)
+    case msg.args.first
+    when /nothing_yet/i
+    else
+      send_msg(":tkellem!tkellem@tkellem PRIVMSG #{nick} :Unknown tkellem command #{msg.args.first}")
+    end
+  end
+
+  def receive_line(line)
+    trace "from client: #{line}"
+    msg = IrcLine.parse(line)
+    case msg.command
+    when /tkellem/i
+      tkellem(msg)
+    when /pass/i
+      @password = msg.args.first
+    when /user/i
+      conn_name, client_name = msg.args.last.strip.split(' ')
+      connect(conn_name, client_name, @password)
+    when /nick/i
+      if connected?
+        irc_server.change_nick(msg.last)
+      else
+        @nick = msg.last
+      end
+    when /quit/i
+      # DENIED
+      close_connection
+    when /ping/i
+      send_msg(":tkellem PONG tkellem :#{msg.last}")
+    else
+      if !connected?
+        close_connection
+      else
+        # pay it forward
+        irc_server.send_msg(msg)
+      end
+    end
+  end
+
+  def simulate_join(room)
+    send_msg(":#{irc_server.nick}!#{name}@tkellem JOIN #{room}")
+    # TODO: intercept the NAMES response so that only this bouncer gets it
+    # Otherwise other clients might show an "in this room" line.
+    irc_server.send_msg("NAMES #{room}\r\n")
+  end
+
+  def transient_response(msg)
+    send_msg(msg)
+    if msg.command == "366"
+      # finished joining this room, let's backlog it
+      debug "got final NAMES for #{msg.args[1]}, sending backlog"
+      backlog.send_backlog(self, msg.args[1])
+    end
+  end
+
+  def send_msg(msg)
+    trace "to client: #{msg}"
+    send_data("#{msg}\r\n")
+  end
+
+  def log_name
+    "#{@conn_name}-#{name}"
+  end
+
+  def unbind
+    irc_server.bouncer_disconnect(self) if connected?
+  end
+end
+
+end

data/lib/tkellem/irc_line.rb

@@ -0,0 +1,58 @@
+module Tkellem
+
+class IrcLine
+  RE = %r{(:[^ ]+ )?([^ ]*)(.*)}i
+
+  def self.parse(line)
+    md = RE.match(line) or raise("invalid input: #{line.inspect}")
+
+    self.new(line, md[1], md[2], md[3])
+  end
+
+  attr_reader :prefix, :command, :args
+
+  def initialize(orig, prefix, command, args)
+    @orig = orig
+    @prefix = prefix ? prefix.strip : nil
+    @command = command
+
+    args.strip!
+    idx = args.index(":")
+    if idx
+      @args = args[0...idx].split(' ') + [args[idx+1..-1]]
+    else
+      @args = args.split(' ')
+    end
+  end
+
+  def command?(cmd)
+    @command.downcase == cmd.downcase
+  end
+
+  def replay
+    @orig
+  end
+  alias_method :to_s, :replay
+
+  def last
+    args.last
+  end
+
+  def target_user
+    if prefix && md = %r{^:([^!]+)}.match(prefix)
+      md[1]
+    else
+      nil
+    end
+  end
+
+  def with_timestamp(timestamp)
+    new_command = [prefix, command]
+    new_command += args[0..-2]
+    new_command.push("#{timestamp.strftime("%H:%M:%S")}> #{args.last}")
+    new_command.join(' ')
+  end
+
+end
+
+end

data/lib/tkellem/irc_server.rb

@@ -0,0 +1,156 @@
+require 'set'
+require 'eventmachine'
+require 'tkellem/irc_line'
+require 'tkellem/bouncer_connection'
+require 'tkellem/backlog'
+
+module Tkellem
+
+module IrcServer
+  include EM::Protocols::LineText2
+  include Tkellem::EasyLogger
+
+  def initialize(bouncer, name, do_ssl, nick)
+    set_delimiter "\r\n"
+
+    @bouncer = bouncer
+    @name = name
+    @ssl = do_ssl
+    @nick = nick
+
+    @max_backlog = nil
+    @connected = false
+    @welcomes = []
+    @rooms = Set.new
+    @backlogs = {}
+    @active_conns = []
+    @joined_rooms = false
+    @pending_rooms = []
+  end
+  attr_reader :name, :backlogs, :welcomes, :rooms, :nick, :active_conns
+  alias_method :log_name, :name
+
+  def connected?
+    @connected
+  end
+
+  def set_max_backlog(max_backlog)
+    @max_backlog = max_backlog
+    backlogs.each { |name, backlog| backlog.max_backlog = max_backlog }
+  end
+
+  def post_init
+    if @ssl
+      debug "starting TLS"
+      # TODO: support strict cert checks
+      start_tls :verify_peer => false
+    else
+      ssl_handshake_completed
+    end
+  end
+
+  def ssl_handshake_completed
+    # TODO: support sending a real username, realname, etc
+    send_msg("USER #{nick} localhost blah :#{nick}")
+    change_nick(nick, true)
+  end
+
+  def receive_line(line)
+    trace "from server: #{line}"
+    msg = IrcLine.parse(line)
+
+    case msg.command
+    when /0\d\d/, /2[56]\d/, /37[256]/
+      welcomes << msg
+      got_welcome if msg.command == "376" # end of MOTD
+    when /join/i
+      debug "#{msg.target_user} joined #{msg.last}"
+      rooms << msg.last if msg.target_user == nick
+    when /part/i
+      debug "#{msg.target_user} left #{msg.last}"
+      rooms.delete(msg.last) if msg.target_user == nick
+    when /ping/i
+      send_msg("PONG #{nick}!tkellem #{msg.args.first}")
+    when /pong/i
+      # swallow it, we handle ping-pong from clients separately, in
+      # BouncerConnection
+    else
+    end
+
+    backlogs.each { |name, backlog| backlog.handle_message(msg) }
+  end
+
+  def got_welcome
+    return if @joined_rooms
+    @joined_rooms = true
+    @pending_rooms.each do |room|
+      join_room(room)
+    end
+    @pending_rooms.clear
+
+    # We're all initialized, allow connections
+    @connected = true
+  end
+
+  def change_nick(new_nick, force = false)
+    return if !force && new_nick == @nick
+    @nick = new_nick
+    send_msg("NICK #{new_nick}")
+  end
+
+  def join_room(room_name)
+    if @joined_rooms
+      send_msg("JOIN #{room_name}")
+    else
+      @pending_rooms << room_name
+    end
+  end
+
+  def add_client(name)
+    return if backlogs[name]
+    backlog = Backlog.new(name, @max_backlog)
+    backlogs[name] = backlog
+  end
+
+  def remove_client(name)
+    backlog = backlogs.delete(name)
+    if backlog
+      backlog.active_conns.each do |conn|
+        conn.error!("client removed")
+      end
+    end
+  end
+
+  def send_msg(msg)
+    trace "to server: #{msg}"
+    send_data("#{msg}\r\n")
+  end
+
+  def send_welcome(bouncer_conn)
+    welcomes.each { |msg| bouncer_conn.send_msg(msg) }
+  end
+
+  def unbind
+    debug "OMG we got disconnected."
+    # TODO: reconnect if desired. but not if this server was explicitly shut
+    # down or removed.
+    backlogs.keys.each { |name| remove_client(name) }
+  end
+
+  def bouncer_connect(bouncer_conn)
+    return nil unless backlogs[bouncer_conn.name]
+
+    active_conns << bouncer_conn
+    backlogs[bouncer_conn.name].add_conn(bouncer_conn)
+    backlogs[bouncer_conn.name]
+  end
+
+  def bouncer_disconnect(bouncer_conn)
+    return nil unless backlogs[bouncer_conn.name]
+
+    backlogs[bouncer_conn.name].remove_conn(bouncer_conn)
+    active_conns.delete(bouncer_conn)
+  end
+end
+
+end

data/lib/tkellem.rb

@@ -0,0 +1,45 @@
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
+pathname = File.expand_path(File.dirname(__FILE__))
+$LOAD_PATH.push(pathname) unless $LOAD_PATH.include?(pathname)
+
+module Tkellem
+  module EasyLogger
+    require 'logger'
+
+    def self.logger=(new_logger)
+      @logger = new_logger
+    end
+    def self.logger
+      return @logger if @logger
+      @logger = Logger.new(STDERR)
+      @logger.datetime_format = "%Y-%m-%d"
+      @logger
+    end
+
+    def self.trace=(val)
+      @trace = val
+    end
+    def self.trace
+      @trace || @trace = false
+    end
+
+    def trace(msg)
+      puts("TRACE: #{log_name}: #{msg}") if EasyLogger.trace
+    end
+
+    ::Logger::Severity.constants.each do |level|
+      next if level == "UNKNOWN"
+      module_eval(<<-EVAL, __FILE__, __LINE__)
+      def #{level.downcase}(msg)
+        EasyLogger.logger.#{level.downcase}("\#{log_name} (\#{object_id}): \#{msg}")
+      end
+      EVAL
+    end
+  end
+end
+
+require 'tkellem/bouncer'

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'tkellem'
+require 'rspec'
+
+RSpec.configure do |config|
+end
+
+puts "Yeah... not so much right now"

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: tkellem
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 7
+  - 0
+  version: 0.7.0
+platform: ruby
+authors: 
+- Brian Palmer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-17 00:00:00 -07:00
+default_executable: tkellem
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: brian@codekitchen.net
+executables: 
+- tkellem
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- bin/tkellem
+- examples/config.yml
+- lib/tkellem.rb
+- lib/tkellem/backlog.rb
+- lib/tkellem/bouncer.rb
+- lib/tkellem/bouncer_connection.rb
+- lib/tkellem/irc_line.rb
+- lib/tkellem/irc_server.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/codekitchen/tkellem
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: IRC bouncer with multi-client support
+test_files: 
+- spec/spec_helper.rb