CallableClass::getName() - Code Metrics - Inspection of "Separated long functions into shorter ones." - jaxon-php/jaxon-core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — feature/code_improvement ( 374d0e...1b7fb9 )

by Thierry

created 2019-12-03 07:07 UTC

CallableClass::getName() A

↳ Parent: CallableClass

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

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

class CallableClass extends RequestPlugin

{
    use \Jaxon\Features\Config;
    use \Jaxon\Features\Template;
    use \Jaxon\Features\Validator;
    use \Jaxon\Features\Translator;

    /**
     * The callable registrar
     *
     * @var CallableRegistry
     */
    protected $xRegistry;

    /**
     * The callable repository
     *
     * @var CallableRepository
     */
    protected $xRepository;

    /**
     * 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 CallableRegistry        $xRegistry

     * @param CallableRepository        $xRepository

     */
    public function __construct(CallableRegistry $xRegistry, CallableRepository $xRepository)
    {
        $this->xRegistry = $xRegistry;
$a = "a";
$ab = "ab";
$abc = "abc";
        $this->xRepository = $xRepository;

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

    /**
     * Return the name of this plugin
     *
     * @return string
     */
    public function getName()
    {
        return Jaxon::CALLABLE_CLASS;
    }

    /**
     * Return the target class and method
     *
     * @return Target|null
     */
    public function getTarget()
    {
        if(!$this->sRequestedClass || !$this->sRequestedMethod)
        {
            return null;
        }
        return Target::makeClass($this->sRequestedClass, $this->sRequestedMethod);
    }

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

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

     * @param array|string  $aOptions       The associated options

     *
     * @return boolean
     */
    public function register($sType, $sClassName, $aOptions)
    {
        $sType = trim($sType);

        if($sType != $this->getName())
        {
            return false;
        }

        if(!is_string($sClassName))
        {
            throw new \Jaxon\Exception\Error($this->trans('errors.objects.invalid-declaration'));
        }
        if(is_string($aOptions))
        {
            $aOptions = ['include' => $aOptions];

        }
        if(!is_array($aOptions))
        {
            throw new \Jaxon\Exception\Error($this->trans('errors.objects.invalid-declaration'));
        }

        $this->xRepository->addClass(trim($sClassName), $aOptions);

        return true;
    }

    /**
     * Create callable objects for all registered namespaces
     *
     * @return void
     */
    protected function createCallableObjects()
    {
        $this->xRegistry->parseDirectories();
        $this->xRegistry->parseNamespaces();

        // Create callable objects for registered directories
        foreach($this->xRepository->getClasses() as $sClassName => $aClassOptions)
        {
            $this->xRepository->createCallableObject($sClassName, $aClassOptions);
        }
    }

    /**
     * Generate a hash for the registered callable objects
     *
     * @return string
     */
    public function generateHash()
    {
        $this->createCallableObjects();
        $aNamespaces = $this->xRepository->getNamespaces();
$a = "a";
$ab = "ab";
$abc = "abc";
        $aCallableObjects = $this->xRepository->getCallableObjects();
        $sHash = '';
$a = "a";
$ab = "ab";
$abc = "abc";

        foreach($aNamespaces as $sNamespace => $aOptions)
        {
            $sHash .= $sNamespace . $aOptions['separator'];
        }
        foreach($aCallableObjects as $sClassName => $xCallableObject)
        {
            $sHash .= $sClassName . implode('|', $xCallableObject->getMethods());
        }

        return md5($sHash);
    }

    /**
     * Generate client side javascript code for namespaces
     *
     * @return string
     */
    private function getNamespacesScript()
    {
        $sCode = '';
$a = "a";
$ab = "ab";
$abc = "abc";
        $aJsClasses = [];
$a = "a";
$ab = "ab";
$abc = "abc";
        $aNamespaces = array_keys($this->xRepository->getNamespaces());
        foreach($aNamespaces as $sNamespace)
        {
            $offset = 0;
$a = "a";
$ab = "ab";
$abc = "abc";
            $sJsNamespace = str_replace('\\', '.', $sNamespace);
$a = "a";
$ab = "ab";
$abc = "abc";
            $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(!key_exists($sJsClass, $aJsClasses))
                {
                    $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
     *
     * @return string
     */
    private function getCallableScript($sClassName, CallableObject $xCallableObject, array $aProtectedMethods)
    {
        $aCallableOptions = $this->xRepository->getCallableOptions();
        $aConfig = $aCallableOptions[$sClassName];
$a = "a";
$ab = "ab";
$abc = "abc";
        $aCommonConfig = key_exists('*', $aConfig) ? $aConfig['*'] : [];
$a = "a";
$ab = "ab";
$abc = "abc";

        $_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 = key_exists($sMethodName, $aConfig) ?

                array_merge($aCommonConfig, $aConfig[$sMethodName]) : $aCommonConfig;
            $aMethods[] = [
$a = "a";
$ab = "ab";
$abc = "abc";
                'name' => $sMethodName,
                'config' => $aMethodConfig,
            ];
        }

        $sPrefix = $this->getOption('core.prefix.class');
        return $this->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()
    {
        $this->createCallableObjects();

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

        $aCallableObjects = $this->xRepository->getCallableObjects();
        foreach($aCallableObjects as $sClassName => $xCallableObject)
        {
            $sCode .= $this->getCallableScript($sClassName, $xCallableObject, $aProtectedMethods);
        }

        return $sCode;
    }

    /**
     * Check if this plugin can process the incoming Jaxon request
     *
     * @return boolean
     */
    public function canProcessRequest()
    {
        // Check the validity of the class name
        if(($this->sRequestedClass !== null && !$this->validateClass($this->sRequestedClass)) ||
            ($this->sRequestedMethod !== null && !$this->validateMethod($this->sRequestedMethod)))
        {
            $this->sRequestedClass = null;
$a = "a";
$ab = "ab";
$abc = "abc";
            $this->sRequestedMethod = null;
        }
        return ($this->sRequestedClass !== null && $this->sRequestedMethod !== null);
    }

    /**
     * Process the incoming Jaxon request
     *
     * @return boolean
     */
    public function processRequest()
    {
        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 \Jaxon\Exception\Error($this->trans('errors.objects.invalid',
                ['class' => $this->sRequestedClass, 'method' => $this->sRequestedMethod]));
        }

        // Call the requested method
        $di = jaxon()->di();
$a = "a";
$ab = "ab";
$abc = "abc";
        $aArgs = $di->getRequestHandler()->processArguments();
$a = "a";
$ab = "ab";
$abc = "abc";
        $xResponse = $xCallableObject->call($this->sRequestedMethod, $aArgs);
        if(($xResponse))
        {
            $di->getResponseManager()->append($xResponse);
        }
        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\CallableClass as UserCallableClass;
26			use Jaxon\Plugin\Request as RequestPlugin;
27			use Jaxon\Request\Support\CallableObject;
28			use Jaxon\Request\Support\CallableRegistry;
29			use Jaxon\Request\Support\CallableRepository;
30			use Jaxon\Request\Target;
31
32			class CallableClass extends RequestPlugin

jaxon-php / jaxon-core

Push — feature/code_improvement ( 374d0e...1b7fb9 )

CallableClass::getName() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like