Jaxon\Plugin\Request\CallableClass\CallableClassPlugin

Complexity

Total Complexity

29

Size/Duplication

Total Lines	282
Duplicated Lines	0 %

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	register()	0	5	1
A	getCallableScript()	0	7	2
A	getCallable()	0	3	1
A	checkOptions()	0	15	4
A	processRequest()	0	31	5
A	getScript()	0	15	2
A	getName()	0	3	1
A	getHash()	0	4	1
A	__construct()	0	18	2
A	canProcessRequest()	0	9	4
A	setTarget()	0	10	2
A	getNamespacesScript()	0	23	4

<?php

/**
 * CallableClassPlugin.php - Jaxon callable class plugin
 *
 * This class registers user defined callable classes, generates client side javascript code,
 * and calls their methods 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
 */

PHP version not specified

Missing @category tag in file comment

namespace Jaxon\Plugin\Request\CallableClass;

use Jaxon\Jaxon;
use Jaxon\CallableClass;
use Jaxon\Di\Container;
use Jaxon\Exception\RequestException;
use Jaxon\Exception\SetupException;
use Jaxon\Plugin\RequestPlugin;
use Jaxon\Request\Handler\ParameterReader;
use Jaxon\Request\Target;
use Jaxon\Request\Validator;
use Jaxon\Response\ResponseInterface;
use Jaxon\Utils\Template\TemplateEngine;
use Jaxon\Utils\Translation\Translator;
use Psr\Http\Message\ServerRequestInterface;

use ReflectionClass;
use ReflectionException;
use ReflectionMethod;

use function is_array;
use function is_string;
use function is_subclass_of;
use function md5;
use function strlen;
use function trim;
use function uksort;

class CallableClassPlugin extends RequestPlugin

Missing doc comment for class CallableClassPlugin

{
    /**
     * @var string
     */
    protected $sPrefix;

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

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

    /**
     * The parameter reader
     *
     * @var ParameterReader
     */
    protected $xParameterReader;

    /**
     * The callable registry
     *
     * @var CallableRegistry
     */
    protected $xRegistry;

    /**
     * The callable repository
     *
     * @var CallableRepository
     */
    protected $xRepository;

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

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

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

    /**
     * The methods that must not be exported to js
     *
     * @var array
     */
    protected $aProtectedMethods = [];

    /**
     * The class constructor
     *
     * @param string  $sPrefix

Missing parameter comment

Expected 13 spaces after parameter type; 2 found

     * @param Container $di

Missing parameter comment

Expected 10 spaces after parameter type; 1 found

     * @param ParameterReader $xParameterReader

Missing parameter comment

Expected 4 spaces after parameter type; 1 found

     * @param CallableRegistry $xRegistry    The callable class registry

Expected 3 spaces after parameter type; 1 found

Expected 8 spaces after parameter name; 4 found

     * @param CallableRepository $xRepository    The callable object repository

Expected 6 spaces after parameter name; 4 found

     * @param TemplateEngine $xTemplateEngine

Missing parameter comment

Expected 5 spaces after parameter type; 1 found

     * @param Translator $xTranslator

Missing parameter comment

Expected 9 spaces after parameter type; 1 found

     * @param Validator $xValidator

Missing parameter comment

Expected 10 spaces after parameter type; 1 found

     */
    public function __construct(string $sPrefix, Container $di, ParameterReader $xParameterReader,

Expected 2 blank lines before function; 1 found

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

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

        $this->sPrefix = $sPrefix;

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

        $this->xParameterReader = $xParameterReader;
        $this->xRegistry = $xRegistry;

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

        $this->xRepository = $xRepository;

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

        $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

        // The methods of the CallableClass class must not be exported
        $xCallableClass = new ReflectionClass(CallableClass::class);
        foreach($xCallableClass->getMethods(ReflectionMethod::IS_PUBLIC) as $xMethod)
        {
            $this->aProtectedMethods[] = $xMethod->getName();
        }
    }

Expected 2 blank lines after function; 1 found

    /**
     * @inheritDoc
     */

Missing @return tag in function comment

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

Expected 2 blank lines after function; 1 found

    /**

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

Parameter $xOptions 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->validateClass(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

    /**

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

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

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

     * @inheritDoc
     */

Missing @return tag in function comment

    public function register(string $sType, string $sCallable, array $aOptions): bool
    {
        $sClassName = trim($sCallable);
        $this->xRepository->addClass($sClassName, $aOptions);
        return true;
    }

Expected 2 blank lines after function; 1 found

    /**

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

     * @inheritDoc
     * @throws SetupException
     */

Missing @return tag in function comment

    public function getCallable(string $sCallable)
    {
        return $this->xRegistry->getCallableObject($sCallable);
    }

Expected 2 blank lines after function; 1 found

    /**
     * @inheritDoc
     */

Missing @return tag in function comment

    public function getHash(): string
    {
        $this->xRegistry->parseCallableClasses();
        return md5($this->xRepository->getHash());
    }

Expected 2 blank lines after function; 1 found

    /**
     * Generate client side javascript code for namespaces
     *
     * @return string
     */
    private function getNamespacesScript(): string
    {
        $sCode = '';

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

        $aJsClasses = [];
        $aNamespaces = $this->xRepository->getNamespaces();
        foreach($aNamespaces as $sNamespace)
        {
            $offset = 0;

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

            $sJsNamespace = str_replace('\\', '.', $sNamespace);
            $sJsNamespace .= '.Null'; // This is a sentinel. The last token is not processed in the while loop.
            while(($dotPosition = strpos($sJsNamespace, '.', $offset)) !== false)

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

            {
                $sJsClass = substr($sJsNamespace, 0, $dotPosition);
                // Generate code for this object
                if(!isset($aJsClasses[$sJsClass]))
                {
                    $sCode .= $this->sPrefix . "$sJsClass = {};\n";

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

                    $aJsClasses[$sJsClass] = $sJsClass;
                }
                $offset = $dotPosition + 1;
            }
        }
        return $sCode;
    }

Expected 2 blank lines after function; 1 found

    /**
     * Generate client side javascript code for a callable class
     *
     * @param string $sClassName

Missing parameter comment

Expected 9 spaces after parameter type; 1 found

     * @param CallableObject $xCallableObject The corresponding callable object
     *
     * @return string
     */
    private function getCallableScript(string $sClassName, CallableObject $xCallableObject): string
    {
        $aProtectedMethods = is_subclass_of($sClassName, CallableClass::class) ? $this->aProtectedMethods : [];
        return $this->xTemplateEngine->render('jaxon::callables/object.js', [
            'sPrefix' => $this->sPrefix,
            'sClass' => $xCallableObject->getJsName(),
            'aMethods' => $xCallableObject->getMethods($aProtectedMethods),
        ]);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Generate client side javascript code for the registered callable objects
     *
     * @return string
     * @throws SetupException
     */
    public function getScript(): string
    {
        $this->xRegistry->parseCallableClasses();
        $aCallableObjects = $this->xRepository->getCallableObjects();
        // Sort the options by key length asc
        uksort($aCallableObjects, function($name1, $name2) {
            return strlen($name1) - strlen($name2);
        });

        $sCode = $this->getNamespacesScript();
        foreach($aCallableObjects as $sClassName => $xCallableObject)
        {
            $sCode .= $this->getCallableScript($sClassName, $xCallableObject);
        }
        return $sCode;
    }

Expected 2 blank lines after function; 1 found

    /**

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

     * @inheritDoc
     */

Missing @return tag in function comment

    public static function canProcessRequest(ServerRequestInterface $xRequest): bool
    {
        $aBody = $xRequest->getParsedBody();
        if(is_array($aBody))
        {
            return isset($aBody['jxncls']) && isset($aBody['jxnmthd']);
        }
        $aParams = $xRequest->getQueryParams();
        return isset($aParams['jxncls']) && isset($aParams['jxnmthd']);
    }

Expected 2 blank lines after function; 1 found

    /**

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

     * @inheritDoc
     */

Missing @return tag in function comment

    public function setTarget(ServerRequestInterface $xRequest)
    {
        $aBody = $xRequest->getParsedBody();
        if(is_array($aBody))
        {
            $this->xTarget = Target::makeClass(trim($aBody['jxncls']), trim($aBody['jxnmthd']));
            return;
        }
        $aParams = $xRequest->getQueryParams();

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

        $this->xTarget = Target::makeClass(trim($aParams['jxncls']), trim($aParams['jxnmthd']));
    }

Expected 2 blank lines after function; 1 found

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

Missing @return tag in function comment

    public function processRequest(): ?ResponseInterface
    {
        $sRequestedClass = $this->xTarget->getClassName();
        $sRequestedMethod = $this->xTarget->getMethodName();

        if(!$this->xValidator->validateClass($sRequestedClass) ||
            !$this->xValidator->validateMethod($sRequestedMethod))
        {
            // Unable to find the requested object or method
            throw new RequestException($this->xTranslator->trans('errors.objects.invalid',
                ['class' => $sRequestedClass, 'method' => $sRequestedMethod]));
        }

        // Call the requested method
        try
        {
            $xCallableObject = $this->xRegistry->getCallableObject($sRequestedClass);
            return $xCallableObject->call($sRequestedMethod, $this->xParameterReader->args());
        }
        catch(ReflectionException $e)
        {
            // Unable to find the requested class or method
            $this->di->logger()->error($e->getMessage());
            throw new RequestException($this->xTranslator->trans('errors.objects.invalid',
                ['class' => $sRequestedClass, 'method' => $sRequestedMethod]));
        }
        catch(SetupException $e)
        {
            // Unable to get the callable object
            throw new RequestException($this->xTranslator->trans('errors.objects.invalid',
                ['class' => $sRequestedClass, 'method' => $sRequestedMethod]));
        }
    }

Expected 2 blank lines after function; 0 found

}