Ds\Router\Dispatcher\Dispatcher

Complexity

Total Complexity

47

Size/Duplication

Total Lines	376
Duplicated Lines	5.85 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
B	dispatch()	0	26	5
A	_processStringHandler()	0	16	2
A	_findClass()	0	14	4
B	_getParams()	3	23	4
A	_getConstructParams()	0	11	2
A	_getParamsFromVariableName()	3	14	4
B	_getParamsFromTypeHint()	0	27	6
A	_processConstructArgs()	0	16	3
A	_callController()	0	18	3
A	_checkWhiteList()	8	8	3
A	_checkInList()	0	9	3
A	_checkBlackList()	8	8	3
A	createNewResponse()	0	8	1
A	withNamespace()	0	6	1
A	withNamespaces()	0	8	2

<?php
/**
 * This file is part of the PSR Http Framework.
 *
 * (c) Dan Smith <dan--smith@hotmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace Ds\Router\Dispatcher;

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Ds\Router\Exceptions\DispatchException;
use Zend\Diactoros\Response;
use Zend\Diactoros\Stream;

/**
 * Class Dispatcher
 *
 * @package Ds\Router\Dispatcher
 * @author  Dan Smith    <dan--smith@hotmail.com>
 * @license http://opensource.org/licenses/gpl-license.php GNU Public License
 * @link    https://github.com/djsmithme/Router
 */
class Dispatcher
{
    /**
     * Dispatcher default options.
     *
     * @var array
     */
    protected static $defaults = [
        'stringHandlerPattern' => '::',
        'autoWire' => true
    ];
    /**
     * @var array
     */
    private $options;
    /**
     * @var array
     */
    private $providedArguments;
    /**
     * @var array
     */
    private $constructParams;

    /**
     * Handler Class Namespaces.
     *
     * @var array.
     */
    private $namespaces = [];

    /**
     * Dispatcher constructor.
     *
     * @param array $options
     */
    public function __construct(array $options = array())
    {
        $options = \array_replace_recursive(self::$defaults, $options);
        $this->options = $options;
    }

    /**
     * Get response from handler string.
     *
     * @param $request
     * @param string|\Closure $handler
     * @param array $constructor
     * @return ResponseInterface
     * @throws \Exception
     */
    public function dispatch(ServerRequestInterface $request, $handler, array $constructor = array())
    {
        $handlerType = \gettype($handler);
        $response = null;
        switch ($handlerType) {
            case 'string':
                $resolvedHandler = $this->_processStringHandler($handler);
                $this->_getParams($resolvedHandler['controller'], $constructor);
                $response = $this->_callController($request, $resolvedHandler['controller'], $resolvedHandler['method']);
                break;
            case 'object':
                if (\is_callable($handler)) {
                    $response = $handler($request);

The expression $handler($request); of type ? adds the type Zend\Diactoros\Response to the return on line 101 which is incompatible with the return type documented by Ds\Router\Dispatcher\Dispatcher::dispatch of type Psr\Http\Message\ResponseInterface.

                }
                break;
            default:
                throw new DispatchException(
                    "Handler type: {$handlerType} is not valid."
                );
        }

        if (!$response instanceof \Psr\Http\Message\ResponseInterface) {
            $response = $this->createNewResponse($response);

The expression $this->createNewResponse($response); of type Zend\Diactoros\Response adds the type Zend\Diactoros\Response to the return on line 101 which is incompatible with the return type documented by Ds\Router\Dispatcher\Dispatcher::dispatch of type Psr\Http\Message\ResponseInterface.

        }
        return $response;
    }

    /***
     * Get Controller/Method from handler string.
     *
     * @param $handler
     * @return mixed
     * @throws DispatchException
     */
    protected function _processStringHandler($handler)
    {
        $controllerMethod = \explode(
            $this->options['stringHandlerPattern'], $handler
        );

        try {
            $resolvedHandler['controller'] = $this->_findClass($controllerMethod[0]);

$resolvedHandler was never initialized. Although not strictly required by PHP, it is generally a good practice to add $resolvedHandler = array(); before regardless.

        } catch (\Exception $e) {
            throw new DispatchException($e->getMessage());
        }

        $resolvedHandler['method'] = $controllerMethod[1] ?? null;

        return $resolvedHandler;
    }

    /**
     * Find class from namespace.
     *
     * @param string $class
     * @return string
     * @throws DispatchException
     */
    protected function _findClass($class)
    {
        if (\class_exists($class)) {
            return $class;
        }

        foreach ($this->namespaces as $namespace) {
            if (\class_exists($namespace . $class)) {
                return $namespace . $class;
            }
        }

        throw new DispatchException("Controller : {$class} does not exist");
    }

    /**
     * Find class construct parameters from provided arguments.
     *
     * @param string $controllerName
     * @param array $args
     * @return array
     * @throws DispatchException
     */
    protected function _getParams(string $controllerName, array $args)
    {
        if ($this->options['autoWire'] === false) {
            $this->providedArguments = $args;
            return $this->providedArguments;
        }

        $this->providedArguments = [];
        $this->constructParams = $this->_getConstructParams($controllerName);

        try {
            $this->_getParamsFromVariableName($args);
        } catch (\Exception $e) {
            $this->_getParamsFromTypeHint($args);
        }

        if (\count($this->providedArguments) - \count($this->constructParams) > 0) {

This code seems to be duplicated across your project.

            throw new DispatchException('Missing parameters');
        }

        \ksort($this->providedArguments);
        return $this->providedArguments;
    }

    /**
     * Reflect Controller construct and get parameters.
     *
     * @param $controllerName
     * @internal
     *
     * @return \ReflectionParameter[]
     */
    protected function _getConstructParams($controllerName)
    {
        $controllerReflection = new \ReflectionClass($controllerName);
        $constructor = $controllerReflection->getConstructor();

        if (null === $constructor) {
            return [];
        }

        return $constructor->getParameters();
    }

    /**
     * Find controller constructor params based on $arg[index]
     *
     * @param $args
     * @throws DispatchException
     */
    protected function _getParamsFromVariableName($args)
    {
        foreach ($this->constructParams as $index => $param) {
            $parameterVarName = $param->getName();
            $constructorParamIndex = (int)$param->getPosition();

            if (isset($args[$parameterVarName])) {
                $this->providedArguments[$constructorParamIndex] = $args[$parameterVarName];
            }
        }
        if (\count($this->constructParams) - \count($this->providedArguments) > 0) {

This code seems to be duplicated across your project.

            throw new DispatchException('Missing parameters');
        }
    }

    /**
     * Find missing parameters based on Class name or type hint.
     *
     * @param $args
     */
    protected function _getParamsFromTypeHint($args)
    {
        $processedArgs = $this->_processConstructArgs($args);

        foreach ($this->constructParams as $index => $param) {

            /**
             * @var \ReflectionClass $constructorParamClass ;
             */
            $constructorParamClass = $param->getClass();
            $constructorParamIndex = (int)$param->getPosition();

            if (isset($this->providedArguments[$constructorParamIndex])) {
                continue;
            }

            if ($constructorParamClass) {
                $constructParamTypeHint = $constructorParamClass->getName();

Consider using $constructorParamClass->name. There is an issue with getName() and APC-enabled PHP versions.

                foreach ((array)$processedArgs['object'] as $useParam) {
                    $key = \array_search($constructParamTypeHint, $useParam['interfaces'], true);
                    if ($key !== false) {
                        $this->providedArguments[$constructorParamIndex] = $useParam['value'];
                    }
                }
            }
        }
    }

    /**
     * Process provided arguments.
     *
     * @param array $args
     * @return array
     */
    protected function _processConstructArgs(array $args = [])
    {
        $arguments = [];
        foreach ($args as $index => $param) {
            switch (\gettype($param)) {
                case 'object':

case statements should be defined using a colon.

                    $arguments['object'][] = [
                        'class' => \get_class($param),
                        'interfaces' => \class_implements($param),
                        'value' => $param
                    ];
                    break;
            }
        }
        return $arguments;
    }

    /**
     * Call controller with provided request and return Response.
     *
     * @param ServerRequestInterface $request     Server Request
     * @param string                 $controller  Controller class.
     * @param string                 $method      Controller method.
     *
     * @return ResponseInterface
     * @throws DispatchException
     */
    protected function _callController(ServerRequestInterface $request, string $controller, string $method)
    {
        $controllerObj = new $controller(...$this->providedArguments);

        try {
            $this->_checkWhiteList($controller, $this->options);
            $this->_checkBlackList($controller, $this->options);
        } catch (\Exception $e) {
            unset($controllerObj);
            throw new DispatchException($e->getMessage());
        }

        if (!method_exists($controllerObj,$method)){
            throw new DispatchException('Controller method does not exist');
        }

        return $controllerObj->{$method}($request);
    }

    /**
     * Checks controller instance against whitelist.
     *
     * @param $controller
     * @param $options
     * @throws DispatchException
     */
    protected function _checkWhiteList($controller, $options)

This method seems to be duplicated in your project.

    {
        if (isset($options['blacklist'])) {
            if (!$this->_checkInList($controller, $options['blacklist'])) {
                throw new DispatchException("Controller: {$controller}, not part of allowed whitelist.");
            }
        }
    }

    /**
     * Internal function for checking controller instance against class list.
     *
     * @param $controller
     * @param array $classList
     * @internal
     * @return bool
     */
    protected function _checkInList($controller, array $classList)
    {
        foreach ((array)$classList as $classes) {
            if ($controller instanceof $classes) {
                return true;
            }
        }
        return false;
    }

    /**
     * Checks controller instance against blacklist.
     *
     * @param $controller
     * @param $options
     * @throws DispatchException
     */
    protected function _checkBlackList($controller, $options)

This method seems to be duplicated in your project.

    {
        if (isset($options['blacklist'])) {
            if ($this->_checkInList($controller, $options['blacklist'])) {
                throw new DispatchException("Controller: {$controller}, found on blacklist.");
            }
        }
    }

    /**
     * Create a new PSR-7 Response.
     *
     * @param $controllerResponse
     * @return Response
     * @throws \InvalidArgumentException
     */
    public function createNewResponse($controllerResponse)
    {
        $response = new Response();
        $body = new Stream("php://memory", "wb+");
        $body->write($controllerResponse);
        $body->rewind();
        return $response->withBody($body);
    }

    /**
     * With Class Namespace.
     *
     * @param $namespace
     * @return Dispatcher
     */
    public function withNamespace($namespace)
    {
        $new = clone $this;
        $new->namespaces[$namespace] = $namespace;
        return $new;
    }

    /**
     * With class Namespaces.
     *
     * @param array $namespaces
     * @return Dispatcher
     */
    public function withNamespaces(array $namespaces)
    {
        $new = clone $this;
        foreach ($namespaces as $ns) {
            $new->namespaces[$ns] = $ns;
        }
        return $new;
    }
}