Jaxon\Request\Plugin\CallableFunction\CallableFunctionPlugin

Complexity

Total Complexity

22

Size/Duplication

Total Lines	220
Duplicated Lines	0 %

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getName()	0	3	1
A	getHash()	0	3	1
A	getTarget()	0	7	2
A	__construct()	0	17	3
A	processRequest()	0	18	3
A	getScript()	0	9	2
A	getCallableScript()	0	6	1
A	canProcessRequest()	0	8	3
A	checkOptions()	0	15	4
A	register()	0	13	2

<?php

/**
 * CallableFunctionPlugin.php - Jaxon user function plugin
 *
 * This class registers user defined functions, generates client side javascript code,
 * and calls them on user request
 *
 * @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
 */

Missing @category tag in file comment

PHP version not specified

namespace Jaxon\Request\Plugin\CallableFunction;

use Jaxon\Jaxon;
use Jaxon\Container\Container;
use Jaxon\Plugin\RequestPlugin;
use Jaxon\Request\Handler\RequestHandler;
use Jaxon\Request\Target;
use Jaxon\Request\Validator;
use Jaxon\Response\ResponseManager;
use Jaxon\Utils\Template\Engine as TemplateEngine;
use Jaxon\Utils\Translation\Translator;
use Jaxon\Exception\RequestException;
use Jaxon\Exception\SetupException;

use function implode;
use function is_array;
use function is_string;
use function md5;
use function trim;

class CallableFunctionPlugin extends RequestPlugin

Missing doc comment for class CallableFunctionPlugin

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

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

    /**
     * The request handler
     *
     * @var RequestHandler
     */
    protected $xRequestHandler;

    /**
     * The response manager
     *
     * @var ResponseManager
     */
    protected $xResponseManager;

    /**
     * The request data validator
     *
     * @var Validator
     */
    protected $xValidator;

    /**
     * @var TemplateEngine
     */
    protected $xTemplateEngine;

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

    /**
     * The registered user functions names
     *
     * @var array
     */
    protected $aFunctions = [];

    /**
     * The name of the function that is being requested (during the request processing phase)
     *
     * @var string
     */
    protected $sRequestedFunction = null;

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

Expected 7 spaces after parameter type; 2 found

Missing parameter comment

     * @param RequestHandler  $xRequestHandler

Missing parameter comment

     * @param ResponseManager  $xResponseManager

Missing parameter comment

Expected 1 spaces after parameter type; 2 found

     * @param TemplateEngine  $xTemplateEngine

Missing parameter comment

     * @param Translator  $xTranslator

Expected 6 spaces after parameter type; 2 found

Missing parameter comment

     * @param Validator  $xValidator

Expected 7 spaces after parameter type; 2 found

Missing parameter comment

     */
    public function __construct(Container $di, RequestHandler $xRequestHandler, ResponseManager $xResponseManager,

Expected 2 blank lines before function; 1 found

        TemplateEngine $xTemplateEngine, Translator $xTranslator, Validator $xValidator)
    {
        $this->di = $di;

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

        $this->xRequestHandler = $xRequestHandler;
        $this->xResponseManager = $xResponseManager;
        $this->xTemplateEngine = $xTemplateEngine;
        $this->xTranslator = $xTranslator;

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

        $this->xValidator = $xValidator;

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

        if(isset($_GET['jxnfun']))
        {
            $this->sRequestedFunction = $_GET['jxnfun'];
        }
        if(isset($_POST['jxnfun']))
        {
            $this->sRequestedFunction = $_POST['jxnfun'];
        }
    }

Expected 2 blank lines after function; 1 found

    /**
     * @inheritDoc
     */

Missing @return tag in function comment

    public function getName(): string
    {
        return Jaxon::CALLABLE_FUNCTION;
    }

Expected 2 blank lines after function; 1 found

    /**
     * @inheritDoc
     */

Missing @return tag in function comment

    public function getTarget(): ?Target
    {
        if(!$this->sRequestedFunction)
        {
            return null;
        }
        return Target::makeFunction($this->sRequestedFunction);
    }

Expected 2 blank lines after function; 1 found

    /**

Parameter $xOptions should have a doc-comment as per coding-style.

Parameter $sCallable should have a doc-comment as per coding-style.

     * @inheritDoc
     * @throws SetupException
     */

Missing @return tag in function comment

    public function checkOptions(string $sCallable, $xOptions): array
    {
        if(!$this->xValidator->validateFunction(trim($sCallable)))
        {
            throw new SetupException($this->xTranslator->trans('errors.objects.invalid-declaration'));
        }
        if(is_string($xOptions))
        {
            $xOptions = ['include' => $xOptions];
        }
        elseif(!is_array($xOptions))
        {
            throw new SetupException($this->xTranslator->trans('errors.objects.invalid-declaration'));
        }
        return $xOptions;
    }

Expected 2 blank lines after function; 1 found

    /**
     * Register a user defined function
     *
     * @param string $sType    The type of request handler being registered

Expected 5 spaces after parameter name; 4 found

     * @param string $sCallable    The name of the function being registered

Expected 1 spaces after parameter name; 4 found

     * @param array $aOptions    The associated options

Expected 2 spaces after parameter type; 1 found

Expected 2 spaces after parameter name; 4 found

     *
     * @return bool
     */
    public function register(string $sType, string $sCallable, array $aOptions): bool
    {
        $sFunctionName = trim($sCallable);
        // Check if an alias is defined
        $sJsFunction = $sFunctionName;
        if(isset($aOptions['alias']))
        {
            $sJsFunction = (string)$aOptions['alias'];
            unset($aOptions['alias']);
        }
        $this->aFunctions[$sFunctionName] = $sFunctionName;
        $this->di->registerCallableFunction($sFunctionName, $sJsFunction, $aOptions);
        return true;
    }

Expected 2 blank lines after function; 1 found

    /**
     * @inheritDoc
     */

Missing @return tag in function comment

    public function getHash(): string
    {
        return md5(implode('', $this->aFunctions));
    }

Expected 2 blank lines after function; 1 found

    /**
     * Generate the javascript function stub that is sent to the browser on initial page load
     *
     * @param CallableFunction $xFunction

Missing parameter comment

     *
     * @return string
     */
    private function getCallableScript(CallableFunction $xFunction): string
    {
        return $this->xTemplateEngine->render('jaxon::callables/function.js', [
            'sName' => $xFunction->getName(),
            'sJsName' => $xFunction->getJsName(),
            'aOptions' => $xFunction->getOptions(),
        ]);
    }

Expected 2 blank lines after function; 1 found

    /**
     * @inheritDoc
     */

Missing @return tag in function comment

    public function getScript(): string
    {
        $code = '';
        foreach($this->aFunctions as $sName)
        {
            $xFunction = $this->di->getCallableFunction($sName);
            $code .= $this->getCallableScript($xFunction);

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

        }
        return $code;
    }

Expected 2 blank lines after function; 1 found

    /**
     * @inheritDoc
     */

Missing @return tag in function comment

    public function canProcessRequest(): bool
    {
        // Check the validity of the function name
        if(($this->sRequestedFunction) && !$this->xValidator->validateFunction($this->sRequestedFunction))
        {
            $this->sRequestedFunction = null;
        }
        return ($this->sRequestedFunction != null);
    }

Expected 2 blank lines after function; 1 found

    /**
     * @inheritDoc
     * @throws RequestException
     */

Missing @return tag in function comment

    public function processRequest(): bool
    {
        // Security check: make sure the requested function was registered.
        if(!isset($this->aFunctions[$this->sRequestedFunction]))
        {
            // Unable to find the requested function
            throw new RequestException($this->xTranslator->trans('errors.functions.invalid',
                ['name' => $this->sRequestedFunction]));
        }

        $xFunction = $this->di->getCallableFunction($this->sRequestedFunction);
        $aArgs = $this->xRequestHandler->processArguments();

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

        $xResponse = $xFunction->call($aArgs);
        if(($xResponse))
        {
            $this->xResponseManager->append($xResponse);
        }
        return true;
    }

Expected 2 blank lines after function; 0 found

}