Merge lp:~isoschiz/endroid/lp1047334 into lp:~ben-hutchings/endroid/roomowner

[Martin Morrison]

Fixes to the memo plugin

[Ben Hutchings (ben-hutchings)]

review: Approve

=== modified file 'src/endroid/plugins/command.py'
--- src/endroid/plugins/command.py	2013-08-06 10:32:33 +0000
+++ src/endroid/plugins/command.py	2013-08-12 13:56:25 +0000
@@ -9,6 +9,7 @@
 
 __all__ = (
     'CommandPlugin',
+    'command',
     )
 
 # A single registration
@@ -24,13 +25,52 @@
 # - subcommands is a dict of subcommand (simple str) to Handlers object
 Handlers = namedtuple('Handlers', ('handlers', 'subcommands'))
 
+def command(wrapped=None, synonyms=(), helphint="", hidden=False, chat_only=False,
+            muc_only=False):
+    """
+    Decorator used to mark command functions in subclasses of CommandPlugin.
+
+    In it's simplest form, can be used to mark a function as a command:
+
+        >>> class Foo(CommandPlugin):
+        ...     @command
+        ...     def foo_bar(self, msg, args):
+        ...         do_stuff_here()
+
+    This will register the command string ("foo", "bar") with the Command plugin
+    when the Foo plugin is initialised.
+
+    The decorator also takes a series of optional keyword arguments to control
+    the behaviour of the registration:
+
+        synonyms: sequence of synonyms (either strings, or sequences of strings)
+        helphint: a helpful hint to display in help for the command
+        hidden: whether the command is hidden in the help
+        chat_only: set to True if the command should only be registered in chat
+        muc_only: set to True if the command should only be registered in muc
+
+    """
+    def decorator(fn):
+        fn.is_command = True
+        fn.synonyms = synonyms
+        fn.helphint = helphint
+        fn.hidden = hidden
+        fn.chat_only = chat_only
+        fn.muc_only = muc_only
+        return fn
+    if wrapped is None:
+        return decorator
+    else:
+        return decorator(wrapped)
+
 class CommandPluginMeta(PluginMeta):
     """
     Metaclass to support simple command-driven plugins. This should not be used
     directly, but rather by subclassing from CommandPlugin rather than Plugin.
     """
     def __new__(meta, name, bases, dct):
-        cmds = dict((c, f) for c, f in dct.items() if c.startswith("cmd_"))
+        cmds = dict((c, f) for c, f in dct.items()
+                    if c.startswith("cmd_") or getattr(c, "is_command", False))
         init = dct.get('endroid_init', lambda _: None)
         def endroid_init(self):
             com = self.get('endroid.plugins.command')
@@ -41,7 +81,10 @@
                     reg_fn = com.register_muc
                 else:
                     reg_fn = com.register_both
-                reg_fn(getattr(self, cmd), cmd.split("_")[1:],
+                words = cmd.split("_")
+                if not getattr(cmd, "is_command", False):
+                    words = words[1:]
+                reg_fn(getattr(self, cmd), words,
                        helphint=getattr(fn, "helphint", ""),
                        hidden=getattr(fn, "hidden", False),
                        synonyms=getattr(fn, "synonyms", ()))
@@ -49,17 +92,20 @@
         dct['endroid_init'] = endroid_init
         dct['dependencies'] = tuple(dct.get('dependencies', ()) +
                                     ('endroid.plugins.command',))
-        return PluginMeta.__new__(meta, name, bases, dct)
+        return super(CommandPluginMeta, meta).__new__(meta, name, bases, dct)
 
 class CommandPlugin(Plugin):
     """
     Parent class for simple command-driven plugins. Such plugins don't need to
     explicitly register their commands. Instead, they can just define methods
-    prefixed with "cmd_" and they will automatically be registered. Any
-    additional underscores in the method name will be converted to spaces in
-    the registration (so cmd_foo_bar is registered as ('foo', 'bar')).
-
-    In addition, certain options can be passed by adding fields to the methods:
+    prefixed with "cmd_" or decorated with the 'command' decorator, and they
+    will automatically be registered. Any additional underscores in the method
+    name will be converted to spaces in the registration (so cmd_foo_bar is
+    registered as ('foo', 'bar')).
+
+    In addition, certain options can be passed by adding fields to the methods,
+    or as keyword arguments to the decorator:
+
     - hidden: don't show the command in help if set to True.
     - synonyms: an iterable of alternative keyword sequences to register the
         method against. All synonyms are hidden.
@@ -169,14 +215,14 @@
     # -------------------------------------------------------------------------
     # Registration methods
 
-    def register_handler(self, callback, cmd, helphint, hidden, handlers,
+    def _register_handler(self, callback, cmd, helphint, hidden, handlers,
                          synonyms=()):
         """
         Register a new handler.
 
         callback is the callback handle to call.
         command is either a single keyword, or a sequence of keywords to match.
-        helphint and hidden are argument to the Registration object.
+        helphint and hidden are arguments to the Registration object.
         handlers are the top-level handlers to add the registration to.
         """
         # Register any synonyms (done before we frig with the handlers)
@@ -194,13 +240,13 @@
     def register_muc(self, callback, command, helphint="", hidden=False,
                      synonyms=()):
         """Register a new handler for MUC messages."""
-        self.register_handler(callback, command, helphint, hidden,
+        self._register_handler(callback, command, helphint, hidden,
                               self._muc_handlers, synonyms)
     
     def register_chat(self, callback, command, helphint="", hidden=False,
                       synonyms=()):
         """Register a new handler for chat messages."""
-        self.register_handler(callback, command, helphint, hidden,
+        self._register_handler(callback, command, helphint, hidden,
                               self._chat_handlers, synonyms)
 
     def register_both(self, callback, command, helphint="", hidden=False,

=== modified file 'src/endroid/plugins/memo.py'
--- src/endroid/plugins/memo.py	2013-07-30 11:25:48 +0000
+++ src/endroid/plugins/memo.py	2013-08-12 13:56:25 +0000
@@ -8,7 +8,7 @@
 See MESSAGES['usage'] for details.
 """
 
-from endroid.pluginmanager import Plugin
+from endroid.plugins.command import CommandPlugin, command
 from endroid.database import Database
 from endroid.database import EndroidUniqueID
 
@@ -26,11 +26,12 @@
 memo usage - Output this message
 memo [list] - List messages in inbox
 memo send <recipient> <message> - Send a message
-memo {view|delete} <message-id> -Handle a specific message""",
+memo {view|delete} <message-id> - Handle a specific message""",
 
     'usage-send' : "memo send <recipient> <message> \t Send a message",
     'usage-view' : "memo view <message-id> \t View a specific message",
     'usage-delete' : "memo delete <message-id> \t Delete a specific message",
+
     'duplicate-id-error' : "Error: There are messages sharing the same PK id",
     'id-not-found-error' : "There is no message with id {0}.  Try 'memo list'.",
     'deletion-sucess' : "Sucessfully deleted one message",
@@ -44,33 +45,21 @@
     }
 
 
-class Memo(Plugin):
+class Memo(CommandPlugin):
     name = "memo"
-    
-    def dependencies(self):
-        return ('endroid.plugins.command',)
-    
-    def enInit(self):
-        com = self.get('endroid.plugins.command')
-        com.register_chat(self._handle_list, 'memo', '[list]')
-        com.register_chat(self._handle_list, ('memo', 'list'), hidden=True)
-        com.register_chat(self._handle_send, ('memo', 'send'),
-                          '<recipient> <message>')
-        com.register_chat(self._handle_view, ('memo', 'view'), '<message-id>')
-        com.register_chat(self._handle_delete, ('memo', 'delete'),
-                          '<message-id>')
-        com.register_chat(lambda m, _: m.reply(MESSAGES['usage']),
-                          ('memo', 'usage'))
+    help_topics = {
+        '': lambda _: MESSAGES['help'],
+        'usage': lambda _: MESSAGES['usage'],
+        'send': lambda _: MESSAGES['usage-send'],
+        'view': lambda _: MESSAGES['usage-view'],
+        'delete': lambda _: MESSAGES['usage-delete'],
+    }
+    
+    def endroid_init(self):
         self.db = Database(DB_NAME)
-        self.setup_db()
-
-    def setup_db(self):
         if not self.db.table_exists(DB_TABLE):
             self.db.create_table(DB_TABLE, DB_COLUMNS)
 
-    def help(self):
-        return MESSAGES['help']
-
     def _message_text_summary(self, text):
         # First assume text is too long, try to shorten.
         summary = ""
@@ -81,8 +70,13 @@
             summary += word + ' '
         # Looks like memo is already short enough.  Return it.
         return summary[:-1]
-     
-    def _handle_delete(self, msg, args):
+
+    @command
+    def memo_usage(self, msg, args):
+        msg.reply(MESSAGES['usage'])
+
+    @command(helphint="<message-id>")
+    def memo_delete(self, msg, args):
         args = args.split()
         if len(args) != 1 or not args[0].isdigit():
             msg.reply(MESSAGES['usage-delete'])
@@ -99,7 +93,15 @@
             self.db.delete(DB_TABLE, {EndroidUniqueID : int(args[0])})
             msg.reply(MESSAGES['deletion-sucess'])
 
-    def _handle_list(self, msg, args):
+    @command(helphint="[list]")
+    def memo(self, msg, args):
+        args = args.split()
+        if len(args) > 0 and args[0] in {"send", "view", "delete", "usage"}:
+            msg.unhandled()
+            return
+        if len(args) > 1 or (len(args) == 1 and args[0] != "list"):
+            msg.reply(MESSAGES['usage'])
+            return
         memos = []
         cond = {"recipient" : msg.sender}
         rows = self.db.fetch(DB_TABLE, DB_COLUMNS, cond)
@@ -114,7 +116,8 @@
         else:
             msg.reply(MESSAGES['inbox-empty'])
     
-    def _handle_view(self, msg, args):
+    @command(helphint="<message-id>")
+    def memo_view(self, msg, args):
         args = args.split()
         if len(args) != 1 or not args[0].isdigit():
             msg.reply(MESSAGES['usage-view'])
@@ -132,7 +135,8 @@
             data = (row["sender"], row["text"])
             msg.reply(MESSAGES['view-message'].format(*data))
 
-    def _handle_send(self, msg, args):
+    @command(helphint="<recipient> <message>")
+    def memo_send(self, msg, args):
         args = args.split()
         if len(args) < 2:
             msg.reply(MESSAGES['usage-send'])