CallableObject::getJsName() - Code Metrics - Inspection of "Registering a class that does not exist thows an e..." - jaxon-php/jaxon-core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 8eafb5...9551a9 )

by Thierry

created 2022-03-13 15:13 UTC

CallableObject::getJsName() A

↳ Parent: CallableObject

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

/**
 * CallableObject.php - Jaxon callable object
 *
 * This class stores a reference to an object whose methods can be called from
 * the client via an Jaxon request
 *
 * The Jaxon plugin manager will call <CallableObject->getClientScript> so that
 * stub functions can be generated and sent to the browser.
 *
 * @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\Container\Container;
use Jaxon\Response\Response;

use ReflectionClass;
use ReflectionException;

use function array_map;
use function array_merge;
use function in_array;
use function is_array;
use function is_string;
use function strlen;

class CallableObject

{
    /**
     * The DI container
     *
     * @var Container
     */
    protected $di;


    /**
     * The reflection class of the user registered callable object
     *
     * @var ReflectionClass
     */
    private $xReflectionClass;

    /**
     * A list of methods of the user registered callable object the library must not export to javascript
     *
     * @var array
     */
    private $aProtectedMethods = [];

    /**
     * A list of methods to call before processing the request
     *
     * @var array
     */
    private $aBeforeMethods = [];

    /**
     * A list of methods to call after processing the request
     *
     * @var array
     */
    private $aAfterMethods = [];

    /**
     * The callable object options
     *
     * @var array
     */
    private $aOptions = [];

    /**
     * The namespace the callable class was registered from
     *
     * @var string
     */
    private $sNamespace = '';

    /**
     * The character to use as separator in javascript class names
     *
     * @var string
     */
    private $sSeparator = '.';

    /**
     * The class constructor
     *
     * @param Container  $di

     * @param ReflectionClass $xReflectionClass    The reflection class

     *
     */
    public function __construct(Container $di, ReflectionClass $xReflectionClass)

    {
        $this->di = $di;
$a = "a";
$ab = "ab";
$abc = "abc";
        $this->xReflectionClass = $xReflectionClass;
    }


    /**
     * Set callable object options
     *
     * @param array  $aOptions

     *
     * @return void
     */
    public function setOptions(array $aOptions)
    {
        $this->aOptions = $aOptions;
    }


    /**
     * Get callable object options
     *
     * @return array
     */
    public function getOptions(): array
    {
        return $this->aOptions;
    }


    /**
     * Get the reflection class
     *
     * @return ReflectionClass
     */
    public function getReflectionClass(): ReflectionClass
    {
        return $this->xReflectionClass;
    }


    /**
     * Get the class name of this callable object, without the namespace if any
     *
     * @return string
     */
    public function getClassName(): string
    {
        // Get the class name without the namespace.
        return $this->xReflectionClass->getShortName();
    }


    /**
     * Get the name of this callable object
     *
     * @return string
     */
    public function getName(): string
    {
        // Get the class name with the namespace.
        return $this->xReflectionClass->getName();
    }


    /**
     * Get the name of the corresponding javascript class
     *
     * @return string
     */
    public function getJsName(): string
    {
        return str_replace('\\', $this->sSeparator, $this->getName());
    }


    /**
     * Get the namespace of this callable object
     *
     * @return string
     */
    public function getNamespace(): string
    {
        // The namespace of the registered class.
        return $this->xReflectionClass->getNamespaceName();
    }


    /**
     * Get the namespace the callable class was registered from
     *
     * @return string
     */
    public function getRootNamespace(): string
    {
        // The namespace the callable class was registered from.
        return $this->sNamespace;
    }


    /**
     * Set hook methods
     *
     * @param array $aHookMethods    The array of hook methods

     * @param string|array $xValue    The value of the configuration option

     *
     * @return void
     */
    public function setHookMethods(array &$aHookMethods, $xValue)
    {
        foreach($xValue as $sCalledMethod => $xMethodToCall)
        {
            if(is_array($xMethodToCall))
            {
                $aHookMethods[$sCalledMethod] = $xMethodToCall;
            }
            elseif(is_string($xMethodToCall))
            {
                $aHookMethods[$sCalledMethod] = [$xMethodToCall];
            }
        }
    }


    /**
     * Set configuration options / call options for each method
     *
     * @param string $sName    The name of the configuration option

     * @param string|array $xValue    The value of the configuration option

     *
     * @return void
     */
    public function configure(string $sName, $xValue)
    {
        switch($sName)
        {
        // Set the separator
        case 'separator':
            if($xValue == '_' || $xValue == '.')
            {
                $this->sSeparator = $xValue;
            }
            break;
        // Set the namespace
        case 'namespace':
            if(is_string($xValue))
            {
                $this->sNamespace = $xValue;
            }
            break;
        // Set the protected methods
        case 'protected':
            if(is_array($xValue))
            {
                $this->aProtectedMethods = array_merge($this->aProtectedMethods, $xValue);
            }
            elseif(is_string($xValue))

            {
                $this->aProtectedMethods[] = $xValue;
            }
            break;
        // Set the methods to call before processing the request
        case '__before':
            $this->setHookMethods($this->aBeforeMethods, $xValue);
            break;
        // Set the methods to call after processing the request
        case '__after':
            $this->setHookMethods($this->aAfterMethods, $xValue);
            break;
        default:
            break;
        }
    }


    /**
     * Return a list of methods of the callable object
     *
     * @param array $aProtectedMethods    The protected methods

     *
     * @return array
     */
    private function _getMethods(array $aProtectedMethods): array
    {
        $aMethods = [];
        foreach($this->xReflectionClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $xMethod)
        {
            $sMethodName = $xMethod->getShortName();
            // Don't take magic __call, __construct, __destruct methods
            if(strlen($sMethodName) > 2 && substr($sMethodName, 0, 2) == '__')
            {
                continue;
            }
            // Don't take protected methods
            if(in_array($sMethodName, $aProtectedMethods) || in_array($sMethodName, $this->aProtectedMethods))
            {
                continue;
            }
            $aMethods[] = $sMethodName;
        }
        return $aMethods;
    }


    /**
     * Return a list of methods of the callable object to export to javascript
     *
     * @param array $aProtectedMethods    The protected methods

     *
     * @return array
     */
    public function getMethods(array $aProtectedMethods): array
    {
        $aConfig = $this->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['*']) : [];

        $aMethods = [];
        foreach($this->_getMethods($aProtectedMethods) as $sMethodName)
        {
            // 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),
            ];
        }
        return $aMethods;
    }


    /**
     * Get the registered callable object
     *
     * @return null|object
     */
    public function getRegisteredObject()
    {
        return $this->di->get($this->xReflectionClass->getName());
    }


    /**
     * Check if the specified method name is one of the methods of the registered callable object
     *
     * @param string $sMethod    The name of the method to check

     *
     * @return bool
     */
    public function hasMethod(string $sMethod): bool
    {
        return $this->xReflectionClass->hasMethod($sMethod);
    }


    /**
     * Call the specified method of the registered callable object using the specified array of arguments
     *
     * @param array $aClassMethods    The method config options

     * @param string $sMethod    The method called by the request

     *
     * @return void
     * @throws ReflectionException
     */
    private function callHookMethods(array $aClassMethods, string $sMethod)
    {
        $aMethods = [];
        if(isset($aClassMethods[$sMethod]))
        {
            $aMethods = $aClassMethods[$sMethod];
        }
        elseif(isset($aClassMethods['*']))
        {
            $aMethods = $aClassMethods['*'];
        }
        foreach($aMethods as $xKey => $xValue)
        {
            $sMethodName = $xValue;
            $aMethodArgs = [];
            if(is_string($xKey))
            {
                $sMethodName = $xKey;
                $aMethodArgs = is_array($xValue) ? $xValue : [$xValue];
            }
            if(!$this->xReflectionClass->hasMethod($sMethodName))
            {
                continue;
            }
            $reflectionMethod = $this->xReflectionClass->getMethod($sMethodName);
            $reflectionMethod->setAccessible(true); // Make it possible to call protected methods
            $reflectionMethod->invokeArgs($this->getRegisteredObject(), $aMethodArgs);
        }
    }


    /**
     * Call the specified method of the registered callable object using the specified array of arguments
     *
     * @param string $sMethod    The name of the method to call

     * @param array $aArgs    The arguments to pass to the method

     *
     * @return null|Response
     * @throws ReflectionException
     */
    public function call(string $sMethod, array $aArgs): ?Response
    {
        if(!$this->hasMethod($sMethod))
        {
            return null;
        }

        // Methods to call before processing the request
        $this->callHookMethods($this->aBeforeMethods, $sMethod);

        $reflectionMethod = $this->xReflectionClass->getMethod($sMethod);
        $xResponse = $reflectionMethod->invokeArgs($this->getRegisteredObject(), $aArgs);
$a = "a";
$ab = "ab";
$abc = "abc";

        // Methods to call after processing the request
        $this->callHookMethods($this->aAfterMethods, $sMethod);

        return $xResponse;
    }

}


1			<?php
2
3			/**
4			* CallableObject.php - Jaxon callable object
5			*
6			* This class stores a reference to an object whose methods can be called from
7			* the client via an Jaxon request
8			*
9			* The Jaxon plugin manager will call <CallableObject->getClientScript> so that
10			* stub functions can be generated and sent to the browser.
11			*
12			* @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...
13			* @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...
14			* @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...
15			* @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...
16			* @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...
17			* @author Thierry Feuzeu <[email protected]>
18			* @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...
19			* @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...
20			* @copyright 2016 Thierry Feuzeu <[email protected]>
21			* @license https://opensource.org/licenses/BSD-3-Clause BSD 3-Clause License
22			* @link https://github.com/jaxon-php/jaxon-core
23			*/
			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...
24
25			namespace Jaxon\Request\Plugin\CallableClass;
26
27			use Jaxon\Container\Container;
28			use Jaxon\Response\Response;
29
30			use ReflectionClass;
31			use ReflectionException;
32

jaxon-php / jaxon-core

Push — master ( 8eafb5...9551a9 )

CallableObject::getJsName() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like