Delegate history and valid command to Kaylee

The plugins shouldn't be in charge of running the
valid_sentence_command.  They also certainly shouldn't have to manage
the history file.  Both of these functions have been delegated to the
Kaylee object, by way of a 'processed' signal emitted by a plugin as
soon as it knows it will handle the voice command.

kayleevc/kaylee.py

@@ -5,6 +5,7 @@
 
 import importlib
 import sys
+import subprocess
 import signal
 import os.path
 from gi.repository import GObject, GLib
@@ -25,13 +26,12 @@ class Kaylee:
         # Load configuration
         self.config = Config()
         self.options = vars(self.config.options)
-        self.commands = self.options['plugins']['.shell']
 
         # Load plugins
         self.plugins = []
         for plugin in self.options['plugins'].keys():
             pmod = importlib.import_module(plugin, 'kayleevc.plugins')
-            self.plugins.append(pmod.Plugin(self.config))
+            self.plugins.append(pmod.Plugin(self.config, plugin))
 
         # Create a hasher
         self.hasher = Hasher(self.config)
@@ -72,6 +72,7 @@ class Kaylee:
         # Connect the recognizer's finished signal to all the plugins
         for plugin in self.plugins:
             self.recognizer.connect('finished', plugin.recognizer_finished)
+            plugin.connect('processed', self.plugin_processed)
 
     def update_voice_commands_if_changed(self):
         """Use hashes to test if the voice commands have changed"""
@@ -105,9 +106,19 @@ class Kaylee:
                     strings.write(word + " ")
             strings.write("\n")
 
-    def log_history(self, text):
+    def plugin_processed(self, plugin, text):
+        """Callback for ``processed`` signal from plugins
+
+        Runs the valid_sentence_command and logs the recognized sentence to the
+        history file.
+        """
+        # Run the valid_sentence_command if it's set
+        if self.options['valid_sentence_command']:
+            subprocess.call(self.options['valid_sentence_command'], shell=True)
+
+        # Log the command to the history file
         if self.options['history']:
-            self.history.append(text)
+            self.history.append("{}: {}".format(plugin.name, text))
             if len(self.history) > self.options['history']:
                 # Pop off the first item
                 self.history.pop(0)
@@ -117,9 +128,6 @@ class Kaylee:
                 for line in self.history:
                     hfile.write(line + '\n')
 
-    def recognizer_finished(self, recognizer, text):
-        pass
-
     def run(self):
         if self.ui:
             self.ui.run()

kayleevc/plugins/pluginbase.py

@@ -5,15 +5,27 @@
 
 from abc import ABCMeta, abstractmethod
 
+from gi.repository import GObject
+from gi.types import GObjectMeta
 
-class PluginBase(metaclass=ABCMeta):
+
+class GObjectABCMeta(ABCMeta, GObjectMeta):
+    pass
+
+
+class PluginBase(GObject.Object, metaclass=GObjectABCMeta):
     """Base class for Kaylee plugins
 
     Each Kaylee plugin module must define a subclass of this class, named
     ``Plugin``.
     """
 
-    def __init__(self, config):
+    __gsignals__ = {
+        'processed' : (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
+                      (GObject.TYPE_STRING,))
+    }
+
+    def __init__(self, config, name):
         """Initialize the plugin
 
         All strings to be included in the corpus should be elements of
@@ -21,7 +33,9 @@ class PluginBase(metaclass=ABCMeta):
         that the words required for number support are automatically included,
         so they need not be listed explicitly on a per-plugin basis.
         """
+        super().__init__()
         self.config = config
+        self.name = name
         self.corpus_strings = set()
 
     @abstractmethod
@@ -29,6 +43,8 @@ class PluginBase(metaclass=ABCMeta):
         """Process a recognized voice command
 
         This method must return True if the command was handled by the plugin,
-        and False otherwise.
+        and False otherwise.  As soon as it has been determined that the
+        command will be handled, this method must emit a ``processed`` signal
+        with ``text`` as its parameter.
         """
         pass

kayleevc/plugins/shell.py

@@ -11,11 +11,11 @@ from ..numbers import NumberParser
 
 class Plugin(PluginBase):
 
-    def __init__(self, config):
-        super().__init__(config)
+    def __init__(self, config, name):
+        super().__init__(config, name)
         self.options = vars(self.config.options)
         self.number_parser = NumberParser()
-        self.commands = self.options['plugins']['.shell']
+        self.commands = self.options['plugins'][name]
 
         for voice_cmd in self.commands.keys():
             self.corpus_strings.add(voice_cmd.strip().replace('%d', ''))
@@ -34,25 +34,15 @@ class Plugin(PluginBase):
         numt, nums = self.number_parser.parse_all_numbers(text)
         # Is there a matching command?
         if text in self.commands:
-            # Run the valid_sentence_command if it's set
-            # TODO: determine how to support this with plugins
-            if self.options['valid_sentence_command']:
-                subprocess.call(self.options['valid_sentence_command'],
-                                shell=True)
+            self.emit('processed', text)
             cmd = self.commands[text]
             self._run_command(cmd)
-            # TODO: Logging can be handled along with valid_sentence_command
-            #self.log_history(text)
             return True
         elif numt in self.commands:
-            # Run the valid_sentence_command if it's set
-            if self.options['valid_sentence_command']:
-                subprocess.call(self.options['valid_sentence_command'],
-                                shell=True)
+            self.emit('processed', text)
             cmd = self.commands[numt]
             cmd = cmd.format(*nums)
             self._run_command(cmd)
-            #self.log_history(text)
             return True
         else:
             # TODO: This could be implemented as a plugin, implicitly loaded