FOS\RestBundle\Routing\Loader\RestRouteLoader

Complexity

Total Complexity

26

Size/Duplication

Total Lines	145
Duplicated Lines	4.14 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

72.13%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	6	27	8
A	getControllerReader()	0	4	1
A	load()	0	10	1
A	supports()	0	9	3
C	getControllerLocator()	0	54	13

<?php

/*
 * This file is part of the FOSRestBundle package.
 *
 * (c) FriendsOfSymfony <http://friendsofsymfony.github.com/>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace FOS\RestBundle\Routing\Loader;

use FOS\RestBundle\Routing\Loader\Reader\RestControllerReader;
use Symfony\Bundle\FrameworkBundle\Controller\ControllerNameParser;
use Symfony\Component\Config\FileLocatorInterface;
use Symfony\Component\Config\Loader\Loader;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpKernel\Kernel;

/**
 * RestRouteLoader REST-enabled controller router loader.
 *
 * @author Konstantin Kudryashov <ever.zet@gmail.com>
 * @author Bulat Shakirzyanov <mallluhuct@gmail.com>
 */
class RestRouteLoader extends Loader
{
    protected $container;
    protected $controllerParser;
    protected $controllerReader;
    protected $defaultFormat;
    protected $locator;

    /**
     * Initializes loader.
     *
     * @param ContainerInterface   $container
     * @param FileLocatorInterface $locator
     * @param RestControllerReader $controllerReader
     * @param string               $defaultFormat
     */
    public function __construct(
        ContainerInterface $container,
        FileLocatorInterface $locator,
        $controllerReader,
        $defaultFormat = 'html'
    ) {
        $this->container = $container;
        $this->locator = $locator;

        if ($controllerReader instanceof ControllerNameParser || null === $controllerReader) {
            @trigger_error(sprintf('Not passing an instance of %s as the 3rd argument of %s() is deprecated since FOSRestBundle 2.8.', RestControllerReader::class, __METHOD__), E_USER_DEPRECATED);

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

            $this->controllerParser = $controllerReader;

            if (!$defaultFormat instanceof RestControllerReader) {
                throw new \TypeError(sprintf('Argument 4 passed to %s() must be an instance of %s, %s given.', __METHOD__, RestControllerReader::class, is_object($defaultFormat) ? get_class($defaultFormat) : gettype($defaultFormat)));

The call to TypeError::__construct() has too many arguments starting with sprintf('Argument 4 passed to %s() must be an instance of %s, %s given.', __METHOD__, \FOS\RestBundle\Routing\Loader\Reader\RestControllerReader::class, is_object($defaultFormat) ? get_class($defaultFormat) : gettype($defaultFormat)).

            }

            $this->controllerReader = $defaultFormat;
            $this->defaultFormat = func_num_args() > 4 ? func_get_arg(4) : 'html';
        } elseif (!$controllerReader instanceof RestControllerReader) {
            throw new \TypeError(sprintf('Argument 3 passed to %s() must be an instance of %s, %s given.', __METHOD__, RestControllerReader::class, is_object($controllerReader) ? get_class($controllerReader) : gettype($controllerReader)));

The call to TypeError::__construct() has too many arguments starting with sprintf('Argument 3 passed to %s() must be an instance of %s, %s given.', __METHOD__, \FOS\RestBundle\Routing\Loader\Reader\RestControllerReader::class, is_object($controllerReader) ? get_class($controllerReader) : gettype($controllerReader)).

        } else {
            $this->controllerReader = $controllerReader;
            $this->defaultFormat = $defaultFormat;
        }
    }

    /**
     * Returns controller reader.
     *
     * @return RestControllerReader
     */
    public function getControllerReader()
    {
        return $this->controllerReader;
    }

    /**
     * {@inheritdoc}
     */
    public function load($controller, $type = null)
    {
        list($prefix, $class) = $this->getControllerLocator($controller);

        $collection = $this->controllerReader->read(new \ReflectionClass($class));
        $collection->prependRouteControllersWithPrefix($prefix);
        $collection->setDefaultFormat($this->defaultFormat);

        return $collection;
    }

    /**
     * {@inheritdoc}
     */
    public function supports($resource, $type = null)
    {
        return is_string($resource)
            && 'rest' === $type
            && !in_array(
                pathinfo($resource, PATHINFO_EXTENSION),
                ['xml', 'yml', 'yaml']
            );
    }

    /**
     * Returns controller locator by it's id.
     *
     * @param string $controller
     *
     * @throws \InvalidArgumentException
     *
     * @return array
     */
    private function getControllerLocator($controller)
    {
        $class = null;
        $prefix = null;

        if (0 === strpos($controller, '@')) {
            $file = $this->locator->locate($controller);
            $controllerClass = ClassUtils::findClassInFile($file);

It seems like $file defined by $this->locator->locate($controller) on line 124 can also be of type array; however, FOS\RestBundle\Routing\Loader\ClassUtils::findClassInFile() does only seem to accept string, maybe add an additional type check?

            if (false === $controllerClass) {
                throw new \InvalidArgumentException(sprintf('Can\'t find class for controller "%s"', $controller));
            }

            $controller = $controllerClass;
        }

        if ($this->container->has($controller)) {
            // service_id
            $prefix = $controller.':';

            if (Kernel::VERSION_ID >= 40100) {
                $prefix .= ':';
            }

            $useScope = method_exists($this->container, 'enterScope') && $this->container->hasScope('request');

The method hasScope() does not seem to exist on object<Symfony\Component\DependencyInjection\ContainerInterface>.

            if ($useScope) {
                $this->container->enterScope('request');

The method enterScope() does not seem to exist on object<Symfony\Component\DependencyInjection\ContainerInterface>.

                $this->container->set('request', new Request());
            }
            $class = get_class($this->container->get($controller));
            if ($useScope) {
                $this->container->leaveScope('request');

The method leaveScope() does not seem to exist on object<Symfony\Component\DependencyInjection\ContainerInterface>.

            }
        } elseif (class_exists($controller)) {
            // full class name
            $class = $controller;
            $prefix = $class.'::';
        } elseif ($this->controllerParser && false !== strpos($controller, ':')) {
            // bundle:controller notation
            try {
                $notation = $this->controllerParser->parse($controller.':method');
                list($class) = explode('::', $notation);
                $prefix = $class.'::';
            } catch (\Exception $e) {
                throw new \InvalidArgumentException(sprintf('Can\'t locate "%s" controller.', $controller));
            }
        }

        if (empty($class)) {
            throw new \InvalidArgumentException(sprintf('Class could not be determined for Controller identified by "%s".', $controller));
        }

        return [$prefix, $class];
    }
}