Jaxon\Plugin\Manager\PluginManager

Complexity

Total Complexity

17

Size/Duplication

Total Lines	189
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	getResponsePlugin()	0	12	3
A	registerCallable()	0	10	3
B	registerPlugin()	0	36	7
A	getRequestHandlers()	0	3	1
A	__construct()	0	5	1
A	getParameterReader()	0	3	1
A	registerPlugins()	0	11	1

<?php

/**
 * PluginManager.php - Jaxon plugin registry
 *
 * Register Jaxon plugins and callables.
 *
 * @package jaxon-core

Package name "jaxon-core" is not valid; consider "Jaxoncore" instead

 * @author Jared White

Content of the @author tag must be in the form "Display Name <username@example.com>"

 * @author J. Max Wilson

Content of the @author tag must be in the form "Display Name <username@example.com>"

 * @author Joseph Woolley

Content of the @author tag must be in the form "Display Name <username@example.com>"

 * @author Steffen Konerow

Content of the @author tag must be in the form "Display Name <username@example.com>"

 * @author Thierry Feuzeu <thierry.feuzeu@gmail.com>
 * @copyright Copyright (c) 2005-2007 by Jared White & J. Max Wilson

@copyright tag must contain a year and the name of the copyright holder

 * @copyright Copyright (c) 2008-2010 by Joseph Woolley, Steffen Konerow, Jared White  & J. Max Wilson

@copyright tag must contain a year and the name of the copyright holder

 * @copyright 2016 Thierry Feuzeu <thierry.feuzeu@gmail.com>
 * @license https://opensource.org/licenses/BSD-3-Clause BSD 3-Clause License
 * @link https://github.com/jaxon-php/jaxon-core
 */

PHP version not specified

Missing @category tag in file comment

namespace Jaxon\Plugin\Manager;

use Jaxon\Jaxon;
use Jaxon\App\I18n\Translator;
use Jaxon\Di\Container;
use Jaxon\Exception\SetupException;
use Jaxon\Plugin\CallableRegistryInterface;
use Jaxon\Plugin\Code\CodeGenerator;
use Jaxon\Plugin\CodeGeneratorInterface;
use Jaxon\Plugin\Request\CallableClass\CallableClassPlugin;
use Jaxon\Plugin\Request\CallableDir\CallableDirPlugin;
use Jaxon\Plugin\Request\CallableFunction\CallableFunctionPlugin;
use Jaxon\Plugin\RequestHandlerInterface;
use Jaxon\Plugin\RequestPlugin;
use Jaxon\Plugin\Response\DataBag\DataBagPlugin;
use Jaxon\Plugin\Response\Dialog\DialogPlugin;
use Jaxon\Plugin\Response\JQuery\JQueryPlugin;
use Jaxon\Plugin\ResponsePlugin;
use Jaxon\Plugin\ResponsePluginInterface;
use Jaxon\Request\Handler\ParameterReader;
use Jaxon\Response\Response;

use function class_implements;
use function in_array;

class PluginManager

Missing doc comment for class PluginManager

{
    /**
     * @var Container
     */
    protected $di;

Expected 1 blank line(s) before first member var; 0 found

    /**
     * @var CodeGenerator
     */
    private $xCodeGenerator;

    /**
     * @var Translator
     */
    protected $xTranslator;

    /**
     * Request plugins, indexed by name
     *
     * @var array<CallableRegistryInterface>
     */
    private $aRegistryPlugins = [];

    /**
     * Request handlers, indexed by name
     *
     * @var array<RequestHandlerInterface>
     */
    private $aRequestHandlers = [];

    /**
     * Response plugins, indexed by name
     *
     * @var array<ResponsePluginInterface>
     */
    private $aResponsePlugins = [];

    /**
     * The constructor
     *
     * @param Container $di

Expected 5 spaces after parameter type; 1 found

Missing parameter comment

     * @param CodeGenerator $xCodeGenerator

Missing parameter comment

     * @param Translator $xTranslator

Missing parameter comment

Expected 4 spaces after parameter type; 1 found

     */
    public function __construct(Container $di, CodeGenerator $xCodeGenerator, Translator $xTranslator)

Expected 2 blank lines before function; 1 found

    {
        $this->di = $di;

Equals sign not aligned with surrounding assignments; expected 13 spaces but found 1 space

        $this->xCodeGenerator = $xCodeGenerator;
        $this->xTranslator = $xTranslator;

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the request plugins
     *
     * @return array<RequestPlugin>
     */
    public function getRequestHandlers(): array
    {
        return $this->aRequestHandlers;
    }

Expected 2 blank lines after function; 1 found

    /**
     * Register a plugin
     *
     * Below is a table for priorities and their description:
     * - 0 to 999: Plugins that are part of or extensions to the jaxon core
     * - 1000 to 8999: User created plugins, typically, these plugins don't care about order
     * - 9000 to 9999: Plugins that generally need to be last or near the end of the plugin list
     *
     * @param string $sClassName    The plugin class

Expected 2 spaces after parameter name; 4 found

Expected 2 spaces after parameter type; 1 found

     * @param string $sPluginName    The plugin name

Expected 1 spaces after parameter name; 4 found

Expected 2 spaces after parameter type; 1 found

     * @param integer $nPriority    The plugin priority, used to order the plugins

Expected 3 spaces after parameter name; 4 found

     *
     * @return void
     * @throws SetupException
     */
    public function registerPlugin(string $sClassName, string $sPluginName, int $nPriority = 1000)
    {
        $bIsUsed = false;

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space

        $aInterfaces = class_implements($sClassName);
        if(in_array(CodeGeneratorInterface::class, $aInterfaces))
        {
            $this->xCodeGenerator->addCodeGenerator($sClassName, $nPriority);
            $bIsUsed = true;
        }
        if(in_array(CallableRegistryInterface::class, $aInterfaces))
        {
            $this->aRegistryPlugins[$sPluginName] = $sClassName;
            $bIsUsed = true;

Equals sign not aligned with surrounding assignments; expected 30 spaces but found 1 space

        }
        if(in_array(RequestHandlerInterface::class, $aInterfaces))
        {
            $this->aRequestHandlers[$sPluginName] = $sClassName;
            $bIsUsed = true;

Equals sign not aligned with surrounding assignments; expected 30 spaces but found 1 space

        }
        if(in_array(ResponsePluginInterface::class, $aInterfaces))
        {
            $this->aResponsePlugins[$sPluginName] = $sClassName;
            $bIsUsed = true;

Equals sign not aligned with surrounding assignments; expected 30 spaces but found 1 space

        }

        if(!$bIsUsed)
        {
            // The class is invalid.
            $sMessage = $this->xTranslator->trans('errors.register.invalid', ['name' => $sClassName]);
            throw new SetupException($sMessage);
        }

        // Register the plugin in the DI container, if necessary
        if(!$this->di->has($sClassName))
        {
            $this->di->auto($sClassName);
        }
    }

Expected 2 blank lines after function; 1 found

    /**
     * Find the specified response plugin by name and return a reference to it if one exists
     *
     * @param string $sName    The name of the plugin

Expected 8 spaces after parameter type; 1 found

Expected 5 spaces after parameter name; 4 found

     * @param Response|null $xResponse    The response to attach the plugin to

Expected 1 spaces after parameter name; 4 found

     *
     * @return ResponsePlugin|null
     */
    public function getResponsePlugin(string $sName, ?Response $xResponse = null): ?ResponsePlugin
    {
        if(!isset($this->aResponsePlugins[$sName]))
        {
            return null;
        }
        $xPlugin = $this->di->g($this->aResponsePlugins[$sName]);

$this->aResponsePlugins[$sName] of type Jaxon\Plugin\ResponsePluginInterface is incompatible with the type string expected by parameter $sClass of Jaxon\Di\Container::g().

        if(($xResponse))
        {
            $xPlugin->setResponse($xResponse);
        }
        return $xPlugin;
    }

Expected 2 blank lines after function; 1 found

    /**
     * Register a function or callable class
     *
     * Call the request plugin with the $sType defined as name.
     *
     * @param string $sType    The type of request handler being registered

Expected 5 spaces after parameter name; 4 found

Expected 7 spaces after parameter type; 1 found

     * @param string $sCallable    The callable entity being registered

Expected 1 spaces after parameter name; 4 found

Expected 7 spaces after parameter type; 1 found

     * @param array|string $xOptions    The associated options

Expected 2 spaces after parameter name; 4 found

     *
     * @return void
     * @throws SetupException
     */
    public function registerCallable(string $sType, string $sCallable, $xOptions = [])
    {
        if(isset($this->aRegistryPlugins[$sType]) &&
            ($xPlugin = $this->di->g($this->aRegistryPlugins[$sType])))

Variable assignment found within a condition. Did you mean to do a comparison ?

$this->aRegistryPlugins[$sType] of type Jaxon\Plugin\CallableRegistryInterface is incompatible with the type string expected by parameter $sClass of Jaxon\Di\Container::g().

        {
            $xPlugin->register($sType, $sCallable, $xPlugin->checkOptions($sCallable, $xOptions));
            return;
        }
        throw new SetupException($this->xTranslator->trans('errors.register.plugin',
            ['name' => $sType, 'callable' => $sCallable]));
    }

Expected 2 blank lines after function; 1 found

    /**
     * Register the Jaxon request plugins
     *
     * @return void
     * @throws SetupException
     */
    public function registerPlugins()
    {
        // Request plugins
        $this->registerPlugin(CallableClassPlugin::class, Jaxon::CALLABLE_CLASS, 101);
        $this->registerPlugin(CallableFunctionPlugin::class, Jaxon::CALLABLE_FUNCTION, 102);
        $this->registerPlugin(CallableDirPlugin::class, Jaxon::CALLABLE_DIR, 103);

        // Response plugins
        $this->registerPlugin(JQueryPlugin::class, JQueryPlugin::NAME, 700);
        $this->registerPlugin(DataBagPlugin::class, DataBagPlugin::NAME, 700);
        $this->registerPlugin(DialogPlugin::class, DialogPlugin::NAME, 750);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the parameter reader
     *
     * @return ParameterReader
     */
    public function getParameterReader()
    {
        return $this->di->g(ParameterReader::class);
    }

Expected 2 blank lines after function; 0 found

}