BrainExe\Core\Annotations\Builder\Controller

Complexity

Total Complexity

8

Size/Duplication

Total Lines	110
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

81.39%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	setDefaults()	0	23	3
B	build()	0	34	3
B	handleRouteAnnotation()	0	26	2

<?php

namespace BrainExe\Core\Annotations\Builder;

use BrainExe\Core\Annotations\Service;
use BrainExe\Core\Annotations\Guest;
use BrainExe\Core\Annotations\Role;
use BrainExe\Core\Annotations\Route;
use BrainExe\Core\DependencyInjection\CompilerPass\ControllerCompilerPass;
use BrainExe\Core\Annotations\Controller as ControllerAnnotation;
use ReflectionClass;
use ReflectionMethod;
use Symfony\Component\DependencyInjection\Definition;

class Controller extends ServiceDefinition
{

    /**
     * @param ReflectionClass $reflectionClass
     * @param ControllerAnnotation|Service $annotation
     * @param Definition $definition
     * @return array
     */
    public function build(ReflectionClass $reflectionClass, Service $annotation, Definition $definition)
    {
        /** @var Definition $definition */
        [, $definition] = parent::build(
            $reflectionClass,
            $annotation,
            $definition
        );
        $serviceId = $reflectionClass->getName();

        $definition->addTag(ControllerCompilerPass::CONTROLLER_TAG);
        $definition->setPublic(false);
        $definition->setShared(false);

        foreach ($reflectionClass->getMethods() as $method) {
            /** @var Route $routeAnnotation */
            $routeAnnotation = $this->reader->getMethodAnnotation(
                $method,
                Route::class
            );

            if ($routeAnnotation) {
                $this->handleRouteAnnotation(
                    $annotation,

$annotation of type object<BrainExe\Core\Annotations\Service> is not a sub-type of object<BrainExe\Core\Annotations\Controller>. It seems like you assume a child class of the class BrainExe\Core\Annotations\Service to be always present.

                    $method,
                    $routeAnnotation,
                    $serviceId,
                    $definition
                );
            }
        }

        return [$serviceId, $definition];
    }


    /**
     * @param Route $routeAnnotation
     * @param ReflectionMethod $method
     * @param string $serviceId
     * @param Guest $guestAnnotation
     * @param Role $roleAnnotation
     */
    protected function setDefaults(
        Route $routeAnnotation,
        ReflectionMethod $method,
        string $serviceId,
        Guest $guestAnnotation = null,
        Role $roleAnnotation = null
    ) {
        $defaults = $routeAnnotation->getDefaults();
        $defaults['_controller'] = [
            $serviceId,
            $method->getName()
        ];

        if ($guestAnnotation) {
            $defaults['_guest'] = true;
        }

        if ($roleAnnotation) {
            $defaults['_role'] = $roleAnnotation->role;
        }

        $routeAnnotation->setDefaults($defaults);
    }

    /**
     * @param ControllerAnnotation $annotation
     * @param ReflectionMethod $method
     * @param Route $routeAnnotation
     * @param string $serviceId
     * @param Definition $definition
     */
    private function handleRouteAnnotation(
        ControllerAnnotation $annotation,
        ReflectionMethod$method,
        Route $routeAnnotation,
        string $serviceId,
        Definition $definition
    ) {
        /** @var Guest $guestAnnotation */
        $guestAnnotation = $this->reader->getMethodAnnotation($method, Guest::class);

        /** @var Role $roleAnnotation */
        $roleAnnotation = $this->reader->getMethodAnnotation($method, Role::class);

        $this->setDefaults($routeAnnotation, $method, $serviceId, $guestAnnotation, $roleAnnotation);

        if ($annotation->requirements) {

The expression $annotation->requirements of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $routeAnnotation->setRequirements(
                array_merge(
                    $routeAnnotation->getRequirements(),
                    $annotation->requirements
                )
            );
        }

        $definition->addTag(ControllerCompilerPass::ROUTE_TAG, [$routeAnnotation]);
    }
}