CallableClassPlugin::processRequest() - Code Metrics - Inspection of "Added a new class: ConfigManager." - jaxon-php/jaxon-core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( a07882...2b8759 )

by Thierry

created 2022-03-17 03:57 UTC

CallableClassPlugin::processRequest() A

↳ Parent: CallableClassPlugin

Complexity

Conditions	5
Paths	5

Size

Total Lines	28
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	5
eloc	13
nc	5
nop	0
dl	0
loc	28
rs	9.5222
c	0
b	0
f	0

<?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

 * @author Jared White

 * @author J. Max Wilson

 * @author Joseph Woolley

 * @author Steffen Konerow

 * @author Thierry Feuzeu <[email protected]>
 * @copyright Copyright (c) 2005-2007 by Jared White & J. Max Wilson

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

 * @copyright 2016 Thierry Feuzeu <[email protected]>
 * @license https://opensource.org/licenses/BSD-3-Clause BSD 3-Clause License
 * @link https://github.com/jaxon-php/jaxon-core
 */


namespace Jaxon\Request\Plugin\CallableClass;

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

use ReflectionClass;
use ReflectionMethod;
use ReflectionException;

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

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


    /**
     * 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 methods that must not be exported to js
     *
     * @var array
     */
    protected $aProtectedMethods = [];

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

     * @param RequestHandler  $xRequestHandler

     * @param ResponseManager  $xResponseManager

     * @param CallableRegistry $xRegistry    The callable class registry

     * @param CallableRepository $xRepository    The callable object repository

     * @param TemplateEngine  $xTemplateEngine

     * @param Translator  $xTranslator

     * @param Validator  $xValidator

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

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

        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']);
        }

        // 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();
        }
    }


    /**
     * @inheritDoc
     */

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


    /**
     * @inheritDoc
     */

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


    /**

     * @inheritDoc
     * @throws SetupException
     */

    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;
    }


    /**
     * Register a callable class
     *
     * @param string $sType    The type of request handler being registered

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

     * @param array $aOptions    The associated options

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


    /**
     * @inheritDoc
     */

    public function getHash(): string
    {
        $this->xRegistry->parseCallableClasses();
        $aNamespaces = $this->xRepository->getNamespaces();
        $aClasses = $this->xRepository->getClasses();
$a = "a";
$ab = "ab";
$abc = "abc";
        $sHash = '';
$a = "a";
$ab = "ab";
$abc = "abc";

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

        return md5($sHash);
    }


    /**
     * Generate client side javascript code for namespaces
     *
     * @return string
     */
    private function getNamespacesScript(): string
    {
        $sCode = '';
$a = "a";
$ab = "ab";
$abc = "abc";
        $sPrefix = $this->xConfig->getOption('core.prefix.class');
$a = "a";
$ab = "ab";
$abc = "abc";
        $aJsClasses = [];
        $aNamespaces = array_keys($this->xRepository->getNamespaces());
        foreach($aNamespaces as $sNamespace)
        {
            $offset = 0;
$a = "a";
$ab = "ab";
$abc = "abc";
            $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)

            {
                $sJsClass = substr($sJsNamespace, 0, $dotPosition);
                // Generate code for this object
                if(!isset($aJsClasses[$sJsClass]))
                {
                    $sCode .= "$sPrefix$sJsClass = {};\n";
$a = "a";
$ab = "ab";
$abc = "abc";
                    $aJsClasses[$sJsClass] = $sJsClass;
                }
                $offset = $dotPosition + 1;
            }
        }
        return $sCode;
    }


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

     * @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->xConfig->getOption('core.prefix.class'),
            'sClass' => $xCallableObject->getJsName(),
            'aMethods' => $xCallableObject->getMethods($aProtectedMethods),
        ]);
    }


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

        $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($sClassName, $xCallableObject);
$a = "a";
$ab = "ab";
$abc = "abc";
        }

        return $sCode;
    }


    /**
     * @inheritDoc
     */

    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);
    }


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

    public function processRequest(): bool
    {
        // Find the requested method
        $xCallableObject = $this->xRegistry->getCallableObject($this->sRequestedClass);
        if(!$xCallableObject || !$xCallableObject->hasMethod($this->sRequestedMethod))

        {
            // 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;
    }

}


1			<?php
2
3			/**
4			* CallableClassPlugin.php - Jaxon callable class plugin
5			*
6			* This class registers user defined callable classes, generates client side javascript code,
7			* and calls their methods on user request
8			*
9			* @package jaxon-core
			0 ignored issues – show Coding Style introduced 2019-11-20 07:47 UTC by Report Bug Copy Issue Report Package name "jaxon-core" is not valid; consider "Jaxoncore" instead Loading history...
10			* @author Jared White
			0 ignored issues – show Coding Style introduced 2019-11-20 07:47 UTC by Report Bug Copy Issue Report Content of the @author tag must be in the form "Display Name <[email protected]>" Loading history...
11			* @author J. Max Wilson
			0 ignored issues – show Coding Style introduced 2019-11-20 07:47 UTC by Report Bug Copy Issue Report Content of the @author tag must be in the form "Display Name <[email protected]>" Loading history...
12			* @author Joseph Woolley
			0 ignored issues – show Coding Style introduced 2019-11-20 07:47 UTC by Report Bug Copy Issue Report Content of the @author tag must be in the form "Display Name <[email protected]>" Loading history...
13			* @author Steffen Konerow
			0 ignored issues – show Coding Style introduced 2019-11-20 07:47 UTC by Report Bug Copy Issue Report Content of the @author tag must be in the form "Display Name <[email protected]>" Loading history...
14			* @author Thierry Feuzeu <[email protected]>
15			* @copyright Copyright (c) 2005-2007 by Jared White & J. Max Wilson
			0 ignored issues – show Coding Style introduced 2019-11-20 07:47 UTC by Report Bug Copy Issue Report @copyright tag must contain a year and the name of the copyright holder Loading history...
16			* @copyright Copyright (c) 2008-2010 by Joseph Woolley, Steffen Konerow, Jared White & J. Max Wilson
			0 ignored issues – show Coding Style introduced 2019-11-20 07:47 UTC by Report Bug Copy Issue Report @copyright tag must contain a year and the name of the copyright holder Loading history...
17			* @copyright 2016 Thierry Feuzeu <[email protected]>
18			* @license https://opensource.org/licenses/BSD-3-Clause BSD 3-Clause License
19			* @link https://github.com/jaxon-php/jaxon-core
20			*/
			0 ignored issues – show Coding Style introduced 2019-11-20 07:47 UTC by Report Bug Copy Issue Report Missing @category tag in file comment Loading history... Coding Style introduced 2019-11-20 07:47 UTC by Report Bug Copy Issue Report PHP version not specified Loading history...
21
22			namespace Jaxon\Request\Plugin\CallableClass;
23
24			use Jaxon\Jaxon;
25			use Jaxon\CallableClass;
26			use Jaxon\Plugin\RequestPlugin;
27			use Jaxon\Request\Handler\RequestHandler;
28			use Jaxon\Request\Target;
29			use Jaxon\Request\Validator;
30			use Jaxon\Response\ResponseManager;
31			use Jaxon\Utils\Config\Config;
32			use Jaxon\Utils\Template\Engine as TemplateEngine;

jaxon-php / jaxon-core

Push — master ( a07882...2b8759 )

CallableClassPlugin::processRequest() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like