plugin manager

src/Psy/Configuration.php

@@ -16,6 +16,7 @@
 use Psy\ExecutionLoop\Loop;
 use Psy\Output\OutputPager;
 use Psy\Output\ShellOutput;
+use Psy\Plugin\PluginManager;
 use Psy\Presenter\PresenterManager;
 use Psy\Readline\GNUReadline;
 use Psy\Readline\Libedit;
@@ -33,9 +34,10 @@ class Configuration
         'defaultIncludes', 'useReadline', 'usePcntl', 'codeCleaner', 'pager',
         'loop', 'configDir', 'dataDir', 'runtimeDir', 'manualDbFile',
         'requireSemicolons', 'historySize', 'eraseDuplicates', 'tabCompletion',
-        'tabCompletionMatchers',
+        'tabCompletionMatchers', 'registerPlugins',
     );
 
+    private $registerPlugins = true;
     private $defaultIncludes;
     private $configDir;
     private $dataDir;
@@ -96,6 +98,27 @@ public function __construct(array $config = array())
         // go go gadget, config!
         $this->loadConfig($config);
         $this->init();
+
+        // ask the plugin manager for configurations
+        if ($this->getRegisterPlugins()) {
+            $this->loadConfig(PluginManager::getConfiguration($config));
+        }
+    }
+
+    /**
+     * @param $bool
+     */
+    public function setRegisterPlugins($bool)
+    {
+        $this->registerPlugins = (bool) $bool;
+    }
+
+    /**
+     * @return bool
+     */
+    public function getRegisterPlugins()
+    {
+        return $this->registerPlugins;
     }
 
     /**

src/Psy/Plugin/AbstractPlugin.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace Psy\Plugin;
+
+abstract class AbstractPlugin
+{
+    public static function register()
+    {
+        PluginManager::register(new static(), static::getName());
+    }
+
+    /**
+     * @return string
+     *
+     * @throws \Exception
+     */
+    public static function getName()
+    {
+        throw new \Exception('Missing plugin name');
+    }
+
+    // any publicly exposed configuration piece below here ↓
+
+    /**
+     * @return array
+     */
+    public static function getCommands()
+    {
+        // add your own commands
+        return array();
+    }
+
+    /**
+     * @return array
+     */
+    public static function getPresenters()
+    {
+        // add your own presenters
+        return array();
+    }
+
+    /**
+     * @return array
+     */
+    public static function getMatchers()
+    {
+        // add your own presenters
+        return array();
+    }
+}

src/Psy/Plugin/PluginManager.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace Psy\Plugin;
+
+class PluginManager
+{
+    /**
+     * @var array
+     */
+    protected static $exposedConfigurationItems = array(
+        'commands', 'matchers', 'presenters',
+    );
+
+    /** @var AbstractPlugin[] */
+    protected static $plugins = array();
+
+    /**
+     * @param AbstractPlugin $plugin
+     * @param $name
+     *
+     * @throws \Exception
+     */
+    public static function register(AbstractPlugin $plugin, $name)
+    {
+        if (array_key_exists($name, self::$plugins)) {
+            throw new \Exception(
+                sprintf('The plugin "%s" was already registered.', $name)
+            );
+        }
+        self::$plugins[$name] = $plugin;
+    }
+
+    /**
+     * @param array $configuration
+     *
+     * @return array
+     */
+    public static function getConfiguration($configuration = array())
+    {
+        foreach (self::$plugins as $plugin) {
+            foreach (self::$exposedConfigurationItems as $cfgBlock) {
+                $getter = sprintf('get%s', ucfirst($cfgBlock));
+                $cfgData = call_user_func(array($plugin, $getter));
+                if (array_key_exists($cfgBlock, $configuration)) {
+                    if (is_array($configuration[$cfgBlock])) {
+                        // is array, let's merge
+                        $configuration[$cfgBlock] = array_merge(
+                            $configuration[$cfgBlock],
+                            $cfgData
+                        );
+                    } else {
+                        // not an array, it will be overwritten
+                        $configuration[$cfgBlock] = $cfgData;
+                    }
+                } else {
+                    $configuration[$cfgBlock] = $cfgData;
+                }
+            }
+        }
+
+        return $configuration;
+    }
+}

test/Psy/Test/Plugin/ManagerTest.php

@@ -0,0 +1,101 @@
+<?php
+
+namespace Psy\Test\Plugin;
+
+use Psy\Plugin\PluginManager;
+
+class ManagerTest extends \PHPUnit_Framework_TestCase
+{
+    public function setup()
+    {
+        $prop = new \ReflectionProperty('Psy\Plugin\PluginManager', 'plugins');
+        $prop->setAccessible(true);
+        $prop->setValue('Psy\Plugin\Manager', array());
+    }
+
+    public function testRegisterMultiplePlugins()
+    {
+        $mockedPlugin = $this->getMock('Psy\Plugin\AbstractPlugin');
+        PluginManager::register($mockedPlugin, 'mock1');
+        PluginManager::register($mockedPlugin, 'mock2');
+
+        $prop = new \ReflectionProperty('Psy\Plugin\PluginManager', 'plugins');
+        $prop->setAccessible(true);
+        $plugins = $prop->getValue('Psy\Plugin\PluginManager');
+        $this->assertArrayHasKey('mock1', $plugins);
+        $this->assertArrayHasKey('mock2', $plugins);
+    }
+
+    public function testConfigurationWithSinglePlugin()
+    {
+        $commands = array(
+            'cmd1', 'cmd2',
+        );
+
+        $presenters = array(
+            'presenter1', 'presenter2',
+        );
+
+        $matchers = array(
+            'matcher1', 'matcher2',
+        );
+
+        $stub = new PluginStub();
+        $stub->setCommands($commands);
+        $stub->setPresenters($presenters);
+        $stub->setMatchers($matchers);
+
+        PluginManager::register($stub, 'mock');
+
+        $config = PluginManager::getConfiguration();
+        $this->assertArraySubset($commands, $config['commands']);
+        $this->assertArraySubset($presenters, $config['presenters']);
+        $this->assertArraySubset($matchers, $config['matchers']);
+    }
+
+    public function testConfigurationWithMultiplePlugins()
+    {
+        $commands1 = array(
+            'cmd1', 'cmd2',
+        );
+
+        $presenters1 = array(
+            'presenter1', 'presenter2',
+        );
+
+        $matchers1 = array(
+            'matcher1', 'matcher2',
+        );
+
+        $stub1 = new PluginStub();
+        $stub1->setCommands($commands1);
+        $stub1->setPresenters($presenters1);
+        $stub1->setMatchers($matchers1);
+
+        PluginManager::register($stub1, 'mock1');
+
+        $commands2 = array(
+            'cmd3', 'cmd4',
+        );
+
+        $presenters2 = array(
+            'presenter3', 'presenter4',
+        );
+
+        $matchers2 = array(
+            'matcher3', 'matcher4',
+        );
+
+        $stub2 = new PluginStub();
+        $stub2->setCommands($commands2);
+        $stub2->setPresenters($presenters2);
+        $stub2->setMatchers($matchers2);
+
+        PluginManager::register($stub2, 'mock2');
+
+        $config = PluginManager::getConfiguration();
+        $this->assertArraySubset($commands1, $config['commands']);
+        $this->assertArraySubset($presenters1, $config['presenters']);
+        $this->assertArraySubset($matchers1, $config['matchers']);
+    }
+}

test/Psy/Test/Plugin/PluginStub.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace Psy\Test\Plugin;
+
+use Psy\Plugin\AbstractPlugin;
+
+class PluginStub extends AbstractPlugin
+{
+    // due to the static nature, and the negative of Mr bergmann to audit static code
+    // the data here is treated as a FIFO pile.
+    protected static $matchers = array();
+    protected static $presenters = array();
+    protected static $commands = array();
+
+    public function setMatchers(array $matchers)
+    {
+        self::$matchers[] = $matchers;
+    }
+
+    public function setPresenters(array $presenters)
+    {
+        self::$presenters[] = $presenters;
+    }
+
+    public function setCommands(array $commands)
+    {
+        self::$commands[] = $commands;
+    }
+
+    public static function getMatchers()
+    {
+        return array_shift(self::$matchers);
+    }
+
+    public static function getPresenters()
+    {
+        return array_shift(self::$presenters);
+    }
+
+    public static function getCommands()
+    {
+        return array_shift(self::$commands);
+    }
+}