Spiechu\SymfonyCommonsBundle\Service\DataCollector

Complexity

Total Complexity

20

Size/Duplication

Total Lines	138
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

69.09%

Importance

Changes	2
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	getGlobalResponseSchemas()	0	4	1
A	getSubscribedEvents()	0	6	1
A	getKnownResponseSchemas()	0	4	2
A	getKnownResponseSchemaNumber()	0	10	2
A	getValidationErrors()	0	8	2
A	__construct()	0	6	1
A	collect()	0	8	2
A	getName()	0	4	1
A	onCheckResult()	0	4	1
A	responseWasChecked()	0	4	1
B	extractRoutesData()	0	25	4
A	extractControllerResponseValidator()	0	12	2

<?php

declare(strict_types=1);

namespace Spiechu\SymfonyCommonsBundle\Service;

use Doctrine\Common\Annotations\Reader;
use Spiechu\SymfonyCommonsBundle\Annotation\Controller\ResponseSchemaValidator;
use Spiechu\SymfonyCommonsBundle\Event\ResponseSchemaCheck\CheckResult;
use Spiechu\SymfonyCommonsBundle\Event\ResponseSchemaCheck\Events;
use Spiechu\SymfonyCommonsBundle\EventListener\RequestSchemaValidatorListener;
use Symfony\Component\DependencyInjection\Container;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\DataCollector\DataCollector as BaseDataCollector;
use Symfony\Component\Routing\RouterInterface;

class DataCollector extends BaseDataCollector implements EventSubscriberInterface
{
    const COLLECTOR_NAME = 'spiechu_symfony_commons.data_collector';

    /**
     * @var RouterInterface
     */
    protected $router;

    /**
     * @var Reader
     */
    protected $reader;

    /**
     * @var Container
     */
    protected $container;

    public function __construct(RouterInterface $router, Reader $reader, Container $container)
    {
        $this->router = $router;
        $this->reader = $reader;
        $this->container = $container;
    }

    /**
     * {@inheritdoc}
     */
    public function collect(Request $request, Response $response, \Exception $exception = null): void
    {
        $this->data['known_response_schemas'] = $request->attributes->has(RequestSchemaValidatorListener::ATTRIBUTE_RESPONSE_SCHEMAS)
            ? $request->attributes->get(RequestSchemaValidatorListener::ATTRIBUTE_RESPONSE_SCHEMAS)
            : null;

        $this->extractRoutesData();
    }

    /**
     * {@inheritdoc}
     */
    public function getName(): string
    {
        return static::COLLECTOR_NAME;
    }

    public function getGlobalResponseSchemas(): array
    {
        return $this->data['global_response_schemas'];
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents(): array
    {
        return [
            Events::CHECK_RESULT => ['onCheckResult', 100],
        ];
    }

    public function onCheckResult(CheckResult $checkResult): void
    {
        $this->data['validation_result'] = $checkResult->getValidationResult();
    }

    public function getKnownResponseSchemas(): array
    {
        return empty($this->data['known_response_schemas']) ? [] : $this->data['known_response_schemas'];
    }

    public function getKnownResponseSchemaNumber(): int
    {
        $counter = 0;

        foreach ($this->getKnownResponseSchemas() as $format) {
            $counter += count($format);
        }

        return $counter;
    }

    public function responseWasChecked(): bool
    {
        return array_key_exists('validation_result', $this->data);
    }

    /**
     * @return ValidationViolation[]
     */
    public function getValidationErrors(): array
    {
        if (!$this->responseWasChecked()) {
            return [];
        }

        return $this->data['validation_result']->getViolations();
    }

    protected function extractRoutesData(): void
    {
        $this->data['global_response_schemas'] = [];

        foreach ($this->router->getRouteCollection() as $name => $route) {
            $defaults = $route->getDefaults();

            if (empty($defaults['_controller'])) {
                continue;
            }

            $methodAnnotation = $this->extractControllerResponseValidator($defaults['_controller']);

            if (!$methodAnnotation instanceof ResponseSchemaValidator) {
                continue;
            }

            $this->data['global_response_schemas'][] = [
                'path' => $route->getPath(),
                'name' => $name,
                'controller' => $defaults['_controller'],
                'response_schemas' => $methodAnnotation->getSchemas(),
            ];
        }
    }

    protected function extractControllerResponseValidator(string $controllerDefinition): ?ResponseSchemaValidator
    {
        [$controllerDefinition, $controllerMethod] = explode(':', $controllerDefinition, 2);

The variable $controllerMethod does not exist. Did you forget to declare it?

        $controllerClass = $this->container->has($controllerDefinition)
            ? $this->container->get($controllerDefinition)
            : $controllerDefinition;

        $reflectedMethod = new \ReflectionMethod($controllerClass, ltrim($controllerMethod, ':'));

        return $this->reader->getMethodAnnotation($reflectedMethod, ResponseSchemaValidator::class);
    }
}