Kambo\Router\Dispatcher\ClosureAutoBind

Complexity

Total Complexity

15

Size/Duplication

Total Lines	134
Duplicated Lines	5.22 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	dispatchRoute()	0	16	2
A	dispatchNotFound()	0	8	2
A	setNotFoundHandler()	0	12	2
A	isClosure()	0	4	2
B	getFunctionArguments()	7	16	5
A	getFunctionArgumentsNames()	0	10	2

<?php
namespace Kambo\Router\Dispatcher;

// \Spl
use Closure;
use InvalidArgumentException;
use ReflectionFunction;

// \Kambo\Router
use Kambo\Router\Dispatcher;
use Kambo\Router\Route\Route\Parsed;

/**
 * Dispatcher with closure support
 *
 * @package Kambo\Router\Dispatcher
 * @author  Bohuslav Simek <bohuslav@simek.si>
 * @license MIT
 */
class ClosureAutoBind implements Dispatcher
{
    /**
     * Not found handler will be called if nothing has been found.
     *
     * @var \Closure
     */
    private $notFoundHandler;

    /**
     * Dispatch found route with given parameters
     *
     * @param \Kambo\Router\Route\Route\Parsed $route      Instance of found and parsed route.
     * @param array                            $parameters Additional parameters which will be passed into
     *                                                     the dispatcher.
     *
     * @return mixed
     */
    public function dispatchRoute(Parsed $route, array $parameters)
    {
        $handler = $route->getHandler();
        if ($this->isClosure($handler)) {
            $paramMap  = $this->getFunctionArgumentsNames($handler);
            $arguments = $this->getFunctionArguments(
                $paramMap,
                $route->getParameters(),
                $route->getPlaceholders()
            );

            return call_user_func_array($handler, $arguments);
        } else {
            return $this->dispatchNotFound();
        }
    }

    /**
     * Called if any of route did not match the request.
     * Call the defined handler or simply do nothing if the handler is not
     * specified.
     *
     * @return mixed|null
     */
    public function dispatchNotFound()
    {
        if (isset($this->notFoundHandler)) {
            return call_user_func($this->notFoundHandler);
        }

        return null;
    }

    /**
     * Sets not found handler
     *
     * @param string $handler handler that will be excuted if nothing has been
     *                        found
     *
     * @return self for fluent interface
     *
     * @throws InvalidArgumentException if the provided value is not closure
     */
    public function setNotFoundHandler($handler)
    {
        if (!$this->isClosure($handler)) {
            throw new InvalidArgumentException(
                'Handler must be closure'
            );
        }

        $this->notFoundHandler = $handler;

It seems like $handler of type string is incompatible with the declared type object<Closure> of property $notFoundHandler.

        return $this;
    }

    // ------------ PRIVATE METHODS

    /**
     * Check if variable is closure
     *
     * @param mixed $type variable to check
     *
     * @return boolean return true if is
     */
    private function isClosure($type)
    {
        return is_object($type) && ($type instanceof Closure);
    }

    /**
     * Get arguments for closure function in proper order
     * from provided parameters
     *
     * @param mixed $paramMap   parameter map for getting proper order
     * @param mixed $matches    parameters from request
     * @param mixed $parameters expected parameters from route
     *
     * @return array Parameters in right order, if there are not any
     *         parametrs an empty array is returned.
     */
    private function getFunctionArguments($paramMap, $matches, $parameters)
    {
        $output  = [];
        $matches = array_values($matches);
        if (isset($parameters)) {
            foreach ($parameters as $valueName) {
                foreach ($paramMap as $possition => $value) {
                    if ($value == $valueName[1][0]) {
                        $output[] = $matches[$possition];
                    }
                }
            }
        }

        return $output;
    }

    /**
     * Get name of parameters for provided closure
     *
     * @param \Closure $closure
     *
     * @return array
     */
    private function getFunctionArgumentsNames($closure)
    {
        $closureReflection = new ReflectionFunction($closure);
        $result            = [];
        foreach ($closureReflection->getParameters() as $param) {
            $result[] = $param->name;
        }

        return $result;
    }
}