def doPrivmsg(self, irc, msg):
     channel = msg.args[0]
     self.timeout(irc, channel)
     if ircmsgs.isCtcp(msg) and not ircmsgs.isAction(msg):
         return
     #channel = msg.args[0]
     if irc.isChannel(channel):
         if ircmsgs.isAction(msg):
             text = ircmsgs.unAction(msg)
         else:
             text = msg.args[1]
         if 'ping' in text.lower():
             text = text.replace('!','')\
                     .replace(',','')\
                     .replace(':','')\
                     .replace('?','')
             if len(text.split()) == 2:        
                 if text.lower().startswith('ping'):
                     self.ping(irc, msg, channel, text, inverse=True)
                 elif text.lower().endswith('ping'):
                     self.ping(irc, msg, channel, text)
         elif 'pong' in text.lower():
             text = text.replace(',','')\
                     .replace(':','')\
                     .replace('!','')\
                     .replace('?','')
             if len(text.split()) == 2:        
                 if text.lower().startswith('pong'):
                     self.pong(irc, msg, channel, text, inverse=True)
                 elif text.lower().endswith('pong'):
                     self.pong(irc, msg, channel, text)

    def doPrivmsg(self, irc, msg):
        """check regular IRC chat for votes"""
        # check for a regular channel message
        if ircmsgs.isCtcp(msg) and not ircmsgs.isAction(msg):
            return
        channel = msg.args[0]
        if not irc.isChannel(channel):
            return
        
        # is there an active vote in the channel?
        if not (channel in self._voter_decision):
            return
        
        # get the text of the vote
        if ircmsgs.isAction(msg):
            text = ircmsgs.unAction(msg)
        else:
            text = msg.args[1]
        
        # is it a vote?
        if not text in VALID_VOTE:
            return
        
        # get the voter
        voter = msg.prefix

        # update the cache
        self._voter_decision[channel][voter] = text

 def outFilter(self, irc, msg):
     if msg.command == 'PRIVMSG':
         if ircmsgs.isAction(msg):
             s = ircmsgs.unAction(msg)
         else:
             s = msg.args[1]
         reply = []
         bananaProb = 0.1
         maybeBanana = False
         chance = random.random()
         self.log.debug("bananchance: "+str(chance)+" "+str(bananaProb)+" "+s)
         if chance < bananaProb:
             for word in s.split():
                 if maybeBanana:
                     maybeBanana = False
                     chance = random.random()
                     reply.append("banana")
                 else:
                     reply.append(word)
                 if word == "the":
                     maybeBanana = True
             if ircmsgs.isAction(msg):
                 msg = ircmsgs.action(msg.args[0], " ".join(reply), msg=msg)
             else:
                 msg = ircmsgs.IrcMsg(msg = msg, args=(msg.args[0], " ".join(reply)))
     return msg

 def doPrivmsg(self, irc, msg):
     if ircmsgs.isCtcp(msg) and not ircmsgs.isAction(msg):
         return
     channel = msg.args[0]
     if irc.isChannel(channel):
         if ircmsgs.isAction(msg):
             text = ircmsgs.unAction(msg)
         else:
             text = msg.args[1]
         for info in present_links(text, color=True):
             irc.reply(info, prefixNick=False)

 def doPrivmsg(self, irc, msg):
     if ircmsgs.isCtcp(msg) and not ircmsgs.isAction(msg):
         return
     channel = msg.args[0]
     if irc.isChannel(channel):
         if ircmsgs.isAction(msg):
             text = ircmsgs.unAction(msg)
         else:
             text = msg.args[1]
         for url in utils.web.urlRe.findall(text):
             self.fetch_url(irc, channel, url)

 def doPrivmsg(self, irc, msg):
     if ircmsgs.isCtcp(msg) and not ircmsgs.isAction(msg):
         return
     channel = msg.args[0]
     if callbacks.addressed(irc.nick, msg):
         return
     if self.registryValue('titleSnarfer', channel):
         if irc.isChannel(channel):
             if ircmsgs.isAction(msg):
                 text = ircmsgs.unAction(msg)
             else:
                 text = msg.args[1]
             for info in present_links(text, color=True):
                 irc.reply(info, prefixNick=False, private=False, notice=False)

 def doPrivmsg(self, irc, msg):
     (recipients, text) = msg.args
     for channel in recipients.split(','):
         if irc.isChannel(channel) and not self.logging_disabled.get(channel):
             noLogPrefix = self.registryValue('noLogPrefix', channel)
             if ((noLogPrefix and text.startswith(noLogPrefix)) or
                (text.startswith('@on')) or
                (text.startswith('mb-chat-logger: on')) or
                (text.startswith('mb-chat-logger, on'))):
                 return
             nick = msg.nick or irc.nick
             if ircmsgs.isAction(msg):
                 self.doLog(irc, channel, 'log',
                            '* %s %s', nick, ircmsgs.unAction(msg))
                 self.doLog(irc, channel, 'html',
                            '<span>&bull; <span class="nick">%s</span> %s</span>', 
                            cgi.escape(nick),
                            replaceurls(cgi.escape(ircmsgs.unAction(msg))),
                            cls="action privmsg")
             else:
                 self.doLog(irc, channel, 'log', '<%s> %s', nick, text)
                 self.doLog(irc, channel, 'html', 
                            '<span><span class="nick">&lt;%s&gt;</span> %s</span>', 
                            cgi.escape(nick), 
                            replaceurls(cgi.escape(text)),
                            cls="privmsg")

def combine(msgs, reverse=True, stamps=False, nicks=True, compact=True,
            joiner=r' \ ', nocolor=False):
    """
    Formats and returns a list of IrcMsg objects (<msgs>) as a string.
    <reverse>, if True, prints messages from last to first.
    <stamps>, if True, appends timestamps to messages.
    <reverse>, if True, orders messages by earliest to most recent.
    <compact>, if False, append nicks to consecutive messages
    <joiner>, the character joining lines together (default: ' \ ').
    <nocolor>, if True, strips color from messages.
    Sample output:
        <bigman> DUNK \ <bigbitch> \ bluh \ bluh
    """
    output = []
    lastnick = ''
    for msg in reversed(msgs) if reverse else msgs:
        isaction = ircmsgs.isAction(msg)
        if isaction:
            text = '[%s %s]' % (msg.nick, ircmsgs.unAction(msg))
        else:
            if compact and ircutils.nickEqual(msg.nick, lastnick) or not nicks:
                text = msg.args[1]
            else:
                lastnick = msg.nick
                text = '<%s> %s' % (msg.nick, msg.args[1])
        if stamps:
            stampfmt = '%d-%m-%y %H:%M:%S'
            stamp = time.strftime(stampfmt, time.localtime(msg.receivedAt))
            text = '[{0}] {1}'.format(stamp, text)
        output.append(ircutils.stripFormatting(text))
    return joiner.join(output)

    def replacer(self, irc, msg, regex):
        if not self.registryValue('enable', msg.args[0]):
            return None
        iterable = reversed(irc.state.history)
        msg.tag('Replacer')
        target = regex.group('nick') or ''

        if target:
            checkNick = target
            prefix = '%s thinks %s' % (msg.nick, target)
        else:
            checkNick = msg.nick
            prefix = msg.nick

        try:
            message = 's' + msg.args[1][len(target):].split('s', 1)[-1]
            (pattern, replacement, count) = self._unpack_sed(message)
        except ValueError as e:
            self.log.warning(_("Replacer error: %s"), e)
            if self.registryValue('displayErrors', msg.args[0]):
                irc.error(_("Replacer error: %s" % e), Raise=True)
            return None

        next(iterable)
        for m in iterable:
            if m.nick == checkNick and \
                    m.args[0] == msg.args[0] and \
                    m.command == 'PRIVMSG':

                if ircmsgs.isAction(m):
                    text = ircmsgs.unAction(m)
                    tmpl = 'do'
                else:
                    text = m.args[1]
                    tmpl = 'say'

                try:
                    if not self._regexsearch(text, pattern):
                        continue
                except TimeoutError as e: # Isn't working for some reason
                    self.log.error('TIMEOUT ERROR CAUGHT!!')
                    break
                except Exception as e:
                    self.log.error('Replacer: %s' % type(e).__name__)
                    break

                if self.registryValue('ignoreRegex', msg.args[0]) and \
                        m.tagged('Replacer'):
                    continue
                irc.reply(_("%s meant to %s “ %s ”") %
                          (prefix, tmpl, pattern.sub(replacement,
                           text, count)), prefixNick=False)
                return None

        self.log.debug(_("""Replacer: Search %r not found in the last %i
                       messages."""), regex, len(irc.state.history))
        if self.registryValue("displayErrors", msg.args[0]):
            irc.error(_("Search not found in the last %i messages.") %
                      len(irc.state.history), Raise=True)
        return None

    def doPrivmsg(self, irc, msg):
        channel = msg.args[0]
        linkapi = LinkDBApi()

        if irc.isChannel(channel):
            if ircmsgs.isAction(msg):
                text = ircmsgs.unAction(msg)
            else:
                text = msg.args[1]

            usrmsg = safe_unicode(text)
            for url in utils.web.urlRe.findall(usrmsg):
                if re.search(badurls, url) is not None:
                    continue

                uid = linkapi.insert_and_get_uid(msg.nick)
                urlseen = linkapi.get_url_and_timestamp(url)

                if urlseen is "":
                    titlename = get_url_title(url)
                    if len(titlename) > 0:
                        linkid = linkapi.insert_and_get_linkid(uid, \
                                     titlename, url)
                        irc.reply("Title: %s" % (titlename))
                else:
                    if linkapi.is_link_old(url):
                        linkapi.updateLinkLastseen(url)
                    irc.reply("Title: %s [title updated: %s]" % (urlseen[0], \
                              time.ctime(urlseen[1])))

 def doPrivmsg(self, irc, msg):
     if ircmsgs.isCtcp(msg) and not ircmsgs.isAction(msg):
         return
     channel = msg.args[0]
     if irc.isChannel(channel):
         if ircmsgs.isAction(msg):
             text = ircmsgs.unAction(msg)
         else:
             text = msg.args[1]
         for url in utils.web.urlRe.findall(text):
             r = self.registryValue('nonSnarfingRegexp', channel)
             if r and r.search(url):
                 self.log.debug('Skipping adding %u to db.', url)
                 continue
             self.log.debug('Adding %u to db.', url)
             self.db.add(channel, url, msg)

 def doPrivmsg(self, msg):
     isAction = ircmsgs.isAction(msg)
     if ircmsgs.isCtcp(msg) and not isAction:
         return
     self.doPayload(*msg.args)
     if isAction:
         self.actions += 1

def msgtotext(msg):
    """
    Returns only the message text from an IrcMsg (<msg>).
    """
    isaction = ircmsgs.isAction(msg)
    text = ircmsgs.unAction(msg) if isaction else msg.args[1]
    return ircutils.stripFormatting(text), isaction

 def assertActionRegexp(self, query, regexp, flags=re.I, **kwargs):
     m = self._feedMsg(query, **kwargs)
     if m is None:
         raise TimeoutError, query
     self.failUnless(ircmsgs.isAction(m))
     s = ircmsgs.unAction(m)
     self.failUnless(re.search(regexp, s, flags), "%r does not match %r" % (s, regexp))

    def doPrivmsg(self, irc, msg):
        global BADURLS
        channel = msg.args[0]
        linkapi = LinkDBApi()

        if irc.isChannel(channel):
            if ircmsgs.isAction(msg):
                text = ircmsgs.unAction(msg)
            else:
                text = msg.args[1]

            for url in utils.web.urlRe.findall(text):
                if re.search(BADURLS, url) is not None:
                    continue

                url = unicode(url, "utf-8")
                urlseen = linkapi.getByLink(url)
                if urlseen is "":
                    titlename = self.title(url)
                    if len(titlename) > 0:
                        linkapi.insertLink(msg.nick, titlename, url)
                        try:
                            irc.reply("%s [%s]" % (titlename, url))
                        except UnicodeDecodeError:
                            irc.reply("%s [%s]" % (titlename.encode("utf-8"), url))
                else:
                    linkapi.updateLinkLastseen(url)
                    irc.reply("%s [%s]" % (urlseen[2], urlseen[3]))

 def _formatPrivmsg(self, nick, network, msg):
     channel = msg.args[0]
     if self.registryValue('includeNetwork', channel):
         network = '@' + network
     else:
         network = ''
     # colorize nicks
     color = self.registryValue('color', channel) # Also used further down.
     if color:
         nick = ircutils.IrcString(nick)
         newnick = ircutils.mircColor(nick, *ircutils.canonicalColor(nick))
         colors = ircutils.canonicalColor(nick, shift=4)
         nick = newnick
     if ircmsgs.isAction(msg):
         if color:
             t = ircutils.mircColor('*', *colors)
         else:
             t = '*'
         s = format('%s %s%s %s', t, nick, network, ircmsgs.unAction(msg))
     else:
         if color:
             lt = ircutils.mircColor('<', *colors)
             gt = ircutils.mircColor('>', *colors)
         else:
             lt = '<'
             gt = '>'
         s = format('%s%s%s%s %s', lt, nick, network, gt, msg.args[1])
     return s

 def doPrivmsg(self, irc, msg):
     if ircmsgs.isCtcp(msg) and not ircmsgs.isAction(msg):
         return
     (channel, text) = msg.args
     if irc.isChannel(channel):
         irc = self._getRealIrc(irc)
         if channel not in self.registryValue('channels'):
             return
         ignores = self.registryValue('ignores', channel)
         for ignore in ignores:
             if ircutils.hostmaskPatternEqual(ignore, msg.prefix):
                 self.log.debug('Refusing to relay %s, ignored by %s.',
                                msg.prefix, ignore)
                 return
         # Let's try to detect other relay bots.
         if self._checkRelayMsg(msg):
             if self.registryValue('punishOtherRelayBots', channel):
                 self._punishRelayers(msg)
             # Either way, we don't relay the message.
             else:
                 self.log.warning('Refusing to relay message from %s, '
                                  'it appears to be a relay message.',
                                  msg.prefix)
         else:
             network = self._getIrcName(irc)
             s = self._formatPrivmsg(msg.nick, network, msg)
             m = self._msgmaker(channel, s)
             self._sendToOthers(irc, m)

 def newf(self, irc, msg, match, *L, **kwargs):
     url = match.group(0)
     channel = msg.args[0]
     if not irc.isChannel(channel) or (ircmsgs.isCtcp(msg) and not
                                       ircmsgs.isAction(msg)):
         return
     if ircdb.channels.getChannel(channel).lobotomized:
         self.log.debug('Not snarfing in %s: lobotomized.', channel)
         return
     if _snarfed.has(channel, url):
         self.log.info('Throttling snarf of %s in %s.', url, channel)
         return
     irc = SnarfIrc(irc, channel, url)
     def doSnarf():
         _snarfLock.acquire()
         try:
             # This has to be *after* we've acquired the lock so we can be
             # sure that all previous urlSnarfers have already run to
             # completion.
             if msg.repliedTo:
                 self.log.debug('Not snarfing, msg is already repliedTo.')
                 return
             f(self, irc, msg, match, *L, **kwargs)
         finally:
             _snarfLock.release()
     if threading.currentThread() is not world.mainThread:
         doSnarf()
     else:
         L = list(L)
         t = UrlSnarfThread(target=doSnarf, url=url)
         t.start()

 def doPrivmsg(self, irc, msg):
     (recipients, text) = msg.args
     for channel in recipients.split(','):
         if irc.isChannel(channel):
             noLogPrefix = self.registryValue('noLogPrefix', channel)
             cap = ircdb.makeChannelCapability(channel, 'logChannelMessages')
             try:
                 logChannelMessages = ircdb.checkCapability(msg.prefix, cap,
                     ignoreOwner=True)
             except KeyError:
                 logChannelMessages = True
             nick = msg.nick or irc.nick
             if msg.tagged('LogsToDB__relayed'):
                 (nick, text) = text.split(' ', 1)
                 nick = nick[1:-1]
                 msg.args = (recipients, text)
             if (noLogPrefix and text.startswith(noLogPrefix)) or \
                     not logChannelMessages:
                 text = '-= THIS MESSAGE NOT LOGGED =-'
             if ircmsgs.isAction(msg):
                 self.doLog(irc, channel,
                            '* %s %s\n', nick, ircmsgs.unAction(msg))
             else:
                 self.doLog(irc, channel, '<%s> %s\n', nick, text)
             
             message = msg.args[1]
             self.logViewerDB.add_message(msg.nick, msg.prefix, message, channel)
             self.logViewerFile.write_message(msg.nick, message)

 def tokenize(self, m):
     if ircmsgs.isAction(m):
         return ircmsgs.unAction(m).split()
     elif ircmsgs.isCtcp(m):
         return []
     else:
         return m.args[1].split()