Limnoria/plugins/Topic/plugin.py

629 lines
25 KiB
Python
Raw Normal View History

2005-02-02 05:39:30 +01:00
###
# Copyright (c) 2002-2004, Jeremiah Fincher
# Copyright (c) 2010-2021, The Limnoria Contributors
2005-02-02 05:39:30 +01:00
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice,
# this list of conditions, and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions, and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of the author of this software nor the name of
# contributors to this software may be used to endorse or promote products
# derived from this software without specific prior written consent.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
###
import os
import re
2005-02-02 05:39:30 +01:00
import random
import shutil
import tempfile
2005-02-02 05:39:30 +01:00
import supybot.conf as conf
import supybot.ircdb as ircdb
2005-02-02 05:39:30 +01:00
import supybot.utils as utils
import supybot.world as world
2005-02-02 05:39:30 +01:00
from supybot.commands import *
import supybot.ircmsgs as ircmsgs
import supybot.plugins as plugins
import supybot.ircutils as ircutils
import supybot.callbacks as callbacks
from supybot.i18n import PluginInternationalization
_ = PluginInternationalization('Topic')
import supybot.ircdb as ircdb
2005-02-02 05:39:30 +01:00
2015-08-11 16:50:23 +02:00
import supybot.utils.minisix as minisix
pickle = minisix.pickle
2014-12-27 19:41:56 +01:00
2005-02-02 05:39:30 +01:00
def canChangeTopic(irc, msg, args, state):
assert not state.channel
callConverter('channel', irc, msg, args, state)
callConverter('inChannel', irc, msg, args, state)
if state.channel not in irc.state.channels:
state.error(format(_('I\'m not currently in %s.'), state.channel),
Raise=True)
2005-02-02 05:39:30 +01:00
c = irc.state.channels[state.channel]
2014-05-07 07:11:43 +02:00
if 't' in c.modes and not c.isHalfopPlus(irc.nick):
state.error(format(_('I can\'t change the topic, I\'m not (half)opped '
2014-12-27 19:41:56 +01:00
'and %s is +t.'), state.channel), Raise=True)
2005-02-02 05:39:30 +01:00
def getTopic(irc, msg, args, state, format=True):
separator = state.cb.registryValue('separator', state.channel, irc.network)
if separator in args[0] and not \
state.cb.registryValue('allowSeparatorinTopics',
state.channel, irc.network):
state.errorInvalid('topic', args[0],
format(_('The topic must not include %q.'),
separator))
2005-02-02 05:39:30 +01:00
topic = args.pop(0)
if format:
env = {'topic': topic}
formatter = state.cb.registryValue('format', state.channel, irc.network)
2005-02-02 05:39:30 +01:00
topic = ircutils.standardSubstitute(irc, msg, formatter, env)
state.args.append(topic)
2014-12-27 19:41:56 +01:00
2005-02-02 05:39:30 +01:00
def getTopicNumber(irc, msg, args, state):
def error(s):
state.errorInvalid(_('topic number'), s)
2005-02-02 05:39:30 +01:00
try:
n = int(args[0])
if not n:
raise ValueError
except ValueError:
error(args[0])
if n > 0:
n -= 1
topic = irc.state.getTopic(state.channel)
separator = state.cb.registryValue('separator', state.channel, irc.network)
2005-02-02 05:39:30 +01:00
topics = splitTopic(topic, separator)
if not topics:
state.error(format(_('There are no topics in %s.'), state.channel),
Raise=True)
2005-02-02 05:39:30 +01:00
try:
topics[n]
except IndexError:
error(args[0])
2005-02-02 05:39:30 +01:00
del args[0]
while n < 0:
n += len(topics)
state.args.append(n)
addConverter('topic', getTopic)
addConverter('topicNumber', getTopicNumber)
addConverter('canChangeTopic', canChangeTopic)
2014-12-27 19:41:56 +01:00
2005-02-02 05:39:30 +01:00
def splitTopic(topic, separator):
return list(filter(None, topic.split(separator)))
2005-02-02 05:39:30 +01:00
datadir = conf.supybot.directories.data()
filename = conf.supybot.directories.data.dirize('Topic.pickle')
2014-12-27 19:41:56 +01:00
class Topic(callbacks.Plugin):
"""This plugin allows you to use many topic-related functions,
such as Add, Undo, and Remove."""
2014-12-27 19:41:56 +01:00
2005-02-02 05:39:30 +01:00
def __init__(self, irc):
self.__parent = super(Topic, self)
self.__parent.__init__(irc)
self.undos = ircutils.IrcDict()
self.redos = ircutils.IrcDict()
self.lastTopics = ircutils.IrcDict()
self.watchingFor332 = ircutils.IrcSet()
try:
pkl = open(filename, 'rb')
try:
self.undos = pickle.load(pkl)
self.redos = pickle.load(pkl)
self.lastTopics = pickle.load(pkl)
self.watchingFor332 = pickle.load(pkl)
except Exception as e:
self.log.debug('Unable to load pickled data: %s', e)
pkl.close()
except IOError as e:
self.log.debug('Unable to open pickle file: %s', e)
world.flushers.append(self._flush)
def die(self):
world.flushers.remove(self._flush)
self.__parent.die()
def _flush(self):
try:
pklfd, tempfn = tempfile.mkstemp(suffix='topic', dir=datadir)
pkl = os.fdopen(pklfd, 'wb')
try:
pickle.dump(self.undos, pkl)
pickle.dump(self.redos, pkl)
pickle.dump(self.lastTopics, pkl)
pickle.dump(self.watchingFor332, pkl)
except Exception as e:
self.log.warning('Unable to store pickled data: %s', e)
pkl.close()
shutil.move(tempfn, filename)
except (IOError, shutil.Error) as e:
self.log.warning('File error: %s', e)
2005-02-02 05:39:30 +01:00
def _splitTopic(self, irc, channel):
topic = irc.state.getTopic(channel)
separator = self.registryValue('separator', channel, irc.network)
2005-02-02 05:39:30 +01:00
return splitTopic(topic, separator)
def _joinTopic(self, irc, channel, topics):
separator = self.registryValue('separator', channel, irc.network)
2005-02-02 05:39:30 +01:00
return separator.join(topics)
def _addUndo(self, irc, channel, topics):
2005-02-02 05:39:30 +01:00
stack = self.undos.setdefault(channel, [])
stack.append(topics)
maxLen = self.registryValue('undo.max', channel, irc.network)
2014-12-27 19:41:56 +01:00
del stack[:len(stack) - maxLen]
2005-02-02 05:39:30 +01:00
def _addRedo(self, irc, channel, topics):
2005-02-02 05:39:30 +01:00
stack = self.redos.setdefault(channel, [])
stack.append(topics)
maxLen = self.registryValue('undo.max', channel, irc.network)
2014-12-27 19:41:56 +01:00
del stack[:len(stack) - maxLen]
2005-02-02 05:39:30 +01:00
def _getUndo(self, channel):
try:
return self.undos[channel].pop()
except (KeyError, IndexError):
return None
def _getRedo(self, channel):
try:
return self.redos[channel].pop()
except (KeyError, IndexError):
return None
2013-08-17 21:51:17 +02:00
def _formatTopics(self, irc, channel, topics, fit=False):
2005-02-02 05:39:30 +01:00
topics = [s for s in topics if s and not s.isspace()]
self.lastTopics[channel] = topics
newTopic = self._joinTopic(irc, channel, topics)
2005-02-02 05:39:30 +01:00
try:
maxLen = irc.state.supported['topiclen']
2005-02-04 06:04:40 +01:00
if fit:
while len(newTopic) > maxLen:
topics.pop(0)
self.lastTopics[channel] = topics
newTopic = self._joinTopic(irc, channel, topics)
2005-02-04 06:04:40 +01:00
elif len(newTopic) > maxLen:
if self.registryValue('recognizeTopiclen', channel, irc.network):
irc.error(format(_('That topic is too long for this '
2014-12-27 19:41:56 +01:00
'server (maximum length: %i; this topic: '
'%i).'), maxLen, len(newTopic)),
2005-02-02 05:39:30 +01:00
Raise=True)
except KeyError:
pass
2013-08-17 21:51:17 +02:00
return newTopic
2013-08-17 21:51:17 +02:00
def _sendTopics(self, irc, channel, topics=None, isDo=False, fit=False):
if isinstance(topics, list) or isinstance(topics, tuple):
assert topics is not None
2013-08-17 21:51:17 +02:00
topics = self._formatTopics(irc, channel, topics, fit)
self._addUndo(irc, channel, topics)
2005-02-02 05:39:30 +01:00
if not isDo and channel in self.redos:
del self.redos[channel]
2013-08-17 21:51:17 +02:00
irc.queueMsg(ircmsgs.topic(channel, topics))
2005-02-02 05:39:30 +01:00
irc.noReply()
def _checkManageCapabilities(self, irc, msg, channel):
"""Check if the user has any of the required capabilities to manage
the channel topic.
The list of required capabilities is in requireManageCapability
channel config.
2014-07-13 17:23:11 +02:00
Also allow if the user is a chanop. Since they can change the topic
manually anyway.
"""
c = irc.state.channels[channel]
if msg.nick in c.ops or msg.nick in c.halfops or 't' not in c.modes:
return True
capabilities = self.registryValue('requireManageCapability',
channel, irc.network)
if capabilities:
for capability in re.split(r'\s*;\s*', capabilities):
if capability.startswith('channel,'):
2014-12-27 19:41:56 +01:00
capability = ircdb.makeChannelCapability(
channel, capability[8:])
if capability and ircdb.checkCapability(msg.prefix, capability):
return
capabilities = self.registryValue('requireManageCapability',
channel, irc.network)
irc.errorNoCapability(capabilities, Raise=True)
else:
return
2005-02-02 05:39:30 +01:00
def doJoin(self, irc, msg):
if ircutils.strEqual(msg.nick, irc.nick):
# We're joining a channel, let's watch for the topic.
self.watchingFor332.add(msg.args[0])
def do315(self, irc, msg):
# Try to restore the topic when not set yet.
channel = msg.args[1]
c = irc.state.channels.get(channel)
if c is None or not self.registryValue('setOnJoin', channel, irc.network):
return
if irc.nick not in c.ops and 't' in c.modes:
self.log.debug('Not trying to restore topic in %s. I\'m not opped '
2014-12-27 19:41:56 +01:00
'and %s is +t.', channel, channel)
return
try:
topics = self.lastTopics[channel]
except KeyError:
self.log.debug('No topic to auto-restore in %s.', channel)
else:
newTopic = self._formatTopics(irc, channel, topics)
2013-08-17 21:51:17 +02:00
if c.topic == '' or (c.topic != newTopic and
self.registryValue('alwaysSetOnJoin',
channel, irc.network)):
2013-08-17 21:51:17 +02:00
self._sendTopics(irc, channel, newTopic)
2005-02-02 05:39:30 +01:00
def do332(self, irc, msg):
if msg.args[1] in self.watchingFor332:
self.watchingFor332.remove(msg.args[1])
# Store an undo for the topic when we join a channel. This allows
# us to undo the first topic change that takes place in a channel.
self._addUndo(irc, msg.args[1], [msg.args[2]])
2005-02-02 05:39:30 +01:00
def topic(self, irc, msg, args, channel):
"""[<channel>]
Returns the topic for <channel>. <channel> is only necessary if the
message isn't sent in the channel itself.
"""
topic = irc.state.channels[channel].topic
irc.reply(topic)
topic = wrap(topic, ['inChannel'])
def add(self, irc, msg, args, channel, topic):
"""[<channel>] <topic>
Adds <topic> to the topics for <channel>. <channel> is only necessary
if the message isn't sent in the channel itself.
"""
self._checkManageCapabilities(irc, msg, channel)
topics = self._splitTopic(irc, channel)
2005-02-02 05:39:30 +01:00
topics.append(topic)
self._sendTopics(irc, channel, topics)
add = wrap(add, ['canChangeTopic', rest('topic')])
2005-02-04 06:04:40 +01:00
def fit(self, irc, msg, args, channel, topic):
"""[<channel>] <topic>
Adds <topic> to the topics for <channel>. If the topic is too long
for the server, topics will be popped until there is enough room.
<channel> is only necessary if the message isn't sent in the channel
itself.
"""
self._checkManageCapabilities(irc, msg, channel)
topics = self._splitTopic(irc, channel)
2005-02-04 06:04:40 +01:00
topics.append(topic)
self._sendTopics(irc, channel, topics, fit=True)
fit = wrap(fit, ['canChangeTopic', rest('topic')])
2005-02-02 05:39:30 +01:00
def replace(self, irc, msg, args, channel, i, topic):
"""[<channel>] <number> <topic>
Replaces topic <number> with <topic>.
"""
self._checkManageCapabilities(irc, msg, channel)
topics = self._splitTopic(irc, channel)
2005-02-02 05:39:30 +01:00
topics[i] = topic
self._sendTopics(irc, channel, topics)
replace = wrap(replace, ['canChangeTopic', 'topicNumber', rest('topic')])
def insert(self, irc, msg, args, channel, topic):
"""[<channel>] <topic>
Adds <topic> to the topics for <channel> at the beginning of the topics
currently on <channel>. <channel> is only necessary if the message
isn't sent in the channel itself.
"""
self._checkManageCapabilities(irc, msg, channel)
topics = self._splitTopic(irc, channel)
2005-02-02 05:39:30 +01:00
topics.insert(0, topic)
self._sendTopics(irc, channel, topics)
insert = wrap(insert, ['canChangeTopic', rest('topic')])
def shuffle(self, irc, msg, args, channel):
"""[<channel>]
Shuffles the topics in <channel>. <channel> is only necessary if the
message isn't sent in the channel itself.
"""
self._checkManageCapabilities(irc, msg, channel)
topics = self._splitTopic(irc, channel)
2005-02-02 05:39:30 +01:00
if len(topics) == 0 or len(topics) == 1:
irc.error(_('I can\'t shuffle 1 or fewer topics.'), Raise=True)
2005-02-02 05:39:30 +01:00
elif len(topics) == 2:
topics.reverse()
else:
original = topics[:]
while topics == original:
random.shuffle(topics)
self._sendTopics(irc, channel, topics)
shuffle = wrap(shuffle, ['canChangeTopic'])
def reorder(self, irc, msg, args, channel, numbers):
"""[<channel>] <number> [<number> ...]
Reorders the topics from <channel> in the order of the specified
<number> arguments. <number> is a one-based index into the topics.
<channel> is only necessary if the message isn't sent in the channel
itself.
"""
self._checkManageCapabilities(irc, msg, channel)
topics = self._splitTopic(irc, channel)
2005-02-02 05:39:30 +01:00
num = len(topics)
if num == 0 or num == 1:
irc.error(_('I cannot reorder 1 or fewer topics.'), Raise=True)
2005-02-02 05:39:30 +01:00
if len(numbers) != num:
irc.error(_('All topic numbers must be specified.'), Raise=True)
2015-08-10 19:36:07 +02:00
if sorted(numbers) != list(range(num)):
irc.error(_('Duplicate topic numbers cannot be specified.'))
2005-02-02 05:39:30 +01:00
return
newtopics = [topics[i] for i in numbers]
self._sendTopics(irc, channel, newtopics)
reorder = wrap(reorder, ['canChangeTopic', many('topicNumber')])
def list(self, irc, msg, args, channel):
"""[<channel>]
Returns a list of the topics in <channel>, prefixed by their indexes.
Mostly useful for topic reordering. <channel> is only necessary if the
message isn't sent in the channel itself.
"""
topics = self._splitTopic(irc, channel)
2005-02-02 05:39:30 +01:00
L = []
for (i, t) in enumerate(topics):
2014-12-27 19:41:56 +01:00
L.append(format(_('%i: %s'), i + 1, utils.str.ellipsisify(t, 30)))
2005-02-02 05:39:30 +01:00
s = utils.str.commaAndify(L)
irc.reply(s)
list = wrap(list, ['inChannel'])
def get(self, irc, msg, args, channel, number):
"""[<channel>] <number>
Returns topic number <number> from <channel>. <number> is a one-based
index into the topics. <channel> is only necessary if the message
isn't sent in the channel itself.
"""
topics = self._splitTopic(irc, channel)
2005-02-02 05:39:30 +01:00
irc.reply(topics[number])
get = wrap(get, ['inChannel', 'topicNumber'])
def change(self, irc, msg, args, channel, number, replacer):
"""[<channel>] <number> <regexp>
Changes the topic number <number> on <channel> according to the regular
expression <regexp>. <number> is the one-based index into the topics;
<regexp> is a regular expression of the form
s/regexp/replacement/flags. <channel> is only necessary if the message
isn't sent in the channel itself.
"""
self._checkManageCapabilities(irc, msg, channel)
topics = self._splitTopic(irc, channel)
2005-02-02 05:39:30 +01:00
topics[number] = replacer(topics[number])
self._sendTopics(irc, channel, topics)
change = wrap(change, ['canChangeTopic', 'topicNumber', 'regexpReplacer'])
def set(self, irc, msg, args, channel, number, topic):
"""[<channel>] [<number>] <topic>
Sets the topic <number> to be <text>. If no <number> is given, this
sets the entire topic. <channel> is only necessary if the message
isn't sent in the channel itself.
"""
self._checkManageCapabilities(irc, msg, channel)
if number is not None:
topics = self._splitTopic(irc, channel)
2005-02-02 05:39:30 +01:00
topics[number] = topic
else:
topics = [topic]
self._sendTopics(irc, channel, topics)
set = wrap(set, ['canChangeTopic',
optional('topicNumber'),
2005-02-02 05:39:30 +01:00
rest(('topic', False))])
def remove(self, irc, msg, args, channel, numbers):
"""[<channel>] <number1> [<number2> <number3>...]
2005-02-02 05:39:30 +01:00
Removes topics <numbers> from the topic for <channel> Topics are
2005-02-02 05:39:30 +01:00
numbered starting from 1; you can also use negative indexes to refer
to topics starting the from the end of the topic. <channel> is only
necessary if the message isn't sent in the channel itself.
"""
self._checkManageCapabilities(irc, msg, channel)
topics = self._splitTopic(irc, channel)
numbers = set(numbers)
for n in numbers:
# Equivalent of marking the topic for deletion; there's no
# simple, easy way of removing multiple items from a list.
# pop() will shift the indices after every run.
topics[n] = ''
topics = [topic for topic in topics if topic != '']
2005-02-02 05:39:30 +01:00
self._sendTopics(irc, channel, topics)
remove = wrap(remove, ['canChangeTopic', many('topicNumber')])
2005-02-02 05:39:30 +01:00
def lock(self, irc, msg, args, channel):
"""[<channel>]
Locks the topic (sets the mode +t) in <channel>. <channel> is only
necessary if the message isn't sent in the channel itself.
"""
self._checkManageCapabilities(irc, msg, channel)
2005-02-02 05:39:30 +01:00
irc.queueMsg(ircmsgs.mode(channel, '+t'))
irc.noReply()
lock = wrap(lock, ['channel', ('haveHalfop+', _('lock the topic'))])
2005-02-02 05:39:30 +01:00
def unlock(self, irc, msg, args, channel):
"""[<channel>]
2011-07-20 21:28:43 +02:00
Unlocks the topic (sets the mode -t) in <channel>. <channel> is only
2005-02-02 05:39:30 +01:00
necessary if the message isn't sent in the channel itself.
"""
self._checkManageCapabilities(irc, msg, channel)
2005-02-02 05:39:30 +01:00
irc.queueMsg(ircmsgs.mode(channel, '-t'))
irc.noReply()
unlock = wrap(unlock, ['channel', ('haveHalfop+', _('unlock the topic'))])
2005-02-02 05:39:30 +01:00
def restore(self, irc, msg, args, channel):
"""[<channel>]
Restores the topic to the last topic set by the bot. <channel> is only
necessary if the message isn't sent in the channel itself.
"""
self._checkManageCapabilities(irc, msg, channel)
2005-02-02 05:39:30 +01:00
try:
topics = self.lastTopics[channel]
if not topics:
raise KeyError
2005-02-02 05:39:30 +01:00
except KeyError:
irc.error(format(_('I haven\'t yet set the topic in %s.'),
channel))
2005-02-02 05:39:30 +01:00
return
self._sendTopics(irc, channel, topics)
restore = wrap(restore, ['canChangeTopic'])
2014-11-21 03:07:52 +01:00
def refresh(self, irc, msg, args, channel):
"""[<channel>]
Refreshes current topic set by anyone. Restores topic if empty.
<channel> is only necessary if the message isn't sent in the channel
itself.
"""
self._checkManageCapabilities(irc, msg, channel)
2014-11-21 03:07:52 +01:00
topic = irc.state.channels[channel].topic
if topic:
self._sendTopics(irc, channel, topic)
return
try:
topics = self.lastTopics[channel]
if not topics:
raise KeyError
except KeyError:
2014-12-27 19:41:56 +01:00
irc.error(format(_('I haven\'t yet set the topic in %s.'),
channel))
return
self._sendTopics(irc, channel, topics)
refresh = wrap(refresh, ['canChangeTopic'])
2014-11-21 03:07:52 +01:00
2005-02-02 05:39:30 +01:00
def undo(self, irc, msg, args, channel):
"""[<channel>]
Restores the topic to the one previous to the last topic command that
set it. <channel> is only necessary if the message isn't sent in the
channel itself.
"""
self._checkManageCapabilities(irc, msg, channel)
self._addRedo(irc, channel, self._getUndo(channel)) # current topic.
2014-12-27 19:41:56 +01:00
topics = self._getUndo(channel) # This is the topic list we want.
2005-02-02 05:39:30 +01:00
if topics is not None:
self._sendTopics(irc, channel, topics, isDo=True)
else:
irc.error(format(_('There are no more undos for %s.'), channel))
2005-02-02 05:39:30 +01:00
undo = wrap(undo, ['canChangetopic'])
def redo(self, irc, msg, args, channel):
"""[<channel>]
Undoes the last undo. <channel> is only necessary if the message isn't
sent in the channel itself.
"""
self._checkManageCapabilities(irc, msg, channel)
2005-02-02 05:39:30 +01:00
topics = self._getRedo(channel)
if topics is not None:
self._sendTopics(irc, channel, topics, isDo=True)
else:
irc.error(format(_('There are no redos for %s.'), channel))
2005-02-02 05:39:30 +01:00
redo = wrap(redo, ['canChangeTopic'])
def swap(self, irc, msg, args, channel, first, second):
"""[<channel>] <first topic number> <second topic number>
Swaps the order of the first topic number and the second topic number.
<channel> is only necessary if the message isn't sent in the channel
itself.
"""
self._checkManageCapabilities(irc, msg, channel)
topics = self._splitTopic(irc, channel)
2005-02-02 05:39:30 +01:00
if first == second:
irc.error(_('I refuse to swap the same topic with itself.'))
2005-02-02 05:39:30 +01:00
return
t = topics[first]
topics[first] = topics[second]
topics[second] = t
self._sendTopics(irc, channel, topics)
swap = wrap(swap, ['canChangeTopic', 'topicNumber', 'topicNumber'])
def save(self, irc, msg, args, channel):
"""[<channel>]
Saves the topic in <channel> to be restored with 'topic default'
later. <channel> is only necessary if the message isn't sent in
the channel itself.
"""
self._checkManageCapabilities(irc, msg, channel)
topic = irc.state.getTopic(channel)
if topic:
self.setRegistryValue('default', value=topic, channel=channel)
else:
self.setRegistryValue('default', value='', channel=channel)
irc.replySuccess()
save = wrap(save, ['channel', 'inChannel'])
2005-02-02 05:39:30 +01:00
def default(self, irc, msg, args, channel):
"""[<channel>]
Sets the topic in <channel> to the default topic for <channel>. The
default topic for a channel may be configured via the configuration
variable supybot.plugins.Topic.default.
"""
self._checkManageCapabilities(irc, msg, channel)
topic = self.registryValue('default', channel, irc.network)
2005-02-02 05:39:30 +01:00
if topic:
self._sendTopics(irc, channel, [topic])
else:
irc.error(format(_('There is no default topic configured for %s.'),
2005-02-02 05:39:30 +01:00
channel))
default = wrap(default, ['canChangeTopic'])
def separator(self, irc, msg, args, channel, separator):
"""[<channel>] <separator>
Sets the topic separator for <channel> to <separator> Converts the
current topic appropriately.
"""
self._checkManageCapabilities(irc, msg, channel)
topics = self._splitTopic(irc, channel)
2005-02-02 05:39:30 +01:00
self.setRegistryValue('separator', separator, channel)
self._sendTopics(irc, channel, topics)
separator = wrap(separator, ['canChangeTopic', 'something'])
Class = Topic
# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79: