Knp\Rad\ResourceResolver\EventListener\ResourcesListener

Complexity

Total Complexity

22

Size/Duplication

Total Lines	132
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
C	resolveResources()	0	46	11
A	addParser()	0	6	1
A	addParameterCaster()	0	6	1
A	throwMissingException()	0	14	2
A	parse()	0	8	3
A	castParameter()	0	8	3

<?php

namespace Knp\Rad\ResourceResolver\EventListener;

use Knp\Rad\ResourceResolver\CasterContainer;
use Knp\Rad\ResourceResolver\ParameterCaster;
use Knp\Rad\ResourceResolver\Parser;
use Knp\Rad\ResourceResolver\ParserContainer;
use Knp\Rad\ResourceResolver\ResourceContainer;
use Knp\Rad\ResourceResolver\ResourceResolver;
use Knp\Rad\ResourceResolver\RoutingNormalizer;
use Symfony\Component\HttpKernel\Event\FilterControllerEvent;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;

class ResourcesListener implements CasterContainer, ParserContainer
{
    /** @var Parser[] */
    private $parsers;

    /** @var ResourceContainer */
    private $container;

    /** @var ResourceResolver */
    private $resolver;

    /** @var ParameterCaster[] */
    private $parameterCasters;

    /** @var RoutingNormalizer */
    private $normalizer;

    public function __construct(ResourceResolver $resolver, ResourceContainer $container, RoutingNormalizer $normalizer)
    {
        $this->resolver         = $resolver;
        $this->container        = $container;
        $this->parsers          = [];
        $this->parameterCasters = [];
        $this->normalizer       = $normalizer;
    }

    public function resolveResources(FilterControllerEvent $event)
    {
        $request   = $event->getRequest();
        $resources = [];

        foreach ($request->attributes->get('_resources', []) as $resourceKey => $resourceValue) {
            $resourceValue = $this->parse($resourceValue) ?: $resourceValue;

Equals sign not aligned with surrounding assignments; expected 11 spaces but found 1 space

            $resources[$resourceKey] = $resourceValue;
        }

        foreach ($resources as $resourceKey => $resourceDetails) {
            $resourceDetails = $this->normalizer->normalizeDeclaration($resourceDetails);
            $parameters = [];

Equals sign not aligned with surrounding assignments; expected 6 spaces but found 1 space

            foreach ($resourceDetails['arguments'] as $parameter) {
                $parameter = $this->castParameter($parameter) ?: $parameter;

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

                $parameters[] = $parameter;
            }

            $resource = $this
                ->resolver
                ->resolveResource(
                    $resourceDetails['service'],
                    $resourceDetails['method'],
                    $parameters
                )
            ;

            if (false !== $resourceDetails['required'] && null === $resource) {
                if (!array_key_exists('on-missing', $resourceDetails)) {
                    throw new NotFoundHttpException(sprintf('The resource %s could not be found', $resourceKey));
                }

                if (!is_array($resourceDetails['on-missing']) || !array_key_exists('throw', $resourceDetails['on-missing'])) {
                    throw new \InvalidArgumentException('"on-missing" must be an array and contain "throw" parameter.');
                }
                $this->throwMissingException($resourceDetails['on-missing'], $resourceKey);
            }

            $request->attributes->set($resourceKey, $resource);

            $this->container->addResource($resourceKey, $resource);
        }

        return $event;
    }

    /**
     * {@inheritdoc}
     */
    public function addParser(Parser $parser)
    {
        $this->parsers[] = $parser;

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function addParameterCaster(ParameterCaster $parameterCaster)
    {
        $this->parameterCasters[] = $parameterCaster;

        return $this;
    }

    private function throwMissingException(array $configuration, $resourceKey)
    {
        if (!in_array($configuration['throw'], array_keys($this->exceptions))) {
            throw new \InvalidArgumentException(sprintf(
                '%s is not an available HTTP return code. Available are %s.',
                $configuration['throw'],
                implode(', ', array_keys($this->exceptions))

The property exceptions does not exist. Did you maybe forget to declare it?

            ));
        }

        $message = sprintf('The resource %s was not found.', $resourceKey);

        throw new $this->exceptions[$configuration['throw']]($message);
    }

    /**
     * @return null|array
     */
    private function parse($resourceDetails)
    {
        foreach ($this->parsers as $parser) {
            if (true === $parser->supports($resourceDetails)) {
                return $parser->parse($resourceDetails);
            }
        }
    }

    /**
     * @return mixed
     */
    private function castParameter($parameter)
    {
        foreach ($this->parameterCasters as $parameterCaster) {
            if (true === $parameterCaster->supports($parameter)) {
                return $parameterCaster->cast($parameter);
            }
        }
    }
}