CallableClassPlugin::getCallable() - Code Metrics - Inspection of "Update the readme." - jaxon-php/jaxon-mono - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( fd5484...10601e )

by Thierry

created 2025-10-20 16:21 UTC

CallableClassPlugin::getCallable() A

↳ Parent: CallableClassPlugin

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	1
nc	1
nop	1
dl	0
loc	3
rs	10
c	1
b	0
f	0

<?php

/**
 * CallableClassPlugin.php - Jaxon callable class plugin
 *
 * This class registers user defined callable classes, 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\Plugin\Request\CallableClass;

use Jaxon\Jaxon;
use Jaxon\App\I18n\Translator;
use Jaxon\Di\ComponentContainer;
use Jaxon\Exception\RequestException;
use Jaxon\Exception\SetupException;
use Jaxon\Plugin\AbstractRequestPlugin;
use Jaxon\Request\Target;
use Jaxon\Request\Validator;
use Jaxon\Utils\Template\TemplateEngine;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Log\LoggerInterface;
use ReflectionException;

use function array_map;
use function array_merge;
use function explode;
use function implode;
use function is_array;
use function is_string;
use function md5;
use function str_repeat;
use function trim;

class CallableClassPlugin extends AbstractRequestPlugin
{
    /**
     * @var array
     */
    private array $aCallableObjects = [];

    /**
     * The class constructor
     *
     * @param string $sPrefix
     * @param LoggerInterface $xLogger
     * @param ComponentContainer $cdi
     * @param ComponentRegistry $xRegistry
     * @param Translator $xTranslator
     * @param TemplateEngine $xTemplateEngine
     * @param Validator $xValidator
     */
    public function __construct(private string $sPrefix,
        private LoggerInterface $xLogger, private ComponentContainer $cdi,
        private ComponentRegistry $xRegistry, private Translator $xTranslator,
        private TemplateEngine $xTemplateEngine, private Validator $xValidator)
    {}

    /**
     * @inheritDoc
     */
    public function getName(): string
    {
        return Jaxon::CALLABLE_CLASS;
    }

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

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

    /**
     * @inheritDoc
     * @throws SetupException
     */
    public function getCallable(string $sCallable): CallableObject|null
    {
        return $this->cdi->makeCallableObject($sCallable);
    }

    /**
     * @inheritDoc
     */
    public function getHash(): string
    {
        $this->xRegistry->registerAllComponents();
        return md5($this->xRegistry->getHash());
    }

    /**
     * Add a callable object to the script generator
     *
     * @param CallableObject $xCallableObject
     *
     * @return void
     */
    private function addCallable(CallableObject $xCallableObject): void
    {
        if($xCallableObject->excluded())
        {
            return;
        }

        $aCallableObject = &$this->aCallableObjects;
        foreach(explode('.', $xCallableObject->getJsName()) as $sName)
        {
            if(!isset($aCallableObject['children'][$sName]))
            {
                $aCallableObject['children'][$sName] = [];
            }
            $aCallableObject = &$aCallableObject['children'][$sName];
        }
        $aCallableObject['methods'] = $xCallableObject->getCallableMethods();
    }

    /**
     * @param string $sIndent
     * @param array $aTemplateVars
     *
     * @return string
     */
    private function renderMethod(string $sIndent, array $aTemplateVars): string
    {
        return $sIndent . trim($this->xTemplateEngine
            ->render('jaxon::callables/method.js', $aTemplateVars));
    }

    /**
     * @param string $sJsClass
     * @param array $aCallable
     * @param int $nRepeat
     *
     * @return string
     */
    private function renderCallable(string $sJsClass, array $aCallable, int $nRepeat): string
    {
        $nRepeat += 2; // Indentation.
        $sIndent = str_repeat(' ', $nRepeat);

        $fMethodCallback = fn($aMethod) => $this->renderMethod($sIndent,
            ['sJsClass' => $sJsClass, 'aMethod' => $aMethod]);
        $aMethods = !isset($aCallable['methods']) ? [] :
            array_map($fMethodCallback, $aCallable['methods']);

        $aChildren = [];
        foreach($aCallable['children'] ?? [] as $sName => $aChild)
        {
            $aChildren[] = $this->renderChild("$sName:", "$sJsClass.$sName",
                $aChild, $nRepeat) . ',';
        }

        return implode("\n", array_merge($aMethods, $aChildren));
    }

    /**
     * @param string $sJsVar
     * @param string $sJsClass
     * @param array $aCallable
     * @param int $nRepeat
     *
     * @return string
     */
    private function renderChild(string $sJsVar, string $sJsClass,
        array $aCallable, int $nRepeat = 0): string
    {
        $sIndent = str_repeat(' ', $nRepeat);
        $sScript = $this->renderCallable($sJsClass, $aCallable, $nRepeat);

        return <<<CODE
$sIndent$sJsVar {
$sScript
$sIndent}
CODE;
    }

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

        $this->aCallableObjects = ['children' => []];
        foreach($this->cdi->getCallableObjects() as $xCallableObject)
        {
            $this->addCallable($xCallableObject);
        }

        $aScripts = [];
        foreach($this->aCallableObjects['children'] as $sJsClass => $aCallable)
        {
            $aScripts[] = $this->renderChild("{$this->sPrefix}$sJsClass =",
                $sJsClass, $aCallable) . ';';
        }
        return implode("\n", $aScripts) . "\n";
    }

    /**
     * @inheritDoc
     */
    public static function canProcessRequest(ServerRequestInterface $xRequest): bool
    {
        $aCall = $xRequest->getAttribute('jxncall');
        return $aCall !== null && ($aCall['type'] ?? '') === 'class' &&
            isset($aCall['name']) && isset($aCall['method']) &&
            is_string($aCall['name']) && is_string($aCall['method']);
    }

    /**
     * @inheritDoc
     */
    public function setTarget(ServerRequestInterface $xRequest): Target
    {
        $this->xTarget = Target::makeClass($xRequest->getAttribute('jxncall'));
        return $this->xTarget;
    }

    /**
     * @param string $sExceptionMessage
     * @param string $sErrorCode
     * @param array $aErrorParams
     *
     * @throws RequestException
     * @return void
     */
    private function throwException(string $sExceptionMessage,
        string $sErrorCode, array $aErrorParams = []): void
    {
        $sMessage = $this->xTranslator->trans($sErrorCode, $aErrorParams) .
            (!$sExceptionMessage ? '' : "\n$sExceptionMessage");
        $this->xLogger->error($sMessage);
        throw new RequestException($sMessage);
    }

    /**
     * @inheritDoc
     * @throws RequestException
     */
    public function processRequest(): void
    {
        $sClassName = $this->xTarget->getClassName();
        $sMethodName = $this->xTarget->getMethodName();
        // Will be used to print a translated error message.
        $aErrorParams = ['class' => $sClassName, 'method' => $sMethodName];

        if(!$this->xValidator->validateJsObject($sClassName) ||
            !$this->xValidator->validateMethod($sMethodName))
        {
            // Unable to find the requested object or method
            $this->throwException('', 'errors.objects.invalid', $aErrorParams);
        }

        // Call the requested method
        try
        {
            $sError = 'errors.objects.find';
            /** @var CallableObject */
            $xCallableObject = $this->getCallable($sClassName);

            if($xCallableObject->excluded($sMethodName))
            {
                // Unable to find the requested class or method
                $this->throwException('', 'errors.objects.excluded', $aErrorParams);
            }

            $sError = 'errors.objects.call';
            $xCallableObject->call($this->xTarget);
        }
        catch(ReflectionException|SetupException $e)
        {
            // Unable to execute the requested class or method
            $this->throwException($e->getMessage(), $sError, $aErrorParams);
        }
    }
}


1			<?php
2
3			/**
4			* CallableClassPlugin.php - Jaxon callable class plugin
5			*
6			* This class registers user defined callable classes, and calls their methods on user request.
7			*
8			* @package jaxon-core
9			* @author Jared White
10			* @author J. Max Wilson
11			* @author Joseph Woolley
12			* @author Steffen Konerow
13			* @author Thierry Feuzeu <[email protected]>
14			* @copyright Copyright (c) 2005-2007 by Jared White & J. Max Wilson
15			* @copyright Copyright (c) 2008-2010 by Joseph Woolley, Steffen Konerow, Jared White & J. Max Wilson
16			* @copyright 2016 Thierry Feuzeu <[email protected]>
17			* @license https://opensource.org/licenses/BSD-3-Clause BSD 3-Clause License
18			* @link https://github.com/jaxon-php/jaxon-core
19			*/
20
21			namespace Jaxon\Plugin\Request\CallableClass;
22
23			use Jaxon\Jaxon;
24			use Jaxon\App\I18n\Translator;
25			use Jaxon\Di\ComponentContainer;
26			use Jaxon\Exception\RequestException;
27			use Jaxon\Exception\SetupException;
28			use Jaxon\Plugin\AbstractRequestPlugin;
29			use Jaxon\Request\Target;
30			use Jaxon\Request\Validator;
31			use Jaxon\Utils\Template\TemplateEngine;
32			use Psr\Http\Message\ServerRequestInterface;
33			use Psr\Log\LoggerInterface;
34			use ReflectionException;
35
36			use function array_map;
37			use function array_merge;
38			use function explode;
39			use function implode;
40			use function is_array;
41			use function is_string;
42			use function md5;
43			use function str_repeat;
44			use function trim;
45
46			class CallableClassPlugin extends AbstractRequestPlugin
47			{
48			/**
49			* @var array
50			*/
51			private array $aCallableObjects = [];
52
53			/**
54			* The class constructor
55			*
56			* @param string $sPrefix
57			* @param LoggerInterface $xLogger
58			* @param ComponentContainer $cdi
59			* @param ComponentRegistry $xRegistry
60			* @param Translator $xTranslator
61			* @param TemplateEngine $xTemplateEngine
62			* @param Validator $xValidator
63			*/
64			public function __construct(private string $sPrefix,
65			private LoggerInterface $xLogger, private ComponentContainer $cdi,
66			private ComponentRegistry $xRegistry, private Translator $xTranslator,
67			private TemplateEngine $xTemplateEngine, private Validator $xValidator)
68			{}
69
70			/**
71			* @inheritDoc
72			*/
73			public function getName(): string
74			{
75			return Jaxon::CALLABLE_CLASS;
76			}
77
78			/**
79			* @inheritDoc
80			* @throws SetupException
81			*/
82			public function checkOptions(string $sCallable, $xOptions): array
83			{
84			if(!$this->xValidator->validateClass(trim($sCallable)))
85			{
86			throw new SetupException($this->xTranslator->trans('errors.objects.invalid-declaration'));
87			}
88			if(is_string($xOptions))
89			{
90			$xOptions = ['include' => $xOptions];
91			}
92			elseif(!is_array($xOptions))
93			{
94			throw new SetupException($this->xTranslator->trans('errors.objects.invalid-declaration'));
95			}
96			return $xOptions;
97			}
98
99			/**
100			* @inheritDoc
101			*/
102			public function register(string $sType, string $sCallable, array $aOptions): bool
103			{
104			$sClassName = trim($sCallable);
105			$this->xRegistry->registerComponent($sClassName, $aOptions);
106			return true;
107			}
108
109			/**
110			* @inheritDoc
111			* @throws SetupException
112			*/
113			public function getCallable(string $sCallable): CallableObject\|null
114			{
115			return $this->cdi->makeCallableObject($sCallable);
116			}
117
118			/**
119			* @inheritDoc
120			*/
121			public function getHash(): string
122			{
123			$this->xRegistry->registerAllComponents();
124			return md5($this->xRegistry->getHash());
125			}
126
127			/**
128			* Add a callable object to the script generator
129			*
130			* @param CallableObject $xCallableObject
131			*
132			* @return void
133			*/
134			private function addCallable(CallableObject $xCallableObject): void
135			{
136			if($xCallableObject->excluded())
137			{
138			return;
139			}
140
141			$aCallableObject = &$this->aCallableObjects;
142			foreach(explode('.', $xCallableObject->getJsName()) as $sName)
143			{
144			if(!isset($aCallableObject['children'][$sName]))
145			{
146			$aCallableObject['children'][$sName] = [];
147			}
148			$aCallableObject = &$aCallableObject['children'][$sName];
149			}
150			$aCallableObject['methods'] = $xCallableObject->getCallableMethods();
151			}
152
153			/**
154			* @param string $sIndent
155			* @param array $aTemplateVars
156			*
157			* @return string
158			*/
159			private function renderMethod(string $sIndent, array $aTemplateVars): string
160			{
161			return $sIndent . trim($this->xTemplateEngine
162			->render('jaxon::callables/method.js', $aTemplateVars));
163			}
164
165			/**
166			* @param string $sJsClass
167			* @param array $aCallable
168			* @param int $nRepeat
169			*
170			* @return string
171			*/
172			private function renderCallable(string $sJsClass, array $aCallable, int $nRepeat): string
173			{
174			$nRepeat += 2; // Indentation.
175			$sIndent = str_repeat(' ', $nRepeat);
176
177			$fMethodCallback = fn($aMethod) => $this->renderMethod($sIndent,
178			['sJsClass' => $sJsClass, 'aMethod' => $aMethod]);
179			$aMethods = !isset($aCallable['methods']) ? [] :
180			array_map($fMethodCallback, $aCallable['methods']);
181
182			$aChildren = [];
183			foreach($aCallable['children'] ?? [] as $sName => $aChild)
184			{
185			$aChildren[] = $this->renderChild("$sName:", "$sJsClass.$sName",
186			$aChild, $nRepeat) . ',';
187			}
188
189			return implode("\n", array_merge($aMethods, $aChildren));
190			}
191
192			/**
193			* @param string $sJsVar
194			* @param string $sJsClass
195			* @param array $aCallable
196			* @param int $nRepeat
197			*
198			* @return string
199			*/
200			private function renderChild(string $sJsVar, string $sJsClass,
201			array $aCallable, int $nRepeat = 0): string
202			{
203			$sIndent = str_repeat(' ', $nRepeat);
204			$sScript = $this->renderCallable($sJsClass, $aCallable, $nRepeat);
205
206			return <<<CODE
207			$sIndent$sJsVar {
208			$sScript
209			$sIndent}
210			CODE;
211			}
212
213			/**
214			* Generate client side javascript code for the registered callable objects
215			*
216			* @return string
217			* @throws SetupException
218			*/
219			public function getScript(): string
220			{
221			$this->xRegistry->registerAllComponents();
222
223			$this->aCallableObjects = ['children' => []];
224			foreach($this->cdi->getCallableObjects() as $xCallableObject)
225			{
226			$this->addCallable($xCallableObject);
227			}
228
229			$aScripts = [];
230			foreach($this->aCallableObjects['children'] as $sJsClass => $aCallable)
231			{
232			$aScripts[] = $this->renderChild("{$this->sPrefix}$sJsClass =",
233			$sJsClass, $aCallable) . ';';
234			}
235			return implode("\n", $aScripts) . "\n";
236			}
237
238			/**
239			* @inheritDoc
240			*/
241			public static function canProcessRequest(ServerRequestInterface $xRequest): bool
242			{
243			$aCall = $xRequest->getAttribute('jxncall');
244			return $aCall !== null && ($aCall['type'] ?? '') === 'class' &&
245			isset($aCall['name']) && isset($aCall['method']) &&
246			is_string($aCall['name']) && is_string($aCall['method']);
247			}
248
249			/**
250			* @inheritDoc
251			*/
252			public function setTarget(ServerRequestInterface $xRequest): Target
253			{
254			$this->xTarget = Target::makeClass($xRequest->getAttribute('jxncall'));
255			return $this->xTarget;
256			}
257
258			/**
259			* @param string $sExceptionMessage
260			* @param string $sErrorCode
261			* @param array $aErrorParams
262			*
263			* @throws RequestException
264			* @return void
265			*/
266			private function throwException(string $sExceptionMessage,
267			string $sErrorCode, array $aErrorParams = []): void
268			{
269			$sMessage = $this->xTranslator->trans($sErrorCode, $aErrorParams) .
270			(!$sExceptionMessage ? '' : "\n$sExceptionMessage");
271			$this->xLogger->error($sMessage);
272			throw new RequestException($sMessage);
273			}
274
275			/**
276			* @inheritDoc
277			* @throws RequestException
278			*/
279			public function processRequest(): void
280			{
281			$sClassName = $this->xTarget->getClassName();
282			$sMethodName = $this->xTarget->getMethodName();
283			// Will be used to print a translated error message.
284			$aErrorParams = ['class' => $sClassName, 'method' => $sMethodName];
285
286			if(!$this->xValidator->validateJsObject($sClassName) \|\|
287			!$this->xValidator->validateMethod($sMethodName))
288			{
289			// Unable to find the requested object or method
290			$this->throwException('', 'errors.objects.invalid', $aErrorParams);
291			}
292
293			// Call the requested method
294			try
295			{
296			$sError = 'errors.objects.find';
297			/** @var CallableObject */
298			$xCallableObject = $this->getCallable($sClassName);
299
300			if($xCallableObject->excluded($sMethodName))
301			{
302			// Unable to find the requested class or method
303			$this->throwException('', 'errors.objects.excluded', $aErrorParams);
304			}
305
306			$sError = 'errors.objects.call';
307			$xCallableObject->call($this->xTarget);
308			}
309			catch(ReflectionException\|SetupException $e)
310			{
311			// Unable to execute the requested class or method
312			$this->throwException($e->getMessage(), $sError, $aErrorParams);
313			}
314			}
315			}
316

jaxon-php / jaxon-mono

Push — main ( fd5484...10601e )

CallableClassPlugin::getCallable() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like