PluginRegistry.inc.php

<?php
 
define('PLUGINS_PREFIX', 'plugins/');
 
class PluginRegistry {
   //
   // Public methods
   //
   static function &getPlugins($category = null) {
      $plugins =& Registry::get('plugins', true, []); // Reference necessary
      if ($category !== null) {
         if (!isset($plugins[$category])) $plugins[$category] = [];
         return $plugins[$category];
      }
      return $plugins;
   }
 
   static function getAllPlugins() {
      $plugins =& self::getPlugins();
      $allPlugins = [];
      if (!empty($plugins)) foreach ($plugins as $list) {
         if (is_array($list)) $allPlugins += $list;
      }
      return $allPlugins;
   }
 
   static function register($category, $plugin, $path, $mainContextId = null) {
      $pluginName = $plugin->getName();
      $plugins =& self::getPlugins();
 
      // Allow the plugin to register.
      if (!$plugin->register($category, $path, $mainContextId)) return false;
 
      // If the plugin was already loaded, do not load it again.
      if (isset($plugins[$category][$pluginName])) return false;
 
      if (isset($plugins[$category])) $plugins[$category][$pluginName] = $plugin;
      else $plugins[$category] = [$pluginName => $plugin];
      return true;
   }
 
   static function getPlugin($category, $name) {
      $plugins =& self::getPlugins();
      return $plugins[$category][$name]??null;
   }
 
   static function loadCategory ($category, $enabledOnly = false, $mainContextId = null) {
      $plugins = [];
      $categoryDir = PLUGINS_PREFIX . $category;
      if (!is_dir($categoryDir)) return $plugins;
 
      if ($enabledOnly && Config::getVar('general', 'installed')) {
         // Get enabled plug-ins from the database.
         $application = Application::get();
         $products = $application->getEnabledProducts('plugins.'.$category, $mainContextId);
         foreach ($products as $product) {
            $file = $product->getProduct();
            $plugin = self::_instantiatePlugin($category, $categoryDir, $file, $product->getProductClassname());
            if ($plugin instanceof Plugin) {
               $plugins[$plugin->getSeq()]["$categoryDir/$file"] = $plugin;
            }
         }
      } else {
         // Get all plug-ins from disk. This does not require
         // any database access and can therefore be used during
         // first-time installation.
         $handle = opendir($categoryDir);
         while (($file = readdir($handle)) !== false) {
            if ($file == '.' || $file == '..') continue;
            $plugin = self::_instantiatePlugin($category, $categoryDir, $file);
            if ($plugin && is_object($plugin)) {
               $plugins[$plugin->getSeq()]["$categoryDir/$file"] = $plugin;
            }
         }
         closedir($handle);
      }
 
      // Fire a hook prior to registering plugins for a category
      // n.b.: this should not be used from a PKPPlugin::register() call to "jump categories"
      HookRegistry::call('PluginRegistry::loadCategory', [&$category, &$plugins]);
 
      // Register the plugins in sequence.
      ksort($plugins);
      foreach ($plugins as $seq => $junk1) {
         foreach ($plugins[$seq] as $pluginPath => $junk2) {
            self::register($category, $plugins[$seq][$pluginPath], $pluginPath, $mainContextId);
         }
      }
      unset($plugins);
 
      // Return the list of successfully-registered plugins.
      $plugins =& self::getPlugins($category);
 
      // Fire a hook after all plugins of a category have been loaded, so they
      // are able to interact if required
      HookRegistry::call('PluginRegistry::categoryLoaded::' . $category, [&$plugins]);
 
      // Sort the plugins by priority before returning.
      uasort($plugins, function($a, $b) {
         return $a->getSeq() - $b->getSeq();
      });
 
      return $plugins;
   }
 
   static function loadPlugin($category, $pathName, $mainContextId = null) {
      $pluginPath = PLUGINS_PREFIX . $category . '/' . $pathName;
      if (!is_dir($pluginPath) || !file_exists($pluginPath . '/index.php')) return null;
 
      $plugin = @include("$pluginPath/index.php");
      if (!is_object($plugin)) return null;
 
      self::register($category, $plugin, $pluginPath, $mainContextId);
      return $plugin;
   }
 
   static function getCategories() {
      $application = Application::get();
      $categories = $application->getPluginCategories();
      HookRegistry::call('PluginRegistry::getCategories', [&$categories]);
      return $categories;
   }
 
   static function loadAllPlugins($enabledOnly = false) {
      // Retrieve and register categories (order is significant).
      foreach (self::getCategories() as $category) {
         self::loadCategory($category, $enabledOnly);
      }
      return self::getAllPlugins();
   }
 
 
   //
   // Private helper methods
   //
   static function _instantiatePlugin($category, $categoryDir, $file, $classToCheck = null) {
      if(!is_null($classToCheck) && !preg_match('/[a-zA-Z0-9]+/', $file)) throw new Exception('Invalid product name "'.$file.'"!');
 
      $pluginPath = "$categoryDir/$file";
      if (!is_dir($pluginPath)) return null;
 
      // Try the plug-in wrapper first for backwards
      // compatibility.
      $pluginWrapper = "$pluginPath/index.php";
      if (file_exists($pluginWrapper)) {
         $plugin = include($pluginWrapper);
         assert(is_a($plugin, $classToCheck ?: 'Plugin'));
         return $plugin;
      } else {
         // Try the well-known plug-in class name next.
         $pluginClassName = ucfirst($file).ucfirst($category).'Plugin';
         $pluginClassFile = $pluginClassName.'.inc.php';
         if (file_exists("$pluginPath/$pluginClassFile")) {
            // Try to instantiate the plug-in class.
            $pluginPackage = 'plugins.'.$category.'.'.$file;
            $plugin = instantiate($pluginPackage.'.'.$pluginClassName, $pluginClassName, $pluginPackage, 'register');
            assert(is_a($plugin, $classToCheck ?: 'Plugin'));
            return $plugin;
         }
      }
      return null;
   }
}