cinch 1.1.3 → 2.0.0.pre.1

data/lib/cinch/handler_list.rb

@@ -0,0 +1,86 @@
+require "thread"
+require "set"
+require "cinch/cached_list"
+
+module Cinch
+  # @since 2.0.0
+  class HandlerList
+    include Enumerable
+
+    def initialize
+      @handlers = Hash.new {|h,k| h[k] = []}
+      @mutex = Mutex.new
+    end
+
+    def register(handler)
+      @mutex.synchronize do
+        handler.bot.loggers.debug "[on handler] Registering handler with pattern `#{handler.pattern.inspect}`, reacting on `#{handler.event}`"
+        @handlers[handler.event] << handler
+      end
+    end
+
+    # @param [Handler, Array<Handler>] *handlers The handlers to unregister
+    # @return [void]
+    # @see Handler#unregister
+    def unregister(*handlers)
+      @mutex.synchronize do
+        handlers.each do |handler|
+          @handlers[handler.event].delete(handler)
+        end
+      end
+    end
+
+    # @api private
+    # @return [Array<Handler>]
+    def find(type, msg = nil)
+      if handlers = @handlers[type]
+        if msg.nil?
+          return handlers
+        end
+
+        handlers = handlers.select { |handler|
+          msg.match(handler.pattern.to_r(msg), type)
+        }.group_by {|handler| handler.group}
+
+        handlers.values_at(*(handlers.keys - [nil])).map(&:first) + (handlers[nil] || [])
+      end
+    end
+
+    # @param [Symbol] event The event type
+    # @param [Message, nil] msg The message which is responsible for
+    #   and attached to the event, or nil.
+    # @param [Array] *arguments A list of additional arguments to pass
+    #   to event handlers
+    # @return [void]
+    def dispatch(event, msg = nil, *arguments)
+      if handlers = find(event, msg)
+        already_run = Set.new
+        handlers.each do |handler|
+          next if already_run.include?(handler.block)
+          already_run << handler.block
+          # calling Message#match multiple times is not a problem
+          # because we cache the result
+          if msg
+            captures = msg.match(handler.pattern.to_r(msg), event).captures
+          else
+            captures = []
+          end
+
+          handler.call(msg, captures, arguments)
+        end
+      end
+    end
+
+    # @yield [handler] Yields all registered handlers
+    # @yieldparam [Handler] handler
+    # @return [void]
+    def each(&block)
+      @handlers.values.flatten.each(&block)
+    end
+
+    # @api private
+    def stop_all
+      each { |h| h.stop }
+    end
+  end
+end

data/lib/cinch/helpers.rb

@@ -1,21 +1,178 @@
+# TODO @since for all methods
 module Cinch
+  # The Helpers module contains a number of methods whose purpose is
+  # to make writing plugins easier by hiding parts of the API. The
+  # {#Channel} helper, for example, provides an easier way for turning
+  # a String object into a {Channel} object than directly using
+  # {ChannelList}: Compare `Channel("#some_channel")` with
+  # `bot.channel_list.find_ensured("#some_channel")`.
+  #
+  # The Helpers module automatically gets included in all plugins.
   module Helpers
+    # @group Type casts
+
+    # Helper method for turning a String into a {Target} object.
+    #
+    # @param [String] target a target name
+    # @return [Target] a {Target} object
+    # @example
+    #   on :message, /^message (.+)$/ do |m, target|
+    #     Target(target).send "hi!"
+    #   end
+    def Target(target)
+      return target if target.is_a?(Target)
+      Target.new(target, bot)
+    end
+
     # Helper method for turning a String into a {Channel} object.
     #
-    # @param (see Bot#Channel)
-    # @return (see Bot#Channel)
-    # @example (see Bot#Channel)
-    def Channel(*args)
-      @bot.Channel(*args)
+    # @param [String] channel a channel name
+    # @return [Channel] a {Channel} object
+    # @example
+    #   on :message, /^please join (#.+)$/ do |m, target|
+    #     Channel(target).join
+    #   end
+    def Channel(channel)
+      return channel if channel.is_a?(Channel)
+      bot.channel_list.find_ensured(channel)
     end
 
     # Helper method for turning a String into an {User} object.
     #
-    # @param (see Bot#User)
-    # @return (see Bot#User)
-    # @example (see Bot#User)
-    def User(*args)
-      @bot.User(*args)
+    # @param [String] user a user's nickname
+    # @return [User] an {User} object
+    # @example
+    #   on :message, /^tell me everything about (.+)$/ do |m, target|
+    #     user = User(target)
+    #     m.reply "%s is named %s and connects from %s" % [user.nick, user.name, user.host]
+    #   end
+    def User(user)
+      return user if user.is_a?(User)
+      if user == bot.nick
+        bot
+      else
+        bot.user_list.find_ensured(user)
+      end
+    end
+
+    # @example Used as a class method in a plugin
+    #   timer 5, method: :some_method
+    #   def some_method
+    #     Channel("#cinch-bots").send(Time.now.to_s)
+    #   end
+    #
+    # @example Used as an instance method in a plugin
+    #   match "start timer"
+    #   def execute(m)
+    #     Timer(5) { puts "timer fired" }
+    #   end
+    #
+    # @example Used as an instance method in a traditional `on` handler
+    #   on :message, "start timer" do
+    #     Timer(5) { puts "timer fired" }
+    #   end
+    #
+    # @param [Number] interval Interval in seconds
+    # @param [Proc] block A proc to execute
+    # @option options [Symbol] :method (:timer) Method to call (only
+    #   if no proc is provided)
+    # @option options [Boolean] :threaded (true) Call method in a
+    #   thread?
+    # @option options [Number] :shots (Float::INFINITY) How often
+    #   should the timer fire?
+    # @option options [Boolean] :start_automatically (true) If true,
+    #   the timer will automatically start after the bot finished
+    #   connecting.
+    # @option options [Boolean] :stop_automaticall (true) If true, the
+    #   timer will automatically stop when the bot disconnects.
+    # @return [Timer]
+    # @since 2.0.0
+    def Timer(interval, options = {}, &block)
+      options = {:method => :timer, :threaded => true, :interval => interval}.merge(options)
+      block ||= self.method(options[:method])
+      timer = Cinch::Timer.new(bot, options, &block)
+      timer.start
+
+      timer
+    end
+
+    # @endgroup
+
+    # @group Logging
+
+    # Use this method to automatically log exceptions to the loggers.
+    #
+    # @example
+    #   def my_method
+    #     rescue_exception do
+    #       something_that_might_raise()
+    #     end
+    #   end
+    #
+    # @return [void]
+    # @since 2.0.0
+    def rescue_exception
+      begin
+        yield
+      rescue => e
+        bot.loggers.exception(e)
+      end
+    end
+
+    # (see Logger#log)
+    def log(messages, event = :debug, level = event)
+      @bot.loggers.log(messages, event, level)
+    end
+
+    # (see Logger#debug)
+    def debug(message)
+      log(message, :debug)
+    end
+
+    # (see Logger#error)
+    def error(message)
+      log(message, :error)
+    end
+
+    # (see Logger#fatal)
+    def fatal(message)
+      log(message, :fatal)
     end
+
+    # (see Logger#info)
+    def info(message)
+      log(message, :info)
+    end
+
+    # (see Logger#warn)
+    def warn(message)
+      log(message, :warn)
+    end
+
+    # (see Logger#incoming)
+    def incoming(message)
+      log(message, :incoming, :log)
+    end
+
+    # (see Logger#outgoing)
+    def outgoing(message)
+      log(message, :outgoing, :log)
+    end
+
+    # (see Logger#exception)
+    def exception(e)
+      log(e.message, :exception, :error)
+    end
+    # @endgroup
+
+    # @group Formatting
+
+    # (see Formatting.format)
+    def Format(*args)
+      Formatting.format(*args)
+    end
+    alias_method :Color, :Format
+
+    # @endgroup
   end
 end

data/lib/cinch/irc.rb

@@ -1,121 +1,227 @@
 require "timeout"
 require "net/protocol"
+require "cinch/network"
 
 module Cinch
+  # This class manages the connection to the IRC server. That includes
+  # processing incoming and outgoing messages, creating Ruby objects
+  # and invoking plugins.
   class IRC
+    include Helpers
+
     # @return [ISupport]
     attr_reader :isupport
+
+    # @return [Bot]
+    attr_reader :bot
+
+    # @return [Network] The detected network
+    attr_reader :network
+
     def initialize(bot)
       @bot      = bot
       @isupport = ISupport.new
     end
 
-    # Establish a connection.
-    #
-    # @return [void]
-    def connect
-      @registration = []
+    # @return [TCPSocket]
+    # @api private
+    # @since 2.0.0
+    def socket
+      @socket.io
+    end
 
+    # @api private
+    # @return [void]
+    # @since 2.0.0
+    def setup
+      @registration  = []
+      @network       = Network.new(:unknown, :unknown)
       @whois_updates = Hash.new {|h, k| h[k] = {}}
       @in_lists      = Set.new
+    end
 
+    # @api private
+    # @return [Boolean] True if the connection could be established
+    def connect
       tcp_socket = nil
+
       begin
         Timeout::timeout(@bot.config.timeouts.connect) do
           tcp_socket = TCPSocket.new(@bot.config.server, @bot.config.port, @bot.config.local_host)
         end
       rescue Timeout::Error
-        @bot.logger.debug("Timed out while connecting")
-        return
+        @bot.loggers.warn("Timed out while connecting")
+        return false
+      rescue SocketError => e
+        @bot.loggers.warn("Could not connect to the IRC server. Please check your network: #{e.message}")
+        return false
       rescue => e
-        @bot.logger.log_exception(e)
-        return
+        @bot.loggers.exception(e)
+        return false
       end
 
-      if @bot.config.ssl == true || @bot.config.ssl == false
-        @bot.logger.debug "Deprecation warning: Beginning from version 1.1.0, @config.ssl should be a set of options, not a boolean value!"
+      if @bot.config.ssl.use
+        setup_ssl(tcp_socket)
+      else
+        @socket = tcp_socket
       end
 
-      if @bot.config.ssl == true || (@bot.config.ssl.is_a?(OpenStruct) && @bot.config.ssl.use)
-        require 'openssl'
+      @socket              = Net::BufferedIO.new(@socket)
+      @socket.read_timeout = @bot.config.timeouts.read
+      @queue               = MessageQueue.new(@socket, @bot)
 
-        ssl_context = OpenSSL::SSL::SSLContext.new
+      return true
+    end
 
-        if @bot.config.ssl.is_a?(OpenStruct)
-          if @bot.config.ssl.client_cert
-            ssl_context.cert = OpenSSL::X509::Certificate.new(File.read(@bot.config.ssl.client_cert))
-            ssl_context.key = OpenSSL::PKey::RSA.new(File.read(@bot.config.ssl.client_cert))
-          end
-          ssl_context.ca_path = @bot.config.ssl.ca_path
-          ssl_context.verify_mode = @bot.config.ssl.verify ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
-        else
-          ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    # @api private
+    # @return [void]
+    # @since 2.0.0
+    def setup_ssl(socket)
+      # require openssl in this method so the bot doesn't break for
+      # people who don't have SSL but don't want to use SSL anyway.
+      require 'openssl'
+
+      ssl_context = OpenSSL::SSL::SSLContext.new
+
+      if @bot.config.ssl.is_a?(Configuration::SSL)
+        if @bot.config.ssl.client_cert
+          ssl_context.cert = OpenSSL::X509::Certificate.new(File.read(@bot.config.ssl.client_cert))
+          ssl_context.key  = OpenSSL::PKey::RSA.new(File.read(@bot.config.ssl.client_cert))
         end
-        @bot.logger.debug "Using SSL with #{@bot.config.server}:#{@bot.config.port}"
 
-        @socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, ssl_context)
-        @socket.sync = true
-        @socket.connect
+        ssl_context.ca_path     = @bot.config.ssl.ca_path
+        ssl_context.verify_mode = @bot.config.ssl.verify ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
       else
-        @socket = tcp_socket
+        ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
       end
+      @bot.loggers.info "Using SSL with #{@bot.config.server}:#{@bot.config.port}"
 
-      @socket = Net::BufferedIO.new(@socket)
-      @socket.read_timeout = @bot.config.timeouts.read
+      @socket      = OpenSSL::SSL::SSLSocket.new(socket, ssl_context)
+      @socket.sync = true
+      @socket.connect
+    end
 
-      @queue = MessageQueue.new(@socket, @bot)
-      message "PASS #{@bot.config.password}" if @bot.config.password
-      message "NICK #{@bot.generate_next_nick}"
-      message "USER #{@bot.config.user} 0 * :#{@bot.config.realname}"
+    # @api private
+    # @return [void]
+    # @since 2.0.0
+    def send_cap_ls
+      send "CAP LS"
+    end
+
+    # @api private
+    # @return [void]
+    # @since 2.0.0
+    def send_cap_req
+      send "CAP REQ :" + ([:"away-notify", :"multi-prefix", :sasl] & @network.capabilities).join(" ")
+    end
+
+    # @since 2.0.0
+    # @api private
+    # @return [void]
+    def send_cap_end
+      send "CAP END"
+    end
+
+    # @api private
+    # @return [void]
+    # @since 2.0.0
+    def send_login
+      send "PASS #{@bot.config.password}" if @bot.config.password
+      send "NICK #{@bot.generate_next_nick!}"
+      send "USER #{@bot.config.user} 0 * :#{@bot.config.realname}"
+    end
 
-      reading_thread = Thread.new do
+    # @api private
+    # @return [Thread] the reading thread
+    # @since 2.0.0
+    def start_reading_thread
+      Thread.new do
         begin
           while line = @socket.readline
-            begin
-              line = Cinch.encode_incoming(line, @bot.config.encoding)
+            rescue_exception do
+              line = Cinch::Utilities::Encoding.encode_incoming(line, @bot.config.encoding)
               parse line
-            rescue => e
-              @bot.logger.log_exception(e)
             end
           end
         rescue Timeout::Error
-          @bot.logger.debug "Connection timed out."
+          @bot.loggers.warn "Connection timed out."
         rescue EOFError
-          @bot.logger.debug "Lost connection."
+          @bot.loggers.warn "Lost connection."
         rescue => e
-          @bot.logger.log_exception(e)
+          @bot.loggers.exception(e)
         end
 
         @socket.close
-        @bot.dispatch(:disconnect)
-        @bot.handler_threads.each { |t| t.join(10); t.kill }
+        @bot.handlers.dispatch(:disconnect)
+        # FIXME won't we kill all :disconnect handlers here? prolly
+        # not, as they have 10 seconds to finish. that should be
+        # plenty of time
+        @bot.handlers.stop_all
       end
+    end
 
-      @sending_thread = Thread.new do
-        begin
+    # @api private
+    # @return [Thread] the sending thread
+    # @since 2.0.0
+    def start_sending_thread
+      Thread.new do
+        rescue_exception do
           @queue.process!
-        rescue => e
-          @bot.logger.log_exception(e)
         end
       end
+    end
 
-      ping_thread = Thread.new do
+    # @api private
+    # @return [Thread] The ping thread.
+    # @since 2.0.0
+    def start_ping_thread
+      Thread.new do
         while true
           sleep @bot.config.ping_interval
-          message("PING 0") # PING requires a single argument. In our
-                            # case the value doesn't matter though.
+          # PING requires a single argument. In our case the value
+          # doesn't matter though.
+          send("PING 0")
         end
       end
+    end
 
-      reading_thread.join
-      @sending_thread.kill
-      ping_thread.kill
+    # @since 2.0.0
+    def send_sasl
+      if @bot.config.sasl.username && @sasl_current_method = @sasl_remaining_methods.pop
+        @bot.loggers.info "[SASL] Trying to authenticate with #{@sasl_current_method.mechanism_name}"
+        send "AUTHENTICATE #{@sasl_current_method.mechanism_name}"
+      else
+        send_cap_end
+      end
+    end
+
+    # Establish a connection.
+    #
+    # @return [void]
+    # @since 2.0.0
+    def start
+      setup
+      if connect
+        @sasl_remaining_methods = [SASL::Plain, SASL::DH_Blowfish]
+        send_cap_ls
+        send_login
+
+        reading_thread = start_reading_thread
+        sending_thread = start_sending_thread
+        ping_thread    = start_ping_thread
+
+        reading_thread.join
+        sending_thread.kill
+        ping_thread.kill
+      end
     end
 
     # @api private
     # @return [void]
     def parse(input)
-      @bot.logger.log(input, :incoming) if @bot.config.verbose
+      return if input.chomp.empty?
+      @bot.loggers.incoming(input)
+
       msg          = Message.new(input, @bot)
       events       = [[:catchall]]
 
@@ -125,7 +231,9 @@ module Cinch
           events << [:connect]
           @bot.last_connection_was_successful = true
         end
-      elsif ["PRIVMSG", "NOTICE"].include?(msg.command)
+      end
+
+      if ["PRIVMSG", "NOTICE"].include?(msg.command)
         events << [:ctcp] if msg.ctcp?
         if msg.channel?
           events << [:channel]
@@ -134,24 +242,28 @@ module Cinch
         end
 
         if msg.command == "PRIVMSG"
-          events << [:message] << [:privmsg]
+          events << [:message]
         else
           events << [:notice]
         end
-      else
-        meth = "on_#{msg.command.downcase}"
-        __send__(meth, msg, events) if respond_to?(meth, true)
 
-        if msg.error?
-          events << [:error]
-        else
-          events << [msg.command.downcase.to_sym]
+        if msg.action?
+          events << [:action]
         end
       end
 
-      msg.instance_variable_set(:@events, events.map(&:first))
+      meth = "on_#{msg.command.downcase}"
+      __send__(meth, msg, events) if respond_to?(meth, true)
+
+      if msg.error?
+        events << [:error]
+      else
+        events << [msg.command.downcase.to_sym]
+      end
+
+      msg.events = events.map(&:first)
       events.each do |event, *args|
-        @bot.dispatch(event, msg, *args)
+        @bot.handlers.dispatch(event, msg, *args)
       end
     end
 
@@ -160,52 +272,173 @@ module Cinch
       (("001".."004").to_a - @registration).empty?
     end
 
-    # Send a message.
+    # Send a message to the server.
+    # @param [String] msg
     # @return [void]
-    def message(msg)
+    def send(msg)
       @queue.queue(msg)
     end
 
     private
+    def set_leaving_user(message, user, events)
+      events << [:leaving, user]
+    end
+
+    # @since 2.0.0
+    def detect_network(msg, event)
+      old_network = @network
+      new_network = nil
+      new_ircd    = nil
+      case event
+      when "002"
+        if msg.params.last =~ /^Your host is .+?, running version (.+)$/
+          case $1
+          when /\+snircd\(/
+            new_ircd = :snircd
+          when /^u[\d\.]+$/
+            new_ircd = :ircu
+          when /^(.+?)-?\d+/
+            new_ircd = $1.downcase.to_sym
+          end
+        elsif msg.params.last == "Your host is jtvchat"
+          new_network = :jtv
+          new_ircd    = :jtv
+        end
+      when "005"
+        case @isupport["NETWORK"]
+        when "NGameTV"
+          new_network = :ngametv
+          new_ircd    = :ngametv
+        when nil
+        else
+          new_network = @isupport["NETWORK"].downcase.to_sym
+        end
+      end
+
+      new_network ||= old_network.name
+      new_ircd    ||= old_network.ircd
+
+      if old_network.unknown_ircd? && new_ircd != :unknown
+        @bot.loggers.info "Detected IRCd: #{new_ircd}"
+      end
+      if !old_network.unknown_ircd? && new_ircd != old_network.ircd
+        @bot.loggers.info "Detected different IRCd: #{old_network.ircd} -> #{new_ircd}"
+      end
+      if old_network.unknown_network? && new_network != :unknown
+        @bot.loggers.info "Detected network: #{new_network}"
+      end
+      if !old_network.unknown_network? && new_network != old_network.name
+        @bot.loggers.info "Detected different network: #{old_network.name} -> #{new_network}"
+      end
+
+      @network.name = new_network
+      @network.ircd = new_ircd
+    end
+
+    def process_ban_mode(msg, events, param, direction)
+      mask = param
+      ban = Ban.new(mask, msg.user, Time.now)
+
+      if direction == :add
+        msg.channel.bans_unsynced << ban
+        events << [:ban, ban]
+      else
+        msg.channel.bans_unsynced.delete_if {|b| b.mask == ban.mask}.first
+        events << [:unban, ban]
+      end
+    end
+
+    def process_owner_mode(msg, events, param, direction)
+      owner = User(param)
+      if direction == :add
+        msg.channel.owners_unsynced << owner unless msg.channel.owners_unsynced.include?(owner)
+        events << [:owner, owner]
+      else
+        msg.channel.owners_unsynced.delete(owner)
+        events << [:deowner, owner]
+      end
+    end
+
+    # @since 2.0.0
+    def on_away(msg, events)
+      if msg.message.to_s.empty?
+        # unaway
+        m.user.sync(:away, nil, true)
+        events << [:unaway]
+      else
+        # away
+        m.user.sync(:away, msg.message, true)
+        events << [:away]
+      end
+    end
+
+    # @since 2.0.0
+    def on_cap(msg, events)
+      case msg.params[1]
+      when "LS"
+        @network.capabilities.concat msg.message.split(" ").map(&:to_sym)
+        send_cap_req
+      when "ACK"
+        if @network.capabilities.include?(:sasl)
+          send_sasl
+        else
+          send_cap_end
+        end
+      when "NACK"
+        send_cap_end
+      end
+    end
+
     def on_join(msg, events)
       if msg.user == @bot
         @bot.channels << msg.channel
         msg.channel.sync_modes
       end
       msg.channel.add_user(msg.user)
+      msg.user.online = true
     end
 
     def on_kick(msg, events)
-      target = @bot.user_manager.find_ensured(msg.params[1])
+      target = User(msg.params[1])
       if target == @bot
         @bot.channels.delete(msg.channel)
       end
       msg.channel.remove_user(target)
+
+      set_leaving_user(msg, target, events)
     end
 
     def on_kill(msg, events)
-      user = @bot.user_manager.find_ensured(msg.params[1])
-      @bot.channel_manager.each do |channel|
+      user = User(msg.params[1])
+
+      @bot.channel_list.each do |channel|
         channel.remove_user(user)
       end
+
       user.unsync_all
-      @bot.user_manager.delete(user)
+      user.online = false
+
+      set_leaving_user(msg, user, events)
     end
 
+    # @version 1.1.0
     def on_mode(msg, events)
       if msg.channel?
         add_and_remove = @bot.irc.isupport["CHANMODES"]["A"] + @bot.irc.isupport["CHANMODES"]["B"] + @bot.irc.isupport["PREFIX"].keys
 
-        param_modes = {:add => @bot.irc.isupport["CHANMODES"]["C"] + add_and_remove,
-          :remove => add_and_remove}
+        param_modes = {
+          :add    => @bot.irc.isupport["CHANMODES"]["C"] + add_and_remove,
+          :remove => add_and_remove
+        }
 
         modes = ModeParser.parse_modes(msg.params[1], msg.params[2..-1], param_modes)
         modes.each do |direction, mode, param|
           if @bot.irc.isupport["PREFIX"].keys.include?(mode)
-            target = @bot.User(param)
+            target = User(param)
+
             # (un)set a user-mode
             if direction == :add
-              msg.channel.users[target] << mode unless msg.channel.users[@bot.User(param)].include?(mode)
+              msg.channel.users[target] << mode unless msg.channel.users[User(param)].include?(mode)
             else
               msg.channel.users[target].delete mode
             end
@@ -222,23 +455,16 @@ module Cinch
           elsif @bot.irc.isupport["CHANMODES"]["A"].include?(mode)
             case mode
             when "b"
-              mask = param
-              ban = Ban.new(mask, msg.user, Time.now)
-
-              if direction == :add
-                msg.channel.bans_unsynced << ban
-                events << [:ban, ban]
-              else
-                msg.channel.bans_unsynced.delete_if {|b| b.mask == ban.mask}.first
-                events << [:unban, ban]
-              end
+              process_ban_mode(msg, events, param, direction)
+            when "q"
+              process_owner_mode(msg, events, param, direction) if @network.owner_list_mode
             else
-              raise UnsupportedFeature, mode
+              raise Exceptions::UnsupportedMode, mode
             end
           else
             # channel options
             if direction == :add
-              msg.channel.modes_unsynced[mode] = param
+              msg.channel.modes_unsynced[mode] = param.nil? ? true : param
             else
               msg.channel.modes_unsynced.delete(mode)
             end
@@ -246,26 +472,40 @@ module Cinch
         end
 
         events << [:mode_change, modes]
+      elsif msg.params.first == bot.nick
+        modes = ModeParser.parse_modes(msg.params[1], msg.params[2..-1])
+        modes.each do |direction, mode, _|
+          if direction == :add
+            @bot.modes << mode
+          else
+            @bot.modes.delete(mode)
+          end
+        end
       end
     end
 
     def on_nick(msg, events)
       if msg.user == @bot
-        @bot.config.nick = msg.params.last
+        @bot.set_nick msg.params.last
       end
 
       msg.user.update_nick(msg.params.last)
+      msg.user.online = true
     end
 
     def on_part(msg, events)
       msg.channel.remove_user(msg.user)
+      msg.user.channels_unsynced.delete msg.channel
+
       if msg.user == @bot
         @bot.channels.delete(msg.channel)
       end
+
+      set_leaving_user(msg, msg.user, events)
     end
 
     def on_ping(msg, events)
-      message "PONG :#{msg.params.first}"
+      send "PONG :#{msg.params.first}"
     end
 
     def on_topic(msg, events)
@@ -273,27 +513,87 @@ module Cinch
     end
 
     def on_quit(msg, events)
-      @bot.channel_manager.each do |channel|
+      @bot.channel_list.each do |channel|
         channel.remove_user(msg.user)
       end
       msg.user.unsync_all
-      @bot.user_manager.delete(msg.user)
+      msg.user.online = true
+
+      set_leaving_user(msg, msg.user, events)
+
+      if msg.message.downcase == "excess flood" && msg.user == @bot
+        @bot.warn ["Looks like your bot has been kicked because of excess flood.",
+                    "If you haven't modified the throttling options manually, please file a bug report at https://github.com/cinchrb/cinch/issues and include the following information:",
+                    "- Server: #{@bot.config.server}",
+                    "- Messages per second: #{@bot.config.messages_per_second}",
+                    "- Server queue size: #{@bot.config.server_queue_size}"]
+      end
+    end
+
+    # @since 2.0.0
+    def on_privmsg(msg, events)
+      if msg.user
+        msg.user.online = true
+      end
+
+
+      if msg.message =~ /^\001DCC SEND (\S+) (\d+) (\d+)(?: (\d+))?\001$/
+        process_dcc_send($1, $2, $3, $4, msg, events)
+      end
+    end
+
+    # @since 2.0.0
+    def process_dcc_send(filename, ip, port, size, m, events)
+      ip   = ip.to_i
+      ip   = [24, 16, 8, 0].collect {|b| (ip >> b) & 255}.join('.')
+      port = port.to_i
+      size = size.to_i
+
+      @bot.loggers.info "DCC: Incoming DCC SEND: File name: %s - Size: %dB - IP: %s - Port: %d" % [filename, size, ip, port]
+
+      dcc = DCC::Incoming::Send.new(user: m.user, filename: filename, size: size, ip: ip, port: port)
+      events << [:dcc_send, dcc]
+    end
+
+    # @since 2.0.0
+    def on_001(msg, events)
+      # Ensure that we know our real, possibly truncated or otherwise
+      # modified nick.
+      @bot.set_nick msg.params.first
+    end
+
+    # @since 2.0.0
+    def on_002(msg, events)
+      detect_network(msg, "002")
     end
 
     def on_005(msg, events)
       # ISUPPORT
       @isupport.parse(*msg.params[1..-2].map {|v| v.split(" ")}.flatten)
+      detect_network(msg, "005")
+    end
+
+    # @since 2.0.0
+    def on_301(msg, events)
+      # RPL_AWAY
+      user = User(msg.params.first)
+      away = msg.message
+
+      if @whois_updates[user]
+        @whois_updates[user].merge!({:away => away})
+      end
     end
 
+    # @since 1.1.0
     def on_307(msg, events)
       # RPL_WHOISREGNICK
-      user = @bot.user_manager.find_ensured(msg.params[1])
+      user = User(msg.params[1])
       @whois_updates[user].merge!({:authname => user.nick})
     end
 
     def on_311(msg, events)
       # RPL_WHOISUSER
-      user = @bot.user_manager.find_ensured(msg.params[1])
+      user = User(msg.params[1])
       @whois_updates[user].merge!({
                                     :user => msg.params[2],
                                     :host => msg.params[3],
@@ -303,7 +603,7 @@ module Cinch
 
     def on_317(msg, events)
       # RPL_WHOISIDLE
-      user = @bot.user_manager.find_ensured(msg.params[1])
+      user = User(msg.params[1])
       @whois_updates[user].merge!({
                                     :idle => msg.params[2].to_i,
                                     :signed_on_at => Time.at(msg.params[3].to_i),
@@ -312,7 +612,7 @@ module Cinch
 
     def on_318(msg, events)
       # RPL_ENDOFWHOIS
-      user = @bot.user_manager.find_ensured(msg.params[1])
+      user = User(msg.params[1])
 
       if @whois_updates[user].empty? && !user.attr(:unknown?, true, true)
         user.end_of_whois(nil)
@@ -324,16 +624,16 @@ module Cinch
 
     def on_319(msg, events)
       # RPL_WHOISCHANNELS
-      user = @bot.user_manager.find_ensured(msg.params[1])
-      channels = msg.params[2].scan(/#{@isupport["CHANTYPES"].join}[^ ]+/o).map {|c| @bot.channel_manager.find_ensured(c) }
+      user     = User(msg.params[1])
+      channels = msg.params[2].scan(/#{@isupport["CHANTYPES"].join}[^ ]+/o).map {|c| Channel(c) }
       user.sync(:channels, channels, true)
     end
 
     def on_324(msg, events)
       # RPL_CHANNELMODEIS
-
-      modes = {}
+      modes     = {}
       arguments = msg.params[3..-1]
+
       msg.params[2][1..-1].split("").each do |mode|
         if (@isupport["CHANMODES"]["B"] + @isupport["CHANMODES"]["C"]).include?(mode)
           modes[mode] = arguments.shift
@@ -347,8 +647,9 @@ module Cinch
 
     def on_330(msg, events)
       # RPL_WHOISACCOUNT
-      user = @bot.user_manager.find_ensured(msg.params[1])
+      user     = User(msg.params[1])
       authname = msg.params[2]
+
       @whois_updates[user].merge!({:authname => authname})
     end
 
@@ -362,6 +663,35 @@ module Cinch
       msg.channel.sync(:topic, msg.params[2])
     end
 
+    def on_352(msg, events)
+      # RPL_WHOREPLY
+      # "<channel> <user> <host> <server> <nick> <H|G>[*][@|+] :<hopcount> <real name>"
+      _, channel, user, host, server, nick, flags, hopsrealname = msg.params
+      hops, realname = hopsrealname.split(" ", 2)
+      channel     = Channel(channel)
+      user_object = User(nick)
+      user_object.sync(:user, user, true)
+      user_object.sync(:host, host, true)
+    end
+
+    def on_354(msg, events)
+      # RPL_WHOSPCRPL
+      # We are using the following format: %acfhnru
+
+      #                          _         user      host                                 nick      f account  realame
+      # :leguin.freenode.net 354 dominikh_ ~a        ip-88-152-125-117.unitymediagroup.de dominikh_ H 0        :d
+      # :leguin.freenode.net 354 dominikh_ ~FiXato   fixato.net                           FiXato    H FiXato   :FiXato, using WeeChat -- More? See: http://twitter
+      # :leguin.freenode.net 354 dominikh_ ~dominikh cinch/developer/dominikh             dominikh  H DominikH :dominikh
+      # :leguin.freenode.net 354 dominikh_ ~oddmunds s21-04214.dsl.no.powertech.net       oddmunds  H 0        :oddmunds
+
+      _, channel, user, host, nick, _, account, realname = msg.params
+      channel = Channel(channel)
+      user_object = User(nick)
+      user_object.sync(:user, user, true)
+      user_object.sync(:host, host, true)
+      user_object.sync(:authname, account == "0" ? nil : account, true)
+    end
+
     def on_353(msg, events)
       # RPL_NAMEREPLY
       unless @in_lists.include?(:names)
@@ -372,14 +702,16 @@ module Cinch
       msg.params[3].split(" ").each do |user|
         m = user.match(/^([#{@isupport["PREFIX"].values.join}]+)/)
         if m
-          prefixes = m[1].split.map {|s| @isupport["PREFIX"].key(s)}
+          prefixes = m[1].split("").map {|s| @isupport["PREFIX"].key(s)}
           nick   = user[prefixes.size..-1]
         else
           nick   = user
           prefixes = []
         end
-        user = @bot.user_manager.find_ensured(nick)
+        user        = User(nick)
+        user.online = true
         msg.channel.add_user(user, prefixes)
+        user.channels_unsynced << msg.channel unless user.channels_unsynced.include?(msg.channel)
       end
     end
 
@@ -389,6 +721,7 @@ module Cinch
       msg.channel.mark_as_synced(:users)
     end
 
+    # @version 2.0.0
     def on_367(msg, events)
       # RPL_BANLIST
       unless @in_lists.include?(:bans)
@@ -397,9 +730,19 @@ module Cinch
       @in_lists << :bans
 
       mask = msg.params[2]
-      by   = @bot.user_manager.find_ensured(msg.params[3].split("!").first)
-      at   = Time.at(msg.params[4].to_i)
+      if @network.jtv?
+        # on the justin tv network, ban "masks" only consist of the
+        # nick/username
+        mask = "%s!%s@%s" % [mask, mask, mask + ".irc.justin.tv"]
+      end
+
+      if msg.params[3]
+        by = User(msg.params[3].split("!").first)
+      else
+        by = nil
+      end
 
+      at  = Time.at(msg.params[4].to_i)
       ban = Ban.new(mask, by, at)
       msg.channel.bans_unsynced << ban
     end
@@ -416,16 +759,40 @@ module Cinch
       msg.channel.mark_as_synced(:bans)
     end
 
+    def on_386(msg, events)
+      # RPL_QLIST
+      unless @in_lists.include?(:owners)
+        msg.channel.owners_unsynced.clear
+      end
+      @in_lists << :owners
+
+      owner = User(msg.params[2])
+      msg.channel.owners_unsynced << owner
+    end
+
+    def on_387(msg, events)
+      # RPL_ENDOFQLIST
+      if @in_lists.include?(:owners)
+        @in_lists.delete :owners
+      else
+        #we never received an owner, yet an end of list -> no owners
+        msg.channel.owners_unsynced.clear
+      end
+
+      msg.channel.mark_as_synced(:owners)
+    end
+
     def on_396(msg, events)
       # RPL_HOSTHIDDEN
       # note: designed for freenode
-      @bot.user_manager.find_ensured(msg.params[0]).sync(:host, msg.params[1], true)
+      User(msg.params[0]).sync(:host, msg.params[1], true)
     end
 
     def on_401(msg, events)
       # ERR_NOSUCHNICK
-      user = @bot.user_manager.find_ensured(msg.params[1])
+      user = User(msg.params[1])
       user.sync(:unknown?, true, true)
+      msg.user.online = false
       if @whois_updates.key?(user)
         user.end_of_whois(nil, true)
         @whois_updates.delete user
@@ -435,7 +802,7 @@ module Cinch
     def on_402(msg, events)
       # ERR_NOSUCHSERVER
 
-      if user = @bot.user_manager.find(msg.params[1]) # not _ensured, we only want a user that already exists
+      if user = @bot.user_list.find(msg.params[1]) # not _ensured, we only want a user that already exists
         user.end_of_whois(nil, true)
         @whois_updates.delete user
         # TODO freenode specific, test on other IRCd
@@ -444,12 +811,60 @@ module Cinch
 
     def on_433(msg, events)
       # ERR_NICKNAMEINUSE
-      @bot.nick = @bot.generate_next_nick(msg.params[1])
+      @bot.nick = @bot.generate_next_nick!(msg.params[1])
     end
 
     def on_671(msg, events)
-      user = @bot.user_manager.find_ensured(msg.params[1])
+      user = User(msg.params[1])
       @whois_updates[user].merge!({:secure? => true})
     end
+
+    # @since 2.0.0
+    def on_730(msg, events)
+      # RPL_MONONLINE
+      msg.params.last.split(",").each do |mask|
+        user = User(Mask.new(mask).nick)
+        # User is responsible for emitting an event
+        user.online = true
+      end
+    end
+
+    # @since 2.0.0
+    def on_731(msg, events)
+      # RPL_MONOFFLINE
+      msg.params.last.split(",").each do |nick|
+        user = User(nick)
+        # User is responsible for emitting an event
+        user.online = false
+      end
+    end
+
+    # @since 2.0.0
+    def on_734(msg, events)
+      # ERR_MONLISTFULL
+      user = User(msg.params[2])
+      user.monitored = false
+    end
+
+    # @since 2.0.0
+    def on_903(msg, events)
+      # SASL authentication successful
+      @bot.loggers.info "[SASL] SASL authentication with #{@sasl_current_method.mechanism_name} successful"
+      send_cap_end
+    end
+
+    # @since 2.0.0
+    def on_904(msg, events)
+      # SASL authentication failed
+      @bot.loggers.info "[SASL] SASL authentication with #{@sasl_current_method.mechanism_name} failed"
+      send_sasl
+    end
+
+    # @since 2.0.0
+    def on_authenticate(msg, events)
+      send "AUTHENTICATE " + @sasl_current_method.generate(@bot.config.sasl.username,
+                                                           @bot.config.sasl.password,
+                                                           msg.params.last)
+    end
   end
 end