application/plugin/PluginManager.php

   1 <?php
   2 namespace Shaarli\Plugin;
   3
   4 use Shaarli\Config\ConfigManager;
   5 use Shaarli\Plugin\Exception\PluginFileNotFoundException;
   6
   7 /**
   8  * Class PluginManager
   9  *
  10  * Use to manage, load and execute plugins.
  11  */
  12 class PluginManager
  13 {
  14     /**
  15      * List of authorized plugins from configuration file.
  16      *
  17      * @var array $authorizedPlugins
  18      */
  19     private $authorizedPlugins = [];
  20
  21     /**
  22      * List of loaded plugins.
  23      *
  24      * @var array $loadedPlugins
  25      */
  26     private $loadedPlugins = array();
  27
  28     /**
  29      * @var ConfigManager Configuration Manager instance.
  30      */
  31     protected $conf;
  32
  33     /**
  34      * @var array List of plugin errors.
  35      */
  36     protected $errors;
  37
  38     /**
  39      * Plugins subdirectory.
  40      *
  41      * @var string $PLUGINS_PATH
  42      */
  43     public static $PLUGINS_PATH = 'plugins';
  44
  45     /**
  46      * Plugins meta files extension.
  47      *
  48      * @var string $META_EXT
  49      */
  50     public static $META_EXT = 'meta';
  51
  52     /**
  53      * Constructor.
  54      *
  55      * @param ConfigManager $conf Configuration Manager instance.
  56      */
  57     public function __construct(&$conf)
  58     {
  59         $this->conf = $conf;
  60         $this->errors = array();
  61     }
  62
  63     /**
  64      * Load plugins listed in $authorizedPlugins.
  65      *
  66      * @param array $authorizedPlugins Names of plugin authorized to be loaded.
  67      *
  68      * @return void
  69      */
  70     public function load($authorizedPlugins)
  71     {
  72         $this->authorizedPlugins = $authorizedPlugins;
  73
  74         $dirs = glob(self::$PLUGINS_PATH . '/*', GLOB_ONLYDIR);
  75         $dirnames = array_map('basename', $dirs);
  76         foreach ($this->authorizedPlugins as $plugin) {
  77             $index = array_search($plugin, $dirnames);
  78
  79             // plugin authorized, but its folder isn't listed
  80             if ($index === false) {
  81                 continue;
  82             }
  83
  84             try {
  85                 $this->loadPlugin($dirs[$index], $plugin);
  86             } catch (PluginFileNotFoundException $e) {
  87                 error_log($e->getMessage());
  88             }
  89         }
  90     }
  91
  92     /**
  93      * Execute all plugins registered hook.
  94      *
  95      * @param string $hook   name of the hook to trigger.
  96      * @param array  $data   list of data to manipulate passed by reference.
  97      * @param array  $params additional parameters such as page target.
  98      *
  99      * @return void
 100      */
 101     public function executeHooks($hook, &$data, $params = array())
 102     {
 103         if (!empty($params['target'])) {
 104             $data['_PAGE_'] = $params['target'];
 105         }
 106
 107         if (isset($params['loggedin'])) {
 108             $data['_LOGGEDIN_'] = $params['loggedin'];
 109         }
 110
 111         if (isset($params['basePath'])) {
 112             $data['_BASE_PATH_'] = $params['basePath'];
 113         }
 114
 115         foreach ($this->loadedPlugins as $plugin) {
 116             $hookFunction = $this->buildHookName($hook, $plugin);
 117
 118             if (function_exists($hookFunction)) {
 119                 $data = call_user_func($hookFunction, $data, $this->conf);
 120             }
 121         }
 122     }
 123
 124     /**
 125      * Load a single plugin from its files.
 126      * Call the init function if it exists, and collect errors.
 127      * Add them in $loadedPlugins if successful.
 128      *
 129      * @param string $dir        plugin's directory.
 130      * @param string $pluginName plugin's name.
 131      *
 132      * @return void
 133      * @throws \Shaarli\Plugin\Exception\PluginFileNotFoundException - plugin files not found.
 134      */
 135     private function loadPlugin($dir, $pluginName)
 136     {
 137         if (!is_dir($dir)) {
 138             throw new PluginFileNotFoundException($pluginName);
 139         }
 140
 141         $pluginFilePath = $dir . '/' . $pluginName . '.php';
 142         if (!is_file($pluginFilePath)) {
 143             throw new PluginFileNotFoundException($pluginName);
 144         }
 145
 146         $conf = $this->conf;
 147         include_once $pluginFilePath;
 148
 149         $initFunction = $pluginName . '_init';
 150         if (function_exists($initFunction)) {
 151             $errors = call_user_func($initFunction, $this->conf);
 152             if (!empty($errors)) {
 153                 $this->errors = array_merge($this->errors, $errors);
 154             }
 155         }
 156
 157         $this->loadedPlugins[] = $pluginName;
 158     }
 159
 160     /**
 161      * Construct normalize hook name for a specific plugin.
 162      *
 163      * Format:
 164      *      hook_<plugin_name>_<hook_name>
 165      *
 166      * @param string $hook       hook name.
 167      * @param string $pluginName plugin name.
 168      *
 169      * @return string - plugin's hook name.
 170      */
 171     public function buildHookName($hook, $pluginName)
 172     {
 173         return 'hook_' . $pluginName . '_' . $hook;
 174     }
 175
 176     /**
 177      * Retrieve plugins metadata from *.meta (INI) files into an array.
 178      * Metadata contains:
 179      *   - plugin description [description]
 180      *   - parameters split with ';' [parameters]
 181      *
 182      * Respects plugins order from settings.
 183      *
 184      * @return array plugins metadata.
 185      */
 186     public function getPluginsMeta()
 187     {
 188         $metaData = array();
 189         $dirs = glob(self::$PLUGINS_PATH . '/*', GLOB_ONLYDIR | GLOB_MARK);
 190
 191         // Browse all plugin directories.
 192         foreach ($dirs as $pluginDir) {
 193             $plugin = basename($pluginDir);
 194             $metaFile = $pluginDir . $plugin . '.' . self::$META_EXT;
 195             if (!is_file($metaFile) || !is_readable($metaFile)) {
 196                 continue;
 197             }
 198
 199             $metaData[$plugin] = parse_ini_file($metaFile);
 200             $metaData[$plugin]['order'] = array_search($plugin, $this->authorizedPlugins);
 201
 202             if (isset($metaData[$plugin]['description'])) {
 203                 $metaData[$plugin]['description'] = t($metaData[$plugin]['description']);
 204             }
 205             // Read parameters and format them into an array.
 206             if (isset($metaData[$plugin]['parameters'])) {
 207                 $params = explode(';', $metaData[$plugin]['parameters']);
 208             } else {
 209                 $params = array();
 210             }
 211             $metaData[$plugin]['parameters'] = array();
 212             foreach ($params as $param) {
 213                 if (empty($param)) {
 214                     continue;
 215                 }
 216
 217                 $metaData[$plugin]['parameters'][$param]['value'] = '';
 218                 // Optional parameter description in parameter.PARAM_NAME=
 219                 if (isset($metaData[$plugin]['parameter.' . $param])) {
 220                     $metaData[$plugin]['parameters'][$param]['desc'] = t($metaData[$plugin]['parameter.' . $param]);
 221                 }
 222             }
 223         }
 224
 225         return $metaData;
 226     }
 227
 228     /**
 229      * Return the list of encountered errors.
 230      *
 231      * @return array List of errors (empty array if none exists).
 232      */
 233     public function getErrors()
 234     {
 235         return $this->errors;
 236     }
 237 }