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

 
 import importlib
 import sys
+import subprocess
 import signal
 import os.path
 from gi.repository import GObject, GLib
         # 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)
         # 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"""
                     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)
                 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

 
 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
         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
         """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

 
 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', ''))
         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