Jaxon\Request\Plugin\CallableClass

Complexity

Total Complexity

43

Size/Duplication

Total Lines	349
Duplicated Lines	0 %

Importance

Changes	4
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	processRequest()	0	33	6
A	__construct()	0	28	5
A	register()	0	5	1
B	getCallableScript()	0	33	7
A	getHash()	0	17	3
A	getName()	0	3	1
A	getTarget()	0	7	3
A	checkOptions()	0	15	4
A	getScript()	0	26	3
A	canProcessRequest()	0	10	6
A	getNamespacesScript()	0	24	4

<?php

/**
 * CallableClass.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\Request\Plugin;

use Jaxon\Jaxon;
use Jaxon\Request\Handler\Handler as RequestHandler;
use Jaxon\Response\Manager as ResponseManager;
use Jaxon\CallableClass as UserCallableClass;
use Jaxon\Plugin\Request as RequestPlugin;
use Jaxon\Request\Support\CallableObject;
use Jaxon\Request\Support\CallableRegistry;
use Jaxon\Request\Support\CallableRepository;
use Jaxon\Request\Target;
use Jaxon\Request\Validator;
use Jaxon\Exception\RequestException;
use Jaxon\Exception\SetupException;
use Jaxon\Utils\Config\Config;
use Jaxon\Utils\Template\Engine as TemplateEngine;
use Jaxon\Utils\Translation\Translator;
use ReflectionException;

use function trim;
use function strlen;
use function is_string;
use function is_array;
use function in_array;
use function uksort;
use function md5;
use function array_map;
use function array_merge;
use function is_subclass_of;

class CallableClass extends RequestPlugin

Missing doc comment for class CallableClass

{
    /**
     * @var Config
     */
    protected $xConfig;

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 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 value of the class parameter of the incoming Jaxon request
     *
     * @var string
     */
    protected $sRequestedClass = '';

    /**
     * The value of the method parameter of the incoming Jaxon request
     *
     * @var string
     */
    protected $sRequestedMethod = '';

    /**
     * The class constructor
     *
     * @param Config  $xConfig

Missing parameter comment

Expected 13 spaces after parameter type; 2 found

     * @param RequestHandler  $xRequestHandler

Missing parameter comment

Expected 5 spaces after parameter type; 2 found

     * @param ResponseManager  $xResponseManager

Expected 4 spaces after parameter type; 2 found

Missing parameter comment

     * @param CallableRegistry $xRegistry    The callable class registry

Expected 8 spaces after parameter name; 4 found

Expected 3 spaces after parameter type; 1 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; 2 found

     * @param Translator  $xTranslator

Missing parameter comment

Expected 9 spaces after parameter type; 2 found

     * @param Validator  $xValidator

Missing parameter comment

Expected 10 spaces after parameter type; 2 found

     */
    public function __construct(Config $xConfig, RequestHandler $xRequestHandler,

Expected 2 blank lines before function; 1 found

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

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

        $this->xRequestHandler = $xRequestHandler;
        $this->xResponseManager = $xResponseManager;
        $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

        if(isset($_GET['jxncls']))
        {
            $this->sRequestedClass = trim($_GET['jxncls']);
        }
        if(isset($_GET['jxnmthd']))
        {
            $this->sRequestedMethod = trim($_GET['jxnmthd']);
        }
        if(isset($_POST['jxncls']))
        {
            $this->sRequestedClass = trim($_POST['jxncls']);
        }
        if(isset($_POST['jxnmthd']))
        {
            $this->sRequestedMethod = trim($_POST['jxnmthd']);
        }
    }

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

    /**
     * @inheritDoc
     */

Missing @return tag in function comment

    public function getTarget(): ?Target
    {
        if(!$this->sRequestedClass || !$this->sRequestedMethod)
        {
            return null;
        }
        return Target::makeClass($this->sRequestedClass, $this->sRequestedMethod);
    }

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

    /**
     * Register a callable class
     *
     * @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 class 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
    {
        $sClassName = trim($sCallable);
        $this->xRepository->addClass($sClassName, $aOptions);
        return true;
    }

Expected 2 blank lines after function; 1 found

    /**
     * @inheritDoc
     */

Missing @return tag in function comment

    public function getHash(): string
    {
        $this->xRegistry->parseCallableClasses();
        $aNamespaces = $this->xRepository->getNamespaces();
        $aClasses = $this->xRepository->getClasses();

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

        $sHash = '';

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

        foreach($aNamespaces as $sNamespace => $aOptions)
        {
            $sHash .= $sNamespace . $aOptions['separator'];
        }
        foreach($aClasses as $sClassName => $aOptions)
        {
            $sHash .= $sClassName . $aOptions['timestamp'];
        }

        return md5($sHash);
    }

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

        $sPrefix = $this->xConfig->getOption('core.prefix.class');

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

        $aJsClasses = [];
        $aNamespaces = array_keys($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 .= "$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 CallableObject $xCallableObject    The corresponding callable object

Expected 3 spaces after parameter name; 4 found

     * @param string $sClassName    The class name

Expected 9 spaces after parameter type; 1 found

Expected 8 spaces after parameter name; 4 found

     * @param array $aProtectedMethods    The protected methods

Expected 1 spaces after parameter name; 4 found

Expected 10 spaces after parameter type; 1 found

     *
     * @return string
     */
    private function getCallableScript(CallableObject $xCallableObject, string $sClassName, array $aProtectedMethods): string
    {
        $aConfig = $xCallableObject->getOptions();

        // Convert an option to string, to be displayed in the js script template.
        $fConvertOption = function($xOption) {
            return is_array($xOption) ? json_encode($xOption) : $xOption;
        };
        $aCommonConfig = isset($aConfig['*']) ? array_map($fConvertOption, $aConfig['*']) : [];

        $_aProtectedMethods = is_subclass_of($sClassName, UserCallableClass::class) ? $aProtectedMethods : [];
        $aMethods = [];

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

        foreach($xCallableObject->getMethods() as $sMethodName)
        {
            // Don't export methods of the CallableClass class
            if(in_array($sMethodName, $_aProtectedMethods))
            {
                continue;
            }
            // Specific options for this method
            $aMethodConfig = isset($aConfig[$sMethodName]) ?

Expected 1 space after "?"; newline found

                array_map($fConvertOption, $aConfig[$sMethodName]) : [];
            $aMethods[] = [

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

                'name' => $sMethodName,
                'config' => array_merge($aCommonConfig, $aMethodConfig),
            ];
        }

        $sPrefix = $this->xConfig->getOption('core.prefix.class');
        return $this->xTemplateEngine->render('jaxon::support/object.js', [
            'sPrefix' => $sPrefix,
            'sClass' => $xCallableObject->getJsName(),
            'aMethods' => $aMethods,
        ]);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Generate client side javascript code for the registered callable objects
     *
     * @return string
     */
    public function getScript(): string
    {
        $this->xRegistry->registerCallableObjects();

        // The methods of the \Jaxon\CallableClass class must not be exported
        $xCallableClass = new \ReflectionClass(UserCallableClass::class);

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

        $aProtectedMethods = [];
        foreach($xCallableClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $xMethod)
        {
            $aProtectedMethods[] = $xMethod->getName();
        }

        $sCode = $this->getNamespacesScript();

        $aClassNames = $this->xRepository->getClassNames();
        // Sort the options by key length asc
        uksort($aClassNames, function($name1, $name2) {
            return strlen($name1) - strlen($name2);
        });
        foreach($aClassNames as $sClassName)
        {
            $xCallableObject = $this->xRegistry->getCallableObject($sClassName);
            $sCode .= $this->getCallableScript($xCallableObject, $sClassName, $aProtectedMethods);

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

        }

        return $sCode;
    }

Expected 2 blank lines after function; 1 found

    /**
     * @inheritDoc
     */

Missing @return tag in function comment

    public function canProcessRequest(): bool
    {
        // Check the validity of the class name
        if(($this->sRequestedClass !== null && !$this->xValidator->validateClass($this->sRequestedClass)) ||
            ($this->sRequestedMethod !== null && !$this->xValidator->validateMethod($this->sRequestedMethod)))
        {
            $this->sRequestedClass = null;
            $this->sRequestedMethod = null;
        }
        return ($this->sRequestedClass !== null && $this->sRequestedMethod !== null);
    }

Expected 2 blank lines after function; 1 found

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

Missing @return tag in function comment

    public function processRequest(): bool
    {
        if(!$this->canProcessRequest())
        {
            return false;
        }

        // Find the requested method
        $xCallableObject = $this->xRegistry->getCallableObject($this->sRequestedClass);
        if(!$xCallableObject || !$xCallableObject->hasMethod($this->sRequestedMethod))

$xCallableObject is of type Jaxon\Request\Support\CallableObject, thus it always evaluated to true.

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

        // Call the requested method
        $aArgs = $this->xRequestHandler->processArguments();
        try
        {
            $xResponse = $xCallableObject->call($this->sRequestedMethod, $aArgs);
            if(($xResponse))
            {
                $this->xResponseManager->append($xResponse);
            }
        }
        catch(ReflectionException $e)
        {
            // Unable to find the requested class
            throw new RequestException($this->xTranslator->trans('errors.objects.invalid',
                ['class' => $this->sRequestedClass, 'method' => $this->sRequestedMethod]));
        }
        return true;
    }

Expected 2 blank lines after function; 0 found

}