cinch 1.1.3 → 2.0.0.pre.1

data/docs/readme.md

@@ -0,0 +1,18 @@
+# @title README
+
+
+- {file:changes.md Changelog}
+- {file:migrating.md Migration guides}
+
+# Important documents
+
+The following is a list of important documents to read.
+
+- {file:bot_options.md Bot options}
+- {file:common_tasks.md Common Tasks}
+- {file:common_mistakes.md Common mistakes}
+- {Cinch::DCC DCC}
+- {file:encodings.md Encodings}
+- {file:logging.md Logging}
+- {Cinch::SASL SASL}
+- {file:events.d Events}

data/examples/plugins/custom_prefix.rb

@@ -3,7 +3,7 @@ require 'cinch'
 class SomeCommand
   include Cinch::Plugin
 
-  prefix "~"
+  prefix /^~/
   match "somecommand"
 
   def execute(m)

data/examples/plugins/dice_roll.rb

@@ -0,0 +1,38 @@
+require 'cinch'
+
+class DiceRoll
+  include Cinch::Plugin
+
+  # [[<repeats>#]<rolls>]d<sides>[<+/-><offset>]
+  match(/roll (?:(?:(\d+)#)?(\d+))?d(\d+)(?:([+-])(\d+))?/)
+  def execute(m, repeats, rolls, sides, offset_op, offset)
+    repeats = repeats.to_i
+    repeats = 1 if repeats < 1
+    rolls   = rolls.to_i
+    rolls   = 1 if rolls < 1
+
+    total = 0
+
+    repeats.times do
+      rolls.times do
+        score = rand(sides.to_i) + 1
+        if offset_op
+          score = score.send(offset_op, offset.to_i)
+        end
+        total += score
+      end
+    end
+
+    m.reply "Your dice roll was: #{total}", true
+  end
+end
+
+bot = Cinch::Bot.new do
+  configure do |c|
+    c.server = 'irc.freenode.org'
+    c.channels = ['#cinch-bots']
+    c.plugins.plugins = [DiceRoll]
+  end
+end
+
+bot.start

data/examples/plugins/lambdas.rb

@@ -9,7 +9,7 @@ class DirectAddressing
   #
   # The reason we are using a lambda is that the bot's nick can change
   # and the prefix has to be up to date.
-  prefix lambda{ |m| m.bot.nick + ": " }
+  prefix lambda{ |m| Regexp.new("^" + Regexp.escape(m.bot.nick + ": " ))}
 
   match "hello", method: :greet
   def greet(m)

data/examples/plugins/memo.rb

@@ -1,39 +1,42 @@
 #!/usr/bin/env ruby
 
 require 'cinch'
+require 'cinch/storage/yaml'
 
 class Memo
-  class MemoStruct < Struct.new(:nick, :channel, :text, :time)
+  class MemoStruct < Struct.new(:user, :channel, :text, :time)
     def to_s
-      "[#{time.asctime}] <#{channel}/#{nick}> #{text}"
+      "[#{time.asctime}] <#{channel}/#{user}> #{text}"
     end
   end
 
   include Cinch::Plugin
 
-  listen_to :message
-  match /memo (.+?) (.+)/
-
   def initialize(*args)
     super
-    @memos = {}
+    storage[:memos] ||= {}
   end
 
+  listen_to :message
+  match /memo (.+?) (.+)/
+
   def listen(m)
-    if @memos.has_key?(m.user.nick)
-      m.user.send @memos.delete(m.user.nick).to_s
+    if storage[:memos].has_key?(m.user.nick)
+      m.user.send storage[:memos].delete(m.user.nick).to_s
+      storage.save
     end
   end
 
   def execute(m, nick, message)
-    if @memos.key?(nick)
+    if storage[:memos].key?(nick)
       m.reply "There's already a memo for #{nick}. You can only store one right now"
     elsif nick == m.user.nick
       m.reply "You can't leave memos for yourself.."
     elsif nick == bot.nick
       m.reply "You can't leave memos for me.."
     else
-      @memos[nick] = MemoStruct.new(m.user.nick, m.channel, message, Time.now)
+      storage[:memos][nick] = MemoStruct.new(m.user.name, m.channel.name, message, Time.now)
+      storage.save
       m.reply "Added memo for #{nick}"
     end
   end
@@ -44,6 +47,9 @@ bot = Cinch::Bot.new do
     c.server = "irc.freenode.org"
     c.channels = ["#cinch-bots"]
     c.plugins.plugins = [Memo]
+    c.storage.backend = Cinch::Storage::YAML
+    c.storage.basedir = "./yaml/"
+    c.storage.autosave = true
   end
 end
 

data/examples/plugins/url_shorten.rb

@@ -26,6 +26,7 @@ bot = Cinch::Bot.new do
   configure do |c|
     c.server = "irc.freenode.org"
     c.channels = ["#cinch-bots"]
+    c.plugins.plugins = [TinyURL]
   end
 end
 

data/lib/cinch.rb

@@ -1,61 +1,6 @@
+require 'cinch/version'
+require 'cinch/utilities/kernel'
+require 'cinch/utilities/string'
+require 'cinch/utilities/deprecation'
+require 'cinch/utilities/encoding'
 require 'cinch/bot'
-
-module Cinch
-  VERSION = '1.1.3'
-
-  # @return [String]
-  # @todo Handle mIRC color codes more gracefully.
-  # @api private
-  def self.filter_string(string)
-    string.gsub(/[\x00-\x1f]/, '')
-  end
-
-  # @api private
-  def self.encode_incoming(string, encoding)
-    string = string.dup
-    if encoding == :irc
-      # If incoming text is valid UTF-8, it will be interpreted as
-      # such. If it fails validation, a CP1252 -> UTF-8 conversion
-      # is performed. This allows you to see non-ASCII from mIRC
-      # users (non-UTF-8) and other users sending you UTF-8.
-      #
-      # (from http://xchat.org/encoding/#hybrid)
-      string.force_encoding("UTF-8")
-      if !string.valid_encoding?
-        string.force_encoding("CP1252").encode!("UTF-8", {:invalid => :replace, :undef => :replace})
-      end
-    else
-      string.force_encoding(encoding).encode!({:invalid => :replace, :undef => :replace})
-      string = string.chars.select { |c| c.valid_encoding? }.join
-    end
-
-    return string
-  end
-
-  # @api private
-  def self.encode_outgoing(string, encoding)
-    string = string.dup
-    if encoding == :irc
-      # If your text contains only characters that fit inside the CP1252
-      # code page (aka Windows Latin-1), the entire line will be sent
-      # that way. mIRC users should see it correctly. XChat users who
-      # are using UTF-8 will also see it correctly, because it will fail
-      # UTF-8 validation and will be assumed to be CP1252, even by older
-      # XChat versions.
-      #
-      # If the text doesn't fit inside the CP1252 code page, (for eaxmple if you
-      # type Eastern European characters, or Russian) it will be sent as UTF-8. Only
-      # UTF-8 capable clients will be able to see these characters correctly
-      #
-      # (from http://xchat.org/encoding/#hybrid)
-      begin
-        string.encode!("CP1252")
-      rescue Encoding::UndefinedConversionError
-      end
-    else
-      string.encode!(encoding, {:invalid => :replace, :undef => :replace})
-    end
-
-    return string
-  end
-end

data/lib/cinch/ban.rb

@@ -1,10 +1,16 @@
 require "cinch/mask"
 module Cinch
+  # This class represents channel bans.
   class Ban
-    # @return [Mask, String]
+    # @return [Mask] A {Mask} object for non-extended bans
+    # @return [String] A String object for extended bans (see {#extended})
     attr_reader :mask
 
-    # @return [User]
+    # The user who created the ban. Might be nil on networks that do
+    # not strictly follow the RFCs, for example IRCnet in some(?)
+    # cases.
+    #
+    # @return [User, nil] The user who created the ban
     attr_reader :by
 
     # @return [Time]
@@ -13,17 +19,17 @@ module Cinch
     # @return [Boolean] whether this is an extended ban (as used by for example Freenode)
     attr_reader :extended
 
-    # @param [String] mask The mask
-    # @param [User] by The user who created the ban
+    # @param [String, Mask] mask The mask
+    # @param [User, nil] by The user who created the ban.
     # @param [Time] at The time at which the ban was created
     def initialize(mask, by, at)
       @by, @created_at = by, at
-      if mask =~ /^\$/
+      if mask =~ /^[\$~]/
         @extended = true
         @mask     = mask
       else
         @extended = false
-        @mask = Mask.new(mask)
+        @mask = Mask.from(mask)
       end
     end
 
@@ -31,7 +37,7 @@ module Cinch
     # @raise [Exceptions::UnsupportedFeature] Cinch does not support
     #   Freenode's extended bans
     def match(user)
-      raise UnsupportedFeature, "extended bans (freenode) are not supported yet" if @extended
+      raise UnsupportedFeature, "extended bans are not supported yet" if @extended
       @mask =~ user
     end
     alias_method :=~, :match

data/lib/cinch/bot.rb

@@ -3,20 +3,23 @@ require 'socket'
 require "thread"
 require "ostruct"
 require "cinch/rubyext/module"
-require "cinch/rubyext/queue"
 require "cinch/rubyext/string"
-require "cinch/rubyext/infinity"
+require "cinch/rubyext/float"
 
 require "cinch/exceptions"
 
+require "cinch/handler"
 require "cinch/helpers"
-require "cinch/logger/logger"
-require "cinch/logger/null_logger"
+
+require "cinch/logger_list"
+require "cinch/logger"
+
 require "cinch/logger/formatted_logger"
 require "cinch/syncable"
 require "cinch/message"
 require "cinch/message_queue"
 require "cinch/irc"
+require "cinch/target"
 require "cinch/channel"
 require "cinch/user"
 require "cinch/constants"
@@ -27,81 +30,103 @@ require "cinch/isupport"
 require "cinch/plugin"
 require "cinch/pattern"
 require "cinch/mode_parser"
-require "cinch/cache_manager"
-require "cinch/channel_manager"
-require "cinch/user_manager"
+require "cinch/dcc"
+require "cinch/sasl"
+
+require "cinch/handler_list"
+require "cinch/cached_list"
+require "cinch/channel_list"
+require "cinch/user_list"
+require "cinch/plugin_list"
+
+require "cinch/timer"
+require "cinch/formatting"
+
+require "cinch/configuration"
+require "cinch/configuration/bot"
+require "cinch/configuration/plugins"
+require "cinch/configuration/ssl"
+require "cinch/configuration/timeouts"
+require "cinch/configuration/storage"
+require "cinch/configuration/dcc"
+require "cinch/configuration/sasl"
 
 module Cinch
+  # @attr nick
+  # @version 2.0.0
+  class Bot < User
+    include Helpers
+
 
-  class Bot
-    # @return [Config]
+    # @return [Configuration::Bot]
+    # @version 2.0.0
     attr_reader :config
+
+    # The underlying IRC connection
+    #
     # @return [IRC]
     attr_reader :irc
-    # @return [Logger]
-    attr_accessor :logger
+
+    # The logger list containing all loggers
+    #
+    # @return [LoggerList]
+    # @since 2.0.0
+    attr_accessor :loggers
+
     # @return [Array<Channel>] All channels the bot currently is in
     attr_reader :channels
-    # @return [String] the bot's hostname
-    attr_reader :host
-    # @return [Mask]
-    attr_reader :mask
-    # @return [String]
-    attr_reader :user
-    # @return [String]
-    attr_reader :realname
-    # @return [Time]
-    attr_reader :signed_on_at
-    # @return [Array<Plugin>] All registered plugins
+
+    # @return [PluginList] All registered plugins
+    # @version 2.0.0
     attr_reader :plugins
-    # @return [Array<Thread>]
-    # @api private
-    attr_reader :handler_threads
+
     # @return [Boolean] whether the bot is in the process of disconnecting
     attr_reader :quitting
-    # @return [UserManager]
-    attr_reader :user_manager
-    # @return [ChannelManager]
-    attr_reader :channel_manager
+
+    # @return [UserList] All {User users} the bot knows about.
+    # @see UserList
+    # @since 1.1.0
+    attr_reader :user_list
+
+    # @return [ChannelList] All {Channel channels} the bot knows about.
+    # @see ChannelList
+    # @since 1.1.0
+    attr_reader :channel_list
+
+    # @return [PluginList] All loaded plugins.
+    # @version 2.0.0
+    attr_reader :plugins
+
     # @return [Boolean]
     # @api private
     attr_accessor :last_connection_was_successful
 
-    # @group Helper methods
+    # @return [Callback]
+    # @api private
+    attr_reader :callback
 
-    # Helper method for turning a String into a {Channel} object.
+    # The {HandlerList}, providing access to all registered plugins
+    # and plugin manipulation as well as {HandlerList#dispatch calling handlers}.
     #
-    # @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)
-      @channel_manager.find_ensured(channel)
-    end
+    # @return [HandlerList]
+    # @see HandlerList
+    # @since 2.0.0
+    attr_reader :handlers
 
-    # Helper method for turning a String into an {User} object.
+    # The bot's modes.
     #
-    # @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)
-      @user_manager.find_ensured(user)
-    end
+    # @return [Array<String>]
+    # @since 2.0.0
+    attr_reader :modes
+
+    # @group Helper methods
 
     # Define helper methods in the context of the bot.
     #
     # @yield Expects a block containing method definitions
     # @return [void]
     def helpers(&b)
-      Callback.class_eval(&b)
+      @callback.instance_eval(&b)
     end
 
     # Since Cinch uses threads, all handlers can be run
@@ -142,234 +167,47 @@ module Cinch
       semaphore.synchronize(&block)
     end
 
-    # Stop execution of the current {#on} handler.
-    #
-    # @return [void]
-    def halt
-      throw :halt
-    end
-
     # @endgroup
-    # @group Sending messages
 
-    # Sends a raw message to the server.
-    #
-    # @param [String] command The message to send.
-    # @return [void]
-    # @see IRC#message
-    def raw(command)
-      @irc.message(command)
-    end
-
-    # Sends a PRIVMSG to a recipient (a channel or user).
-    # You should be using {Channel#send} and {User#send} instead.
-    #
-    # @param [String] recipient the recipient
-    # @param [String] text the message to send
-    # @param [Boolean] notice Use NOTICE instead of PRIVMSG?
-    # @return [void]
-    # @see Channel#send
-    # @see User#send
-    # @see #safe_msg
-    def msg(recipient, text, notice = false)
-      text = text.to_s
-      split_start = @config.message_split_start || ""
-      split_end   = @config.message_split_end   || ""
-      command = notice ? "NOTICE" : "PRIVMSG"
-
-      text.split(/\r\n|\r|\n/).each do |line|
-        maxlength = 510 - (":" + " #{command} " + " :").size
-        maxlength = maxlength - self.mask.to_s.length - recipient.to_s.length
-        maxlength_without_end = maxlength - split_end.bytesize
-
-        if line.bytesize > maxlength
-          splitted = []
-
-          while line.bytesize > maxlength_without_end
-            pos = line.rindex(/\s/, maxlength_without_end)
-            r = pos || maxlength_without_end
-            splitted << line.slice!(0, r) + split_end.tr(" ", "\u00A0")
-            line = split_start.tr(" ", "\u00A0") + line.lstrip
-          end
-
-          splitted << line
-          splitted[0, (@config.max_messages || splitted.size)].each do |string|
-            string.tr!("\u00A0", " ") # clean string from any non-breaking spaces
-            raw("#{command} #{recipient} :#{string}")
-          end
-        else
-          raw("#{command} #{recipient} :#{line}")
-        end
-      end
-    end
-    alias_method :privmsg, :msg
-    alias_method :send, :msg
-
-    # Sends a NOTICE to a recipient (a channel or user).
-    # You should be using {Channel#notice} and {User#notice} instead.
-    #
-    # @param [String] recipient the recipient
-    # @param [String] text the message to send
-    # @return [void]
-    # @see Channel#notice
-    # @see User#notice
-    # @see #safe_notice
-    def notice(recipient, text)
-      msg(recipient, text, true)
-    end
-
-    # Like {#msg}, but remove any non-printable characters from
-    # `text`. The purpose of this method is to send text of untrusted
-    # sources, like other users or feeds.
-    #
-    # Note: this will **break** any mIRC color codes embedded in the
-    # string.
-    #
-    # @return (see #msg)
-    # @param (see #msg)
-    # @see #msg
-    # @see User#safe_send
-    # @see Channel#safe_send
-    # @todo Handle mIRC color codes more gracefully.
-    def safe_msg(recipient, text)
-      msg(recipient, Cinch.filter_string(text))
-    end
-    alias_method :safe_privmsg, :safe_msg
-    alias_method :safe_send, :safe_msg
-
-    # Like {#safe_msg} but for notices.
-    #
-    # @return (see #safe_msg)
-    # @param (see #safe_msg)
-    # @see #safe_notice
-    # @see #notice
-    # @see User#safe_notice
-    # @see Channel#safe_notice
-    # @todo (see #safe_msg)
-    def safe_notice(recipient, text)
-      msg(recipient, Cinch.filter_string(text), true)
-    end
-
-    # Invoke an action (/me) in/to a recipient (a channel or user).
-    # You should be using {Channel#action} and {User#action} instead.
-    #
-    # @param [String] recipient the recipient
-    # @param [String] text the message to send
-    # @return [void]
-    # @see Channel#action
-    # @see User#action
-    # @see #safe_action
-    def action(recipient, text)
-      raw("PRIVMSG #{recipient} :\001ACTION #{text}\001")
-    end
-
-    # Like {#action}, but remove any non-printable characters from
-    # `text`. The purpose of this method is to send text from
-    # untrusted sources, like other users or feeds.
-    #
-    # Note: this will **break** any mIRC color codes embedded in the
-    # string.
-    #
-    # @param (see #action)
-    # @return (see #action)
-    # @see #action
-    # @see Channel#safe_action
-    # @see User#safe_action
-    # @todo Handle mIRC color codes more gracefully.
-    def safe_action(recipient, text)
-      action(recipient, Cinch.filter_string(text))
-    end
-
-    # @endgroup
     # @group Events &amp; Plugins
 
     # Registers a handler.
     #
-    # @param [String, Symbol, Integer] event the event to match. Available
-    #   events are all IRC commands in lowercase as symbols, all numeric
-    #   replies, and the following:
+    # @param [String, Symbol, Integer] event the event to match. For a
+    #   list of available events, check the {file:events.md Events
+    #   documentation}.
     #
-    #     - :channel (a channel message)
-    #     - :private (a private message)
-    #     - :message (both channel and private messages)
-    #     - :error   (handling errors, use a numeric error code as `match`)
-    #     - :ctcp    (ctcp requests, use a ctcp command as `match`)
-    #
-    # @param [Regexp, String, Integer] match every message of the
+    # @param [Regexp, Pattern, String] regexp every message of the
     #   right event will be checked against this argument and the event
     #   will only be called if it matches
     #
+    # @param [Array<Object>] *args Arguments that should be passed to
+    #   the block, additionally to capture groups of the regexp.
+    #
     # @yieldparam [String] *args each capture group of the regex will
-    #   be one argument to the block. It is optional to accept them,
-    #   though
+    #   be one argument to the block.
     #
-    # @return [void]
-    def on(event, regexps = [], *args, &block)
-      regexps = [*regexps]
-      regexps = [//] if regexps.empty?
-
+    # @return [Handler] The handlers that have been registered
+    def on(event, regexp = //, *args, &block)
       event = event.to_sym
 
-      regexps.map! do |regexp|
-        pattern = case regexp
-                 when Pattern
-                   regexp
-                 when Regexp
-                   Pattern.new(nil, regexp, nil)
-                 else
-                   if event == :ctcp
-                     Pattern.new(/^/, /#{Regexp.escape(regexp.to_s)}(?:$| .+)/, nil)
-                   else
-                     Pattern.new(/^/, /#{Regexp.escape(regexp.to_s)}/, /$/)
-                   end
-                 end
-        debug "[on handler] Registering handler with pattern `#{pattern.inspect}`, reacting on `#{event}`"
-        pattern
-      end
-      (@events[event] ||= []) << [regexps, args, block]
-    end
+      pattern = case regexp
+                when Pattern
+                  regexp
+                when Regexp
+                  Pattern.new(nil, regexp, nil)
+                else
+                  if event == :ctcp
+                    Pattern.generate(:ctcp, regexp)
+                  else
+                    Pattern.new(/^/, /#{Regexp.escape(regexp.to_s)}/, /$/)
+                  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)
-        handlers.each do |handler|
-          regexps, args, block = *handler
-          # calling Message#match multiple times is not a problem
-          # because we cache the result
-          if msg
-            regexp = regexps.find { |rx|
-              msg.match(rx.to_r(msg), event)
-            }
-            captures = msg.match(regexp.to_r(msg), event).captures
-          else
-            captures = []
-          end
+      handler = Handler.new(self, event, pattern, {args: args, execute_in_callback: true}, &block)
+      @handlers.register(handler)
 
-          invoke(block, args, msg, captures, arguments)
-        end
-      end
-    end
-
-    # Register all plugins from `@config.plugins.plugins`.
-    #
-    # @return [void]
-    def register_plugins
-      @config.plugins.plugins.each do |plugin|
-        register_plugin(plugin)
-      end
-    end
-
-    # Registers a plugin.
-    #
-    # @param [Class<Plugin>] plugin The plugin class to register
-    # @return [void]
-    def register_plugin(plugin)
-      @plugins << plugin.new(self)
+      return handler
     end
 
     # @endgroup
@@ -380,8 +218,8 @@ module Cinch
     #
     # @yieldparam [Struct] config the bot's config
     # @return [void]
-    def configure(&block)
-      @callback.instance_exec(@config, &block)
+    def configure
+      yield @config
     end
 
     # Disconnects from the server.
@@ -390,15 +228,11 @@ module Cinch
     # @return [void]
     def quit(message = nil)
       @quitting = true
-      command = message ? "QUIT :#{message}" : "QUIT"
-      raw command
+      command   = message ? "QUIT :#{message}" : "QUIT"
+
+      @irc.send command
     end
 
-    # Connects the bot to a server.
-    #
-    # @param [Boolean] plugins Automatically register plugins from
-    #   `@config.plugins.plugins`?
-    # @return [void]
     # Connects the bot to a server.
     #
     # @param [Boolean] plugins Automatically register plugins from
@@ -406,21 +240,37 @@ module Cinch
     # @return [void]
     def start(plugins = true)
       @reconnects = 0
-      register_plugins if plugins
+      @plugins.register_plugins(@config.plugins.plugins) if plugins
 
       begin
-        @user_manager.each do |user|
+        @user_list.each do |user|
           user.in_whois = false
           user.unsync_all
         end # reset state of all users
 
-        @channel_manager.each do |channel|
+        @channel_list.each do |channel|
           channel.unsync_all
         end # reset state of all channels
 
-        @logger.debug "Connecting to #{@config.server}:#{@config.port}"
+        @join_handler.unregister if @join_handler
+        @join_timer.stop if @join_timer
+
+        join_lambda = lambda { @config.channels.each { |channel| Channel(channel).join }}
+
+        if @config.delay_joins.is_a?(Symbol)
+          @join_handler = join_handler = on(@config.delay_joins) {
+            join_handler.unregister
+            join_lambda.call
+          }.first
+        else
+          @join_timer = Timer.new(self, interval: @config.delay_joins, shots: 1) {
+            join_lambda.call
+          }
+        end
+
+        @loggers.info "Connecting to #{@config.server}:#{@config.port}"
         @irc = IRC.new(self)
-        @irc.connect
+        @irc.start
 
         if @config.reconnect && !@quitting
           # double the delay for each unsuccesful reconnection attempt
@@ -431,15 +281,26 @@ module Cinch
             @reconnects += 1
           end
 
-          # Sleep for a few seconds before reconnecting to prevent being
-          # throttled by the IRC server
+          # Throttle reconnect attempts
           wait = 2**@reconnects
-          @logger.debug "Waiting #{wait} seconds before reconnecting"
-          sleep wait
+          wait = @config.max_reconnect_delay if wait > @config.max_reconnect_delay
+          @loggers.info "Waiting #{wait} seconds before reconnecting"
+          start_time = Time.now
+          while !@quitting && (Time.now - start_time) < wait
+            sleep 1
+          end
         end
       end while @config.reconnect and not @quitting
     end
 
+    # TODO document this
+    def stop
+      @plugins.each do |plugin|
+        plugin.storage.save
+        plugin.storage.unload
+      end
+    end
+
     # @endgroup
     # @group Channel Control
 
@@ -447,30 +308,30 @@ module Cinch
     #
     # @param [String, Channel] channel either the name of a channel or a {Channel} object
     # @param [String] key optionally the key of the channel
-    # @return [void]
+    # @return [Channel] The joined channel
     # @see Channel#join
     def join(channel, key = nil)
-      Channel(channel).join(key)
+      channel = Channel(channel)
+      channel.join(key)
+
+      channel
     end
 
     # Part a channel.
     #
     # @param [String, Channel] channel either the name of a channel or a {Channel} object
     # @param [String] reason an optional reason/part message
-    # @return [void]
+    # @return [Channel] The channel that was left
     # @see Channel#part
     def part(channel, reason = nil)
-      Channel(channel).part(reason)
+      channel = Channel(channel)
+      channel.part(reason)
+
+      channel
     end
 
     # @endgroup
 
-    # (see Logger::Logger#debug)
-    # @see Logger::Logger#debug
-    def debug(msg)
-      @logger.debug(msg)
-    end
-
     # @return [Boolean] True if the bot reports ISUPPORT violations as
     #   exceptions.
     def strict?
@@ -479,66 +340,76 @@ module Cinch
 
     # @yield
     def initialize(&b)
-      @logger = Logger::FormattedLogger.new($stderr)
-      @events = {}
-      @config = OpenStruct.new({
-                                 :server => "localhost",
-                                 :port   => 6667,
-                                 :ssl    => OpenStruct.new({
-                                                             :use => false,
-                                                             :verify => false,
-                                                             :client_cert => nil,
-                                                             :ca_path => "/etc/ssl/certs",
-                                                           }),
-                                 :password => nil,
-                                 :nick   => "cinch",
-                                 :nicks  => nil,
-                                 :realname => "cinch",
-                                 :user => "cinch",
-                                 :verbose => true,
-                                 :messages_per_second => 0.5,
-                                 :server_queue_size => 10,
-                                 :strictness => :forgiving,
-                                 :message_split_start => '... ',
-                                 :message_split_end   => ' ...',
-                                 :max_messages => nil,
-                                 :plugins => OpenStruct.new({
-                                                              :plugins => [],
-                                                              :prefix  => /^!/,
-                                                              :suffix  => nil,
-                                                              :options => Hash.new {|h,k| h[k] = {}},
-                                                            }),
-                                 :channels => [],
-                                 :encoding => :irc,
-                                 :reconnect => true,
-                                 :local_host => nil,
-                                 :timeouts => OpenStruct.new({
-                                                               :read => 240,
-                                                               :connect => 10,
-                                                             }),
-                                 :ping_interval => 120,
-                               })
+      @loggers = LoggerList.new
+      @loggers << Logger::FormattedLogger.new($stderr)
 
+      @config           = Configuration::Bot.new
+      @handlers         = HandlerList.new
       @semaphores_mutex = Mutex.new
-      @semaphores = Hash.new { |h,k| h[k] = Mutex.new }
-      @plugins = []
-      @callback = Callback.new(self)
-      @channels = []
-      @handler_threads = []
-      @quitting = false
+      @semaphores       = Hash.new { |h, k| h[k] = Mutex.new }
+      @callback         = Callback.new(self)
+      @channels         = []
+      @quitting         = false
+      @modes            = []
 
-      @user_manager = UserManager.new(self)
-      @channel_manager = ChannelManager.new(self)
+      @user_list    = UserList.new(self)
+      @channel_list = ChannelList.new(self)
+      @plugins      = PluginList.new(self)
 
+      super(nil, self)
       instance_eval(&b) if block_given?
+    end
 
-      on :connect do
-        bot.config.channels.each do |channel|
-          bot.join channel
-        end
+    # @since 2.0.0
+    # @return [self]
+    # @api private
+    def bot
+      # This method is needed for the Helpers interface
+      self
+    end
+
+    # Sets a mode on the bot.
+    #
+    # @param [String] mode
+    # @return [void]
+    # @since 2.0.0
+    # @see Bot#modes
+    # @see Bot#unset_mode
+    def set_mode(mode)
+      @modes << mode unless @modes.include?(mode)
+      @irc.send "MODE #{nick} +#{mode}"
+    end
+
+    # Unsets a mode on the bot.
+    #
+    # @param [String] mode
+    # @return [void]
+    # @since 2.0.0
+    def unset_mode(mode)
+      @modes.delete(mode)
+      @irc.send "MODE #{nick} -#{mode}"
+    end
+
+    # @since 2.0.0
+    def modes=(modes)
+      (@modes - modes).each do |mode|
+        unset_mode(mode)
+      end
+
+      (modes - @modes).each do |mode|
+        set_mode(mode)
       end
     end
 
+    # Used for updating the bot's nick from within the IRC parser.
+    #
+    # @param [String] nick
+    # @api private
+    # @return [String]
+    def set_nick(nick)
+      @name = nick
+    end
+
     # The bot's nickname.
     # @overload nick=(new_nick)
     #   @raise [Exceptions::NickTooLong] Raised if the bot is
@@ -548,11 +419,8 @@ module Cinch
     # @overload nick
     #   @return [String]
     # @return [String]
-    attr_accessor :nick
-    undef_method "nick"
-    undef_method "nick="
     def nick
-      @config.nick
+      @name
     end
 
     def nick=(new_nick)
@@ -560,7 +428,7 @@ module Cinch
         raise Exceptions::NickTooLong, new_nick
       end
       @config.nick = new_nick
-      raw "NICK #{new_nick}"
+      @irc.send "NICK #{new_nick}"
     end
 
     # Try to create a free nick, first by cycling through all
@@ -568,80 +436,37 @@ module Cinch
     #
     # @param [String] base The base nick to start trying from
     # @api private
-    # @return String
-    def generate_next_nick(base = nil)
+    # @return [String]
+    # @since 2.0.0
+    def generate_next_nick!(base = nil)
       nicks = @config.nicks || []
 
       if base
         # if `base` is not in our list of nicks to try, assume that it's
         # custom and just append an underscore
         if !nicks.include?(base)
-          return base + "_"
+          new_nick =  base + "_"
         else
           # if we have a base, try the next nick or append an
           # underscore if no more nicks are left
           new_index = nicks.index(base) + 1
           if nicks[new_index]
-            return nicks[new_index]
+            new_nick = nicks[new_index]
           else
-            return base + "_"
+            new_nick = base + "_"
           end
         end
       else
         # if we have no base, try the first possible nick
         new_nick = @config.nicks ? @config.nicks.first : @config.nick
       end
-    end
-
-    # @return [Boolean] True if the bot is using SSL to connect to the
-    #   server.
-    def secure?
-      @config[:ssl] == true || (@config[:ssl].is_a?(Hash) && @config[:ssl][:use])
-    end
-
-    # This method is only provided in order to give Bot and User a
-    # common interface.
-    #
-    # @return [false] Always returns `false`.
-    # @see User#unknown? See User#unknown? for the method's real use.
-    def unknown?
-      false
-    end
-
-    [:host, :mask, :user, :realname, :signed_on_at, :secure?].each do |attr|
-      define_method(attr) do
-        User(nick).__send__(attr)
-      end
-    end
 
-    private
-    def find(type, msg = nil)
-      if events = @events[type]
-        if msg.nil?
-          return events
-        end
-
-        events.select { |regexps|
-          regexps.first.any? { |regexp|
-            msg.match(regexp.to_r(msg), type)
-          }
-        }
-      end
+      @config.nick = new_nick
     end
 
-    def invoke(block, args, msg, match, arguments)
-      bargs = match + arguments
-      @handler_threads << Thread.new do
-        begin
-          catch(:halt) do
-            @callback.instance_exec(msg, *args, *bargs, &block)
-          end
-        rescue => e
-          @logger.log_exception(e)
-        ensure
-          @handler_threads.delete Thread.current
-        end
-      end
+    # @return [String]
+    def inspect
+      "#<Bot nick=#{@name.inspect}>"
     end
   end
 end