Phile\Plugin\PluginRepository

Complexity

Total Complexity

14

Size/Duplication

Total Lines	135
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	2

Test Coverage

Coverage

93.88%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getLoadErrors()	0	4	1
B	loadAll()	0	18	5
B	load()	0	27	3
A	reset()	0	5	1
A	autoload()	0	20	3

<?php

namespace Phile\Plugin;

use Phile\Exception\PluginException;

/**
 * Class PluginRepository manages plugin loading
 *
 * @author  PhileCMS
 * @link    https://philecms.com
 * @license http://opensource.org/licenses/MIT
 * @package Phile\Core
 */
class PluginRepository
{

    /**
 * @var array of AbstractPlugin
*/
    protected $plugins = [];

    /**
 * @var array errors during load; keys: 'message' and 'code'
*/
    protected $loadErrors = [];

    /**
     * @var directory plug-in root directory
     */
    protected $directory;

    /**
     * Constructor
     *
     * @param string $directory root directory for plug-in folder
     */
    public function __construct($directory)
    {
        $this->directory = $directory;

It seems like $directory of type string is incompatible with the declared type object<Phile\Plugin\directory> of property $directory.

        spl_autoload_register([$this, 'autoload']);
    }

    /**
     * get load errors
     *
     * @return array
     */
    public function getLoadErrors()
    {
        return $this->loadErrors;
    }

    /**
     * loads all activated plugins from $settings
     *
     * @param  array $settings plugin-settings
     * @return array of AbstractPlugin
     * @throws PluginException
     */
    public function loadAll($settings)
    {
        $this->reset();
        foreach ($settings as $pluginKey => $config) {
            if (!isset($config['active']) || !$config['active']) {
                continue;
            }
            try {
                $this->plugins[$pluginKey] = $this->load($pluginKey);
            } catch (PluginException $e) {
                $this->loadErrors[] = [
                'message' => $e->getMessage(),
                'code' => $e->getCode()
                ];
            }
        }
        return $this->plugins;
    }

    /**
     * load and return single plugin
     *
     * @param  $pluginKey
     * @return AbstractPlugin
     * @throws PluginException
     */
    protected function load($pluginKey)
    {
        list($vendor, $pluginName) = explode('\\', $pluginKey);
        // uppercase first letter convention
        $pluginClassName = '\\Phile\\Plugin\\' . ucfirst($vendor) . '\\' . ucfirst($pluginName) . '\\Plugin';

        if (!class_exists($pluginClassName)) {
            throw new PluginException(
                "the plugin '{$pluginKey}' could not be loaded!",
                1398536479
            );
        }

        /**
 * @var \Phile\Plugin\AbstractPlugin $plugin
*/
        $plugin = new $pluginClassName;
        if (($plugin instanceof AbstractPlugin) === false) {
            throw new PluginException(
                "the plugin '{$pluginKey}' is not an instance of \\Phile\\Plugin\\AbstractPlugin",
                1398536526
            );
        }

        $plugin->initializePlugin($pluginKey);

The method Phile\Plugin\AbstractPlugin::initializePlugin() has been deprecated with message: since 1.5.1 will be declared 'final'

        return $plugin;
    }

    /**
     * clear out repository
     */
    protected function reset()
    {
        $this->loadErrors = [];
        $this->plugins = [];
    }

    /**
     * auto-loader plugin namespace
     *
     * @param $className
     */
    public function autoload($className)
    {
        if (strpos($className, "Phile\\Plugin\\") !== 0) {

The string literal Phile\\Plugin\\ does not require double quotes, as per coding-style, please use single quotes.

            return;
        }

        $className = substr($className, 13);
        $classNameParts = explode('\\', $className);
        $pluginVendor = lcfirst(array_shift($classNameParts));
        $pluginName = lcfirst(array_shift($classNameParts));
        $classPath = array_merge(
            [$pluginVendor, $pluginName, 'Classes'],
            $classNameParts
        );

        $fileName = $this->directory . implode(DS, $classPath) . '.php';
        if (file_exists($fileName)) {
            include_once $fileName;
        }
    }
}