Ds\Router\Adaptor\SymfonyAdaptor

Complexity

Total Complexity

11

Size/Duplication

Total Lines	135
Duplicated Lines	22.96 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	16	1
A	match()	0	18	2
A	createSymfonyRouteCollection()	0	19	2
A	createRouterResponse()	16	16	2
A	createFastRouteHandler()	15	15	2
A	isCached()	0	4	1
A	getCachedRoutes()	0	4	1

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

use Ds\Router\Exceptions\RouterException;
use Ds\Router\Interfaces\RouteCollectionInterface;
use Ds\Router\Interfaces\RouteInterface;
use Ds\Router\Interfaces\SerializerInterface;
use Ds\Router\RouterResponse;
use Symfony\Component\Routing\Matcher\UrlMatcher;
use Symfony\Component\Routing\RequestContext;
use Symfony\Component\Routing\Route;
use Symfony\Component\Routing\RouteCollection;

/**
 * Class SymfonyAdaptor
 *
 * @package Ds\Router\Adaptor
 * @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 SymfonyAdaptor extends AbstractAdaptor
{
    protected $locator;
    protected $context;

    /**
     * FastRouteAdaptor constructor.
     *
     * @param  SerializerInterface $serializer
     * @param  array $options
     * @throws RouterException
     */
    public function __construct(SerializerInterface $serializer, array $options = [])
    {
        parent::__construct($serializer);

        $this->options = $options;

        $this->context = new RequestContext('/');

        $routes = new RouteCollection();

        $routes->add('name',
            new Route('/foo', array('_controller' => 'MyController'))
        );

        $this->context = new RequestContext('/');
    }

    /**
     * Return RouterResponse for given route.
     *
     * @param  RouteCollectionInterface $routes
     * @param  string $method
     * @param  string $requestTarget
     * @return RouterResponse
     * @throws \Symfony\Component\Routing\Exception\ResourceNotFoundException
     * @throws \Symfony\Component\Routing\Exception\MethodNotAllowedException
     */
    public function match(RouteCollectionInterface $routes, $method, $requestTarget)
    {
        $response = ['response'];
        $symfonyRoutes = $this->createSymfonyRouteCollection($routes);

Are you sure the assignment to $symfonyRoutes is correct as $this->createSymfonyRouteCollection($routes) (which targets Ds\Router\Adaptor\SymfonyAdaptor::createSymfonyRouteCollection()) seems to always return null.

        $context = new RequestContext('/');

        $matcher = new UrlMatcher($symfonyRoutes, $context);

$symfonyRoutes is of type null, but the function expects a object<Symfony\Component\Routing\RouteCollection>.

        $parameters = $matcher->match($requestTarget);
        // array('_controller' => 'MyController', '_route' => 'route_name')

63% of this comment could be valid code. Did you maybe forget this after debugging?

        if (!isset($parameters['controller'])) {
            $response['statusCode'] = 404;
        }

        return $this->createRouterResponse($response);
    }

    public function createSymfonyRouteCollection(RouteCollectionInterface $routes)
    {
        $symfonyRoutes = new RouteCollection();

        foreach ($routes as $route) {
            $symfonyRoutes->add(
                \json_encode($route->getNames()),
                new Route(
                    $route->getPattern(),
                    [$route->getHandler()],
                    [],
                    [],
                    [],

array() is of type array, but the function expects a string.

                    [],
                    [$route->getMethod()]
                )
            );
        }
    }

    /**
     * Unserialize any cached content and return RouterResponse.
     *
     * @param  $dispatchResponse
     * @return RouterResponse
     */
    public function createRouterResponse($dispatchResponse)

This method seems to be duplicated in your project.

    {
        if ($dispatchResponse['handler']['type'] === 'object') {
            $dispatchResponse['content'] = $this->serializer->unserialize($dispatchResponse['handler']['content']);
        } else {
            $dispatchResponse['content'] = $dispatchResponse['handler']['content'];
        }

        return new RouterResponse(
            $dispatchResponse['statusCode'],
            $dispatchResponse['allowedMethods'],
            $dispatchResponse['content'],

$dispatchResponse['content'] is of type object<Closure>, but the function expects a array.

            $dispatchResponse['vars'],
            $dispatchResponse['handler']['name']

The call to RouterResponse::__construct() has too many arguments starting with $dispatchResponse['handler']['name'].

        );
    }

    public function createFastRouteHandler(RouteInterface $route)

This method seems to be duplicated in your project.

    {
        $handlerOut = [
            'type' => $route->getHandlerType(),
            'name' => $route->getNames()
        ];

        if ($route->getHandlerType() === 'object') {
            $handlerOut['content'] = $this->serializer->serialize($route->getHandler());

It seems like $route->getHandler() targeting Ds\Router\Interfaces\RouteInterface::getHandler() can also be of type string; however, Ds\Router\Interfaces\SerializerInterface::serialize() does only seem to accept object<Closure>, maybe add an additional type check?

        } else {
            $handlerOut['content'] = $route->getHandler();
        }

        return $handlerOut;
    }

    /**
     * Check if Cache Enabled and whether too skip adding routes.
     *
     * @return boolean
     */
    public function isCached()
    {
        return false;
    }

    /**
     * @inheritdoc
     */
    public function getCachedRoutes($context = '')
    {
        // TODO: Implement getCachedRoutes() method.
    }
}