Veto\Layer\Dispatcher\DispatcherLayer

Complexity

Total Complexity

11

Size/Duplication

Total Lines	77
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	4

Importance

Changes	4
Bugs	0	Features	1

2 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
C	in()	0	59	10

<?php
/**
 * Veto.
 * PHP Microframework.
 *
 * @author Damien Walsh <me@damow.net>
 * @copyright Damien Walsh 2013-2014
 * @version 0.1
 * @package veto
 */
namespace Veto\Layer\Dispatcher;

use Veto\DI\AbstractContainerAccessor;
use Veto\DI\Container;
use Veto\HTTP\Request;
use Veto\HTTP\Response;
use Veto\Layer\Dispatcher\Exception\DispatcherException;
use Veto\Layer\InboundLayerInterface;

/**
 * DispatcherLayer
 *
 * Dispatches a Request to a controller, obtaining a Response.
 */
class DispatcherLayer extends AbstractContainerAccessor implements InboundLayerInterface
{
    /**
     * Set the service container.
     *
     * @param Container $container
     */
    public function __construct(Container $container)
    {
        $this->container = $container;
    }

    /**
     * @param Request $request
     * @return mixed
     * @throws DispatcherException
     */
    public function in(Request $request)
    {
        // Get the controller
        $controllerSpec = $request->getParameter('_controller');

        if (!$controllerSpec) {
            throw DispatcherException::notTagged(
                $request->getMethod(),
                $request->getUri() ? $request->getUri()->getPath() : ''
            );
        }

        $controller = $this->container->get($controllerSpec['class']);

        if (!method_exists($controller, $controllerSpec['method'])) {
            throw DispatcherException::controllerActionDoesNotExist(
                $controllerSpec['method'],
                $controllerSpec['class']
            );
        }

        // Prepare to run the action method
        $actionMethod = new \ReflectionMethod($controller, $controllerSpec['method']);
        $parameters = $actionMethod->getParameters();
        $passedArgs = array();

        foreach ($parameters as $parameter) {

            $hintedClass = $parameter->getClass();
            $parameterName = $parameter->getName();

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

            if ($hintedClass) {
                $hintedClass = $hintedClass->getName();

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

            }

            // Special case - should the Request object be passed here?
            if ($parameterName == 'request' && $hintedClass == 'Veto\HTTP\Request') {
                $passedArgs[] = $request;
            }

            // Should a request parameter be passed here?
            if ($request->hasParameter($parameterName)) {
                $passedArgs[] = $request->getParameter($parameterName);
            }
        }

        $response = $actionMethod->invokeArgs($controller, $passedArgs);

        // By the end of the inbound layer list, a response should have been obtained
        if (!$response instanceof Response) {
            throw DispatcherException::controllerActionDidNotReturnResponse(
                $controllerSpec['method'],
                $controllerSpec['class'],
                gettype($response)
            );
        }

        return $response;
    }
}