CallableClass::__construct() - Code Metrics - Inspection of "Updated PHP versions support in the readme." - jaxon-php/jaxon-core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( dc0218...f79a4b )

by Thierry

created 2022-03-11 18:40 UTC

CallableClass::__construct() A

↳ Parent: CallableClass

Complexity

Conditions	5
Paths	16

Size

Total Lines	28
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	5
eloc	16
c	1
b	0
f	0
nc	16
nop	8
dl	0
loc	28
rs	9.4222

How to fix Many Parameters

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

 * @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;

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

{
    /**
     * @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 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']);
        }
    }


    /**
     * @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 CallableObject $xCallableObject    The corresponding callable object

     * @param string $sClassName    The class name

     * @param array $aProtectedMethods    The protected methods

     *
     * @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 = [];
$a = "a";
$ab = "ab";
$abc = "abc";
        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]) ?

                array_map($fConvertOption, $aConfig[$sMethodName]) : [];
            $aMethods[] = [
$a = "a";
$ab = "ab";
$abc = "abc";
                '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,
        ]);
    }


    /**
     * 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);
$a = "a";
$ab = "ab";
$abc = "abc";
        $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);
$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
     */

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

        {
            // 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			* CallableClass.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 PHP version not specified Loading history... Coding Style introduced 2019-11-20 07:47 UTC by Report Bug Copy Issue Report Missing @category tag in file comment Loading history...
21
22			namespace Jaxon\Request\Plugin;
23
24			use Jaxon\Jaxon;
25			use Jaxon\Request\Handler\Handler as RequestHandler;
26			use Jaxon\Response\Manager as ResponseManager;
27			use Jaxon\CallableClass as UserCallableClass;
28			use Jaxon\Plugin\Request as RequestPlugin;
29			use Jaxon\Request\Support\CallableObject;
30			use Jaxon\Request\Support\CallableRegistry;
31			use Jaxon\Request\Support\CallableRepository;
32			use Jaxon\Request\Target;

jaxon-php / jaxon-core

Push — master ( dc0218...f79a4b )

CallableClass::__construct() A

Complexity

Size

Duplication

Importance

How to fix Many Parameters

Many Parameters

Duplication Side-by-Side

Filter issues like