Ds\Router\Adaptor\RSymfonyAdaptor

Complexity

Total Complexity

13

Size/Duplication

Total Lines	149
Duplicated Lines	32.21 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	match()	18	18	2
B	getSymfonyRouteCollection()	14	38	4
A	createRouterResponse()	16	16	2
A	createFastRouteHandler()	0	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\RouteCollection;
use Symfony\Component\Routing\Route;


/**
 * Class RSymfonyAdaptor
 *
 * @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 RSymfonyAdaptor extends AbstractAdaptor
{
    protected $locator;
    protected $context;

    protected $defaults = [
        'cacheDisabled' => true,
        'cacheFile' => __DIR__ . 'r.cache',
    ];

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

        $this->options = $options;
    }

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

This method seems to be duplicated in your project.

    {
        $response = ['response'];
        $symfonyRoutes = $this->getSymfonyRouteCollection($routes);

Are you sure the assignment to $symfonyRoutes is correct as $this->getSymfonyRouteCollection($routes) (which targets Ds\Router\Adaptor\RSymfonyAdaptor::getSymfonyRouteCollection()) 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 getSymfonyRouteCollection(RouteCollectionInterface $routes)
    {

        if (!$this->options['cacheDisabled'] && file_exists($this->options['cacheFile'])){

This if statement is empty and can be removed.

            //get cached route collection.
        }

        $froute = '/articles/{id:\d+}[/{title}]';

$froute is not used, you could remove the assignment.

        $route = new Route(
            '/path',
            array('handler' => 'some::string'), // default values
            array('month' => '[0-9]{4}-[0-9]{2}'), // requirements
            array(), // options
            '', // host
            array('https','https'), // schemes
            array('GET') // methods
        );


        $symfonyRoutes = new RouteCollection();

        foreach ($routes as $route) {

This code seems to be duplicated across your project.

            $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)
    {
        $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.
    }
}