Jaxon\Request\Support\CallableObject

Complexity

Total Complexity

42

Size/Duplication

Total Lines	331
Duplicated Lines	0 %

Importance

Changes	16
Bugs	3	Features	1

13 Methods

Rating	Name	Duplication	Size	Complexity
A	getRegisteredObject()	0	26	4
A	getRootNamespace()	0	4	1
A	getName()	0	4	1
B	callHookMethods()	0	27	7
A	hasMethod()	0	3	1
A	getNamespace()	0	4	1
A	call()	0	17	2
B	configure()	0	39	11
A	__construct()	0	3	1
A	getMethods()	0	19	5
A	setHookMethods()	0	17	6
A	getJsName()	0	3	1
A	getClassName()	0	4	1

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

Package name "jaxon-core" is not valid; consider "Jaxoncore" instead

 * @author Jared White

Content of the @author tag must be in the form "Display Name <username@example.com>"

 * @author J. Max Wilson

Content of the @author tag must be in the form "Display Name <username@example.com>"

 * @author Joseph Woolley

Content of the @author tag must be in the form "Display Name <username@example.com>"

 * @author Steffen Konerow

Content of the @author tag must be in the form "Display Name <username@example.com>"

 * @author Thierry Feuzeu <thierry.feuzeu@gmail.com>
 * @copyright Copyright (c) 2005-2007 by Jared White & J. Max Wilson

@copyright tag must contain a year and the name of the copyright holder

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

@copyright tag must contain a year and the name of the copyright holder

 * @copyright 2016 Thierry Feuzeu <thierry.feuzeu@gmail.com>
 * @license https://opensource.org/licenses/BSD-3-Clause BSD 3-Clause License
 * @link https://github.com/jaxon-php/jaxon-core
 */

PHP version not specified

Missing @category tag in file comment

namespace Jaxon\Request\Support;

use Jaxon\Request\Request;

The type Jaxon\Request\Request was not found. Maybe you did not declare it correctly or list all dependencies?

use Jaxon\Response\Response;

class CallableObject

Missing doc comment for class CallableObject

{
    /**
     * A reference to the callable object the user has registered
     *
     * @var object
     */
    private $xRegisteredObject = null;

Expected 1 blank line(s) before first member var; 0 found

    /**
     * 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 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 string            $sCallable               The callable object instance or class name

Expected 1 spaces after parameter type; 12 found

Expected 1 spaces after parameter name; 15 found

     *
     */
    public function __construct($sCallable)

Expected 2 blank lines before function; 1 found

    {
        $this->xReflectionClass = new \ReflectionClass($sCallable);
    }

Expected 2 blank lines after function; 1 found

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

Expected 2 blank lines after function; 1 found

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

Expected 2 blank lines after function; 1 found

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

Expected 2 blank lines after function; 1 found

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

Expected 2 blank lines after function; 1 found

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

Expected 2 blank lines after function; 1 found

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

Expected 8 spaces after parameter type; 9 found

Expected 1 spaces after parameter name; 6 found

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

Expected 1 spaces after parameter type; 2 found

Expected 7 spaces after parameter name; 13 found

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

Expected 2 blank lines after function; 1 found

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

Expected 7 spaces after parameter type; 8 found

Expected 2 spaces after parameter name; 14 found

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

Expected 1 spaces after parameter name; 13 found

Expected 1 spaces after parameter type; 2 found

     *
     * @return void
     */
    public function configure($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))

The condition is_string($xValue) is always true.

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

Expected 2 blank lines after function; 1 found

    /**
     * Return a list of methods of the callable object to export to javascript
     *
     * @return array
     */
    public function getMethods()
    {
        $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 excluded methods
            if(in_array($sMethodName, $this->aProtectedMethods))
            {
                continue;
            }
            $aMethods[] = $sMethodName;
        }
        return $aMethods;
    }

Expected 2 blank lines after function; 1 found

    /**
     * Return the registered callable object
     *
     * @return null|object
     */
    public function getRegisteredObject()
    {
        if($this->xRegisteredObject == null)
        {
            $di = jaxon()->di();

Equals sign not aligned with surrounding assignments; expected 22 spaces but found 1 space

            $this->xRegisteredObject = $di->make($this->xReflectionClass);
            // Initialize the object
            if($this->xRegisteredObject instanceof \Jaxon\CallableClass)
            {
                // Set the members of the object
                $cSetter = function($xCallable, $xResponse) {
                    $this->callable = $xCallable;

The property callable does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

                    $this->response = $xResponse;

The property response does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

                };
                $cSetter = $cSetter->bindTo($this->xRegisteredObject, $this->xRegisteredObject);
                // Can now access protected attributes
                \call_user_func($cSetter, $this, jaxon()->getResponse());
            }

            // Run the callback for class initialisation
            if(($xCallback = $di->getRequestHandler()->getCallbackManager()->init()))

Variable assignment found within a condition. Did you mean to do a comparison ?

            {
                \call_user_func($xCallback, $this->xRegisteredObject);
            }
        }
        return $this->xRegisteredObject;
    }

Expected 2 blank lines after function; 1 found

    /**
     * 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

Expected 1 spaces after parameter type; 8 found

Expected 1 spaces after parameter name; 12 found

     *
     * @return boolean
     */
    public function hasMethod($sMethod)
    {
        return $this->xReflectionClass->hasMethod($sMethod)/* || $this->xReflectionClass->hasMethod('__call')*/;

Single line block comment not allowed; use inline ("// text") comment instead

    }

Expected 2 blank lines after function; 1 found

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

Expected 4 spaces after parameter type; 5 found

Expected 1 spaces after parameter name; 6 found

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

Expected 3 spaces after parameter type; 4 found

Expected 7 spaces after parameter name; 12 found

     * @param Response  $xResponse          The response returned by the method

Expected 5 spaces after parameter name; 10 found

Superfluous parameter comment

Expected 1 spaces after parameter type; 2 found

     *
     * @return void
     */
    private function callHookMethods($aClassMethods, $sMethod)
    {
        $aMethods = [];
        if(key_exists($sMethod, $aClassMethods))
        {
            $aMethods = $aClassMethods[$sMethod];
        }
        elseif(key_exists('*', $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);
        }
    }

Expected 2 blank lines after function; 1 found

    /**
     * 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

Expected 1 spaces after parameter name; 12 found

Expected 1 spaces after parameter type; 8 found

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

Expected 2 spaces after parameter type; 9 found

Expected 3 spaces after parameter name; 14 found

     *
     * @return null|Response
     */
    public function call($sMethod, $aArgs)
    {
        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);

Equals sign not aligned with surrounding assignments; expected 8 spaces but found 1 space

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

        return $xResponse;
    }

Expected 2 blank lines after function; 0 found

}