Your IP : 216.73.216.79
<?php namespace System\Classes;
use Db;
use App;
use Str;
use Log;
use File;
use Lang;
use View;
use Cache;
use Config;
use Schema;
use SystemException;
use FilesystemIterator;
use RecursiveIteratorIterator;
use RecursiveDirectoryIterator;
use System\Models\PluginVersion;
use Winter\Storm\Foundation\Application;
use Winter\Storm\Support\ClassLoader;
use Backend\Classes\NavigationManager;
/**
* Plugin manager
*
* @package winter\wn-system-module
* @author Alexey Bobkov, Samuel Georges
*/
class PluginManager
{
use \Winter\Storm\Support\Traits\Singleton;
//
// Disabled by system
//
public const DISABLED_MISSING = 'disabled-missing';
public const DISABLED_REPLACED = 'disabled-replaced';
public const DISABLED_REPLACEMENT_FAILED = 'disabled-replacement-failed';
public const DISABLED_MISSING_DEPENDENCIES = 'disabled-dependencies';
//
// Explicitly disabled for a reason
//
public const DISABLED_REQUEST = 'disabled-request';
public const DISABLED_BY_USER = 'disabled-user';
public const DISABLED_BY_CONFIG = 'disabled-config';
/**
* The application instance, since Plugins are an extension of a Service Provider
*/
protected Application $app;
/**
* @var PluginBase[] Container array used for storing plugin information objects.
*/
protected $plugins = [];
/**
* @var array Array of plugin codes that contain any flags currently associated with the plugin
*/
protected $pluginFlags = [];
/**
* @var PluginVersion[] Local cache of loaded PluginVersion records keyed by plugin code
*/
protected $pluginRecords = [];
/**
* @var array A map of normalized plugin identifiers [lowercase.identifier => Normalized.Identifier]
*/
protected $normalizedMap = [];
/**
* @var array A map of plugin identifiers with their replacements [Original.Plugin => Replacement.Plugin]
*/
protected $replacementMap = [];
/**
* @var array A map of plugins that are currently replaced [Original.Plugin => Replacement.Plugin]
*/
protected $activeReplacementMap = [];
/**
* @var bool Flag to indicate that all plugins have had the register() method called by registerAll() being called on this class.
*/
protected $registered = false;
/**
* @var bool Flag to indicate that all plugins have had the boot() method called by bootAll() being called on this class.
*/
protected $booted = false;
/**
* @var array Cache of registration method results.
*/
protected $registrationMethodCache = [];
/**
* @var bool Prevent all plugins from registering or booting
*/
public static $noInit = false;
/**
* Initializes the plugin manager
*/
protected function init(): void
{
$this->app = App::make('app');
// Load the plugins from the filesystem and sort them by dependencies
$this->loadPlugins();
// Loads the plugin flags (disabled & replacement states) from the cache
// regenerating them if required.
$this->loadPluginFlags();
// Register plugin replacements
$this->registerPluginReplacements();
}
/**
* Finds all available plugins and loads them in to the $this->plugins array.
*/
public function loadPlugins(): array
{
$this->plugins = [];
/**
* Locate all plugins and binds them to the container
*/
foreach ($this->getPluginNamespaces() as $namespace => $path) {
$this->loadPlugin($namespace, $path);
}
// Sort all the plugins by number of dependencies
$this->sortByDependencies();
return $this->getAllPlugins();
}
/**
* Loads a single plugin into the manager.
*
* @param string $namespace Eg: Acme\Blog
* @param string $path Eg: plugins_path().'/acme/blog';
*/
public function loadPlugin(string $namespace, string $path): ?PluginBase
{
$className = $namespace . '\Plugin';
$classPath = $path . '/Plugin.php';
try {
// Autoloader failed?
if (!class_exists($className)) {
include_once $classPath;
}
// Not a valid plugin!
if (!class_exists($className)) {
return null;
}
$pluginObj = new $className($this->app);
} catch (\Throwable $e) {
Log::error('Plugin ' . $className . ' could not be instantiated.', [
'message' => $e->getMessage(),
'file' => $e->getFile(),
'line' => $e->getLine(),
'trace' => $e->getTraceAsString()
]);
return null;
}
$classId = $this->getIdentifier($pluginObj);
$lowerClassId = strtolower($classId);
$this->plugins[$lowerClassId] = $pluginObj;
$this->normalizedMap[$lowerClassId] = $classId;
$replaces = $pluginObj->getReplaces();
if ($replaces) {
foreach ($replaces as $replace) {
$lowerReplace = strtolower($replace);
$this->replacementMap[$lowerReplace] = $lowerClassId;
if (!isset($this->normalizedMap[$lowerReplace])) {
$this->normalizedMap[$lowerReplace] = $replace;
}
}
}
return $pluginObj;
}
/**
* Get the cache key for the current plugin manager state
*/
protected function getFlagCacheKey(): string
{
$loadedPlugins = array_keys($this->plugins);
$configDisabledPlugins = Config::get('cms.disablePlugins', []);
if (!is_array($configDisabledPlugins)) {
$configDisabledPlugins = [];
}
$plugins = $loadedPlugins + $configDisabledPlugins;
return 'system.pluginmanager.state.' . md5(implode('.', $plugins));
}
/**
* Loads the plugin flags (disabled & replacement states) from the cache
* regenerating them if required.
*/
public function loadPluginFlags(): void
{
// Cache the data for a month so that stale keys can be autocleaned if necessary
$data = Cache::remember($this->getFlagCacheKey(), now()->addMonths(1), function () {
// Check the config files & database for plugins to disable
$this->loadDisabled();
// Check plugin dependencies for plugins to disable
$this->loadDependencies();
// Check plugin replacments for plugins to disable
$this->detectPluginReplacements();
return [
$this->pluginFlags,
$this->replacementMap,
$this->activeReplacementMap,
];
});
list($this->pluginFlags, $this->replacementMap, $this->activeReplacementMap) = $data;
}
/**
* Reset the plugin flag cache
*/
public function clearFlagCache(): void
{
Cache::forget($this->getFlagCacheKey());
}
/**
* Runs the register() method on all plugins. Can only be called once.
*
* @param bool $force Defaults to false, if true will force the re-registration of all plugins. Use unregisterAll() instead.
*/
public function registerAll(bool $force = false): void
{
if ($this->registered && !$force) {
return;
}
foreach ($this->plugins as $pluginId => $plugin) {
$this->registerPlugin($plugin, $pluginId);
}
// Ensure that route attributes are properly loaded
// @see Illuminate\Foundation\Support\Providers\RouteServiceProvider->register()
// @fixes wintercms/winter#106
$this->app->booting(function () {
$this->app['router']->getRoutes()->refreshNameLookups();
$this->app['router']->getRoutes()->refreshActionLookups();
});
$this->registered = true;
}
/**
* Unregisters all plugins: the inverse of registerAll().
*/
public function unregisterAll(): void
{
$this->registered = false;
$this->plugins = [];
$this->replacementMap = [];
}
/**
* Registers a single plugin object.
*/
public function registerPlugin(PluginBase $plugin, ?string $pluginId = null): void
{
if (!$pluginId) {
$pluginId = $this->getIdentifier($plugin);
}
$pluginPath = $this->getPluginPath($plugin);
$pluginNamespace = strtolower($pluginId);
/*
* Register language namespaces
*/
$langPath = $pluginPath . '/lang';
if (File::isDirectory($langPath)) {
Lang::addNamespace($pluginNamespace, $langPath);
}
/**
* Prevent autoloaders from loading if plugin is disabled
*/
if ($this->isDisabled($pluginId)) {
return;
}
/*
* Register plugin class autoloaders
*/
$autoloadPath = $pluginPath . '/vendor/autoload.php';
if (File::isFile($autoloadPath)) {
ComposerManager::instance()->autoload($pluginPath . '/vendor');
}
/*
* Register configuration path
*/
$configPath = $pluginPath . '/config';
if (File::isDirectory($configPath)) {
Config::package($pluginNamespace, $configPath, $pluginNamespace);
}
/*
* Register views path
*/
$viewsPath = $pluginPath . '/views';
if (File::isDirectory($viewsPath)) {
View::addNamespace($pluginNamespace, $viewsPath);
}
/**
* Disable plugin registration for restricted pages, unless elevated
*/
if (self::$noInit && !$plugin->elevated) {
return;
}
/**
* Run the plugin's register() method
*/
$plugin->register();
/*
* Add init, if available
*/
$initFile = $pluginPath . '/init.php';
if (File::exists($initFile)) {
require $initFile;
}
/*
* Add routes, if available
*/
$routesFile = $pluginPath . '/routes.php';
if (File::exists($routesFile) && !$this->app->routesAreCached()) {
require $routesFile;
}
}
/**
* Runs the boot() method on all plugins. Can only be called once.
*
* @param bool $force Defaults to false, if true will force the re-booting of all plugins
*/
public function bootAll(bool $force = false): void
{
if ($this->booted && !$force) {
return;
}
foreach ($this->plugins as $plugin) {
$this->bootPlugin($plugin);
}
$this->booted = true;
}
/**
* Boots the provided plugin object.
*/
public function bootPlugin(PluginBase $plugin): void
{
if ((self::$noInit && !$plugin->elevated) || $this->isDisabled($plugin)) {
return;
}
$plugin->boot();
}
/**
* Returns the directory path to a plugin
*/
public function getPluginPath(PluginBase|string $plugin): ?string
{
return $this->findByIdentifier($plugin, true)?->getPluginPath();
}
/**
* Check if a plugin exists and is enabled.
*
* @param string $id Plugin identifier, eg: Namespace.PluginName
* @return bool
*/
public function exists(PluginBase|string $plugin): bool
{
return $this->findByIdentifier($plugin) && !$this->isDisabled($plugin);
}
/**
* Returns an array with all enabled plugins
*
* @return array [$code => $pluginObj]
*/
public function getPlugins(): array
{
$activePlugins = array_diff_key($this->plugins, $this->pluginFlags);
return array_combine(
array_map(
fn($code) => $this->normalizedMap[$code],
array_keys($activePlugins)
),
$activePlugins
);
}
/**
* Returns an array will all plugins detected on the filesystem
*
* @return array [$code => $pluginObj]
*/
public function getAllPlugins(): array
{
$plugins = [];
foreach ($this->plugins as $code => $plugin) {
$plugins[$this->normalizedMap[$code]] = $plugin;
}
return $plugins;
}
/**
* Returns a plugin registration class based on its namespace (Author\Plugin).
*/
public function findByNamespace(string $namespace): ?PluginBase
{
$identifier = $this->getIdentifier($namespace, true);
return $this->plugins[$identifier] ?? null;
}
/**
* Returns a plugin registration class based on its identifier (Author.Plugin).
*/
public function findByIdentifier(PluginBase|string $identifier, bool $ignoreReplacements = false): ?PluginBase
{
if ($identifier instanceof PluginBase) {
return $identifier;
}
$identifier = $this->getNormalizedIdentifier($identifier, true);
if (!$ignoreReplacements && isset($this->replacementMap[$identifier])) {
$identifier = $this->replacementMap[$identifier];
}
return $this->plugins[$identifier] ?? null;
}
/**
* Checks to see if a plugin has been registered.
*/
public function hasPlugin(PluginBase|string $plugin): bool
{
$normalized = $this->getNormalizedIdentifier($plugin, true);
return isset($this->plugins[$normalized]) || isset($this->replacementMap[$normalized]);
}
/**
* Returns a flat array of vendor plugin namespaces and their paths
* ['Author\Plugin' => 'plugins/author/plugin']
*/
public function getPluginNamespaces(): array
{
$classNames = [];
foreach ($this->getVendorAndPluginNames() as $vendorName => $vendorList) {
foreach ($vendorList as $pluginName => $pluginPath) {
$namespace = '\\' . $vendorName . '\\' . $pluginName;
$namespace = Str::normalizeClassName($namespace);
$classNames[$namespace] = $pluginPath;
}
}
return $classNames;
}
/**
* Returns a 2 dimensional array of vendors and their plugins.
* ['vendor' => ['author' => 'plugins/author/plugin']]
*/
public function getVendorAndPluginNames(): array
{
$plugins = [];
$dirPath = $this->app->pluginsPath();
if (!File::isDirectory($dirPath)) {
return $plugins;
}
$it = new RecursiveIteratorIterator(
new RecursiveDirectoryIterator($dirPath, FilesystemIterator::FOLLOW_SYMLINKS)
);
$it->setMaxDepth(2);
$it->rewind();
while ($it->valid()) {
if (($it->getDepth() > 1) && $it->isFile() && (strtolower($it->getFilename()) === "plugin.php")) {
$filePath = dirname($it->getPathname());
$pluginName = basename($filePath);
$vendorName = basename(dirname($filePath));
$plugins[$vendorName][$pluginName] = $filePath;
}
$it->next();
}
return $plugins;
}
/**
* Resolves a plugin identifier (Author.Plugin) from a plugin class name
* (Author\Plugin) or PluginBase instance.
*/
public function getIdentifier(PluginBase|string $plugin, bool $lower = false): string
{
$namespace = Str::normalizeClassName($plugin);
if (strpos($namespace, '\\') === null) {
return $namespace;
}
$parts = explode('\\', $namespace);
$slice = array_slice($parts, 1, 2);
$namespace = implode('.', $slice);
return $lower ? strtolower($namespace) : $namespace;
}
/**
* Resolves a plugin namespace (Author\Plugin) from a plugin class name
* (Author\Plugin\Classes\Example), identifier (Author.Plugin), or
* PluginBase instance.
*/
public function getNamespace(PluginBase|string $plugin): string
{
if (is_string($plugin) && strpos($plugin, '.') !== null) {
$parts = explode('.', $plugin);
$slice = array_slice($parts, 0, 2);
$namespace = implode('\\', $slice);
return Str::normalizeClassName($namespace);
}
return Str::normalizeClassName($plugin);
}
/**
* Normalizes the provided plugin identifier (author.plugin) and resolves
* it case-insensitively to the normalized identifier (Author.Plugin)
* Returns the provided identifier if a match isn't found
*/
public function normalizeIdentifier(string $code): string
{
return $this->getNormalizedIdentifier($code);
}
/**
* Returns the normalized identifier (i.e. Winter.Blog) from the provided
* string or PluginBase instance.
*/
public function getNormalizedIdentifier(PluginBase|string $plugin, bool $lower = false): string
{
$code = $this->getIdentifier($plugin);
$identifier = $this->normalizedMap[strtolower($code)] ?? $code;
return $lower ? strtolower($identifier) : $identifier;
}
/**
* Spins over every plugin object and collects the results of the provided
* method call. Results are cached in memory.
*/
public function getRegistrationMethodValues(string $methodName): array
{
if (isset($this->registrationMethodCache[$methodName])) {
return $this->registrationMethodCache[$methodName];
}
$results = [];
$plugins = $this->getPlugins();
foreach ($plugins as $id => $plugin) {
if (!is_callable([$plugin, $methodName])) {
continue;
}
$results[$id] = $plugin->{$methodName}();
}
return $this->registrationMethodCache[$methodName] = $results;
}
//
// State Management (Disable, Enable, Freeze, Unfreeze)
//
public function getPluginFlags(PluginBase|string $plugin): array
{
$code = $this->getNormalizedIdentifier($plugin, true);
return $this->pluginFlags[$code] ?? [];
}
/**
* Sets the provided flag on the provided plugin
*/
protected function flagPlugin(PluginBase|string $plugin, string $flag): void
{
$code = $this->getNormalizedIdentifier($plugin, true);
$this->pluginFlags[$code][$flag] = true;
}
/**
* Removes the provided flag from the provided plugin
*/
protected function unflagPlugin(PluginBase|string $plugin, string $flag): void
{
// Remove the provided flag from the provided plugin
$code = $this->getNormalizedIdentifier($plugin, true);
unset($this->pluginFlags[$code][$flag]);
// Remove the plugin from the pluginFlags property if it has no flags
if (empty($this->pluginFlags[$code])) {
unset($this->pluginFlags[$code]);
}
}
/**
* Loads all disabled plugins from the cached JSON file.
*/
protected function loadDisabled(): void
{
// Check the config files for disabled plugins
if (($configDisabled = Config::get('cms.disablePlugins')) && is_array($configDisabled)) {
foreach ($configDisabled as $disabled) {
$this->flagPlugin($disabled, static::DISABLED_BY_CONFIG);
}
}
// Check the database for disabled plugins
if (
$this->app->hasDatabase()
&& Schema::hasTable('system_plugin_versions')
) {
$userDisabled = Db::table('system_plugin_versions')->where('is_disabled', 1)->lists('code') ?? [];
foreach ($userDisabled as $code) {
$this->flagPlugin($code, static::DISABLED_BY_USER);
}
}
}
/**
* Determines if a plugin is disabled by looking at the meta information
* or the application configuration.
*/
public function isDisabled(PluginBase|string $plugin): bool
{
$code = $this->getNormalizedIdentifier($plugin, true);
// @TODO: Limit this to only disabled flags if we add more than disabled flags
return !empty($this->pluginFlags[$code]);
}
/**
* Returns the plugin replacements defined in $this->replacementMap
*/
public function getReplacementMap(): array
{
return $this->replacementMap;
}
/**
* Returns the actively replaced plugins defined in $this->activeReplacementMap
*/
public function getActiveReplacementMap(PluginBase|string $plugin = null): array|string|null
{
if ($plugin) {
return $this->normalizedMap[
$this->activeReplacementMap[$this->getNormalizedIdentifier($plugin, true)] ?? null
] ?? null;
}
$map = [];
foreach ($this->activeReplacementMap as $key => $value) {
$map[$this->normalizedMap[$key]] = $this->normalizedMap[$value];
}
return $map;
}
/**
* Evaluates the replacement map to determine which replacements can actually
* take effect
*/
protected function detectPluginReplacements(): void
{
if (empty($this->replacementMap)) {
return;
}
foreach ($this->replacementMap as $target => $replacement) {
// If the replaced plugin isn't present then assume it can be replaced
if (!isset($this->plugins[$target])) {
continue;
}
// Only allow one of the replaced plugin or the replacing plugin to exist
// at once depending on whether the version constraints are met or not
if (
$this->plugins[$replacement]->canReplacePlugin(
$this->normalizeIdentifier($target),
$this->plugins[$target]->getPluginVersion()
)
) {
// Set the plugin flags to disable the target plugin
$this->flagPlugin($target, static::DISABLED_REPLACED);
$this->unflagPlugin($replacement, static::DISABLED_REPLACEMENT_FAILED);
// Register this plugin as actively replaced (i.e. both are present, replaced are disabled)
$this->activeReplacementMap[$target] = $replacement;
} else {
// Set the plugin flags to disable the replacement plugin
$this->flagPlugin($replacement, static::DISABLED_REPLACEMENT_FAILED);
$this->unflagPlugin($target, static::DISABLED_REPLACED);
// Remove the replacement alias to prevent redirection to a disabled plugin
unset($this->replacementMap[$target]);
}
}
}
/**
* Executes the plugin replacements defined in the activeReplacementMap property
*/
protected function registerPluginReplacements(): void
{
foreach ($this->replacementMap as $target => $replacement) {
list($target, $replacement) = array_map(
fn($plugin) => $this->normalizeIdentifier($plugin),
[$target, $replacement]
);
// Alias the replaced plugin to the replacing plugin
$this->aliasPluginAs($replacement, $target);
// Register namespace aliases for any replaced plugins
$this->app->make(ClassLoader::class)->addNamespaceAliases([
// class_alias() expects order to be $real, $alias
$this->getNamespace($replacement) => $this->getNamespace($target),
]);
}
}
/**
* Registers namespace aliasing for multiple subsystems
*/
protected function aliasPluginAs(string $namespace, string $alias): void
{
Lang::registerNamespaceAlias($namespace, $alias);
Config::registerNamespaceAlias($namespace, $alias);
Config::registerPackageFallback($namespace, $alias);
SettingsManager::lazyRegisterOwnerAlias($namespace, $alias);
NavigationManager::lazyRegisterOwnerAlias($namespace, $alias);
}
/**
* Get the PluginVersion record for the provided plugin
*
* @throws InvalidArgumentException if unable to find the requested plugin record in the database
*/
protected function getPluginRecord(PluginBase|string $plugin): PluginVersion
{
$plugin = $this->getNormalizedIdentifier($plugin);
if (isset($this->pluginRecords[$plugin])) {
return $this->pluginRecords[$plugin];
}
$record = PluginVersion::where('code', $plugin)->first();
if (!$record) {
throw new \InvalidArgumentException("$plugin was not found in the database.");
}
return $this->pluginRecords[$plugin] = $record;
}
/**
* Flags the provided plugin as "frozen" (updates cannot be downloaded / installed)
*/
public function freezePlugin(PluginBase|string $plugin): void
{
$record = $this->getPluginRecord($plugin);
$record->is_frozen = true;
$record->save();
}
/**
* "Unfreezes" the provided plugin, allowing for updates to be performed
*/
public function unfreezePlugin(PluginBase|string $plugin): void
{
$record = $this->getPluginRecord($plugin);
$record->is_frozen = false;
$record->save();
}
/**
* Disables the provided plugin using the provided flag (defaults to static::DISABLED_BY_USER)
*/
public function disablePlugin(PluginBase|string $plugin, string|bool $flag = self::DISABLED_BY_USER): bool
{
// $flag used to be (bool) $byUser
if ($flag === true) {
$flag = static::DISABLED_BY_USER;
}
// Flag the plugin as disabled
$this->flagPlugin($plugin, $flag);
// Updates the database record for the plugin if required
if ($flag === static::DISABLED_BY_USER) {
$record = $this->getPluginRecord($plugin);
$record->is_disabled = true;
$record->save();
// Clear the cache so that the next request will regenerate the active flags
$this->clearFlagCache();
}
// Clear the registration values cache
$this->registrationMethodCache = [];
return true;
}
/**
* Enables the provided plugin using the provided flag (defaults to static::DISABLED_BY_USER)
*/
public function enablePlugin(PluginBase|string $plugin, $flag = self::DISABLED_BY_USER): bool
{
// $flag used to be (bool) $byUser
if ($flag === true) {
$flag = static::DISABLED_BY_USER;
}
// Unflag the plugin as disabled
$this->unflagPlugin($plugin, $flag);
// Updates the database record for the plugin if required
if ($flag === static::DISABLED_BY_USER) {
$record = $this->getPluginRecord($plugin);
$record->is_disabled = false;
$record->save();
// Clear the cache so that the next request will regenerate the active flags
$this->clearFlagCache();
}
// Clear the registration values cache
$this->registrationMethodCache = [];
return true;
}
//
// Dependencies
//
/**
* Returns the plugin identifiers that are required by the supplied plugin.
*/
public function getDependencies(PluginBase|string $plugin): array
{
if (is_string($plugin) && (!$plugin = $this->findByIdentifier($plugin))) {
return [];
}
if (!isset($plugin->require) || !$plugin->require) {
return [];
}
return array_map(function ($require) {
return $this->replacementMap[$require] ?? $require;
}, is_array($plugin->require) ? $plugin->require : [$plugin->require]);
}
/**
* Scans the system plugins to locate any dependencies that are not currently
* installed. Returns an array of missing plugin codes keyed by the plugin that requires them.
*
* ['Author.Plugin' => ['Required.Plugin1', 'Required.Plugin2']
*
* PluginManager::instance()->findMissingDependencies();
*
*/
public function findMissingDependencies(): array
{
$missing = [];
foreach ($this->plugins as $id => $plugin) {
if (!$required = $this->getDependencies($plugin)) {
continue;
}
foreach ($required as $require) {
if ($this->hasPlugin($require)) {
continue;
}
if (!in_array($require, $missing)) {
$missing[$this->getIdentifier($plugin)][] = $require;
}
}
}
return $missing;
}
/**
* Checks plugin dependencies and flags plugins with missing dependencies as disabled
*/
protected function loadDependencies(): void
{
foreach ($this->plugins as $id => $plugin) {
if (!$plugin->checkDependencies($this)) {
$this->flagPlugin($id, static::DISABLED_MISSING_DEPENDENCIES);
} else {
$this->unflagPlugin($id, static::DISABLED_MISSING_DEPENDENCIES);
}
}
}
/**
* Sorts a collection of plugins, in the order that they should be actioned,
* according to their given dependencies. Least dependent come first.
*
* @return array Array of sorted plugin identifiers and instantiated classes ['Author.Plugin' => PluginBase]
* @throws SystemException If a possible circular dependency is detected
*/
protected function sortByDependencies(): array
{
ksort($this->plugins);
/*
* Canvas the dependency tree
*/
$checklist = $this->plugins;
$result = [];
$loopCount = 0;
while (count($checklist)) {
if (++$loopCount > 2048) {
throw new SystemException('Too much recursion! Check for circular dependencies in your plugins.');
}
foreach ($checklist as $code => $plugin) {
/*
* Get dependencies and remove any aliens, replacing any dependencies which have been superceded
* by another plugin.
*/
$depends = $this->getDependencies($plugin);
$depends = array_map(function ($depend) {
$depend = $this->getNormalizedIdentifier($depend, true);
if (isset($this->replacementMap[$depend])) {
return $this->replacementMap[$depend];
}
return $depend;
}, $depends);
$depends = array_filter($depends, function ($pluginCode) {
return isset($this->plugins[$pluginCode]);
});
/*
* No dependencies
*/
if (!$depends) {
array_push($result, $code);
unset($checklist[$code]);
continue;
}
/*
* Find dependencies that have not been checked
*/
$depends = array_diff($depends, $result);
if (count($depends) > 0) {
continue;
}
/*
* All dependencies are checked
*/
array_push($result, $code);
unset($checklist[$code]);
}
}
/*
* Reassemble plugin map
*/
$sortedPlugins = [];
foreach ($result as $code) {
$sortedPlugins[$code] = $this->plugins[$code];
}
return $this->plugins = $sortedPlugins;
}
//
// Management
//
/**
* Completely roll back and delete a plugin from the system.
*/
public function deletePlugin(string $id): void
{
/*
* Rollback plugin
*/
UpdateManager::instance()->rollbackPlugin($id);
/*
* Delete from file system
*/
if ($pluginPath = self::instance()->getPluginPath($id)) {
File::deleteDirectory($pluginPath);
// Clear the registration values cache
$this->registrationMethodCache = [];
// Clear the plugin flag cache
$this->clearFlagCache();
}
}
/**
* Tears down a plugin's database tables and rebuilds them.
*/
public function refreshPlugin(string $id): void
{
$manager = UpdateManager::instance();
$manager->rollbackPlugin($id);
$manager->updatePlugin($id);
}
}