From c06e64a6556f1703f9455ad91299c521ad8b3ed8 Mon Sep 17 00:00:00 2001
From: Johannes Löthberg <johannes@kyriasis.com>
Date: Wed, 5 Oct 2016 11:06:16 +0200
Subject: weechat: I give up
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Johannes Löthberg <johannes@kyriasis.com>
---
 weechat/python/chanop.py | 3236 ----------------------------------------------
 1 file changed, 3236 deletions(-)
 delete mode 100644 weechat/python/chanop.py

(limited to 'weechat/python/chanop.py')

diff --git a/weechat/python/chanop.py b/weechat/python/chanop.py
deleted file mode 100644
index 848837e..0000000
--- a/weechat/python/chanop.py
+++ /dev/null
@@ -1,3236 +0,0 @@
-# -*- coding: utf-8 -*-
-###
-# Copyright (c) 2009-2013 by Elián Hanisch <lambdae2@gmail.com>
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-###
-
-###
-#   Helper script for IRC Channel Operators
-#
-#   Inspired by auto_bleh.pl (irssi) and chanserv.py (xchat) scripts.
-#
-#   Networks like Freenode and some channels encourage operators to not stay
-#   permanently with +o privileges and only use it when needed. This script
-#   works along those lines, requesting op, kick/ban/etc and deop
-#   automatically with a single command.
-#   Still this script is very configurable and its behaviour can be configured
-#   in a per server or per channel basis so it can fit most needs without
-#   changing its code.
-#
-#   Features several completions for ban/quiet masks and a memory for channel
-#   masks and users (so users that parted are still bannable by nick).
-#
-#
-#   Commands (see detailed help with /help in WeeChat):
-#   *      /oop: Request or give op.
-#   *    /odeop: Drop or remove op.
-#   *    /okick: Kick user (or users).
-#   *     /oban: Apply ban mask.
-#   *   /ounban: Remove ban mask.
-#   *   /oquiet: Apply quiet mask.
-#   * /ounquiet: Remove quiet mask.
-#   * /obankick: Ban and kick user (or users)
-#   *   /otopic: Change channel topic
-#   *    /omode: Change channel modes
-#   *    /olist: List cached masks (bans or quiets)
-#   *   /ovoice: Give voice to user
-#   * /odevoice: Remove voice from user
-#
-#
-#   Settings:
-#   Most configs (unless noted otherwise) can be defined for a server or a
-#   channel in particular, so it is possible to request op in different
-#   networks, stay always op'ed in one channel while
-#   auto-deop in another.
-#
-#   For define an option for a specific server use:
-#   /set plugins.var.python.chanop.<option>.<server> "value"
-#   For define it in a specific channel use:
-#   /set plugins.var.python.chanop.<option>.<server>.<#channel> "value"
-#
-#   * plugins.var.python.chanop.op_command:
-#     Here you define the command the script must run for request op, normally
-#     is a /msg to a bot, like chanserv in freenode or Q in quakenet.
-#     It accepts the special vars $server, $channel and $nick
-#
-#     By default it ask op to chanserv, if your network doesn't use chanserv,
-#     then you must change it.
-#
-#     Examples:
-#     /set plugins.var.python.chanop.op_command
-#          "/msg chanserv op $channel $nick"
-#     (globally for all servers, like freenode and oftc)
-#     /set plugins.var.python.chanop.op_command.quakenet
-#          "/msg q op $channel $nick"
-#     (for quakenet only)
-#
-#   * plugins.var.python.chanop.autodeop:
-#     Enables auto-deop'ing after using any of the ban or kick commands.
-#     Note that if you got op manually (like with /oop) then the script won't
-#     deop you.
-#     Valid values: 'on', 'off' Default: 'on'
-#
-#   * plugins.var.python.chanop.autodeop_delay:
-#     Time it must pass (without using any commands) before auto-deop, in
-#     seconds. Using zero causes to deop immediately.
-#     Default: 180
-#
-#   * plugins.var.python.chanop.default_banmask:
-#     List of keywords separated by comas. Defines default banmask, when using
-#     /oban, /obankick or /oquiet
-#     You can use several keywords for build a banmask, each keyword defines how
-#     the banmask will be generated for a given hostmask, see /help oban.
-#     Valid keywords are: nick, user, host and exact.
-#     Default: 'host'
-#
-#     Examples:
-#     /set plugins.var.python.chanop.default_banmask host
-#     (bans with *!*@host)
-#     /set plugins.var.python.chanop.default_banmask host,user
-#     (bans with *!user@host)
-#
-#   * plugins.var.python.chanop.kick_reason:
-#     Default kick reason if none was given in the command.
-#
-#   * plugins.var.python.chanop.enable_remove:
-#     If enabled, it will use "/quote remove" command instead of /kick, enable
-#     it only in networks that support it, like freenode.
-#     Valid values: 'on', 'off' Default: 'off'
-#
-#     Example:
-#     /set plugins.var.python.chanop.enable_remove.freenode on
-#
-#   * plugins.var.python.chanop.display_affected:
-#     Whenever a new ban is set, chanop will show the users affected by it.
-#     This is intended for help operators to see if their ban is too wide or
-#     point out clones in the channel.
-#     Valid values: 'on', 'off' Default: 'off'
-#
-#
-#   The following configs are global and can't be defined per server or channel.
-#
-#   * plugins.var.python.chanop.enable_multi_kick:
-#     Enables kicking multiple users with /okick command.
-#     Be careful with this as you can kick somebody by accident if
-#     you're not careful when writting the kick reason.
-#
-#     This also applies to /obankick command, multiple bankicks would be enabled.
-#     Valid values: 'on', 'off' Default: 'off'
-#
-#   * plugins.var.python.chanop.enable_bar:
-#     This will enable a pop-up bar for displaying chanop messages that would
-#     otherwise be printed in the buffer. This bar also shows in realtime the
-#     users affected by a ban you're about to set.
-#     Valid values: 'on', 'off' Default: 'on'
-#
-#
-#   The following configs are defined per server and are updated by the script only.
-#
-#   * plugins.var.python.chanop.watchlist:
-#     Indicates to chanop which channels should watch and keep track of users and
-#     masks. This config is automatically updated when you use any command that needs
-#     op, so manual setting shouldn't be needed.
-#
-#   * plugins.var.python.chanop.isupport:
-#     Only used in WeeChat versions prior to 0.3.3 which lacked support for
-#     irc_005 messages. These aren't meant to be set manually.
-#
-#
-#   Completions:
-#     Chanop has several completions, documented here. Some aren't used by chanop
-#     itself, but can be used in aliases with custom completions.
-#     Examples:
-#     apply exemptions with mask autocompletion
-#     /alias -completion %(chanop_ban_mask) exemption /mode $channel +e
-#     if you use grep.py script, grep with host autocompletion, for look clones.
-#     /alias -completion %(chanop_hosts) ogrep /grep
-#
-#   * chanop_unban_mask (used in /ounban)
-#     Autocompletes with banmasks set in current channel, requesting them if needed.
-#     Supports patterns for autocomplete several masks: *<tab> for all bans, or
-#     *192.168*<tab> for bans with '192.168' string.
-#
-#   * chanop_unquiet (used in /ounquiet)
-#     Same as chanop_unban_mask, but with masks for q channel mode.
-#
-#   * chanop_ban_mask (used in /oban and /oquiet)
-#     Given a partial IRC hostmask, it will try to complete with hostmasks of current
-#     users: *!*@192<tab> will try to complete with matching users, like
-#     *!*@192.168.0.1
-#
-#   * chanop_nicks (used in most commands)
-#     Autocompletes nicks, same as WeeChat's completer, but using chanop's user
-#     cache, so nicks from users that parted the channel will be still be completed.
-#
-#   * chanop_users (not used by chanop)
-#     Same as chanop_nicks, but with the usename part of the hostmask.
-#
-#   * chanop_hosts (not used by chanop)
-#     Same as chanop_nicks, but with the host part of the hostmask (includes previously used
-#     hostnames).
-#
-#
-#   TODO
-#   * use dedicated config file like in urlgrab.py?
-#   * ban expire time
-#   * save ban.mask and ban.hostmask across reloads
-#   * allow to override quiet command (for quiet with ChanServ)
-#   * freenode:
-#    - support for bans with channel forward
-#    - support for extbans (?)
-#   * Sort completions by user activity
-#
-#
-#   History:
-#   2013-05-24
-#   version 0.3.1: bug fixes
-#   * fix exceptions while fetching bans with /mode
-#   * fix crash with /olist command in networks that don't support +q channel masks.
-#
-#   2013-04-14
-#   version 0.3:
-#   * cycle between different banmasks in /oban /oquiet commands.
-#   * added pop-up bar for show information.
-#   * save ban mask information (date and operator)
-#   * remove workarounds for < 0.3.2 weechat versions
-#   * python 3.0 compatibility (not tested)
-#
-#   2013-01-02
-#   version 0.2.7: bug fixes:
-#   * fix /obankick, don't deop before kicking.
-#
-#   2011-09-18
-#   version 0.2.6: bug fixes:
-#   * update script to work with freenode's new quiet messages.
-#   * /omode wouldn't work with several modes.
-#
-#   2011-05-31
-#   version 0.2.5: bug fixes:
-#   * /omode -o nick wouldn't work due to the deopNow switch.
-#   * unban_completer could fetch the same masks several times.
-#   * removing ban forwards falied when using exact mask.
-#   * user nick wasn't updated in every call.
-#
-#   2011-02-02
-#   version 0.2.4: fix python 2.5 compatibility
-#
-#   2011-01-09
-#   version 0.2.3: bug fixes.
-#
-#   2010-12-23
-#   version 0.2.2: bug fixes.
-#
-#   2010-10-28
-#   version 0.2.1: refactoring mostly
-#   * deop_command option removed
-#   * removed --webchat switch, freenode's updates made it superfluous.
-#   * if WeeChat doesn't know a hostmask, use /userhost or /who if needed.
-#   * /oban and /oquiet without arguments show ban/quiet list.
-#   * most commands allows '-o' option, that forces immediate deop (without configured delay).
-#   * updated for WeeChat 0.3.4 (irc_nick infolist changes)
-#
-#   2010-09-20
-#   version 0.2: major update
-#   * fixed quiets for ircd-seven (freenode)
-#   * implemented user and mask cache.
-#   * added commands:
-#     - /ovoice /odevoice for de/voice users.
-#     - /omode for change channel modes.
-#     - /olist for list bans/quiets on cache.
-#   * changed /omute and /ounmute commands to /oquiet and /ounquiet, as q masks
-#     is refered as a quiet rather than a mute.
-#   * autocompletions:
-#     - for bans set on a channel.
-#     - for make new bans.
-#     - for nicks/usernames/hostnames.
-#   * /okban renamed to /obankick. This is because /okban is too similar to
-#     /okick and bankicking somebody due to tab fail was too easy.
-#   * added display_affected feature.
-#   * added --webchat ban option.
-#   * config options removed:
-#     - merge_bans: superseded by isupport methods.
-#     - enable_mute: superseded by isupport methods.
-#     - invert_kickban_order: now is fixed to "ban, then kick"
-#   * Use WeeChat isupport infos.
-#   * /oop and /odeop can op/deop other users.
-#
-#   2009-11-9
-#   version 0.1.1: fixes
-#   * script renamed to 'chanop' because it was causing conflicts with python
-#     'operator' module
-#   * added /otopic command
-#
-#   2009-10-31
-#   version 0.1: Initial release
-###
-
-WEECHAT_VERSION = (0x30200, '0.3.2')
-
-SCRIPT_NAME    = "chanop"
-SCRIPT_AUTHOR  = "Elián Hanisch <lambdae2@gmail.com>"
-SCRIPT_VERSION = "0.3.1"
-SCRIPT_LICENSE = "GPL3"
-SCRIPT_DESC    = "Helper script for IRC Channel Operators"
-
-# default settings
-settings = {
-'op_command'            :'/msg chanserv op $channel $nick',
-'autodeop'              :'on',
-'autodeop_delay'        :'180',
-'default_banmask'       :'host',
-'enable_remove'         :'off',
-'kick_reason'           :'',
-'enable_multi_kick'     :'off',
-'display_affected'      :'on',
-'enable_bar'            :'on',
-}
-
-try:
-    import weechat
-    from weechat import WEECHAT_RC_OK, prnt
-    import_ok = True
-except ImportError:
-    print("This script must be run under WeeChat.")
-    print("Get WeeChat now at: http://www.weechat.org/")
-    import_ok = False
-
-import os
-import re
-import time
-import string
-import getopt
-from collections import defaultdict
-from shelve import DbfilenameShelf as Shelf
-
-chars = string.maketrans('', '')
-
-# -----------------------------------------------------------------------------
-# Messages
-
-script_nick = SCRIPT_NAME
-def error(s, buffer=''):
-    """Error msg"""
-    prnt(buffer, '%s%s %s' % (weechat.prefix('error'), script_nick, s))
-    value = weechat.config_get_plugin('debug')
-    if value and boolDict[value]:
-        import traceback
-        if traceback.sys.exc_type:
-            trace = traceback.format_exc()
-            prnt('', trace)
-
-def say(s, buffer=''):
-    """normal msg"""
-    prnt(buffer, '%s\t%s' %(script_nick, s))
-
-def _no_debug(*args):
-    pass
-
-debug = _no_debug
-
-# -----------------------------------------------------------------------------
-# Config
-
-# TODO Need to refactor all this too
-
-boolDict = {'on':True, 'off':False, True:'on', False:'off'}
-def get_config_boolean(config, get_function=None, **kwargs):
-    if get_function and callable(get_function):
-        value = get_function(config, **kwargs)
-    else:
-        value = weechat.config_get_plugin(config)
-    try:
-        return boolDict[value]
-    except KeyError:
-        default = settings[config]
-        error("Error while fetching config '%s'. Using default value '%s'." %(config, default))
-        error("'%s' is invalid, allowed: 'on', 'off'" %value)
-        return boolDict[default]
-
-def get_config_int(config, get_function=None):
-    if get_function and callable(get_function):
-        value = get_function(config)
-    else:
-        value = weechat.config_get_plugin(config)
-    try:
-        return int(value)
-    except ValueError:
-        default = settings[config]
-        error("Error while fetching config '%s'. Using default value '%s'." %(config, default))
-        error("'%s' is not a number." %value)
-        return int(default)
-
-valid_banmask = set(('nick', 'user', 'host', 'exact'))
-def get_config_banmask(config='default_banmask', get_function=None):
-    if get_function and callable(get_function):
-        value = get_function(config)
-    else:
-        value = weechat.config_get_plugin(config)
-    values = value.lower().split(',')
-    for value in values:
-        if value not in valid_banmask:
-            default = settings[config]
-            error("Error while fetching config '%s'. Using default value '%s'." %(config, default))
-            error("'%s' is an invalid value, allowed: %s." %(value, ', '.join(valid_banmask)))
-            return default
-    #debug("default banmask: %s" %values)
-    return values
-
-def get_config_list(config):
-    value = weechat.config_get_plugin(config)
-    if value:
-        return value.split(',')
-    else:
-        return []
-
-def get_config_specific(config, server='', channel=''):
-    """Gets config defined for either server or channel."""
-    value = None
-    if server and channel:
-        string = '%s.%s.%s' %(config, server, channel)
-        value = weechat.config_get_plugin(string)
-    if server and not value:
-        string = '%s.%s' %(config, server)
-        value = weechat.config_get_plugin(string)
-    if not value:
-        value = weechat.config_get_plugin(config)
-    return value
-
-# -----------------------------------------------------------------------------
-# Utils
-
-now = lambda: int(time.time())
-
-def time_elapsed(elapsed, ret=None, level=2):
-    time_hour = 3600
-    time_day  = 86400
-    time_year = 31536000
-
-    if ret is None:
-        ret = []
-
-    if not elapsed:
-        return ''
-
-    if elapsed > time_year:
-        years, elapsed = elapsed // time_year, elapsed % time_year
-        ret.append('%s%s' %(years, 'y'))
-    elif elapsed > time_day:
-        days, elapsed = elapsed // time_day, elapsed % time_day
-        ret.append('%s%s' %(days, 'd'))
-    elif elapsed > time_hour:
-        hours, elapsed = elapsed // time_hour, elapsed % time_hour
-        ret.append('%s%s' %(hours, 'h'))
-    elif elapsed > 60:
-        mins, elapsed = elapsed // 60, elapsed % 60
-        ret.append('%s%s' %(mins, 'm'))
-    else:
-        secs, elapsed = elapsed, 0
-        ret.append('%s%s' %(secs, 's'))
-
-    if len(ret) >= level or not elapsed:
-        return ' '.join(ret)
-
-    ret = time_elapsed(elapsed, ret, level)
-    return ret
-
-# -----------------------------------------------------------------------------
-# IRC utils
-
-_hostmaskRe = re.compile(r':?\S+!\S+@\S+') # poor but good enough
-def is_hostmask(s):
-    """Returns whether or not the string s starts with something like a hostmask."""
-    return _hostmaskRe.match(s) is not None
-
-def is_ip(s):
-    """Returns whether or not a given string is an IPV4 address."""
-    import socket
-    try:
-        return bool(socket.inet_aton(s))
-    except socket.error:
-        return False
-
-_reCache = {}
-def cachedPattern(f):
-    """Use cached regexp object or compile a new one from pattern."""
-    def getRegexp(pattern, *arg):
-        try:
-            regexp = _reCache[pattern]
-        except KeyError:
-            s = '^'
-            for c in pattern:
-                if c == '*':
-                    s += '.*'
-                elif c == '?':
-                    s += '.'
-                elif c in '[{':
-                    s += r'[\[{]'
-                elif c in ']}':
-                    s += r'[\]}]'
-                elif c in '|\\':
-                    s += r'[|\\]'
-                else:
-                    s += re.escape(c)
-            s += '$'
-            regexp = re.compile(s, re.I)
-            _reCache[pattern] = regexp
-        return f(regexp, *arg)
-    return getRegexp
-
-def hostmaskPattern(f):
-    """Check if pattern is for match a hostmask and remove ban forward if there's one."""
-    def checkPattern(pattern, arg):
-        # XXX this needs a refactor
-        if is_hostmask(pattern):
-            # nick!user@host$#channel
-            if '$' in pattern:
-                pattern = pattern.partition('$')[0]
-            if isinstance(arg, list):
-                arg = [ s for s in arg if is_hostmask(s) ]
-            elif not is_hostmask(arg):
-                return ''
-
-            rt = f(pattern, arg)
-            # this doesn't match any mask in args with a channel forward
-            pattern += '$*'
-            if isinstance(arg, list):
-                rt.extend(f(pattern, arg))
-            elif not rt:
-                rt = f(pattern, arg)
-            return rt
-
-        return ''
-    return checkPattern
-
-match_string = lambda r, s: r.match(s) is not None
-match_list = lambda r, L: [ s for s in L if r.match(s) is not None ]
-
-pattern_match = cachedPattern(match_string)
-pattern_match_list = cachedPattern(match_list)
-hostmask_match = hostmaskPattern(pattern_match)
-hostmask_match_list = hostmaskPattern(pattern_match_list)
-
-def get_nick(s):
-    """':nick!user@host' => 'nick'"""
-    return weechat.info_get('irc_nick_from_host', s)
-
-def get_user(s, trim=False):
-    """'nick!user@host' => 'user'"""
-    assert is_hostmask(s), "Invalid hostmask: %s" % s
-    s = s[s.find('!') + 1:s.find('@')]
-    if trim:
-        # remove the stuff not part of the username.
-        if s[0] == '~':
-            return s[1:]
-        elif s[:2] in ('i=', 'n='):
-            return s[2:]
-    return s
-
-def get_host(s):
-    """'nick!user@host' => 'host'"""
-    assert is_hostmask(s), "Invalid hostmask: %s" % s
-    if ' ' in s:
-        return s[s.find('@') + 1:s.find(' ')]
-    return s[s.find('@') + 1:]
-
-def is_channel(s):
-    return weechat.info_get('irc_is_channel', s)
-
-def is_nick(s):
-    return weechat.info_get('irc_is_nick', s)
-
-def irc_buffer(buffer):
-    """Returns pair (server, channel) or None if buffer isn't an irc channel"""
-    get_string = weechat.buffer_get_string
-    if get_string(buffer, 'plugin') == 'irc' \
-            and get_string(buffer, 'localvar_type') == 'channel':
-        channel = get_string(buffer, 'localvar_channel')
-        server = get_string(buffer, 'localvar_server')
-        return (server, channel)
-
-# -----------------------------------------------------------------------------
-# WeeChat classes
-
-class InvalidIRCBuffer(Exception):
-    pass
-
-def catchExceptions(f):
-    def function(*args, **kwargs):
-        try:
-            return f(*args, **kwargs)
-        except Exception as e:
-            error(e)
-    return function
-
-def callback(method):
-    """This function will take a bound method or function and make it a callback."""
-    # try to create a descriptive and unique name.
-    func = method.func_name
-    try:
-        im_self = method.im_self
-        try:
-            inst = im_self.__name__
-        except AttributeError:
-            try:
-                inst = im_self.name
-            except AttributeError:
-                raise Exception("Instance of %s has no __name__ attribute" %type(im_self))
-        cls = type(im_self).__name__
-        name = '_'.join((cls, inst, func))
-    except AttributeError:
-        # not a bound method
-        name = func
-
-    method = catchExceptions(method)
-
-    # set our callback
-    import __main__
-    setattr(__main__, name, method)
-    return name
-
-def weechat_command(buffer, cmd):
-    """I want to always keep debug() calls for this"""
-    if buffer:
-        debug("%ssending: %r buffer: %s", COLOR_WHITE, cmd, buffer)
-    else:
-        debug("%ssending: %r", COLOR_WHITE, cmd)
-    weechat.command(buffer, cmd)
-
-class Infolist(object):
-    """Class for reading WeeChat's infolists."""
-
-    fields = {
-            'name'        :'string',
-            'option_name' :'string',
-            'value'       :'string',
-            'host'        :'string',
-            'flags'       :'integer',
-            'prefixes'    :'string',
-            'is_connected':'integer',
-            'buffer'      :'pointer',
-            }
-
-    _use_flags = False
-
-    def __init__(self, name, args='', pointer=''):
-        self.cursor = 0
-        #debug('Generating infolist %r %r', name, args)
-        self.pointer = weechat.infolist_get(name, pointer, args)
-        if self.pointer == '':
-            raise Exception("Infolist initialising failed (name:'%s' args:'%s')" %(name, args))
-
-    def __len__(self):
-        """True False evaluation."""
-        if self.pointer:
-            return 1
-        else:
-            return 0
-
-    def __del__(self):
-        """Purge infolist if is no longer referenced."""
-        self.free()
-
-    def __getitem__(self, name):
-        """Implement the evaluation of self[name]."""
-        if self._use_flags and name == 'prefixes':
-            name = 'flags'
-        value = getattr(weechat, 'infolist_%s' %self.fields[name])(self.pointer, name)
-        if self._use_flags and name == 'flags':
-            value = self._flagsAsString(value)
-        return value
-
-    def _flagsAsString(self, n):
-        s = ''
-        if n & 32:
-            s += '+'
-        if n & 8:
-            s += '@'
-        return s
-
-    def __iter__(self):
-        def generator():
-            while self.next():
-                yield self
-        return generator()
-
-    def next(self):
-        self.cursor = weechat.infolist_next(self.pointer)
-        return self.cursor
-
-    def prev(self):
-        self.cursor = weechat.infolist_prev(self.pointer)
-        return self.cursor
-
-    def reset(self):
-        """Moves cursor to beginning of infolist."""
-        if self.cursor == 1: # only if we aren't in the beginning already
-            while self.prev():
-                pass
-
-    def free(self):
-        if self.pointer:
-            weechat.infolist_free(self.pointer)
-            self.pointer = ''
-
-def nick_infolist(server, channel):
-    try:
-        return Infolist('irc_nick', '%s,%s' % (server, channel))
-    except:
-        raise InvalidIRCBuffer('%s.%s' % (server, channel))
-
-class NoArguments(Exception):
-    pass
-
-class ArgumentError(Exception):
-    pass
-
-class Command(object):
-    """Class for hook WeeChat commands."""
-    description, usage, help = "WeeChat command.", "[define usage template]", "detailed help here"
-    command = ''
-    completion = ''
-
-    def __init__(self):
-        assert self.command, "No command defined"
-        self.__name__ = self.command
-        self._pointer = ''
-        self._callback = ''
-
-    def __call__(self, *args):
-        return self.callback(*args)
-
-    def callback(self, data, buffer, args):
-        """Called by WeeChat when /command is used."""
-        self.data, self.buffer, self.args = data, buffer, args
-        debug("%s[%s] data: \"%s\" buffer: \"%s\" args: \"%s\"", COLOR_DARKGRAY,
-                                                                 self.command,
-                                                                 data,
-                                                                 buffer,
-                                                                 args)
-        try:
-            self.parser(args)  # argument parsing
-        except ArgumentError as e:
-            error('Argument error, %s' %e)
-        except NoArguments:
-            pass
-        else:
-            self.execute()
-        return WEECHAT_RC_OK
-
-    def parser(self, args):
-        """Argument parsing, override if needed."""
-        pass
-
-    def execute(self):
-        """This method is called when the command is run, override this."""
-        pass
-
-    def hook(self):
-        assert not self._pointer, \
-                "There's already a hook pointer, unhook first (%s)" %self.command
-        self._callback = callback(self.callback)
-        pointer = weechat.hook_command(self.command,
-                                       self.description,
-                                       self.usage,
-                                       self.help,
-                                       self.completion,
-                                       self._callback, '')
-        if pointer == '':
-            raise Exception("hook_command failed: %s %s" % (SCRIPT_NAME, self.command))
-        self._pointer = pointer
-
-    def unhook(self):
-        if self._pointer:
-            weechat.unhook(self._pointer)
-            self._pointer = ''
-            self._callback = ''
-
-class Bar(object):
-    def __init__(self, name, hidden=False, items=''):
-        self.name = name
-        self.hidden = hidden
-        self._pointer = ''
-        self._items = items
-
-    def new(self):
-        assert not self._pointer, "Bar %s already created" % self.name
-        pointer = weechat.bar_search(self.name)
-        if not pointer:
-            pointer = weechat.bar_new(self.name, boolDict[self.hidden], '0', 'window',
-                                      'active', 'bottom', 'horizontal', 'vertical',
-                                      '0', '1', 'default', 'cyan', 'blue', 'off',
-                                      self._items)
-            if not pointer:
-                raise Exception("bar_new failed: %s %s" % (SCRIPT_NAME, self.name))
-
-        self._pointer = pointer
-
-    def getPointer(self):
-        return weechat.bar_search(self.name)
-
-    def show(self):
-        pointer = self.getPointer()
-        if pointer and self.hidden:
-            weechat.bar_set(pointer, 'hidden', 'off')
-            self.hidden = False
-        return pointer
-
-    def hide(self):
-        pointer = self.getPointer()
-        if pointer and not self.hidden:
-            weechat.bar_set(pointer, 'hidden', 'on')
-            self.hidden = True
-
-    def remove(self):
-        pointer = self.getPointer()
-        if pointer:
-            weechat.bar_remove(pointer)
-            self._pointer = ''
-
-    def __len__(self):
-        """True False evaluation."""
-        if self.getPointer():
-            return 1
-        else:
-            return 0
-
-class PopupBar(Bar):
-    _timer_hook = ''
-    popup_mode = False
-
-    def popup(self, delay=10):
-        if self.show():
-            if self._timer_hook:
-                weechat.unhook(self._timer_hook)
-            self._timer_hook = weechat.hook_timer(delay * 1000, 0, 1, callback(self._timer), '')
-
-    def _timer(self, data, counter):
-        self.hide()
-        self._timer_hook = ''
-        return WEECHAT_RC_OK
-
-# -----------------------------------------------------------------------------
-# Per buffer variables
-
-class BufferVariables(dict):
-    """Keeps variables and objects of a specific buffer."""
-    def __init__(self, buffer):
-        self['buffer'] = buffer
-        self['irc'] = IrcCommands(buffer)
-        self['autodeop'] = True
-        self['deopHook'] = self.opHook = self.opTimeout = None
-        self['server'] = weechat.buffer_get_string(buffer, 'localvar_server')
-        self['channel'] = weechat.buffer_get_string(buffer, 'localvar_channel')
-        self['nick'] = weechat.info_get('irc_nick', self.server)
-
-    def __getattr__(self, k):
-        return self[k]
-
-    def __setattr__(self, k, v):
-        debug(' -- buffer[%s] %s ... %s => %s', self.buffer, k, self.get(k), v)
-        self[k] = v
-
-class ChanopBuffers(object):
-    """Keeps track of BuffersVariables instances in chanop."""
-    buffer = ''
-    _buffer = {} # must be shared across instances
-    def __getattr__(self, k):
-        return self._buffer[self.buffer][k]
-
-    def setup(self, buffer):
-        self.buffer = buffer
-        if buffer not in self._buffer:
-            self._buffer[buffer] = BufferVariables(buffer)
-        else:
-            # update nick, it might have changed.
-            self.vars.nick = weechat.info_get('irc_nick', self.vars.server)
-
-    @property
-    def vars(self):
-        return self._buffer[self.buffer]
-
-    def varsOf(self, buffer):
-        return self._buffer[buffer]
-
-    def replace_vars(self, s):
-        try:
-            return weechat.buffer_string_replace_local_var(self.buffer, s)
-        except AttributeError:
-            if '$channel' in s:
-                s = s.replace('$channel', self.channel)
-            if '$nick' in s:
-                s = s.replace('$nick', self.nick)
-            if '$server' in s:
-                s = s.replace('$server', self.server)
-            return s
-
-    def get_config(self, config):
-        #debug('config: %s' %config)
-        return get_config_specific(config, self.server, self.channel)
-
-    def get_config_boolean(self, config):
-        return get_config_boolean(config, self.get_config)
-
-    def get_config_int(self, config):
-        return get_config_int(config, self.get_config)
-
-# -----------------------------------------------------------------------------
-# IRC messages queue
-
-class Message(ChanopBuffers):
-    command = None
-    args = ()
-    wait = 0
-    def __init__(self, cmd=None, args=(), wait=0):
-        if cmd:  self.command = cmd
-        if args: self.args = args
-        if wait: self.wait = wait
-
-    def payload(self):
-        cmd = self.command
-        if cmd[0] != '/':
-            cmd = '/' + cmd
-        if self.args:
-            cmd += ' ' + ' '.join(self.args)
-        if self.wait:
-            cmd = '/wait %s ' %self.wait + cmd
-        return cmd
-
-    def register(self, buffer):
-        self.buffer = buffer
-
-    def __call__(self):
-        cmd = self.payload()
-        if cmd:
-            self.send(cmd)
-
-    def send(self, cmd):
-        weechat_command(self.buffer, cmd)
-
-    def __repr__(self):
-        return '<Message(%s, %s)>' %(self.command, self.args)
-
-class IrcCommands(ChanopBuffers):
-    """Class that manages and sends the script's commands to WeeChat."""
-
-    # Special message classes
-    class OpMessage(Message):
-        def send(self, cmd):
-            if self.irc.checkOp():
-                # nothing to do
-                return
-
-            self.irc.interrupt = True
-            Message.send(self, cmd)
-
-            def modeOpCallback(buffer, signal, signal_data):
-                vars = self.varsOf(buffer)
-                data = 'MODE %s +o %s' % (vars.channel, vars.nick)
-                signal = signal_data.split(None, 1)[1]
-                if signal == data:
-                    debug('GOT OP')
-                    # add this channel to our watchlist
-                    config = 'watchlist.%s' % vars.server
-                    channels = CaseInsensibleSet(get_config_list(config))
-                    if vars.channel not in channels:
-                        channels.add(vars.channel)
-                        value = ','.join(channels)
-                        weechat.config_set_plugin(config, value)
-                    weechat.unhook(vars.opHook)
-                    weechat.unhook(vars.opTimeout)
-                    vars.opTimeout = vars.opHook = None
-                    vars.irc.interrupt = False
-                    vars.irc.run()
-                return WEECHAT_RC_OK
-
-            def timeoutCallback(buffer, count):
-                vars = self.varsOf(buffer)
-                error("Couldn't get op in '%s', purging command queue..." % vars.channel)
-                weechat.unhook(vars.opHook)
-                if vars.deopHook:
-                    weechat.unhook(vars.deopHook)
-                    vars.deopHook = None
-                vars.opTimeout = vars.opHook = None
-                vars.irc.interrupt = False
-                vars.irc.clear()
-                return WEECHAT_RC_OK
-
-            # wait for a while before timing out.
-            self.vars.opTimeout = weechat.hook_timer(30*1000, 0, 1, callback(timeoutCallback),
-                    self.buffer)
-
-            self.vars.opHook = weechat.hook_signal('%s,irc_in2_MODE' %self.server,
-                    callback(modeOpCallback), self.buffer)
-
-    class UserhostMessage(Message):
-        def send(self, cmd):
-            self.irc.interrupt = True
-            Message.send(self, cmd)
-
-            def msgCallback(buffer, modifier, modifier_data, string):
-                vars = self.varsOf(buffer)
-                if vars.server != modifier_data:
-                    return string
-                nick, host = string.rsplit(None, 1)[1].split('=')
-                nick, host = nick.strip(':*'), host[1:]
-                hostmask = '%s!%s' % (nick, host)
-                debug('USERHOST: %s %s', nick, hostmask)
-                userCache.remember(modifier_data, nick, hostmask)
-                weechat.unhook(vars.msgHook)
-                weechat.unhook(vars.msgTimeout)
-                vars.msgTimeout = vars.msgHook = None
-                vars.irc.interrupt = False
-                vars.irc.run()
-                return ''
-
-            def timeoutCallback(buffer, count):
-                vars = self.varsOf(buffer)
-                weechat.unhook(vars.msgHook)
-                vars.msgTimeout = vars.msgHook = None
-                vars.irc.interrupt = False
-                vars.irc.clear()
-                return WEECHAT_RC_OK
-
-            # wait for a while before timing out.
-            self.vars.msgTimeout = \
-                weechat.hook_timer(30*1000, 0, 1, callback(timeoutCallback), self.buffer)
-
-            self.vars.msgHook = weechat.hook_modifier('irc_in_302',
-                    callback(msgCallback), self.buffer)
-
-
-    class ModeMessage(Message):
-        command = 'mode'
-        def __init__(self, char=None, args=None, **kwargs):
-            self.chars = [ char ]
-            self.charargs = [ args ]
-            self.args = (char, args)
-            Message.__init__(self, **kwargs)
-
-        def payload(self):
-            args = []
-            modeChar = []
-            prefix = ''
-            for m, a in zip(self.chars, self.charargs):
-                if a:
-                    if callable(a):
-                        a = a()
-                        if not a:
-                            continue
-                    args.append(a)
-                if m[0] != prefix:
-                    prefix = m[0]
-                    modeChar.append(prefix)
-                modeChar.append(m[1])
-            args.insert(0, ''.join(modeChar))
-            if args:
-                self.args = args
-                return Message.payload(self)
-
-
-    class DeopMessage(ModeMessage):
-        def send(self, cmd):
-            if self.irc.checkOp():
-                Message.send(self, cmd)
-
-    # IrcCommands methods
-    def __init__(self, buffer):
-        self.interrupt = False
-        self.commands = []
-        self.buffer = buffer
-
-    def checkOp(self):
-        infolist = nick_infolist(self.server, self.channel)
-        while infolist.next():
-            if infolist['name'] == self.nick:
-                return '@' in infolist['prefixes']
-        return False
-
-    def Op(self):
-        if self.opHook and self.opTimeout:
-            # already send command, wait for timeout
-            return
-
-        value = self.replace_vars(self.get_config('op_command'))
-        if not value:
-            raise Exception("No command defined for get op.")
-        msg = self.OpMessage(value)
-        self.queue(msg, insert=True)
-
-    def Deop(self):
-        msg = self.DeopMessage('-o', self.nick)
-        self.queue(msg)
-
-    def Mode(self, mode, args=None, wait=0):
-        msg = self.ModeMessage(mode, args, wait=wait)
-        self.queue(msg)
-
-    def Kick(self, nick, reason=None, wait=0):
-        if not reason:
-            reason = self.get_config('kick_reason')
-        if self.get_config_boolean('enable_remove'):
-            cmd = '/quote remove %s %s :%s' %(self.channel, nick, reason)
-            msg = Message(cmd, wait=wait)
-        else:
-            msg = Message('kick', (nick, reason), wait=wait)
-        self.queue(msg)
-
-    def Voice(self, nick):
-        self.Mode('+v', nick)
-
-    def Devoice(self, nick):
-        self.Mode('-v', nick)
-
-    def Userhost(self, nick):
-        msg = self.UserhostMessage('USERHOST', (nick, ))
-        self.queue(msg, insert=True) # USERHOST should be sent first
-
-    def queue(self, message, insert=False):
-        debug('queuing: %s', message)
-        # merge /modes
-        if self.commands and message.command == 'mode':
-            max_modes = supported_maxmodes(self.server)
-            msg = self.commands[-1]
-            if msg.command == 'mode' and len(msg.chars) < max_modes:
-                msg.chars.append(message.chars[0])
-                msg.charargs.append(message.charargs[0])
-                return
-        if insert:
-            self.commands.insert(0, message)
-        else:
-            self.commands.append(message)
-
-    # it happened once and it wasn't pretty
-    def safe_check(f):
-        def abort_if_too_many_commands(self):
-            if len(self.commands) > 10:
-                error("Limit of 10 commands in queue reached, aborting.")
-                self.clear()
-            else:
-                f(self)
-        return abort_if_too_many_commands
-
-    @safe_check
-    def run(self):
-        while self.commands and not self.interrupt:
-            msg = self.commands.pop(0)
-            msg.register(self.buffer)
-            msg()
-            if self.interrupt:
-                #debug("Interrupting queue")
-                break
-
-    def clear(self):
-        debug('clear queue (%s messages)', len(self.commands))
-        self.commands = []
-
-    def __repr__(self):
-        return '<IrcCommands(%s)>' % ', '.join(map(repr, self.commands))
-
-# -----------------------------------------------------------------------------
-# User/Mask classes
-
-_rfc1459trans = string.maketrans(string.ascii_uppercase + r'\[]',
-                                 string.ascii_lowercase + r'|{}')
-def IRClower(s):
-    return s.translate(_rfc1459trans)
-
-class CaseInsensibleString(str):
-    def __init__(self, s=''):
-        self.lowered = IRClower(s)
-
-    lower    = lambda self: self.lowered
-    translate = lambda self, trans: self.lowered
-    __eq__   = lambda self, s: self.lowered == IRClower(s)
-    __ne__   = lambda self, s: not self == s
-    __hash__ = lambda self: hash(self.lowered)
-
-def caseInsensibleKey(k):
-    if isinstance(k, str):
-        return CaseInsensibleString(k)
-    elif isinstance(k, tuple):
-        return tuple(map(caseInsensibleKey, k))
-    return k
-
-class CaseInsensibleDict(dict):
-    key = staticmethod(caseInsensibleKey)
-
-    def __init__(self, **kwargs):
-        for k, v in kwargs.items():
-            self[k] = v
-
-    def __setitem__(self, k, v):
-        dict.__setitem__(self, self.key(k), v)
-
-    def __getitem__(self, k):
-        return dict.__getitem__(self, self.key(k))
-
-    def __delitem__(self, k):
-        dict.__delitem__(self, self.key(k))
-
-    def __contains__(self, k):
-        return dict.__contains__(self, self.key(k))
-
-    def pop(self, k):
-        return dict.pop(self, self.key(k))
-
-class CaseInsensibleDefaultDict(defaultdict, CaseInsensibleDict):
-    pass
-
-class CaseInsensibleSet(set):
-    normalize = staticmethod(caseInsensibleKey)
-
-    def __init__(self, iterable=()):
-        iterable = map(self.normalize, iterable)
-        set.__init__(self, iterable)
-
-    def __contains__(self, v):
-        return set.__contains__(self, self.normalize(v))
-
-    def update(self, L):
-        set.update(self, map(self.normalize, L))
-
-    def add(self, v):
-        set.add(self, self.normalize(v))
-
-    def remove(self, v):
-        set.remove(self, self.normalize(v))
-
-class ChannelWatchlistSet(CaseInsensibleSet):
-    _updated = False
-    def __contains__(self, v):
-        if not self._updated:
-            self.__updateFromConfig()
-        return CaseInsensibleSet.__contains__(self, v)
-
-    def __updateFromConfig(self):
-        self._updated = True
-        infolist = Infolist('option', 'plugins.var.python.%s.watchlist.*' %SCRIPT_NAME)
-        n = len('python.%s.watchlist.' %SCRIPT_NAME)
-        while infolist.next():
-            name = infolist['option_name']
-            value = infolist['value']
-            server = name[n:]
-            if value:
-                channels = value.split(',')
-            else:
-                channels = []
-            self.update([ (server, channel) for channel in channels ])
-
-chanopChannels = ChannelWatchlistSet()
-
-class ServerChannelDict(CaseInsensibleDict):
-    def getChannels(self, server, item=None):
-        """Return a list of channels that match server and has item if given"""
-        if item:
-            return [ chan for serv, chan in self if serv == server and item in self[serv, chan] ]
-        else:
-            return [ chan for serv, chan in self if serv == server ]
-
-    def purge(self):
-        for key in self.keys():
-            if key not in chanopChannels:
-                debug('removing %s mask list, not in watchlist.', key)
-                del self[key]
-        for data in self.values():
-            data.purge()
-
-# -----------------------------------------------------------------------------
-# Channel Modes (bans)
-
-class MaskObject(object):
-    def __init__(self, mask, hostmask=[], operator='', date=0, expires=0):
-        self.mask = mask
-        self.operator = operator
-        if date:
-            date = int(date)
-        else:
-            date = now()
-        self.date = date
-        if isinstance(hostmask, str):
-            hostmask = [ hostmask ]
-        self.hostmask = hostmask
-        self.expires = int(expires)
-
-    def serialize(self):
-        data = ';'.join([ self.operator,
-                          str(self.date),
-                          str(self.expires),
-                          ','.join(self.hostmask) ])
-        return data
-
-    def deserialize(self, data):
-        op, date, expires, hostmasks = data.split(';')
-        assert op and date, "Error reading chanmask option %s, missing operator or date" % self.mask
-        if not is_hostmask(op):
-            raise Exception('Error reading chanmask option %s, invalid usermask %r' \
-                            % (self.mask, op))
-
-        self.operator = op
-        try:
-            self.date = int(date)
-        except ValueError:
-            self.date = int(time.mktime(time.strptime(date,'%Y-%m-%d %H:%M:%S')))
-        if expires:
-            self.expires = int(expires)
-        else:
-            self.expires = 0
-        if hostmasks:
-            hostmasks = hostmasks.split(',')
-            if not all(map(is_hostmask, hostmasks)):
-                raise Exception('Error reading chanmask option %s, a hostmask is invalid: %s' \
-                                % (self.mask, hostmasks))
-
-            self.hostmask = hostmasks
-
-    def __repr__(self):
-        return "<MaskObject(%s)>" % self.mask
-
-class MaskList(CaseInsensibleDict):
-    """Single list of masks"""
-    def __init__(self, server, channel):
-        self.synced = 0
-
-    def add(self, mask, **kwargs):
-        if mask in self:
-            # mask exists, update it
-            ban = self[mask]
-            for attr, value in kwargs.items():
-                if value and not getattr(ban, attr):
-                    setattr(ban, attr, value)
-        else:
-            ban = self[mask] = MaskObject(mask, **kwargs)
-        return ban
-
-#    def searchByNick(self, nick):
-#        try:
-#            hostmask = userCache.getHostmask(nick, self.server, self.channel)
-#            return self.searchByHostmask(hostmask)
-#        except KeyError:
-#            return []
-
-    def search(self, pattern, reverseMatch=False):
-        if reverseMatch:
-            L = [ mask for mask in self if hostmask_match(mask, pattern) ]
-        else:
-            L = pattern_match_list(pattern, self.keys())
-        return L
-
-    def purge(self):
-        pass
-
-class MaskCache(ServerChannelDict):
-    """Keeps a cache of masks for different channels."""
-    def add(self, server, channel, mask, **kwargs):
-        """Adds a ban to (server, channel) banlist."""
-        key = (server, channel)
-        if key not in self:
-            self[key] = MaskList(*key)
-        ban = self[key].add(mask, **kwargs)
-        return ban
-
-    def remove(self, server, channel, mask=None):#, hostmask=None):
-        key = (server, channel)
-        try:
-            if mask is None:
-                del self[key]
-            else:
-                del self[key][mask]
-                #debug("removing ban: %s" %banmask)
-        except KeyError:
-            pass
-
-class ChanopCache(Shelf):
-    def __init__(self, filename):
-        path = os.path.join(weechat.info_get('weechat_dir', ''), filename)
-        Shelf.__init__(self, path, writeback=True)
-
-class ModeCache(ChanopCache):
-    """class for store channel modes lists."""
-    def __init__(self, filename):
-        ChanopCache.__init__(self, filename)
-        self.modes = set()
-        self.map = CaseInsensibleDict()
-
-        # reset all sync timers
-        for cache in self.values():
-            for masklist in cache.values():
-                masklist.synced = 0
-
-    def registerMode(self, mode, *args):
-        if mode not in self:
-            cache = MaskCache()
-            self[mode] = cache
-
-        if mode not in self.modes:
-            self.modes.add(mode)
-
-        self.map[mode] = mode
-        for name in args:
-            self.map[name] = mode
-
-    def __getitem__(self, mode):
-        try:
-            return ChanopCache.__getitem__(self, mode)
-        except KeyError:
-            return ChanopCache.__getitem__(self, self.map[mode])
-
-    def add(self, server, channel, mode, mask, **kwargs):
-        assert mode in self.modes
-        self[mode].add(server, channel, mask, **kwargs)
-
-    def remove(self, server, channel, mode, mask):
-        self[mode].remove(server, channel, mask)
-
-    def purge(self):
-        for cache in self.values():
-            cache.purge()
-
-class MaskSync(object):
-    """Class for fetch and sync bans of any channel and mode."""
-    __name__ = ''
-    _hide_msg = False
-
-    _hook_mask = ''
-    _hook_end = ''
-
-    # freenode new signals for list quiet messages
-    _hook_quiet_mask = ''
-    _hook_quiet_end = ''
-
-    # sync queue stuff
-    queue = []
-    _maskbuffer = CaseInsensibleDefaultDict(list)
-    _callback = CaseInsensibleDict()
-
-    def hook(self):
-        # 367 - ban mask
-        # 368 - end of ban list
-        # 728 - quiet mask
-        # 729 - end of quiet list
-        self.unhook()
-        self._hook_mask = \
-                weechat.hook_modifier('irc_in_367', callback(self._maskCallback), '')
-        self._hook_end = \
-                weechat.hook_modifier('irc_in_368', callback(self._endCallback), '')
-        self._hook_quiet_mask = \
-                weechat.hook_modifier('irc_in_728', callback(self._maskCallback), '')
-        self._hook_quiet_end = \
-                weechat.hook_modifier('irc_in_729', callback(self._endCallback), '')
-
-    def unhook(self):
-        for hook in ('_hook_mask',
-                     '_hook_end',
-                     '_hook_quiet_mask',
-                     '_hook_quiet_end'):
-            attr = getattr(self, hook)
-            if attr:
-                weechat.unhook(attr)
-                setattr(self, hook, '')
-
-    def fetch(self, server, channel, mode, callback=None):
-        """Fetches masks for a given server and channel."""
-        buffer = weechat.buffer_search('irc', 'server.%s' %server)
-        if not buffer or not weechat.info_get('irc_is_channel', channel):
-            # invalid server or channel
-            return
-
-        # check modes
-        if mode not in supported_modes(server):
-            return
-        maskCache = modeCache[mode]
-        key = (server, channel)
-        # check the last time we did this
-        try:
-            masklist = maskCache[key]
-            if (now() - masklist.synced) < 60:
-                # don't fetch again
-                return
-        except KeyError:
-            pass
-
-        if not self.queue:
-            self.queue.append((server, channel, mode))
-            self._fetch(server, channel, mode)
-        elif (server, channel, mode) not in self.queue:
-            self.queue.append((server, channel, mode))
-
-        if callback:
-            self._callback[server, channel] = callback
-
-    def _fetch(self, server, channel, mode):
-        buffer = weechat.buffer_search('irc', 'server.%s' %server)
-        if not buffer:
-            return
-        cmd = '/mode %s %s' %(channel, mode)
-        self._hide_msg = True
-        weechat_command(buffer, cmd)
-
-    def _maskCallback(self, data, modifier, modifier_data, string):
-        """callback for store a single mask."""
-        #debug("MASK %s: %s %s", modifier, modifier_data, string)
-        args = string.split()
-        if self.queue:
-            server, channel, _ = self.queue[0]
-        else:
-            server, channel = modifier_data, args[3]
-
-        if modifier == 'irc_in_367':
-            try:
-                mask, op, date = args[4:]
-            except IndexError:
-                mask = args[4]
-                op = date = None
-        elif modifier == 'irc_in_728':
-            mask, op, date = args[5:]
-
-        # store temporally until "end list" msg
-        self._maskbuffer[server, channel].append((mask, op, date))
-        if self._hide_msg:
-            string = ''
-        return string
-
-    def _endCallback(self, data, modifier, modifier_data, string):
-        """callback for end of channel's mask list."""
-        #debug("MASK END %s: %s %s", modifier, modifier_data, string)
-        if self.queue:
-            server, channel, mode = self.queue.pop(0)
-        else:
-            args = string.split()
-            server, channel = modifier_data, args[3]
-            if modifier == 'irc_in_368':
-                mode = args[7]
-            elif modifier == 'irc_in_729':
-                mode = args[4]
-            else:
-                return string
-
-        maskCache = modeCache[mode]
-
-        # delete old masks in cache
-        if (server, channel) in maskCache:
-            masklist = maskCache[server, channel]
-            banmasks = [ L[0] for L in self._maskbuffer[server, channel] ]
-            for mask in masklist.keys():
-                if mask not in banmasks:
-                    del masklist[mask]
-
-        for banmask, op, date in self._maskbuffer[server, channel]:
-            maskCache.add(server, channel, banmask, operator=op, date=date)
-        del self._maskbuffer[server, channel]
-        try:
-            maskList = maskCache[server, channel]
-        except KeyError:
-            maskList = maskCache[server, channel] = MaskList(server, channel)
-        maskList.synced = now()
-
-        # run hooked functions if any
-        if (server, channel) in self._callback:
-            self._callback[server, channel]()
-            del self._callback[server, channel]
-
-        if self._hide_msg:
-            string = ''
-        if self.queue:
-            next = self.queue[0]
-            self._fetch(*next)
-        else:
-            assert not self._maskbuffer, "mask buffer not empty: %s" % self._maskbuffer.keys()
-            self._hide_msg = False
-        return string
-
-maskSync = MaskSync()
-
-# -----------------------------------------------------------------------------
-# User cache
-
-class UserObject(object):
-    def __init__(self, nick, hostmask=None):
-        self.nick = nick
-        if hostmask:
-            self._hostmask = [ hostmask ]
-        else:
-            self._hostmask = []
-        self.seen = now()
-        self._channels = 0
-
-    @property
-    def hostmask(self):
-        try:
-            return self._hostmask[-1]
-        except IndexError:
-            return ''
-
-    def update(self, hostmask=None):
-        if hostmask and hostmask != self.hostmask:
-            if hostmask in self._hostmask:
-                del self._hostmask[self._hostmask.index(hostmask)]
-            self._hostmask.append(hostmask)
-        self.seen = now()
-
-    def __len__(self):
-        return len(self.hostmask)
-
-    def __repr__(self):
-        return '<UserObject(%s)>' %(self.hostmask or self.nick)
-
-class ServerUserList(CaseInsensibleDict):
-    def __init__(self, server):
-        self.server = server
-        buffer = weechat.buffer_search('irc', 'server.%s' %server)
-        self.irc = IrcCommands(buffer)
-        self._purge_time = 3600*4 # 4 hours
-
-    def getHostmask(self, nick):
-        user = self[nick]
-        return user.hostmask
-
-    def purge(self):
-        """Purge old nicks"""
-        n = now()
-        for nick, user in self.items():
-            if user._channels < 1 and (n - user.seen) > self._purge_time:
-                #debug('purging old user: %s' % nick)
-                del self[nick]
-
-class UserList(ServerUserList):
-    def __init__(self, server, channel):
-        self.server = server
-        self.channel = channel
-        self._purge_list = CaseInsensibleDict()
-        self._purge_time = 3600*2 # 2 hours
-
-    def __setitem__(self, nick, user):
-        #debug('%s %s: join, %s', self.server, self.channel, nick)
-        if nick not in self:
-            user._channels += 1
-        if nick in self._purge_list:
-            #debug(' - removed from purge list')
-            del self._purge_list[nick]
-        ServerUserList.__setitem__(self, nick, user)
-
-    def part(self, nick):
-        try:
-            #debug('%s %s: part, %s', self.server, self.channel, nick)
-            user = self[nick]
-            self._purge_list[nick] = user
-        except KeyError:
-            pass
-
-    def values(self):
-        if not all(ServerUserList.values(self)):
-            userCache.who(self.server, self.channel)
-        return sorted(ServerUserList.values(self), key=lambda x:x.seen, reverse=True)
-
-    def hostmasks(self, sorted=False, all=False):
-        if sorted:
-            users = self.values()
-        else:
-            users = ServerUserList.values(self)
-        if all:
-            # return all known hostmasks
-            return [ hostmask for user in users for hostmask in user._hostmask ]
-        else:
-            # only current hostmasks
-            return [ user.hostmask for user in users if user._hostmask ]
-
-    def nicks(self, *args, **kwargs):
-#        if not all(self.itervalues()):
-#            userCache.who(self.server, self.channel)
-        L = list(self.items())
-        L.sort(key=lambda x:x[1].seen)
-        return reversed([x[0] for x in L])
-
-    def getHostmask(self, nick):
-        try:
-            user = self[nick]
-        except KeyError:
-            user = userCache[self.server][nick]
-        return user.hostmask
-
-    def purge(self):
-        """Purge old nicks"""
-        n = now()
-        for nick, user in self._purge_list.items():
-            if (n - user.seen) > self._purge_time:
-                #debug('%s %s: forgeting about %s', self.server, self.channel, nick)
-                user._channels -= 1
-                try:
-                    del self._purge_list[nick]
-                    del self[nick]
-                except KeyError:
-                    pass
-
-class UserCache(ServerChannelDict):
-    __name__ = ''
-    servercache = CaseInsensibleDict()
-    _hook_who = _hook_who_end = None
-    _channels = CaseInsensibleSet()
-
-    def generateCache(self, server, channel):
-        debug('* building cache: %s %s', server, channel)
-        users = UserList(server, channel)
-        try:
-            infolist = nick_infolist(server, channel)
-        except:
-            # better to fail silently
-            #debug('invalid buffer')
-            return users
-
-        while infolist.next():
-            nick = infolist['name']
-            host = infolist['host']
-            if host:
-                hostmask = '%s!%s' %(nick, host)
-            else:
-                hostmask = ''
-            user = self.remember(server, nick, hostmask)
-            users[nick] = user
-        self[server, channel] = users
-        debug("new cache of %s users", len(users))
-        return users
-
-    def remember(self, server, nick, hostmask):
-        cache = self[server]
-        try:
-            user = cache[nick]
-            if hostmask:
-                user.update(hostmask)
-        except KeyError:
-            #debug("%s: new user %s %s", server, nick, hostmask)
-            user = UserObject(nick, hostmask)
-            cache[nick] = user
-        return user
-
-    def __getitem__(self, k):
-        if isinstance(k, tuple):
-            try:
-                return ServerChannelDict.__getitem__(self, k)
-            except KeyError:
-                return self.generateCache(*k)
-        elif isinstance(k, str):
-            try:
-                return self.servercache[k]
-            except KeyError:
-                cache = self.servercache[k] = ServerUserList(k)
-                return cache
-
-    def __delitem__(self, k):
-        # when we delete a channel, we need to reduce user._channels count
-        # so they can be purged later.
-        #debug('forgeting about %s', k)
-        for user in self[k].values():
-            user._channels -= 1
-        ServerChannelDict.__delitem__(self, k)
-
-    def getHostmask(self, nick, server, channel=None):
-        """Returns hostmask of nick."""
-        if channel:
-            return self[server, channel].getHostmask(nick)
-        return self[server].getHostmask(nick)
-
-    def who(self, server, channel):
-        if self._hook_who:
-            return
-
-        if (server, channel) in self._channels:
-            return
-
-        self._channels.add((server, channel))
-
-        key = ('%s.%s' %(server, channel)).lower()
-        self._hook_who = weechat.hook_modifier(
-                'irc_in_352', callback(self._whoCallback), key)
-        self._hook_who_end = weechat.hook_modifier(
-                'irc_in_315', callback(self._endWhoCallback), key)
-
-        buffer = weechat.buffer_search('irc', 'server.%s' %server)
-        weechat_command(buffer, '/who %s' % channel)
-
-    def _whoCallback(self, data, modifier, modifier_data, string):
-        #debug('%s %s %s', modifier, modifier_data, string)
-        args = string.split()
-        server, channel = modifier_data, args[3]
-        key = ('%s.%s' %(server, channel)).lower()
-        if key != data:
-            return string
-
-        nick, user, host = args[7], args[4], args[5]
-        hostmask = '%s!%s@%s' %(nick, user, host)
-        debug('WHO: %s', hostmask)
-        self.remember(server, nick, hostmask)
-        return ''
-
-    def _endWhoCallback(self, data, modifier, modifier_data, string):
-        args = string.split()
-        server, channel = modifier_data, args[3]
-        key = ('%s.%s' %(server, channel)).lower()
-        if key != data:
-            return string
-
-        debug('WHO: end.')
-        weechat.unhook(self._hook_who)
-        weechat.unhook(self._hook_who_end)
-        self._hook_who = self._hook_who_end = None
-        return ''
-
-    def purge(self):
-        ServerChannelDict.purge(self)
-        for cache in self.servercache.values():
-            cache.purge()
-
-userCache = UserCache()
-
-# -----------------------------------------------------------------------------
-# Chanop Command Classes
-
-# Base classes for chanop commands
-class CommandChanop(Command, ChanopBuffers):
-    """Base class for our commands, with config and general functions."""
-    infolist = None
-
-    def parser(self, args):
-        if not args:
-            weechat_command('', '/help %s' % self.command)
-            raise NoArguments
-        self.setup(self.buffer)
-
-    def execute(self):
-        self.users = userCache[self.server, self.channel]
-        try:
-            self.execute_chanop()   # call our command and queue messages for WeeChat
-            self.irc.run()          # run queued messages
-        except InvalidIRCBuffer as e:
-            error('Not in a IRC channel (%s)' % e)
-            self.irc.clear()
-        self.infolist = None    # free irc_nick infolist
-
-    def execute_chanop(self):
-        pass
-
-    def nick_infolist(self):
-        # reuse the same infolist instead of creating it many times
-        if not self.infolist:
-            self.infolist = nick_infolist(self.server, self.channel)
-        else:
-            self.infolist.reset()
-        return self.infolist
-
-    def has_op(self, nick):
-        nicks = self.nick_infolist()
-        while nicks.next():
-            if nicks['name'] == nick:
-                return '@' in nicks['prefixes']
-
-    def has_voice(self, nick):
-        nicks = self.nick_infolist()
-        while nicks.next():
-            if nicks['name'] == nick:
-                return '+' in nicks['prefixes']
-
-    def isUser(self, nick):
-        return nick in self.users
-
-    def inChannel(self, nick):
-        return CaseInsensibleString(nick) in [ nick['name'] for nick in self.nick_infolist() ]
-
-    def getHostmask(self, name):
-        try:
-            hostmask = self.users.getHostmask(name)
-            if not hostmask:
-                self.irc.Userhost(name)
-                user = userCache[self.server][name]
-                return lambda: user.hostmask or user.nick
-            return hostmask
-        except KeyError:
-            pass
-
-    def set_mode(self, *nicks):
-        mode = self.prefix + self.mode
-        for nick in nicks:
-            self.irc.Mode(mode, nick)
-
-class CommandWithOp(CommandChanop):
-    """Base class for all the commands that requires op status for work."""
-    _enable_deopNow = True
-    deop_delay = 0
-
-    def __init__(self, *args, **kwargs):
-        CommandChanop.__init__(self, *args, **kwargs)
-        # update help so it adds --deop option
-        if self._enable_deopNow:
-            if self.usage:
-                self.usage += " "
-            if self.help:
-                self.help += "\n"
-            self.usage += "[--deop]"
-            self.help += " -o --deop: Forces deop immediately, without configured delay"\
-                         " (option must be the last argument)."
-
-    def setup(self, buffer):
-        self.deopNow = False
-        CommandChanop.setup(self, buffer)
-
-    def parser(self, args):
-        CommandChanop.parser(self, args)
-        args = args.split()
-        if self._enable_deopNow and args[-1] in ('-o', '--deop'):
-            self.deopNow = True
-            del args[-1]
-            self.args = ' '.join(args)
-        if not self.args:
-            raise NoArguments
-
-    def execute_chanop(self, *args):
-        self.execute_op(*args)
-
-        if not self.irc.commands:
-            # nothing in queue, no reason to op.
-            return
-
-        self.irc.Op()
-        if (self.autodeop and self.get_config_boolean('autodeop')) or self.deopNow:
-            if self.deopNow:
-                delay = self.deop_delay
-            else:
-                delay = self.get_config_int('autodeop_delay')
-            if delay > 0:
-                if self.deopHook:
-                    weechat.unhook(self.deopHook)
-                self.vars.deopHook = weechat.hook_timer(delay * 1000, 0, 1,
-                        callback(self.deopCallback), self.buffer)
-            elif self.irc.commands: # only Deop if there are msgs in queue
-                self.irc.Deop()
-
-    def execute_op(self, *args):
-        """Commands in this method will be run with op privileges."""
-        pass
-
-    def deopCallback(self, buffer, count):
-        #debug('deop %s', buffer)
-        vars = self.varsOf(buffer)
-        if vars.autodeop:
-            if vars.irc.commands:
-                # there are commands in queue yet, wait some more
-                vars.deopHook = weechat.hook_timer(1000, 0, 1,
-                        callback(self.deopCallback), buffer)
-                return WEECHAT_RC_OK
-            else:
-                vars.irc.Deop()
-                vars.irc.run()
-        vars.deopHook = None
-        return WEECHAT_RC_OK
-
-# Chanop commands
-class Op(CommandChanop):
-    description, usage = "Request operator privileges or give it to users.", "[nick [nick ... ]]",
-    help = \
-    "The command used for ask op is defined globally in plugins.var.python.%(name)s.op_command\n"\
-    "It can be defined per server or per channel in:\n"\
-    " plugins.var.python.%(name)s.op_command.<server>\n"\
-    " plugins.var.python.%(name)s.op_command.<server>.<#channel>\n"\
-    "\n"\
-    "After using this command, you won't be autodeoped." %{'name':SCRIPT_NAME}
-    command = 'oop'
-    completion = '%(nicks)'
-
-    prefix = '+'
-    mode = 'o'
-
-    def parser(self, args):
-        # dont show /help if no args
-        self.setup(self.buffer)
-
-    def execute_chanop(self):
-        self.irc.Op()
-        # /oop was used, we assume that the user wants
-        # to stay opped permanently
-        self.vars.autodeop = False
-        if self.args:
-            for nick in self.args.split():
-                if self.inChannel(nick) and not self.has_op(nick):
-                    self.set_mode(nick)
-
-class Deop(Op, CommandWithOp):
-    description, usage, help = \
-    "Removes operator privileges from yourself or users.", "[nick [nick ... ]]", ""
-    command = 'odeop'
-    completion = '%(nicks)'
-
-    prefix = '-'
-    _enable_deopNow = False
-
-    def execute_chanop(self):
-        if self.args:
-            nicks = []
-            for nick in self.args.split():
-                if self.inChannel(nick) and self.has_op(nick):
-                    nicks.append(nick)
-            if nicks:
-                CommandWithOp.execute_chanop(self, nicks)
-        else:
-            self.vars.autodeop = True
-            if self.has_op(self.nick):
-                self.irc.Deop()
-
-    def execute_op(self, nicks):
-        self.set_mode(*nicks)
-
-class Kick(CommandWithOp):
-    description, usage = "Kick nick.", "<nick> [<reason>]"
-    help = \
-    "On freenode, you can set this command to use /remove instead of /kick, users"\
-    " will see it as if the user parted and it can bypass autojoin-on-kick scripts."\
-    " See plugins.var.python.%s.enable_remove config option." %SCRIPT_NAME
-    command = 'okick'
-    completion = '%(nicks)'
-
-    def execute_op(self):
-        nick, s, reason = self.args.partition(' ')
-        if self.inChannel(nick):
-            self.irc.Kick(nick, reason)
-        else:
-            say("Nick not in %s (%s)" % (self.channel, nick), self.buffer)
-            self.irc.clear()
-
-class MultiKick(Kick):
-    description = "Kick one or more nicks."
-    usage = "<nick> [<nick> ... ] [:] [<reason>]"
-    help = Kick.help + "\n\n"\
-    "Note: Is not needed, but use ':' as a separator between nicks and "\
-    "the reason. Otherwise, if there's a nick in the channel matching the "\
-    "first word in reason it will be kicked."
-    completion = '%(nicks)|%*'
-
-    def execute_op(self):
-        args = self.args.split()
-        nicks = []
-        nicks_parted = []
-        #debug('multikick: %s' %str(args))
-        while(args):
-            nick = args[0]
-            if nick[0] == ':' or not self.isUser(nick):
-                break
-            nick = args.pop(0)
-            if self.inChannel(nick):
-                nicks.append(nick)
-            else:
-                nicks_parted.append(nick)
-
-        #debug('multikick: %s, %s' %(nicks, args))
-        reason = ' '.join(args).lstrip(':')
-        if nicks_parted:
-            say("Nick(s) not in %s (%s)" % (self.channel, ', '.join(nicks_parted)), self.buffer)
-        elif not nicks:
-            say("Unknown nick (%s)" % nick, self.buffer)
-        if nicks:
-            for nick in nicks:
-                self.irc.Kick(nick, reason)
-        else:
-            self.irc.clear()
-
-ban_help = \
-"Mask options:\n"\
-" -h  --host: Match hostname (*!*@host)\n"\
-" -n  --nick: Match nick     (nick!*@*)\n"\
-" -u  --user: Match username (*!user@*)\n"\
-" -e --exact: Use exact hostmask.\n"\
-"\n"\
-"If no mask options are supplied, configured defaults are used.\n"\
-"\n"\
-"Completer:\n"\
-"%(script)s will attempt to guess a complete banmask from current\n"\
-"users when using <tab> in an incomplete banmask. Using <tab> in a\n"\
-"complete banmask will generate variations of it. \n"\
-"\n"\
-"Examples:\n"\
-" /%(cmd)s somebody --user --host\n"\
-"   will ban with *!user@hostname mask.\n"\
-" /%(cmd)s nick!*@<tab>\n"\
-"   will autocomple with 'nick!*@host'.\n"\
-" /%(cmd)s nick!*@*<tab>\n"\
-"   will cycle through different banmask variations for the same user.\n"
-
-class Ban(CommandWithOp):
-    description = "Ban user or hostmask."
-    usage = \
-    "<nick|mask> [<nick|mask> ... ] [ [--host] [--user] [--nick] | --exact ]"
-    command = 'oban'
-    help = ban_help % {'script': SCRIPT_NAME, 'cmd': command}
-    completion = '%(chanop_nicks)|%(chanop_ban_mask)|%*'
-
-    banmask = []
-    mode = 'b'
-    prefix = '+'
-
-    def __init__(self):
-        self.maskCache = modeCache[self.mode]
-        CommandWithOp.__init__(self)
-
-    def parser(self, args):
-        if not args:
-            showBans.callback(self.data, self.buffer, self.mode)
-            raise NoArguments
-        CommandWithOp.parser(self, args)
-        self._parser(self.args)
-
-    def _parser(self, args):
-        args = args.split()
-        try:
-            (opts, args) = getopt.gnu_getopt(args, 'hune', ('host', 'user', 'nick', 'exact'))
-        except getopt.GetoptError as e:
-            raise ArgumentError(e)
-        self.banmask = []
-        for k, v in opts:
-            if k in ('-h', '--host'):
-                self.banmask.append('host')
-            elif k in ('-u', '--user'):
-                self.banmask.append('user')
-            elif k in ('-n', '--nick'):
-                self.banmask.append('nick')
-            elif k in ('-e', '--exact'):
-                self.banmask = ['exact']
-                break
-        if not self.banmask:
-            self.banmask = self.get_default_banmask()
-        self.args = ' '.join(args)
-
-    def get_default_banmask(self):
-        return get_config_banmask(get_function=self.get_config)
-
-    def make_banmask(self, hostmask):
-        assert self.banmask
-        template = self.banmask
-
-        def banmask(s):
-            if not is_hostmask(s):
-                return s
-            if 'exact' in template:
-                return s
-            nick = user = host = '*'
-            if 'nick' in template:
-                nick = get_nick(s)
-            if 'user' in template:
-                user = get_user(s)
-            if 'host' in template:
-                host = get_host(s)
-                # check for freenode's webchat, and use a better mask.
-                if host.startswith('gateway/web/freenode'):
-                    ip = host.partition('.')[2]
-                    if is_ip(ip):
-                        host = '*%s' % ip
-            s = '%s!%s@%s' %(nick, user, host)
-            assert is_hostmask(s), "Invalid hostmask: %s" % s
-            return s
-
-        if callable(hostmask):
-            return lambda: banmask(hostmask())
-        return banmask(hostmask)
-
-    def execute_op(self):
-        args = self.args.split()
-        banmasks = []
-        for arg in args:
-            if is_nick(arg):
-                hostmask = self.getHostmask(arg)
-                if not hostmask:
-                    say("Unknown nick (%s)" % arg, self.buffer)
-                    continue
-                mask = self.make_banmask(hostmask)
-                if self.has_voice(arg):
-                    self.irc.Devoice(arg)
-            else:
-                # probably an extban
-                mask = arg
-            banmasks.append(mask)
-        banmasks = set(banmasks) # remove duplicates
-        self.ban(*banmasks)
-
-    def mode_is_supported(self):
-        return self.mode in supported_modes(self.server)
-
-    def ban(self, *banmasks, **kwargs):
-        if self.mode != 'b' and not self.mode_is_supported():
-            error("%s doesn't seem to support channel mode '%s', using regular ban." %(self.server,
-                self.mode))
-            mode = 'b'
-        else:
-            mode = self.mode
-        mode = self.prefix + mode
-        for mask in banmasks:
-            self.irc.Mode(mode, mask, **kwargs)
-
-class UnBan(Ban):
-    description, usage = "Remove bans.", "<nick|mask> [<nick|mask> ... ]"
-    command = 'ounban'
-    help = \
-    "Autocompletion will use channel's bans, patterns allowed for autocomplete multiple"\
-    " bans.\n"\
-    "\n"\
-    "Example:\n"\
-    "/%(cmd)s *192.168*<tab>\n"\
-    "  Will autocomplete with all bans matching *192.168*" %{'cmd':command}
-    completion = '%(chanop_unban_mask)|%(chanop_nicks)|%*'
-    prefix = '-'
-
-    def search_masks(self, hostmask, **kwargs):
-        try:
-            masklist = self.maskCache[self.server, self.channel]
-        except KeyError:
-            return []
-
-        if callable(hostmask):
-            def banmask():
-                L = masklist.search(hostmask(), **kwargs)
-                if L: return L[0]
-
-            return [ banmask ]
-        return masklist.search(hostmask, **kwargs)
-
-    def execute_op(self):
-        args = self.args.split()
-        banmasks = []
-        for arg in args:
-            if is_hostmask(arg):
-                banmasks.extend(self.search_masks(arg))
-            elif is_nick(arg):
-                hostmask = self.getHostmask(arg)
-                if hostmask:
-                    banmasks.extend(self.search_masks(hostmask, reverseMatch=True))
-                else:
-                    # nick unknown to chanop
-                    say("Unknown nick (%s)" % arg, self.buffer)
-            else:
-                banmasks.append(arg)
-        self.ban(*banmasks)
-
-class Quiet(Ban):
-    description = "Silence user or hostmask."
-    command = 'oquiet'
-    help = "This command is only for networks that support channel mode 'q'.\n\n" \
-            + ban_help % {'script': SCRIPT_NAME, 'cmd': command}
-    completion = '%(chanop_nicks)|%(chanop_ban_mask)|%*'
-
-    mode = 'q'
-
-class UnQuiet(UnBan):
-    command = 'ounquiet'
-    description = "Remove quiets."
-    help = "Works exactly like /ounban, but only for quiets. See /help ounban"
-    completion = '%(chanop_unquiet_mask)|%(chanop_nicks)|%*'
-
-    mode = 'q'
-
-class BanKick(Ban, Kick):
-    description = "Bankicks nick."
-    usage = "<nick> [<reason>] [ [--host] [--user] [--nick] | --exact ]"
-    help = "Combines /oban and /okick commands. See /help oban and /help okick."
-    command = 'obankick'
-    completion = '%(chanop_nicks)'
-    deop_delay = 2
-
-    def execute_op(self):
-        nick, s, reason = self.args.partition(' ')
-        if not self.isUser(nick):
-            say("Unknown nick (%s)" % nick, self.buffer)
-            self.irc.clear()
-            return
-
-        hostmask = self.getHostmask(nick)
-        # we already checked that nick is valid, so hostmask shouldn't be None
-        banmask = self.make_banmask(hostmask)
-        self.ban(banmask)
-        if self.inChannel(nick):
-            self.irc.Kick(nick, reason, wait=1)
-
-class MultiBanKick(BanKick):
-    description = "Bankicks one or more nicks."
-    usage = \
-    "<nick> [<nick> ... ] [:] [<reason>] [ [--host)] [--user] [--nick] | --exact ]"
-    completion = '%(chanop_nicks)|%*'
-
-    def execute_op(self):
-        args = self.args.split()
-        nicks = []
-        while(args):
-            nick = args[0]
-            if nick[0] == ':' or not self.isUser(nick):
-                break
-            nicks.append(args.pop(0))
-        reason = ' '.join(args).lstrip(':')
-        if not nicks:
-            say("Unknown nick (%s)" % nick, self.buffer)
-            self.irc.clear()
-            return
-
-        for nick in nicks:
-            hostmask = self.getHostmask(nick)
-            banmask = self.make_banmask(hostmask)
-            self.ban(banmask)
-
-        self.deop_delay = 1
-        for nick in nicks:
-            if self.inChannel(nick):
-                self.deop_delay += 1
-                self.irc.Kick(nick, reason, wait=1)
-
-class Topic(CommandWithOp):
-    description, usage = "Changes channel topic.", "[-delete | topic]"
-    help = "Clear topic if '-delete' is the new topic."
-    command = 'otopic'
-    completion = '%(irc_channel_topic)||-delete'
-
-    def execute_op(self):
-        self.irc.queue(Message('/topic %s' %self.args))
-
-class Voice(CommandWithOp):
-    description, usage, help = "Gives voice to somebody.", "nick [nick ... ]", ""
-    command = 'ovoice'
-    completion = '%(nicks)|%*'
-
-    prefix = '+'
-    mode = 'v'
-
-    def execute_op(self):
-        for nick in self.args.split():
-            if self.inChannel(nick) and not self.has_voice(nick):
-                self.set_mode(nick)
-
-class DeVoice(Voice):
-    description = "Removes voice from somebody."
-    command = 'odevoice'
-
-    prefix = '-'
-
-    def has_voice(self, nick):
-        return not Voice.has_voice(self, nick)
-
-class Mode(CommandWithOp):
-    description, usage, help = "Changes channel modes.", "<channel modes>", ""
-    command = 'omode'
-
-    def execute_op(self):
-        args = self.args.split()
-        modes = args.pop(0)
-        L = []
-        p = ''
-        for c in modes:
-            if c in '+-':
-                p = c
-            elif args:
-                L.append((p + c, args.pop(0)))
-            else:
-                L.append((p + c, None))
-        if not L:
-            return
-
-        for mode, arg in L:
-            self.irc.Mode(mode, arg)
-
-class ShowBans(CommandChanop):
-    description, usage, help = "Lists bans or quiets of a channel.", "(bans|quiets) [channel]", ""
-    command = 'olist'
-    completion = 'bans|quiets %(irc_server_channels)'
-    showbuffer = ''
-
-    padding = 40
-
-    def parser(self, args):
-        server = weechat.buffer_get_string(self.buffer, 'localvar_server')
-        channel = weechat.buffer_get_string(self.buffer, 'localvar_channel')
-        if server:
-            self.server = server
-        if channel:
-            self.channel = channel
-        type, _, args = args.partition(' ')
-        if not type:
-            raise ValueError('missing argument')
-        try:
-            mode = modeCache.map[type]
-        except KeyError:
-            raise ValueError('incorrect argument')
-
-        self.mode = mode
-        # fix self.type so is "readable" (ie, 'bans' instead of 'b')
-        if mode == 'b':
-            self.type = 'bans'
-        elif mode == 'q':
-            self.type = 'quiets'
-        args = args.strip()
-        if args:
-            self.channel = args
-
-    def get_buffer(self):
-        if self.showbuffer:
-            return self.showbuffer
-
-        buffer = weechat.buffer_search('python', SCRIPT_NAME)
-        if not buffer:
-            buffer = weechat.buffer_new(SCRIPT_NAME, '', '', '', '')
-            weechat.buffer_set(buffer, 'localvar_set_no_log', '1')
-            weechat.buffer_set(buffer, 'time_for_each_line', '0')
-        self.showbuffer = buffer
-        return buffer
-
-    def prnt(self, s):
-        weechat.prnt(self.get_buffer(), s)
-
-    def prnt_ban(self, banmask, op, when, hostmask=None):
-        padding = self.padding - len(banmask)
-        if padding < 0:
-            padding = 0
-        self.prnt('%s%s%s %sset by %s%s%s %s' %(color_mask,
-                                                banmask,
-                                                color_reset,
-                                                '.'*padding,
-                                                color_chat_nick,
-                                                op,
-                                                color_reset,
-                                                self.formatTime(when)))
-        if hostmask:
-            hostmasks = ' '.join(hostmask)
-            self.prnt('  %s%s' % (color_chat_host, hostmasks))
-
-    def clear(self):
-        b = self.get_buffer()
-        weechat.buffer_clear(b)
-        weechat.buffer_set(b, 'display', '1')
-        weechat.buffer_set(b, 'title', '%s' %SCRIPT_NAME)
-
-    def set_title(self, s):
-        weechat.buffer_set(self.get_buffer(), 'title', s)
-
-    def formatTime(self, t):
-        t = now() - int(t)
-        elapsed = time_elapsed(t, level=3)
-        return '%s ago' %elapsed
-
-    def execute(self):
-        self.showbuffer = ''
-        if self.mode not in supported_modes(self.server):
-            self.clear()
-            self.prnt("\n%sNetwork '%s' doesn't support %s" % (color_channel,
-                                                               self.server,
-                                                               self.type))
-            return
-
-        maskCache = modeCache[self.mode]
-        key = (self.server, self.channel)
-        try:
-            masklist = maskCache[key]
-        except KeyError:
-            if not (weechat.info_get('irc_is_channel', key[1]) and self.server):
-                error("Command /%s must be used in an IRC buffer." % self.command)
-                return
-
-            masklist = None
-        self.clear()
-        mask_count = 0
-        if masklist:
-            mask_count = len(masklist)
-            self.prnt('\n%s[%s %s]' %(color_channel, key[0], key[1]))
-            masks = [ m for m in masklist.values() ]
-            masks.sort(key=lambda x: x.date)
-            for ban in masks:
-                op = self.server
-                if ban.operator:
-                    try:
-                        op = get_nick(ban.operator)
-                    except:
-                        pass
-                self.prnt_ban(ban.mask, op, ban.date, ban.hostmask)
-        else:
-            self.prnt('No known %s for %s.%s' %(self.type, key[0], key[1]))
-        if masklist is None or not masklist.synced:
-            self.prnt("\n%sList not synced, please wait ..." %color_channel)
-            maskSync.fetch(key[0], key[1], self.mode, lambda: self.execute())
-        self.set_title('List of %s known by chanop in %s.%s (total: %s)' %(self.type,
-                                                                           key[0],
-                                                                           key[1],
-                                                                           mask_count))
-
-# -----------------------------------------------------------------------------
-# Script callbacks
-
-# Decorators
-def signal_parse(f):
-    @catchExceptions
-    def decorator(data, signal, signal_data):
-        server = signal[:signal.find(',')]
-        channel = signal_data.split()[2]
-        if channel[0] == ':':
-            channel = channel[1:]
-        if (server, channel) not in chanopChannels:
-            # signals only processed for channels in watchlist
-            return WEECHAT_RC_OK
-        nick = get_nick(signal_data)
-        hostmask = signal_data[1:signal_data.find(' ')]
-        #debug('%s %s', signal, signal_data)
-        return f(server, channel, nick, hostmask, signal_data)
-    decorator.func_name = f.func_name
-    return decorator
-
-def signal_parse_no_channel(f):
-    @catchExceptions
-    def decorator(data, signal, signal_data):
-        server = signal[:signal.find(',')]
-        nick = get_nick(signal_data)
-        channels = userCache.getChannels(server, nick)
-        if channels:
-            hostmask = signal_data[1:signal_data.find(' ')]
-            #debug('%s %s', signal, signal_data)
-            return f(server, channels, nick, hostmask, signal_data)
-        return WEECHAT_RC_OK
-    decorator.func_name = f.func_name
-    return decorator
-
-isupport = {}
-def get_isupport_value(server, feature):
-    #debug('isupport %s %s', server, feature)
-    try:
-        return isupport[server][feature]
-    except KeyError:
-        if not server:
-            return ''
-        elif server not in isupport:
-            isupport[server] = {}
-        v = weechat.info_get('irc_server_isupport_value', '%s,%s' %(server, feature.upper()))
-        if v:
-            isupport[server][feature] = v
-        else:
-            # old api
-            v = weechat.config_get_plugin('isupport.%s.%s' %(server, feature))
-            if not v:
-                # lets do a /VERSION (it should be done only once.)
-                if '/VERSION' in isupport[server]:
-                    return ''
-                buffer = weechat.buffer_search('irc', 'server.%s' %server)
-                weechat_command(buffer, '/VERSION')
-                isupport[server]['/VERSION'] = True
-        return v
-
-_supported_modes = set('bq') # the script only support b,q masks
-def supported_modes(server):
-    """Returns modes supported by server."""
-    modes = get_isupport_value(server, 'chanmodes')
-    if not modes:
-        return 'b'
-    modes = modes.partition(',')[0] # we only care about the first type
-    modes = ''.join(_supported_modes.intersection(modes))
-    return modes
-
-def supported_maxmodes(server):
-    """Returns max modes number supported by server."""
-    max = get_isupport_value(server, 'modes')
-    try:
-        max = int(max)
-        if max <= 0:
-            max = 1
-    except ValueError:
-        return 1
-    return max
-
-def isupport_cb(data, signal, signal_data):
-    """Callback used for catch isupport msg if current version of WeeChat doesn't
-    support it."""
-    data = signal_data.split(' ', 3)[-1]
-    data, s, s = data.rpartition(' :')
-    data = data.split()
-    server = signal.partition(',')[0]
-    d = {}
-    #debug(data)
-    for s in data:
-        if '=' in s:
-            k, v = s.split('=')
-        else:
-            k, v = s, True
-        k = k.lower()
-        if k in ('chanmodes', 'modes', 'prefix'):
-            config = 'isupport.%s.%s' %(server, k)
-            weechat.config_set_plugin(config, v)
-            d[k] = v
-    isupport[server] = d
-    return WEECHAT_RC_OK
-
-def print_affected_users(buffer, *hostmasks):
-    """Print a list of users, max 8 hostmasks"""
-    def format_user(hostmask):
-        nick, host = hostmask.split('!', 1)
-        return '%s%s%s(%s%s%s)' %(color_chat_nick,
-                                  nick,
-                                  color_delimiter,
-                                  color_chat_host,
-                                  host,
-                                  color_delimiter)
-
-    max = 8
-    count = len(hostmasks)
-    if count > max:
-        hostmasks = hostmasks[:max]
-    say('Affects (%s): %s%s' %(count, ' '.join(map(format_user,
-        hostmasks)), count > max and ' %s...' %color_reset or ''), buffer=buffer)
-
-# Masks list tracking
-@signal_parse
-def mode_cb(server, channel, nick, opHostmask, signal_data):
-    """Keep the banmask list updated when somebody changes modes"""
-    #:m4v!~znc@unaffiliated/m4v MODE #test -bo+v asd!*@* m4v dude
-    pair = signal_data.split(' ', 4)[3:]
-    if len(pair) != 2:
-        # modes without argument, not interesting.
-        return WEECHAT_RC_OK
-    modes, args = pair
-
-    # check if there are interesting modes
-    servermodes = supported_modes(server)
-    s = modes.translate(chars, '+-') # remove + and -
-    if not set(servermodes).intersection(s):
-        return WEECHAT_RC_OK
-
-    # check if channel is in watchlist
-    key = (server, channel)
-    allkeys = CaseInsensibleSet()
-    for maskCache in modeCache.values():
-        allkeys.update(maskCache)
-        if key not in allkeys and key not in chanopChannels:
-            # from a channel we're not tracking
-            return WEECHAT_RC_OK
-
-    prefix = get_isupport_value(server, 'prefix')
-    chanmodes = get_isupport_value(server, 'chanmodes')
-    if not prefix or not chanmodes:
-        # we don't have ISUPPORT data, can't continue
-        return WEECHAT_RC_OK
-
-    # split chanmodes into tuples like ('+', 'b', 'asd!*@*')
-    action = ''
-    chanmode_list = []
-    args = args.split()
-
-    # user channel mode, such as +v or +o, get only the letters and not the prefixes
-    usermodes = ''.join(map(lambda c: c.isalpha() and c or '', prefix))
-    chanmodes = chanmodes.split(',')
-    # modes not supported by script, like +e +I
-    notsupported = chanmodes[0].translate(chars, servermodes)
-    modes_with_args = chanmodes[1] + usermodes + notsupported
-    modes_with_args_when_set = chanmodes[2]
-    for c in modes:
-        if c in '+-':
-            action = c
-        elif c in servermodes:
-            chanmode_list.append((action, c, args.pop(0)))
-        elif c in modes_with_args:
-            del args[0]
-        elif c in modes_with_args_when_set and action == '+':
-            del args[0]
-
-    affected_users = []
-    # update masks
-    for action, mode, mask in chanmode_list:
-        debug('MODE: %s%s %s %s', action, mode, mask, opHostmask)
-        if action == '+':
-            hostmask = hostmask_match_list(mask, userCache[key].hostmasks())
-            if hostmask:
-                affected_users.extend(hostmask)
-            if mask != '*!*@*':
-                # sending this signal with a *!*@* is annoying
-                weechat.hook_signal_send("%s,chanop_mode_%s" % (server, mode),
-                                         weechat.WEECHAT_HOOK_SIGNAL_STRING,
-                                         "%s %s %s %s" % (opHostmask, channel,
-                                                          mask, ','.join(hostmask)))
-            modeCache.add(server, channel, mode, mask, operator=opHostmask, hostmask=hostmask)
-        elif action == '-':
-            modeCache.remove(server, channel, mode, mask)
-
-    if affected_users and get_config_boolean('display_affected',
-            get_function=get_config_specific, server=server, channel=channel):
-        buffer = weechat.buffer_search('irc', '%s.%s' %key)
-        print_affected_users(buffer, *set(affected_users))
-    return WEECHAT_RC_OK
-
-# User cache
-@signal_parse
-def join_cb(server, channel, nick, hostmask, signal_data):
-    if weechat.info_get('irc_nick', server) == nick:
-        # we're joining the channel, the cache is no longer valid
-        #userCache.generateCache(server, channel)
-        try:
-            del userCache[server, channel]
-        except KeyError:
-            pass
-        return WEECHAT_RC_OK
-    user = userCache.remember(server, nick, hostmask)
-    userCache[server, channel][nick] = user
-    return WEECHAT_RC_OK
-
-@signal_parse
-def part_cb(server, channel, nick, hostmask, signal_data):
-    userCache.remember(server, nick, hostmask)
-    userCache[server, channel].part(nick)
-    return WEECHAT_RC_OK
-
-@signal_parse_no_channel
-def quit_cb(server, channels, nick, hostmask, signal_data):
-    userCache.remember(server, nick, hostmask)
-    for channel in channels:
-        userCache[server, channel].part(nick)
-    return WEECHAT_RC_OK
-
-@signal_parse_no_channel
-def nick_cb(server, channels, oldNick, oldHostmask, signal_data):
-    newNick = signal_data[signal_data.rfind(' ') + 2:]
-    newHostmask = '%s!%s' % (newNick, oldHostmask[oldHostmask.find('!') + 1:])
-    userCache.remember(server, oldNick, oldHostmask)
-    user = userCache.remember(server, newNick, newHostmask)
-    for channel in channels:
-        userCache[server, channel].part(oldNick)
-        userCache[server, channel][newNick] = user
-    return WEECHAT_RC_OK
-
-# Garbage collector
-def garbage_collector_cb(data, counter):
-    """This takes care of purging users and masks from channels not in watchlist, and
-    expired users that parted.
-    """
-    debug('* flushing caches')
-    modeCache.purge()
-    userCache.purge()
-
-    if weechat.config_get_plugin('debug'):
-        # extra check that everything is right.
-        for serv, chan in userCache:
-            for nick in [ nick['name'] for nick in nick_infolist(serv, chan) ]:
-                if nick not in userCache[serv, chan]:
-                    error('User cache out of sync, unknown nick. (%s - %s.%s)' % (nick, serv, chan))
-
-    return WEECHAT_RC_OK
-
-# -----------------------------------------------------------------------------
-# Config callbacks
-
-def enable_multi_kick_conf_cb(data, config, value):
-    global cmd_kick, cmd_bankick
-    cmd_kick.unhook()
-    cmd_bankick.unhook()
-    if boolDict[value]:
-        cmd_kick = MultiKick()
-        cmd_bankick = MultiBanKick()
-    else:
-        cmd_kick = Kick()
-        cmd_bankick = BanKick()
-    cmd_kick.hook()
-    cmd_bankick.hook()
-    return WEECHAT_RC_OK
-
-def update_chanop_watchlist_cb(data, config, value):
-    #debug('CONFIG: %s' %(' '.join((data, config, value))))
-    server = config[config.rfind('.')+1:]
-    if value:
-        L = value.split(',')
-    else:
-        L = []
-    for serv, chan in list(chanopChannels):
-        if serv == server:
-            chanopChannels.remove((serv, chan))
-    chanopChannels.update([ (server, channel) for channel in L ])
-    return WEECHAT_RC_OK
-
-def enable_bar_cb(data, config, value):
-    if boolDict[value]:
-        chanop_bar.new()
-        weechat.bar_item_new('chanop_ban_matches', 'item_ban_matches_cb', '')
-        weechat.bar_item_new('chanop_status', 'item_status_cb', '')
-        weechat.hook_modifier('input_text_content', 'input_content_cb', '')
-    else:
-        chanop_bar.remove()
-    return WEECHAT_RC_OK
-
-def enable_debug_cb(data, config, value):
-    global debug
-    if value and boolDict[value]:
-        try:
-            # custom debug module I use, allows me to inspect script's objects.
-            import pybuffer
-            debug = pybuffer.debugBuffer(globals(), '%s_debug' % SCRIPT_NAME)
-            weechat.buffer_set(debug._getBuffer(), 'localvar_set_no_log', '0')
-        except:
-            def debug(s, *args):
-                if not isinstance(s, str):
-                    s = str(s)
-                if args:
-                    s = s % args
-                prnt('', '%s\t%s' % (script_nick, s))
-    else:
-        try:
-            if hasattr(debug, 'close'):
-                debug.close()
-        except NameError:
-            pass
-
-        debug = _no_debug
-
-    return WEECHAT_RC_OK
-
-# -----------------------------------------------------------------------------
-# Completers
-
-def cmpl_get_irc_users(f):
-    """Check if completion is done in a irc channel, and pass the buffer's user list."""
-    @catchExceptions
-    def decorator(data, completion_item, buffer, completion):
-        key = irc_buffer(buffer)
-        if not key:
-            return WEECHAT_RC_OK
-        users = userCache[key]
-        return f(users, data, completion_item, buffer, completion)
-    return decorator
-
-def unban_mask_cmpl(mode, completion_item, buffer, completion):
-    """Completion for applied banmasks, for commands like /ounban /ounquiet"""
-    maskCache = modeCache[mode]
-    key = irc_buffer(buffer)
-    if not key:
-        return WEECHAT_RC_OK
-    server, channel = key
-
-    def cmpl_unban(masklist):
-        input = weechat.buffer_get_string(buffer, 'input')
-        if input[-1] != ' ':
-            input, _, pattern = input.rpartition(' ')
-        else:
-            pattern = ''
-        #debug('%s %s', repr(input), repr(pattern))
-        if pattern and not is_nick(pattern): # FIXME nick completer interferes.
-                                             # NOTE masklist no longer accepts nicks.
-            L = masklist.search(pattern)
-            #debug('unban pattern %s => %s', pattern, L)
-            if L:
-                input = '%s %s ' % (input, ' '.join(L))
-                weechat.buffer_set(buffer, 'input', input)
-                weechat.buffer_set(buffer, 'input_pos', str(len(input)))
-                return
-        elif not masklist:
-            return
-        for mask in masklist.keys():
-            #debug('unban mask: %s', mask)
-            weechat.hook_completion_list_add(completion, mask, 0, weechat.WEECHAT_LIST_POS_END)
-
-    if key not in maskCache or not maskCache[key].synced:
-        # do completion after fetching marks
-        if not maskSync.queue:
-            def callback():
-                masklist = maskCache[key]
-                if chanop_bar:
-                    global chanop_bar_status
-                    if masklist:
-                        chanop_bar_status = 'Got %s +%s masks.' % (len(masklist), mode)
-                    else:
-                        chanop_bar_status = 'No +%s masks found.' % mode
-                    chanop_bar.popup()
-                    weechat.bar_item_update('chanop_status')
-                else:
-                    if masklist:
-                        say('Got %s +%s masks.' % (len(masklist), mode), buffer)
-                    else:
-                       say('No +%s masks found.' % mode, buffer)
-                cmpl_unban(masklist)
-
-            maskSync.fetch(server, channel, mode, callback)
-            if chanop_bar:
-                global chanop_bar_status
-                chanop_bar_status = 'Fetching +%s masks in %s, please wait...' %(mode, channel)
-                weechat.bar_item_update('chanop_status')
-                chanop_bar.popup()
-            else:
-                say('Fetching +%s masks in %s, please wait...' %(mode, channel), buffer)
-    else:
-        # mask list is up to date, do completion
-        cmpl_unban(maskCache[key])
-    return WEECHAT_RC_OK
-
-banmask_cmpl_list = []
-@cmpl_get_irc_users
-def ban_mask_cmpl(users, data, completion_item, buffer, completion):
-    """Completion for banmasks, for commands like /oban /oquiet"""
-    input = weechat.buffer_get_string(buffer, 'input')
-    if input[-1] == ' ':
-        # no pattern, return
-        return WEECHAT_RC_OK
-
-    input, _, pattern = input.rpartition(' ')
-
-    global banmask_cmpl_list
-    if is_hostmask(pattern):
-        if not banmask_cmpl_list:
-            maskList = pattern_match_list(pattern, users.hostmasks(sorted=True, all=True))
-            if maskList:
-                banmask_cmpl_list = [ pattern ]
-
-            def add(mask):
-                if mask not in banmask_cmpl_list:
-                    banmask_cmpl_list.append(mask)
-
-            for mask in maskList:
-                #debug('ban_mask_cmpl: Generating variations for %s', mask)
-                host = get_host(mask)
-                add('*!*@%s' % host)
-                add('%s!*@%s' % (get_nick(mask), host))
-                if host.startswith('gateway/web/freenode'):
-                    ip = host.partition('.')[2]
-                    if is_ip(ip):
-                        add('*!*@*%s' % ip)
-                elif is_ip(host):
-                    user = get_user(mask)
-                    iprange = host.rsplit('.', 2)[0]
-                    add('*!%s@%s.*' % (user, iprange))
-                    add('*!*@%s.*' % iprange)
-            #debug('ban_mask_cmpl: variations: %s', banmask_cmpl_list)
-
-        if pattern in banmask_cmpl_list:
-            i = banmask_cmpl_list.index(pattern) + 1
-            if i == len(banmask_cmpl_list):
-                i = 0
-            mask = banmask_cmpl_list[i]
-            input = '%s %s' % (input, mask)
-            weechat.buffer_set(buffer, 'input', input)
-            weechat.buffer_set(buffer, 'input_pos', str(len(input)))
-            return WEECHAT_RC_OK
-
-    banmask_cmpl_list = []
-
-    if pattern[-1] != '*':
-        search_pattern = pattern + '*'
-    else:
-        search_pattern = pattern
-
-    if '@' in pattern:
-        # complete *!*@hostname
-        prefix = pattern[:pattern.find('@')]
-        make_mask = lambda mask: '%s@%s' %(prefix, mask[mask.find('@') + 1:])
-        get_list = users.hostmasks
-    elif '!' in pattern:
-        # complete *!username@*
-        prefix = pattern[:pattern.find('!')]
-        make_mask = lambda mask: '%s!%s@*' %(prefix, mask[mask.find('!') + 1:mask.find('@')])
-        get_list = users.hostmasks
-    else:
-        # complete nick!*@*
-        make_mask = lambda mask: '%s!*@*' %mask
-        get_list = users.nicks
-
-    for mask in pattern_match_list(search_pattern, get_list(sorted=True, all=True)):
-        mask = make_mask(mask)
-        weechat.hook_completion_list_add(completion, mask, 0, weechat.WEECHAT_LIST_POS_END)
-    return WEECHAT_RC_OK
-
-# Completions for nick, user and host parts of a usermask
-@cmpl_get_irc_users
-def nicks_cmpl(users, data, completion_item, buffer, completion):
-    for nick in users.nicks():
-        weechat.hook_completion_list_add(completion, nick, 0, weechat.WEECHAT_LIST_POS_END)
-    return WEECHAT_RC_OK
-
-@cmpl_get_irc_users
-def hosts_cmpl(users, data, completion_item, buffer, completion):
-    for hostmask in users.hostmasks(sorted=True, all=True):
-        weechat.hook_completion_list_add(completion, get_host(hostmask), 0,
-                weechat.WEECHAT_LIST_POS_SORT)
-    return WEECHAT_RC_OK
-
-@cmpl_get_irc_users
-def users_cmpl(users, data, completion_item, buffer, completion):
-    for hostmask in users.hostmasks(sorted=True, all=True):
-        user = get_user(hostmask)
-        weechat.hook_completion_list_add(completion, user, 0, weechat.WEECHAT_LIST_POS_END)
-    return WEECHAT_RC_OK
-
-# info hooks
-def info_hostmask_from_nick(data, info_name, arguments):
-    #debug('INFO: %s %s', info_name, arguments)
-    args = arguments.split(',')
-    channel = None
-    try:
-        nick, server, channel = args
-    except ValueError:
-        try:
-            nick, server = args
-        except ValueError:
-            return ''
-    try:
-        hostmask = userCache.getHostmask(nick, server, channel)
-    except KeyError:
-        return ''
-    return hostmask
-
-def info_pattern_match(data, info_name, arguments):
-    #debug('INFO: %s %s', info_name, arguments)
-    pattern, string = arguments.split(',')
-    if pattern_match(pattern, string):
-        return '1'
-    return ''
-
-# -----------------------------------------------------------------------------
-# Chanop bar callbacks
-
-chanop_bar_current_buffer = ''
-
-@catchExceptions
-def item_ban_matches_cb(data, item, window):
-    #debug('ban matches item: %s %s', item, window)
-    global chanop_bar_current_buffer
-    buffer = chanop_bar_current_buffer
-    if not buffer:
-        return ''
-
-    input = weechat.buffer_get_string(buffer, 'input')
-    if not input:
-        return ''
-
-    command, _, content = input.partition(' ')
-
-    if command[1:] not in ('oban', 'oquiet'):
-        return ''
-
-    def format(s):
-        return '%s affects: %s' % (command, s)
-
-    channel = weechat.buffer_get_string(buffer, 'localvar_channel')
-    if not channel or not is_channel(channel):
-        return format('(not an IRC channel)')
-
-    server = weechat.buffer_get_string(buffer, 'localvar_server')
-    users = userCache[server, channel]
-    content = content.split()
-    masks = [ mask for mask in content if is_hostmask(mask) or is_nick(mask) ]
-    if not masks:
-        return format('(no valid user mask or nick)')
-
-    #debug('ban matches item: %s', masks)
-
-    affected = []
-    hostmasks = users.hostmasks(all=True)
-    for mask in masks:
-        if is_hostmask(mask):
-            affected.extend(hostmask_match_list(mask, hostmasks))
-        elif mask in users:
-            affected.append(mask)
-    #debug('ban matches item: %s', affected)
-
-    if not affected:
-        return format('(nobody)')
-
-    L = set([ get_nick(h) for h in affected ])
-    return format('(%s) %s' % (len(L), ' '.join(L)))
-
-chanop_bar_status = ''
-def item_status_cb(data, item, window):
-    global chanop_bar_status
-    if chanop_bar_status:
-        return "%s[%s%s%s]%s %s" % (COLOR_BAR_DELIM,
-                                    COLOR_BAR_FG,
-                                    SCRIPT_NAME,
-                                    COLOR_BAR_DELIM,
-                                    color_reset,
-                                    chanop_bar_status)
-    else:
-        return "%s[%s%s%s]" % (COLOR_BAR_DELIM,
-                               COLOR_BAR_FG,
-                               SCRIPT_NAME,
-                               COLOR_BAR_DELIM)
-
-@catchExceptions
-def input_content_cb(data, modifier, modifier_data, string):
-    #debug('input_content_cb: %s %s %r', modifier, modifier_data, string)
-    global chanop_bar_current_buffer, chanop_bar_status
-    if not chanop_bar:
-        return string
-
-    if string and not weechat.string_input_for_buffer(string):
-        command, _, content = string.partition(' ')
-        content = content.strip()
-        if content and command[1:] in ('oban', 'oquiet'):
-            chanop_bar.show()
-            chanop_bar_current_buffer = modifier_data
-            weechat.bar_item_update('chanop_ban_matches')
-            if chanop_bar_status:
-                chanop_bar_status = ''
-                weechat.bar_item_update('chanop_bar_status')
-            return string
-
-    if not chanop_bar._timer_hook:
-        chanop_bar.hide()
-    return string
-
-# -----------------------------------------------------------------------------
-# Main
-
-def unload_chanop():
-    if chanop_bar:
-        # we don't remove it, so custom options configs aren't lost
-        chanop_bar.hide()
-    bar_item = weechat.bar_item_search('chanop_ban_matches')
-    if bar_item:
-        weechat.bar_item_remove(bar_item)
-    return WEECHAT_RC_OK
-
-# Register script
-if __name__ == '__main__' and import_ok and \
-        weechat.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE,
-        SCRIPT_DESC, 'unload_chanop', ''):
-
-    # colors
-    color_delimiter = weechat.color('chat_delimiters')
-    color_chat_nick = weechat.color('chat_nick')
-    color_chat_host = weechat.color('chat_host')
-    color_mask      = weechat.color('white')
-    color_channel   = weechat.color('lightred')
-    color_reset     = weechat.color('reset')
-    COLOR_WHITE     = weechat.color('white')
-    COLOR_DARKGRAY  = weechat.color('darkgray')
-    COLOR_BAR_DELIM = weechat.color('bar_delim')
-    COLOR_BAR_FG    = weechat.color('bar_fg')
-
-    # pretty [chanop]
-    script_nick = '%s[%s%s%s]%s' %(color_delimiter,
-                                   color_chat_nick,
-                                   SCRIPT_NAME,
-                                   color_delimiter,
-                                   color_reset)
-
-    # -------------------------------------------------------------------------
-    # Debug
-
-    enable_debug_cb('', '', weechat.config_get_plugin('debug'))
-    weechat.hook_config('plugins.var.python.%s.debug' % SCRIPT_NAME, 'enable_debug_cb', '')
-
-    # -------------------------------------------------------------------------
-    # Init
-
-    # check weechat version
-    try:
-        version = int(weechat.info_get('version_number', ''))
-    except:
-        version = 0
-    if version < WEECHAT_VERSION[0]:
-        error("This version of WeeChat isn't supported. Use %s or later." % WEECHAT_VERSION[1])
-        raise Exception('unsupported weechat version')
-    if version < 0x30300: # prior to 0.3.3 didn't have support for ISUPPORT msg
-        error('WeeChat < 0.3.3: using ISUPPORT workaround.')
-        weechat.hook_signal('*,irc_in_005', 'isupport_cb', '')
-    if version < 0x30400: # irc_nick flags changed in 0.3.4
-        error('WeeChat < 0.3.4: using irc_nick infolist workaround.')
-        Infolist._use_flags = True
-
-    for opt, val in settings.items():
-        if not weechat.config_is_set_plugin(opt):
-            weechat.config_set_plugin(opt, val)
-
-    modeCache = ModeCache('chanop_mode_cache.dat')
-    modeCache.registerMode('b', 'ban', 'bans')
-    modeCache.registerMode('q', 'quiet', 'quiets')
-
-    # -------------------------------------------------------------------------
-    # remove old chanmask config and save them in shelf
-
-    prefix = 'python.%s.chanmask' % SCRIPT_NAME
-    infolist = Infolist('option', 'plugins.var.%s.*' % prefix)
-    n = len(prefix)
-    while infolist.next():
-        option = infolist['option_name'][n + 1:]
-        server, channel, mode, mask = option.split('.', 3)
-        if mode in modeCache:
-            cache = modeCache[mode]
-            if (server, channel) in cache:
-                masklist = cache[server, channel]
-            else:
-                masklist = cache[server, channel] = MaskList(server, channel)
-        if mask in masklist:
-            masklist[mask].deserialize(infolist['value'])
-        else:
-            obj = masklist[mask] = MaskObject(mask)
-            obj.deserialize(infolist['value'])
-        weechat.config_unset_plugin('chanmask.%s.%s.%s.%s' \
-                % (server, channel, mode, mask))
-    del infolist
-
-    # hook /oop /odeop
-    Op().hook()
-    Deop().hook()
-    # hook /okick /obankick
-    if get_config_boolean('enable_multi_kick'):
-        cmd_kick = MultiKick()
-        cmd_bankick = MultiBanKick()
-    else:
-        cmd_kick = Kick()
-        cmd_bankick = BanKick()
-    cmd_kick.hook()
-    cmd_bankick.hook()
-    # hook /oban /ounban /olist
-    Ban().hook()
-    UnBan().hook()
-    showBans = ShowBans()
-    showBans.hook()
-    # hook /oquiet /ounquiet
-    Quiet().hook()
-    UnQuiet().hook()
-    # hook /otopic /omode /ovoive /odevoice
-    Topic().hook()
-    Mode().hook()
-    Voice().hook()
-    DeVoice().hook()
-
-    maskSync.hook()
-
-    weechat.hook_config('plugins.var.python.%s.enable_multi_kick' % SCRIPT_NAME,
-            'enable_multi_kick_conf_cb', '')
-    weechat.hook_config('plugins.var.python.%s.watchlist.*' % SCRIPT_NAME,
-            'update_chanop_watchlist_cb', '')
-    weechat.hook_config('plugins.var.python.%s.enable_bar' % SCRIPT_NAME,
-            'enable_bar_cb', '')
-
-    weechat.hook_completion('chanop_unban_mask', 'channelmode b masks', 'unban_mask_cmpl', 'b')
-    weechat.hook_completion('chanop_unquiet_mask', 'channelmode q masks', 'unban_mask_cmpl', 'q')
-    weechat.hook_completion('chanop_ban_mask', 'completes partial mask', 'ban_mask_cmpl', '')
-    weechat.hook_completion('chanop_nicks', 'nicks in cache', 'nicks_cmpl', '')
-    weechat.hook_completion('chanop_users', 'usernames in cache', 'users_cmpl', '')
-    weechat.hook_completion('chanop_hosts', 'hostnames in cache', 'hosts_cmpl', '')
-
-    weechat.hook_signal('*,irc_in_join', 'join_cb', '')
-    weechat.hook_signal('*,irc_in_part', 'part_cb', '')
-    weechat.hook_signal('*,irc_in_quit', 'quit_cb', '')
-    weechat.hook_signal('*,irc_in_nick', 'nick_cb', '')
-    weechat.hook_signal('*,irc_in_mode', 'mode_cb', '')
-
-    # run our cleaner function every 30 min.
-    weechat.hook_timer(1000 * 60 * 30, 0, 0, 'garbage_collector_cb', '')
-
-    chanop_bar = PopupBar('chanop_bar', hidden=True,
-            items='chanop_status,chanop_ban_matches')
-    if get_config_boolean('enable_bar'):
-        chanop_bar.new()
-        weechat.bar_item_new('chanop_ban_matches', 'item_ban_matches_cb', '')
-        weechat.bar_item_new('chanop_status', 'item_status_cb', '')
-        weechat.hook_modifier('input_text_content', 'input_content_cb', '')
-    else:
-        chanop_bar.remove()
-
-    weechat.hook_info("chanop_hostmask_from_nick",
-            "Returns nick's hostmask if is known. Returns '' otherwise.",
-            "nick,server[,channel]", "info_hostmask_from_nick", "")
-    weechat.hook_info("chanop_pattern_match",
-            "Test if pattern matches text, is case insensible with IRC case rules.",
-            "pattern,text", "info_pattern_match", "")
-
-
-# vim:set shiftwidth=4 tabstop=4 softtabstop=4 expandtab textwidth=100:
-- 
cgit v1.2.3-70-g09d2